3434 * A wrapper for an {@link Object} or {@link Class} upon which reflective calls
3535 * can be made.
3636 * <p>
37- * An example of using <code>Reflect</code> is <code><pre >
37+ * An example of using <code>Reflect</code> is <pre><code >
3838 * // Static import all reflection methods to decrease verbosity
3939 * import static org.joor.Reflect.*;
4040 *
4545 * // Invoke methods using the call() method:
4646 * .call("toString")
4747 * // Retrieve the wrapped object
48+ * </code></pre>
4849 *
4950 * @author Lukas Eder
5051 * @author Irek Matysiewicz
@@ -61,7 +62,7 @@ public class Reflect {
6162 * Compile a class at runtime and reflect on it.
6263 * <p>
6364 * For example:
64- * <code><pre >
65+ * <pre><code >
6566 * Supplier<String> supplier = Reflect.compile("org.joor.Test", """
6667 * package org.joor;
6768 * class Test implements java.util.function.Supplier<String> {
@@ -70,7 +71,7 @@ public class Reflect {
7071 * }
7172 * }
7273 * """).create().get();
73- * </pre ></code >
74+ * </code ></pre >
7475 *
7576 * @param name The qualified class name
7677 * @param content The source code for the class
@@ -85,7 +86,7 @@ public static Reflect compile(String name, String content) throws ReflectExcepti
8586 * Compile a class at runtime and reflect on it.
8687 * <p>
8788 * For example:
88- * <code><pre >
89+ * <pre><code >
8990 * Supplier<String> supplier = Reflect.compile("org.joor.Test", """
9091 * package org.joor;
9192 * class Test implements java.util.function.Supplier<String> {
@@ -94,7 +95,7 @@ public static Reflect compile(String name, String content) throws ReflectExcepti
9495 * }
9596 * }
9697 * """).create().get();
97- * </pre ></code >
98+ * </code ></pre >
9899 *
99100 * @param name The qualified class name
100101 * @param content The source code for the class
@@ -114,17 +115,17 @@ public static Reflect compile(String name, String content, CompileOptions option
114115 * compilation output.
115116 * <p>
116117 * For example:
117- * <code><pre >
118+ * <pre><code >
118119 * Supplier<String> supplier = Reflect.compile("org.joor.Test", """
119120 * package org.joor;
120- * @ MyAnnotation
121+ * @ MyAnnotation
121122 * class Test implements java.util.function.Supplier<String> {
122123 * public String get() {
123124 * return "Hello World!";
124125 * }
125126 * }
126127 * """).create().get();
127- * </pre ></code >
128+ * </code ></pre >
128129 *
129130 * @param name The qualified class name
130131 * @param content The source code for the class
@@ -142,17 +143,17 @@ public static void process(String name, String content) throws ReflectException
142143 * compilation output.
143144 * <p>
144145 * For example:
145- * <code><pre >
146+ * <pre><code >
146147 * Supplier<String> supplier = Reflect.compile("org.joor.Test", """
147148 * package org.joor;
148- * @ MyAnnotation
149+ * @ MyAnnotation
149150 * class Test implements java.util.function.Supplier<String> {
150151 * public String get() {
151152 * return "Hello World!";
152153 * }
153154 * }
154155 * """).create().get();
155- * </pre ></code >
156+ * </code ></pre >
156157 *
157158 * @param name The qualified class name
158159 * @param content The source code for the class
@@ -549,10 +550,10 @@ private Field field0(String name) throws ReflectException {
549550 * fields. If the wrapped object is any other {@link Object}, then this will
550551 * return instance fields.
551552 * <p>
552- * These two calls are equivalent <code><pre >
553+ * These two calls are equivalent <pre><code >
553554 * on(object).field("myField");
554555 * on(object).fields().get("myField");
555- * </pre ></code >
556+ * </code ></pre >
556557 *
557558 * @return A map containing field names and wrapped values.
558559 */
@@ -605,16 +606,16 @@ public Reflect call(String name) throws ReflectException {
605606 * Just like {@link Method#invoke(Object, Object...)}, this will try to wrap
606607 * primitive types or unwrap primitive type wrappers if applicable. If
607608 * several methods are applicable, by that rule, the first one encountered
608- * is called. i.e. when calling <code><pre >
609+ * is called. i.e. when calling <pre><code >
609610 * on(...).call("method", 1, 1);
610- * </pre ></code > The first of the following methods will be called:
611- * <code><pre >
611+ * </code ></pre > The first of the following methods will be called:
612+ * <pre><code >
612613 * public void method(int param1, Integer param2);
613614 * public void method(Integer param1, int param2);
614615 * public void method(Number param1, Number param2);
615616 * public void method(Number param1, Object param2);
616617 * public void method(int param1, Object param2);
617- * </pre ></code >
618+ * </code ></pre >
618619 * <p>
619620 * The best matching method is searched for with the following strategy:
620621 * <ol>
@@ -751,16 +752,16 @@ public Reflect create() throws ReflectException {
751752 * Just like {@link Constructor#newInstance(Object...)}, this will try to
752753 * wrap primitive types or unwrap primitive type wrappers if applicable. If
753754 * several constructors are applicable, by that rule, the first one
754- * encountered is called. i.e. when calling <code><pre >
755+ * encountered is called. i.e. when calling <pre><code >
755756 * on(C.class).create(1, 1);
756- * </pre ></code > The first of the following constructors will be applied:
757- * <code><pre >
757+ * </code ></pre > The first of the following constructors will be applied:
758+ * <pre><code >
758759 * public C(int param1, Integer param2);
759760 * public C(Integer param1, int param2);
760761 * public C(Number param1, Number param2);
761762 * public C(Number param1, Object param2);
762763 * public C(int param1, Object param2);
763- * </pre ></code >
764+ * </code ></pre >
764765 *
765766 * @param args The constructor arguments
766767 * @return The wrapped new object, to be used for further reflection.
0 commit comments