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 a500f74f27 Utility class modernization
a500f74f27 is described below
commit a500f74f2792af53c1a6e7181e608fff4ad85d40
Author: James Bognar <[email protected]>
AuthorDate: Fri Nov 7 11:43:14 2025 -0500
Utility class modernization
---
.../juneau/common/reflect/AccessibleInfo.java | 14 +++---
.../apache/juneau/common/reflect/ClassInfo.java | 58 +++++++++++-----------
.../juneau/common/reflect/ExecutableInfo.java | 10 ++--
.../apache/juneau/common/reflect/FieldInfo.java | 8 +--
.../apache/juneau/common/reflect/PackageInfo.java | 2 +-
.../juneau/common/reflect/ParameterInfo.java | 12 ++---
6 files changed, 52 insertions(+), 52 deletions(-)
diff --git
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/AccessibleInfo.java
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/AccessibleInfo.java
index d1e6fdd75f..1a02cb0b71 100644
---
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/AccessibleInfo.java
+++
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/AccessibleInfo.java
@@ -32,16 +32,16 @@ import java.lang.reflect.*;
*/
public abstract class AccessibleInfo extends ElementInfo {
- AccessibleObject ao; // Effectively final
+ private final AccessibleObject inner;
/**
* Constructor.
*
- * @param ao The {@link AccessibleObject} being wrapped.
+ * @param inner The {@link AccessibleObject} being wrapped.
*/
- protected AccessibleInfo(AccessibleObject ao, int modifiers) {
+ protected AccessibleInfo(AccessibleObject inner, int modifiers) {
super(modifiers);
- this.ao = ao;
+ this.inner = inner;
}
//-----------------------------------------------------------------------------------------------------------------
@@ -55,8 +55,8 @@ public abstract class AccessibleInfo extends ElementInfo {
*/
public boolean setAccessible() {
try {
- if (nn(ao))
- ao.setAccessible(true);
+ if (nn(inner))
+ inner.setAccessible(true);
return true;
} catch (@SuppressWarnings("unused") SecurityException e) {
return false;
@@ -81,7 +81,7 @@ public abstract class AccessibleInfo extends ElementInfo {
*/
public boolean isAccessible() {
try {
- return (boolean)
AccessibleObject.class.getMethod("isAccessible").invoke(ao);
+ return (boolean)
AccessibleObject.class.getMethod("isAccessible").invoke(inner);
} catch (@SuppressWarnings("unused") Exception ex) {
return false;
}
diff --git
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ClassInfo.java
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ClassInfo.java
index 4c097af3ef..e146541421 100644
---
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ClassInfo.java
+++
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ClassInfo.java
@@ -179,8 +179,8 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
return c == null ? ClassInfo.of(o) : ClassInfo.of(c);
}
- private final Type t; // The underlying Type object (may be Class,
ParameterizedType, GenericArrayType, etc.).
- private Class<?> inner; // The underlying Class object (null for
non-class types like TypeVariable). Effectively final.
+ private final Type innerType; // The underlying Type object (may be
Class, ParameterizedType, GenericArrayType, etc.).
+ private final Class<?> inner; // The underlying Class object (null for
non-class types like TypeVariable).
private final boolean isParameterizedType; // True if this represents
a ParameterizedType (e.g., List<String>).
private final Supplier<Integer> dimensions; // Number of array
dimensions (0 if not an array).
@@ -218,14 +218,14 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
/**
* Constructor.
*
- * @param c The class type.
- * @param t The generic type (if parameterized type).
+ * @param inner The class type.
+ * @param innerType The generic type (if parameterized type).
*/
- protected ClassInfo(Class<?> c, Type t) {
- super(c == null ? 0 : c.getModifiers());
- this.t = t;
- this.inner = c;
- this.isParameterizedType = t == null ? false : (t instanceof
ParameterizedType);
+ protected ClassInfo(Class<?> inner, Type innerType) {
+ super(inner == null ? 0 : inner.getModifiers());
+ this.innerType = innerType;
+ this.inner = inner;
+ this.isParameterizedType = innerType == null ? false :
(innerType instanceof ParameterizedType);
this.dimensions = memoize(this::findDimensions);
this.componentType = memoize(this::findComponentType);
this.packageInfo = memoize(() -> opt(inner).map(x ->
PackageInfo.of(x.getPackage())).orElse(null));
@@ -278,7 +278,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
@Override
public boolean equals(Object o) {
- return (o instanceof ClassInfo o2) && eq(this, o2, (x, y) ->
eq(x.t, y.t));
+ return (o instanceof ClassInfo o2) && eq(this, o2, (x, y) ->
eq(x.innerType, y.innerType));
}
@@ -478,7 +478,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
* An unmodifiable list of all public member classes and
interfaces declared by this class.
* <br>Returns an empty list if this class has no public member
classes or interfaces.
*/
- public List<ClassInfo> getClasses() {
+ public List<ClassInfo> getMemberClasses() {
if (inner == null)
return u(l());
Class<?>[] classes = inner.getClasses();
@@ -499,7 +499,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
* An unmodifiable list of all classes and interfaces declared as
members of this class.
* <br>Returns an empty list if this class declares no classes or
interfaces as members.
*/
- public List<ClassInfo> getDeclaredClasses() {
+ public List<ClassInfo> getDeclaredMemberClasses() {
if (inner == null)
return u(l());
Class<?>[] classes = inner.getDeclaredClasses();
@@ -791,7 +791,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
*
* @return The name of the underlying class in JVM format.
*/
- public String getName() { return nn(inner) ? inner.getName() :
t.getTypeName(); }
+ public String getName() { return nn(inner) ? inner.getName() :
innerType.getTypeName(); }
/**
* Returns the canonical name of the underlying class.
@@ -1107,7 +1107,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
*
* @return The simple name of the underlying class;
*/
- public String getNameSimple() { return nn(inner) ?
inner.getSimpleName() : t.getTypeName(); }
+ public String getNameSimple() { return nn(inner) ?
inner.getSimpleName() : innerType.getTypeName(); }
/**
* Returns a formatted class name with configurable options.
@@ -1225,7 +1225,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
// Get the raw class - for ParameterizedType, extract the raw
type
var ct = inner;
if (ct == null && isParameterizedType) {
- var pt = (ParameterizedType)t;
+ var pt = (ParameterizedType)innerType;
ct = (Class<?>)pt.getRawType();
}
@@ -1243,7 +1243,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
}
}
} else {
- sb.append(t.getTypeName());
+ sb.append(innerType.getTypeName());
}
break;
@@ -1265,7 +1265,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
sb.append(ct.getSimpleName());
}
} else {
- sb.append(t.getTypeName());
+ sb.append(innerType.getTypeName());
}
break;
@@ -1274,14 +1274,14 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
if (nn(ct)) {
sb.append(ct.getSimpleName());
} else {
- sb.append(t.getTypeName());
+ sb.append(innerType.getTypeName());
}
break;
}
// Append type parameters if requested
if (includeTypeParams && isParameterizedType) {
- var pt = (ParameterizedType)t;
+ var pt = (ParameterizedType)innerType;
sb.append('<');
var first = true;
for (var t2 : pt.getActualTypeArguments()) {
@@ -1561,7 +1561,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
@Override
public int hashCode() {
- return t.hashCode();
+ return innerType.hashCode();
}
/**
@@ -1609,7 +1609,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
* @return The wrapped class as a {@link Type}.
*/
public Type innerType() {
- return t;
+ return innerType;
}
/**
@@ -1631,7 +1631,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
public boolean is(ClassInfo c) {
if (nn(this.inner))
return this.inner.equals(c.inner());
- return t.equals(c.t);
+ return innerType.equals(c.innerType);
}
/**
@@ -2146,7 +2146,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
@Override
public String toString() {
- return t.toString();
+ return innerType.toString();
}
/**
@@ -2223,11 +2223,11 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
* @return The first type parameter, or <jk>null</jk> if not
parameterized or no parameters exist.
*/
private Type getFirstParameterType(Class<?> parameterizedType) {
- if (t instanceof ParameterizedType pt) {
+ if (innerType instanceof ParameterizedType pt) {
var ta = pt.getActualTypeArguments();
if (ta.length > 0)
return ta[0];
- } else if (t instanceof Class<?> c) /* Class that extends
Optional<T> */ {
+ } else if (innerType instanceof Class<?> c) /* Class that
extends Optional<T> */ {
if (c != parameterizedType &&
parameterizedType.isAssignableFrom(c))
return ClassInfo.of(c).getParameterType(0,
parameterizedType);
}
@@ -2241,7 +2241,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
* @return <jk>true</jk> if this is Optional<T> or a subclass
like MyOptional extends Optional<String>.
*/
private boolean isParameterizedTypeOf(Class<?> c) {
- return (t instanceof ParameterizedType t2 && t2.getRawType() ==
c) || (t instanceof Class && c.isAssignableFrom((Class<?>)t));
+ return (innerType instanceof ParameterizedType t2 &&
t2.getRawType() == c) || (innerType instanceof Class &&
c.isAssignableFrom((Class<?>)innerType));
}
/**
@@ -2301,7 +2301,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
private int findDimensions() {
int d = 0;
- Type ct = t;
+ Type ct = innerType;
// Handle GenericArrayType (e.g., List<String>[])
while (ct instanceof GenericArrayType gat) {
@@ -2320,7 +2320,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
}
private ClassInfo findComponentType() {
- Type ct = t;
+ Type ct = innerType;
Class<?> cc = inner;
// Handle GenericArrayType (e.g., List<String>[])
@@ -2334,7 +2334,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
}
// Return the deepest component type found
- if (ct != t) {
+ if (ct != innerType) {
return of(ct);
} else if (cc != inner) {
return of(cc);
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 86b8901376..d506fb79bf 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
@@ -55,13 +55,13 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
* Constructor.
*
* @param declaringClass The class that declares this method or
constructor.
- * @param e The constructor or method that this info represents.
+ * @param inner The constructor or method that this info represents.
*/
- protected ExecutableInfo(ClassInfo declaringClass, Executable e) {
- super(e, e.getModifiers());
+ protected ExecutableInfo(ClassInfo declaringClass, Executable inner) {
+ super(inner, inner.getModifiers());
this.declaringClass = declaringClass;
- this.inner = e;
- this.isConstructor = e instanceof Constructor;
+ this.inner = inner;
+ this.isConstructor = inner instanceof Constructor;
this.parameters = memoize(this::findParameters);
this.exceptions = memoize(() ->
stream(inner.getExceptionTypes()).map(ClassInfo::of).toList());
this.declaredAnnotations = memoize(() ->
stream(inner.getDeclaredAnnotations()).map(a ->
AnnotationInfo.of((Annotatable)this, a)).toList());
diff --git
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/FieldInfo.java
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/FieldInfo.java
index 1bc43a8cf7..612ec69fa3 100644
---
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/FieldInfo.java
+++
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/FieldInfo.java
@@ -44,13 +44,13 @@ public class FieldInfo extends AccessibleInfo implements
Comparable<FieldInfo>,
* Convenience method for instantiating a {@link FieldInfo};
*
* @param declaringClass The class that declares this method.
- * @param f The field being wrapped.
+ * @param inner The field being wrapped.
* @return A new {@link FieldInfo} object, or <jk>null</jk> if the
field was null.
*/
- public static FieldInfo of(ClassInfo declaringClass, Field f) {
- if (f == null)
+ public static FieldInfo of(ClassInfo declaringClass, Field inner) {
+ if (inner == null)
return null;
- return ClassInfo.of(declaringClass).getFieldInfo(f);
+ return ClassInfo.of(declaringClass).getFieldInfo(inner);
}
/**
diff --git
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/PackageInfo.java
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/PackageInfo.java
index 555b9c3f2c..43eb71a446 100644
---
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/PackageInfo.java
+++
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/PackageInfo.java
@@ -81,7 +81,7 @@ public class PackageInfo implements Annotatable {
// Instance
//-----------------------------------------------------------------------------------------------------------------
- private Package inner; // Effectively final
+ private final Package inner;
private final Supplier<List<AnnotationInfo<Annotation>>> annotations;
// All annotations on this package, wrapped in AnnotationInfo. Repeated
annotations have been unwrapped and are present as individual instances.
/**
diff --git
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ParameterInfo.java
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ParameterInfo.java
index 9a57a7011e..33f410294d 100644
---
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ParameterInfo.java
+++
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ParameterInfo.java
@@ -69,16 +69,16 @@ public class ParameterInfo extends ElementInfo implements
Annotatable {
/**
* Constructor.
*
- * @param eInfo The constructor or method wrapper.
- * @param p The parameter being wrapped.
+ * @param executable The constructor or method wrapper.
+ * @param inner The parameter being wrapped.
* @param index The parameter index.
* @param type The parameter type.
*/
// TODO - Investigate if we can construct ClassInfo directly from
parameter.
- protected ParameterInfo(ExecutableInfo eInfo, Parameter p, int index,
ClassInfo type) {
- super(p.getModifiers());
- this.executable = eInfo;
- this.inner = p;
+ protected ParameterInfo(ExecutableInfo executable, Parameter inner, int
index, ClassInfo type) {
+ super(inner.getModifiers());
+ this.executable = executable;
+ this.inner = inner;
this.index = index;
this.type = type;
this.annotations = memoize(() ->
stream(inner.getAnnotations()).map(a -> AnnotationInfo.of(this, a)).toList());
