This is an automated email from the ASF dual-hosted git repository.
jamesbognar pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/juneau.git
The following commit(s) were added to refs/heads/master by this push:
new f4d08bebd9 Utility class modernization
f4d08bebd9 is described below
commit f4d08bebd980a58dd976d352ffbaa8fae11e08f2
Author: James Bognar <[email protected]>
AuthorDate: Tue Nov 4 07:17:51 2025 -0500
Utility class modernization
---
.../juneau/common/reflect/ConstructorInfo.java | 7 +-
.../juneau/common/reflect/ExecutableInfo.java | 113 +++------------------
.../apache/juneau/common/reflect/MethodInfo.java | 26 +++--
.../juneau/httppart/bean/MethodInfoUtils.java | 6 +-
.../java/org/apache/juneau/swap/SurrogateSwap.java | 2 +-
.../juneau/common/reflect/ExecutableInfo_Test.java | 24 ++---
6 files changed, 48 insertions(+), 130 deletions(-)
diff --git
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ConstructorInfo.java
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ConstructorInfo.java
index c5785d1de6..9f8771217d 100644
---
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ConstructorInfo.java
+++
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ConstructorInfo.java
@@ -129,9 +129,10 @@ public class ConstructorInfo extends ExecutableInfo
implements Comparable<Constr
if (i == 0) {
i = getParameterCount() - o.getParameterCount();
if (i == 0) {
- for (int j = 0; j < getParameterCount() && i ==
0; j++) {
- Class<?>[] tpt = _getRawParamTypes(),
opt = o._getRawParamTypes();
- i =
tpt[j].getName().compareTo(opt[j].getName());
+ var params = getParameters();
+ var oParams = o.getParameters();
+ for (int j = 0; j < params.size() && i == 0;
j++) {
+ i =
params.get(j).getParameterType().getName().compareTo(oParams.get(j).getParameterType().getName());
}
}
}
diff --git
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ExecutableInfo.java
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ExecutableInfo.java
index 2bd9d23251..c32b9a73ab 100644
---
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ExecutableInfo.java
+++
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ExecutableInfo.java
@@ -47,8 +47,6 @@ public abstract class ExecutableInfo extends AccessibleInfo {
private final Supplier<List<ClassInfo>> exceptions =
memoize(this::findExceptions);
private final Supplier<List<AnnotationInfo<Annotation>>>
declaredAnnotations = memoize(this::findDeclaredAnnotations);
- private volatile Class<?>[] rawParamTypes;
- private volatile Type[] rawGenericParamTypes;
private volatile Annotation[][] rawParameterAnnotations;
private volatile Annotation[] rawDeclaredAnnotations;
@@ -83,7 +81,7 @@ public abstract class ExecutableInfo extends AccessibleInfo {
* @return This object.
*/
public ExecutableInfo forEachParam(Predicate<ParameterInfo> filter,
Consumer<ParameterInfo> action) {
- for (var pi : _getParams())
+ for (var pi : getParameters())
if (test(filter, pi))
action.accept(pi);
return this;
@@ -238,7 +236,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
*/
public final ParameterInfo getParameter(int index) {
checkIndex(index);
- return _getParams()[index];
+ return getParameters().get(index);
}
/**
@@ -261,42 +259,6 @@ public abstract class ExecutableInfo extends
AccessibleInfo {
*/
public final List<ParameterInfo> getParameters() { return
parameters.get(); }
- /**
- * Returns the raw generic parameter type of the parameter at the
specified index.
- *
- * @param index The parameter index.
- * @return The raw generic parameter type of the parameter at the
specified index.
- */
- public final Type getRawGenericParamType(int index) {
- checkIndex(index);
- return _getRawGenericParamTypes()[index];
- }
-
- /**
- * Returns the raw generic parameter types on this executable.
- *
- * @return The raw generic parameter types on this executable.
- */
- public final List<Type> getRawGenericParamTypes() { return
u(l(_getRawGenericParamTypes())); }
-
- /**
- * Returns the raw parameter type of the parameter at the specified
index.
- *
- * @param index The parameter index.
- * @return The raw parameter type of the parameter at the specified
index.
- */
- public final Class<?> getRawParamType(int index) {
- checkIndex(index);
- return _getRawParamTypes()[index];
- }
-
- /**
- * Returns the raw parameter types on this executable.
- *
- * @return The raw parameter types on this executable.
- */
- public final List<Class<?>> getRawParamTypes() { return
u(l(_getRawParamTypes())); }
-
/**
* Returns the short name of this executable.
*
@@ -311,11 +273,11 @@ public abstract class ExecutableInfo extends
AccessibleInfo {
public final String getShortName() {
var sb = new StringBuilder(64);
sb.append(getSimpleName()).append('(');
- Class<?>[] pt = _getRawParamTypes();
- for (int i = 0; i < pt.length; i++) {
+ var params = getParameters();
+ for (int i = 0; i < params.size(); i++) {
if (i > 0)
sb.append(',');
- sb.append(pt[i].getSimpleName());
+
sb.append(params.get(i).getParameterType().getNameSimple());
}
sb.append(')');
return sb.toString();
@@ -467,10 +429,10 @@ public abstract class ExecutableInfo extends
AccessibleInfo {
* @return <jk>true</jk> if this method has this arguments in the exact
order.
*/
public final boolean hasParameterTypes(Class<?>...args) {
- Class<?>[] pt = _getRawParamTypes();
- if (pt.length == args.length) {
- for (int i = 0; i < pt.length; i++)
- if (! pt[i].equals(args[i]))
+ var params = getParameters();
+ if (params.size() == args.length) {
+ for (int i = 0; i < params.size(); i++)
+ if (!
params.get(i).getParameterType().inner().equals(args[i]))
return false;
return true;
}
@@ -484,10 +446,10 @@ public abstract class ExecutableInfo extends
AccessibleInfo {
* @return <jk>true</jk> if this method has this arguments in the exact
order.
*/
public final boolean hasParameterTypes(ClassInfo...args) {
- Class<?>[] pt = _getRawParamTypes();
- if (pt.length == args.length) {
- for (int i = 0; i < pt.length; i++)
- if (! pt[i].equals(args[i].inner()))
+ var params = getParameters();
+ if (params.size() == args.length) {
+ for (int i = 0; i < params.size(); i++)
+ if (!
params.get(i).getParameterType().inner().equals(args[i].inner()))
return false;
return true;
}
@@ -634,29 +596,6 @@ public abstract class ExecutableInfo extends
AccessibleInfo {
// Medium Priority Methods (generic type information)
//-----------------------------------------------------------------------------------------------------------------
- /**
- * Returns an array of {@link Type} objects that represent the
exceptions declared to be thrown by this executable.
- *
- * <p>
- * Returns generic type information including parameterized types,
unlike {@link #getExceptionTypes()} which returns raw types.
- *
- * <p>
- * Same as calling {@link Executable#getGenericExceptionTypes()}.
- *
- * <h5 class='section'>Example:</h5>
- * <p class='bjava'>
- * <jc>// Get generic exception types from method that throws
IOException, IllegalArgumentException</jc>
- * MethodInfo <jv>mi</jv> =
ClassInfo.<jsm>of</jsm>(MyClass.<jk>class</jk>).getMethod(<js>"myMethod"</js>);
- * Type[] <jv>exTypes</jv> =
<jv>mi</jv>.getGenericExceptionTypes();
- * </p>
- *
- * @return An array of {@link Type} objects representing exception
types, or an empty array if none.
- * @see Executable#getGenericExceptionTypes()
- */
- public final Type[] getGenericExceptionTypes() {
- return e.getGenericExceptionTypes();
- }
-
/**
* Returns a string describing this executable, including type
parameters.
*
@@ -804,10 +743,6 @@ public abstract class ExecutableInfo extends
AccessibleInfo {
return rawDeclaredAnnotations;
}
- final ClassInfo[] _getExceptionTypes() {
- return exceptions.get().toArray(new ClassInfo[0]);
- }
-
final Annotation[][] _getParameterAnnotations() {
if (rawParameterAnnotations == null) {
synchronized (this) {
@@ -860,26 +795,4 @@ public abstract class ExecutableInfo extends
AccessibleInfo {
.mapToObj(i -> new ParameterInfo(this, rp[i], i,
ClassInfo.of(ptc[i], genericTypes[i])))
.toList();
}
-
- final ParameterInfo[] _getParams() {
- return parameters.get().toArray(new ParameterInfo[0]);
- }
-
- final Type[] _getRawGenericParamTypes() {
- if (rawGenericParamTypes == null) {
- synchronized (this) {
- rawGenericParamTypes =
e.getGenericParameterTypes();
- }
- }
- return rawGenericParamTypes;
- }
-
- Class<?>[] _getRawParamTypes() {
- if (rawParamTypes == null) {
- synchronized (this) {
- rawParamTypes = e.getParameterTypes();
- }
- }
- return rawParamTypes;
- }
}
\ No newline at end of file
diff --git
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/MethodInfo.java
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/MethodInfo.java
index ba86868ac3..9aae734001 100644
---
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/MethodInfo.java
+++
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/MethodInfo.java
@@ -140,7 +140,8 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
* @return <jk>true</jk> if the method parameters only consist of the
types specified in the list.
*/
public boolean argsOnlyOfType(Class<?>...args) {
- for (var c1 : _getRawParamTypes()) {
+ for (var param : getParameters()) {
+ var c1 = param.getParameterType().inner();
boolean foundMatch = false;
for (var c2 : args)
if (c1 == c2)
@@ -191,10 +192,12 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
public int compareTo(MethodInfo o) {
int i = getSimpleName().compareTo(o.getSimpleName());
if (i == 0) {
- i = _getRawParamTypes().length -
o._getRawParamTypes().length;
+ var params = getParameters();
+ var oParams = o.getParameters();
+ i = params.size() - oParams.size();
if (i == 0) {
- for (int j = 0; j < _getRawParamTypes().length
&& i == 0; j++) {
- i =
_getRawParamTypes()[j].getName().compareTo(o._getRawParamTypes()[j].getName());
+ for (int j = 0; j < params.size() && i == 0;
j++) {
+ i =
params.get(j).getParameterType().getName().compareTo(oParams.get(j).getParameterType().getName());
}
}
}
@@ -443,14 +446,13 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
public String getSignature() {
var sb = new StringBuilder(128);
sb.append(m.getName());
- Class<?>[] pt = _getRawParamTypes();
- if (pt.length > 0) {
+ var params = getParameters();
+ if (params.size() > 0) {
sb.append('(');
- List<ParameterInfo> mpi = getParameters();
- for (int i = 0; i < pt.length; i++) {
+ for (int i = 0; i < params.size(); i++) {
if (i > 0)
sb.append(',');
-
mpi.get(i).getParameterType().appendNameFormatted(sb, ClassNameFormat.FULL,
true, '$', ClassArrayFormat.BRACKETS);
+
params.get(i).getParameterType().appendNameFormatted(sb, ClassNameFormat.FULL,
true, '$', ClassArrayFormat.BRACKETS);
}
sb.append(')');
}
@@ -467,10 +469,12 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
* @return <jk>true</jk> if this method has at least the specified
parameters.
*/
public boolean hasAllArgs(Class<?>...requiredParams) {
- List<Class<?>> rawParamTypes = getRawParamTypes();
+ var paramTypes = getParameters().stream()
+ .map(p -> p.getParameterType().inner())
+ .toList();
for (var c : requiredParams)
- if (! rawParamTypes.contains(c))
+ if (! paramTypes.contains(c))
return false;
return true;
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/httppart/bean/MethodInfoUtils.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/httppart/bean/MethodInfoUtils.java
index f200d73602..3a1b986406 100644
---
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/httppart/bean/MethodInfoUtils.java
+++
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/httppart/bean/MethodInfoUtils.java
@@ -33,10 +33,10 @@ import org.apache.juneau.common.reflect.*;
class MethodInfoUtils {
static void assertArgType(MethodInfo m, Class<? extends Annotation> a,
Class<?>...c) throws InvalidAnnotationException {
- List<Class<?>> ptt = m.getRawParamTypes();
- if (ptt.size() != 1)
+ var params = m.getParameters();
+ if (params.size() != 1)
throw new InvalidAnnotationException("Only one
parameter can be passed to method with @{0} annotation. Method=''{0}''",
scn(a), m);
- Class<?> rt = ptt.get(0);
+ Class<?> rt = params.get(0).getParameterType().inner();
for (var cc : c)
if (rt == cc)
return;
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/SurrogateSwap.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/SurrogateSwap.java
index 82de020db3..31b5ecfbe4 100644
---
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/SurrogateSwap.java
+++
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/SurrogateSwap.java
@@ -55,7 +55,7 @@ public class SurrogateSwap<T,F> extends ObjectSwap<T,F> {
List<SurrogateSwap<?,?>> l = new LinkedList<>();
var ci = ClassInfo.of(c);
ci.forEachPublicConstructor(x -> x.hasNoAnnotation(bc,
BeanIgnore.class) && x.hasNumParams(1) && x.isPublic(), x -> {
- var pt = x.getRawParamType(0);
+ var pt = x.getParameter(0).getParameterType().inner();
if (! pt.equals(c.getDeclaringClass())) {
// Find the unswap method if there is one.
var mi = ci.getPublicMethod(y ->
y.hasReturnType(pt));
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/common/reflect/ExecutableInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/common/reflect/ExecutableInfo_Test.java
index 7ca6712eab..472a985e48 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/common/reflect/ExecutableInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/common/reflect/ExecutableInfo_Test.java
@@ -191,27 +191,27 @@ class ExecutableInfo_Test extends TestBase {
}
@Test void getRawParamTypes() {
- check("", b_c1.getRawParamTypes());
- check("String", b_c2.getRawParamTypes());
- check("", b_m1.getRawParamTypes());
- check("String", b_m2.getRawParamTypes());
+ check("", b_c1.getParameters().stream().map(p ->
p.getParameterType().inner()).toList());
+ check("String", b_c2.getParameters().stream().map(p ->
p.getParameterType().inner()).toList());
+ check("", b_m1.getParameters().stream().map(p ->
p.getParameterType().inner()).toList());
+ check("String", b_m2.getParameters().stream().map(p ->
p.getParameterType().inner()).toList());
}
@Test void getRawParamType() {
- check("String", b_c2.getRawParamType(0));
- check("String", b_m2.getRawParamType(0));
+ check("String",
b_c2.getParameter(0).getParameterType().inner());
+ check("String",
b_m2.getParameter(0).getParameterType().inner());
}
@Test void getRawGenericParamType() {
- check("String", b_c2.getRawGenericParamType(0));
- check("String", b_m2.getRawGenericParamType(0));
+ check("String",
b_c2.getParameter(0).getParameterType().innerType());
+ check("String",
b_m2.getParameter(0).getParameterType().innerType());
}
@Test void getRawGenericParamTypes() {
- check("", b_c1.getRawGenericParamTypes());
- check("String", b_c2.getRawGenericParamTypes());
- check("", b_m1.getRawGenericParamTypes());
- check("String", b_m2.getRawGenericParamTypes());
+ check("", b_c1.getParameters().stream().map(p ->
p.getParameterType().innerType()).toList());
+ check("String", b_c2.getParameters().stream().map(p ->
p.getParameterType().innerType()).toList());
+ check("", b_m1.getParameters().stream().map(p ->
p.getParameterType().innerType()).toList());
+ check("String", b_m2.getParameters().stream().map(p ->
p.getParameterType().innerType()).toList());
}
@Test void getRawParameters() {
