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 3016fbbd51 Utility class cleanup
3016fbbd51 is described below
commit 3016fbbd510e56af79ac957c0c20ef420e014bd1
Author: James Bognar <[email protected]>
AuthorDate: Fri Oct 31 13:31:37 2025 -0400
Utility class cleanup
---
TODO-reflectionMigrationPlan.md | 98 ++++++----
.../org/apache/juneau/reflect/AnnotationInfo.java | 202 +++++++++++++++++++++
.../java/org/apache/juneau/reflect/ClassInfo.java | 26 +--
.../java/org/apache/juneau/reflect/MethodInfo.java | 56 +-----
4 files changed, 280 insertions(+), 102 deletions(-)
diff --git a/TODO-reflectionMigrationPlan.md b/TODO-reflectionMigrationPlan.md
index 76de713a78..f165120b64 100644
--- a/TODO-reflectionMigrationPlan.md
+++ b/TODO-reflectionMigrationPlan.md
@@ -147,14 +147,37 @@ All six classes are currently in:
## Migration Plan
-### Phase 1: Prepare juneau-common
+### Phase 1: Refactor AnnotationInfo/AnnotationList dependencies ✅ COMPLETED
+**Goal**: Remove dependencies from ClassInfo/MethodInfo on
AnnotationInfo/AnnotationList by moving annotation-related methods to
AnnotationInfo as static methods.
+
+**Methods moved from ClassInfo to AnnotationInfo:**
+1. ✅ `ClassInfo.forEachAnnotationInfo(Predicate, Consumer)` →
`AnnotationInfo.forEachAnnotationInfo(ClassInfo, Predicate, Consumer)`
+2. ✅ `ClassInfo.getAnnotationList()` →
`AnnotationInfo.getAnnotationList(ClassInfo)`
+3. ✅ `ClassInfo.getAnnotationList(Predicate)` →
`AnnotationInfo.getAnnotationList(ClassInfo, Predicate)`
+
+**Methods moved from MethodInfo to AnnotationInfo:**
+1. ✅ `MethodInfo.forEachAnnotationInfo(Predicate, Consumer)` →
`AnnotationInfo.forEachAnnotationInfo(MethodInfo, Predicate, Consumer)`
+2. ✅ `MethodInfo.getAnnotationList()` →
`AnnotationInfo.getAnnotationList(MethodInfo)`
+3. ✅ `MethodInfo.getAnnotationList(Predicate)` →
`AnnotationInfo.getAnnotationList(MethodInfo, Predicate)`
+4. ✅ `MethodInfo.getAnnotationListMethodOnly(Predicate)` →
`AnnotationInfo.getAnnotationListMethodOnly(MethodInfo, Predicate)`
+5. ✅ `MethodInfo.forEachAnnotationInfoMethodOnly(Predicate, Consumer)` →
`AnnotationInfo.forEachAnnotationInfoMethodOnly(MethodInfo, Predicate,
Consumer)`
+
+**Implementation completed:**
+1. ✅ Added static methods to AnnotationInfo that take ClassInfo/MethodInfo as
parameters
+2. ✅ Updated ClassInfo/MethodInfo to delegate to the new static methods
(maintains backward compatibility)
+3. ✅ Made `ClassInfo.splitRepeated()` and `MethodInfo.findMatchingOnClass()`
package-private for access by AnnotationInfo
+4. ✅ Removed private helper methods from MethodInfo (now in AnnotationInfo)
+5. ✅ Full project compilation successful
+
+### Phase 2: Prepare juneau-common
1. **Add getMatchingArgs() to ClassUtils**
- Extract `ClassUtils2.getMatchingArgs()` logic
- Add as public method to `org.apache.juneau.common.utils.ClassUtils`
+ - Note: Can use ClassInfo.of() since ClassInfo will be in juneau-common
- Add comprehensive javadoc
- Add unit tests in juneau-common
-### Phase 2: Update reflection classes
+### Phase 3: Move reflection classes
1. **Update imports in all 6 classes**
- Change package from `org.apache.juneau.reflect` to
`org.apache.juneau.common.reflect`
- Update `FieldInfo`: Remove unused `import org.apache.juneau.*;`
@@ -162,21 +185,20 @@ All six classes are currently in:
- Update `ConstructorInfo`: Change `ClassUtils2.getMatchingArgs()` to
`ClassUtils.getMatchingArgs()`
- Note: `ParamInfo` already fixed to use reflection for @Name
-2. **Move all 6 files**
+2. **Move all 6 files using git mv**
- Move from
`juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/`
- To
`juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/`
-### Phase 3: Create backward compatibility
+3. **Update all imports across the codebase**
+ - Update all files that import `org.apache.juneau.reflect.*` to use
`org.apache.juneau.common.reflect.*`
+
+### Phase 4: Create backward compatibility
1. **Add deprecated aliases in juneau-marshall**
- Create `@Deprecated` classes in old package `org.apache.juneau.reflect`
- - Each class extends/wraps the new location
+ - Each class extends the new location
- Point users to new location in deprecation message
-2. **Update juneau-marshall imports**
- - Update all files in juneau-marshall that import these classes
- - Change to use new package location
-
-### Phase 4: Testing & Documentation
+### Phase 5: Testing & Documentation
1. **Run all tests** to ensure nothing broke
2. **Update documentation** to reference new package
3. **Update MIGRATION.md** with notes about deprecated classes
@@ -185,48 +207,58 @@ All six classes are currently in:
### Must be resolved before migration:
-1. **ClassUtils2.getMatchingArgs()** (affects MethodInfo, ConstructorInfo)
+1. **AnnotationInfo/AnnotationList dependencies** (affects ClassInfo,
MethodInfo) - ✅ **RESOLVED**
+ - Status: Phase 1 completed successfully
+ - Solution implemented: Refactored annotation-related methods to static
methods on AnnotationInfo that take ClassInfo/MethodInfo as parameters
+ - Impact: Circular dependency removed, ClassInfo/MethodInfo can now be
moved to juneau-common
+ - Backward compatibility: Original methods now delegate to static methods,
maintaining existing API
+
+2. **ClassUtils2.getMatchingArgs()** (affects MethodInfo, ConstructorInfo)
- Current location: `org.apache.juneau.internal.ClassUtils2`
(juneau-marshall)
- Needs to be: `org.apache.juneau.common.utils.ClassUtils` (juneau-common)
- Impact: Used for smart parameter matching in reflection invoke operations
### Can be fixed during migration:
-2. **Unused import** (affects FieldInfo)
+3. **Unused import** (affects FieldInfo)
- `import org.apache.juneau.*;` appears to be unused
- Simply remove it
### ✅ Already Resolved:
-3. **@Name annotation dependency** (was affecting ParamInfo) - **FIXED**
+4. **@Name annotation dependency** (was affecting ParamInfo) - **FIXED**
- Used reflection to work with any annotation named "Name"
- No longer requires compile-time dependency on specific annotation
- Works with `@Name` from any package
## Recommended Approach
-**Option A: Complete Migration** (RECOMMENDED)
-- Resolve remaining blocker (getMatchingArgs)
-- Move getMatchingArgs() to ClassUtils
-- Then move all 6 classes together
+**Complete Migration with Refactoring** (RECOMMENDED)
+1. **Phase 1**: Refactor AnnotationInfo/AnnotationList dependencies
+ - Move annotation-related methods from ClassInfo/MethodInfo to
AnnotationInfo as static methods
+ - Update ClassInfo/MethodInfo to delegate to the new static methods (keeps
backward compatibility)
+ - This breaks the circular dependency between reflection classes and
annotation classes
+2. **Phase 2**: Add getMatchingArgs() to ClassUtils in juneau-common
+3. **Phase 3**: Move all 6 reflection classes to juneau-common
+4. **Phase 4**: Create deprecated aliases for backward compatibility
+5. **Phase 5**: Test and document
+
+**Benefits:**
- Provides full reflection capability in juneau-common
-
-**Option B: Partial Migration**
-- Move ClassInfo, ExecutableInfo, FieldInfo, ParamInfo first (ready now)
-- Leave MethodInfo, ConstructorInfo until getMatchingArgs dependency resolved
-- Requires careful dependency management
-
-**Option C: Keep Current Structure**
-- Don't move anything
-- Keep all reflection in juneau-marshall
-- Simplest but doesn't achieve the stated goal
+- Removes circular dependencies between modules
+- Maintains backward compatibility through delegation methods
+- Better separation of concerns (annotation processing vs reflection utilities)
## Next Steps
-1. **Review and approve** this plan
-2. **Decide on approach** (A, B, or C)
-3. **Implement Phase 1** (prepare juneau-common)
-4. **Implement Phase 2** (move classes)
-5. **Implement Phase 3** (backward compatibility)
-6. **Test and document**
+1. ✅ **Review and approve** this revised plan (DONE)
+2. ✅ **Implement Phase 1**: Refactor AnnotationInfo dependencies (DONE)
+ - ✅ Added static methods to AnnotationInfo that take ClassInfo/MethodInfo
as parameters
+ - ✅ Updated ClassInfo/MethodInfo to delegate to new static methods
+ - ✅ Made helper methods package-private for AnnotationInfo access
+ - ✅ Full project compilation successful
+3. **Implement Phase 2**: Add getMatchingArgs() to ClassUtils
+4. **Implement Phase 3**: Move reflection classes
+5. **Implement Phase 4**: Create backward compatibility aliases
+6. **Implement Phase 5**: Test and document
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/AnnotationInfo.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/AnnotationInfo.java
index c15902b1db..60ad8731ef 100644
---
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/AnnotationInfo.java
+++
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/AnnotationInfo.java
@@ -343,4 +343,206 @@ public class AnnotationInfo<T extends Annotation> {
}
return methods;
}
+
+
//-----------------------------------------------------------------------------------------------------------------
+ // Static methods for ClassInfo
+
//-----------------------------------------------------------------------------------------------------------------
+
+ /**
+ * Performs an action on all matching annotations on the specified
class/parents/package.
+ *
+ * <p>
+ * Annotations are consumed in the following order:
+ * <ol>
+ * <li>On the package of this class.
+ * <li>On interfaces ordered parent-to-child.
+ * <li>On parent classes ordered parent-to-child.
+ * <li>On this class.
+ * </ol>
+ *
+ * @param classInfo The class to process.
+ * @param filter A predicate to apply to the entries to determine if
action should be performed. Can be <jk>null</jk>.
+ * @param action An action to perform on the entry.
+ */
+ public static void forEachAnnotationInfo(ClassInfo classInfo,
Predicate<AnnotationInfo<?>> filter, Consumer<AnnotationInfo<?>> action) {
+ var c = classInfo.inner();
+ Package p = c.getPackage();
+ if (nn(p))
+ for (var a : p.getDeclaredAnnotations())
+ for (var a2 : classInfo.splitRepeated(a))
+ AnnotationInfo.of(p, a2).accept(filter,
action);
+ ClassInfo[] interfaces = classInfo._getInterfaces();
+ for (int i = interfaces.length - 1; i >= 0; i--)
+ for (var a :
interfaces[i].inner().getDeclaredAnnotations())
+ for (var a2 : classInfo.splitRepeated(a))
+ AnnotationInfo.of(interfaces[i],
a2).accept(filter, action);
+ ClassInfo[] parents = classInfo._getParents();
+ for (int i = parents.length - 1; i >= 0; i--)
+ for (var a :
parents[i].inner().getDeclaredAnnotations())
+ for (var a2 : classInfo.splitRepeated(a))
+ AnnotationInfo.of(parents[i],
a2).accept(filter, action);
+ }
+
+ /**
+ * Constructs an {@link AnnotationList} of all annotations found on the
specified class.
+ *
+ * <p>
+ * Annotations are appended in the following orders:
+ * <ol>
+ * <li>On the package of this class.
+ * <li>On interfaces ordered parent-to-child.
+ * <li>On parent classes ordered parent-to-child.
+ * <li>On this class.
+ * </ol>
+ *
+ * @param classInfo The class to process.
+ * @return A new {@link AnnotationList} object on every call.
+ */
+ public static AnnotationList getAnnotationList(ClassInfo classInfo) {
+ return getAnnotationList(classInfo, x -> true);
+ }
+
+ /**
+ * Constructs an {@link AnnotationList} of all matching annotations on
the specified class.
+ *
+ * <p>
+ * Annotations are appended in the following orders:
+ * <ol>
+ * <li>On the package of this class.
+ * <li>On interfaces ordered parent-to-child.
+ * <li>On parent classes ordered parent-to-child.
+ * <li>On this class.
+ * </ol>
+ *
+ * @param classInfo The class to process.
+ * @param filter A predicate to apply to the entries to determine if
value should be used. Can be <jk>null</jk>.
+ * @return A new {@link AnnotationList} object on every call.
+ */
+ public static AnnotationList getAnnotationList(ClassInfo classInfo,
Predicate<AnnotationInfo<?>> filter) {
+ var l = new AnnotationList();
+ forEachAnnotationInfo(classInfo, filter, x -> l.add(x));
+ return l;
+ }
+
+
//-----------------------------------------------------------------------------------------------------------------
+ // Static methods for MethodInfo
+
//-----------------------------------------------------------------------------------------------------------------
+
+ /**
+ * Performs an action on all matching annotations on the specified
method.
+ *
+ * @param methodInfo The method to process.
+ * @param filter A predicate to apply to the entries to determine if
action should be performed. Can be <jk>null</jk>.
+ * @param action An action to perform on the entry.
+ */
+ public static void forEachAnnotationInfo(MethodInfo methodInfo,
Predicate<AnnotationInfo<?>> filter, Consumer<AnnotationInfo<?>> action) {
+ ClassInfo c = methodInfo.getDeclaringClass();
+ forEachDeclaredAnnotationInfo(c.getPackage(), filter, action);
+ ClassInfo[] interfaces = c._getInterfaces();
+ for (int i = interfaces.length - 1; i >= 0; i--) {
+ forEachDeclaredAnnotationInfo(interfaces[i], filter,
action);
+ forEachDeclaredMethodAnnotationInfo(methodInfo,
interfaces[i], filter, action);
+ }
+ ClassInfo[] parents = c._getParents();
+ for (int i = parents.length - 1; i >= 0; i--) {
+ forEachDeclaredAnnotationInfo(parents[i], filter,
action);
+ forEachDeclaredMethodAnnotationInfo(methodInfo,
parents[i], filter, action);
+ }
+ }
+
+ /**
+ * Constructs an {@link AnnotationList} of all annotations found on the
specified method.
+ *
+ * <p>
+ * Annotations are appended in the following orders:
+ * <ol>
+ * <li>On the package of this class.
+ * <li>On interfaces ordered parent-to-child.
+ * <li>On parent classes ordered parent-to-child.
+ * <li>On this class.
+ * <li>On this method and matching methods ordered parent-to-child.
+ * </ol>
+ *
+ * @param methodInfo The method to process.
+ * @return A new {@link AnnotationList} object on every call.
+ */
+ public static AnnotationList getAnnotationList(MethodInfo methodInfo) {
+ return getAnnotationList(methodInfo, x -> true);
+ }
+
+ /**
+ * Constructs an {@link AnnotationList} of all matching annotations
found on the specified method.
+ *
+ * <p>
+ * Annotations are appended in the following orders:
+ * <ol>
+ * <li>On the package of this class.
+ * <li>On interfaces ordered parent-to-child.
+ * <li>On parent classes ordered parent-to-child.
+ * <li>On this class.
+ * <li>On this method and matching methods ordered parent-to-child.
+ * </ol>
+ *
+ * @param methodInfo The method to process.
+ * @param filter A predicate to apply to the entries to determine if
value should be added. Can be <jk>null</jk>.
+ * @return A new {@link AnnotationList} object on every call.
+ */
+ public static AnnotationList getAnnotationList(MethodInfo methodInfo,
Predicate<AnnotationInfo<?>> filter) {
+ var al = new AnnotationList();
+ forEachAnnotationInfo(methodInfo, filter, x -> al.add(x));
+ return al;
+ }
+
+ /**
+ * Same as {@link #getAnnotationList(MethodInfo, Predicate)} except
only returns annotations defined on methods.
+ *
+ * @param methodInfo The method to process.
+ * @param filter A predicate to apply to the entries to determine if
value should be added. Can be <jk>null</jk>.
+ * @return A new {@link AnnotationList} object on every call.
+ */
+ public static AnnotationList getAnnotationListMethodOnly(MethodInfo
methodInfo, Predicate<AnnotationInfo<?>> filter) {
+ var al = new AnnotationList();
+ forEachAnnotationInfoMethodOnly(methodInfo, filter, x ->
al.add(x));
+ return al;
+ }
+
+ /**
+ * Performs an action on all matching annotations on methods only.
+ *
+ * @param methodInfo The method to process.
+ * @param filter A predicate to apply to the entries to determine if
action should be performed. Can be <jk>null</jk>.
+ * @param action An action to perform on the entry.
+ */
+ public static void forEachAnnotationInfoMethodOnly(MethodInfo
methodInfo, Predicate<AnnotationInfo<?>> filter, Consumer<AnnotationInfo<?>>
action) {
+ ClassInfo c = methodInfo.getDeclaringClass();
+ ClassInfo[] interfaces = c._getInterfaces();
+ for (int i = interfaces.length - 1; i >= 0; i--)
+ forEachDeclaredMethodAnnotationInfo(methodInfo,
interfaces[i], filter, action);
+ ClassInfo[] parents = c._getParents();
+ for (int i = parents.length - 1; i >= 0; i--)
+ forEachDeclaredMethodAnnotationInfo(methodInfo,
parents[i], filter, action);
+ }
+
+
//-----------------------------------------------------------------------------------------------------------------
+ // Private helper methods
+
//-----------------------------------------------------------------------------------------------------------------
+
+ private static void forEachDeclaredAnnotationInfo(ClassInfo ci,
Predicate<AnnotationInfo<?>> filter, Consumer<AnnotationInfo<?>> action) {
+ if (nn(ci))
+ for (var a : ci._getDeclaredAnnotations())
+ AnnotationInfo.of(ci, a).accept(filter, action);
+ }
+
+ private static void forEachDeclaredAnnotationInfo(Package p,
Predicate<AnnotationInfo<?>> filter, Consumer<AnnotationInfo<?>> action) {
+ if (nn(p))
+ for (var a : p.getDeclaredAnnotations())
+ AnnotationInfo.of(p, a).accept(filter, action);
+ }
+
+ private static void forEachDeclaredMethodAnnotationInfo(MethodInfo
methodInfo, ClassInfo ci, Predicate<AnnotationInfo<?>> filter,
Consumer<AnnotationInfo<?>> action) {
+ MethodInfo mi = methodInfo.findMatchingOnClass(ci);
+ if (nn(mi))
+ for (var a : mi._getDeclaredAnnotations())
+ AnnotationInfo.of(mi, a).accept(filter, action);
+ }
}
\ No newline at end of file
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/ClassInfo.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/ClassInfo.java
index 9547672bd0..8cb99f85c7 100644
---
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/ClassInfo.java
+++
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/ClassInfo.java
@@ -223,7 +223,7 @@ public class ClassInfo {
* @param a The annotation to split if repeated.
* @return The nested annotations, or a singleton array of the same
annotation if it's not repeated.
*/
- private static Annotation[] splitRepeated(Annotation a) {
+ static Annotation[] splitRepeated(Annotation a) {
try {
var ci = ClassInfo.of(a.annotationType());
MethodInfo mi = ci.getRepeatedAnnotationMethod();
@@ -524,21 +524,7 @@ public class ClassInfo {
* @return This object.
*/
public ClassInfo forEachAnnotationInfo(Predicate<AnnotationInfo<?>>
filter, Consumer<AnnotationInfo<?>> action) {
- Package p = c.getPackage();
- if (nn(p))
- for (var a : p.getDeclaredAnnotations())
- for (var a2 : splitRepeated(a))
- AnnotationInfo.of(p, a2).accept(filter,
action);
- ClassInfo[] interfaces = _getInterfaces();
- for (int i = interfaces.length - 1; i >= 0; i--)
- for (var a : interfaces[i].c.getDeclaredAnnotations())
- for (var a2 : splitRepeated(a))
- AnnotationInfo.of(interfaces[i],
a2).accept(filter, action);
- ClassInfo[] parents = _getParents();
- for (int i = parents.length - 1; i >= 0; i--)
- for (var a : parents[i].c.getDeclaredAnnotations())
- for (var a2 : splitRepeated(a))
- AnnotationInfo.of(parents[i],
a2).accept(filter, action);
+ AnnotationInfo.forEachAnnotationInfo(this, filter, action);
return this;
}
@@ -724,7 +710,9 @@ public class ClassInfo {
*
* @return A new {@link AnnotationList} object on every call.
*/
- public AnnotationList getAnnotationList() { return getAnnotationList(x
-> true); }
+ public AnnotationList getAnnotationList() {
+ return AnnotationInfo.getAnnotationList(this);
+ }
/**
* Constructs an {@link AnnotationList} of all matching annotations on
this class.
@@ -742,9 +730,7 @@ public class ClassInfo {
* @return A new {@link AnnotationList} object on every call.
*/
public AnnotationList getAnnotationList(Predicate<AnnotationInfo<?>>
filter) {
- var l = new AnnotationList();
- forEachAnnotationInfo(filter, x -> l.add(x));
- return l;
+ return AnnotationInfo.getAnnotationList(this, filter);
}
/**
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/MethodInfo.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/MethodInfo.java
index efb87bf959..3116ac6e42 100644
---
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/MethodInfo.java
+++
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/MethodInfo.java
@@ -253,18 +253,7 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
* @return This object.
*/
public MethodInfo forEachAnnotationInfo(Predicate<AnnotationInfo<?>>
filter, Consumer<AnnotationInfo<?>> action) {
- ClassInfo c = this.declaringClass;
- forEachDeclaredAnnotationInfo(c.getPackage(), filter, action);
- ClassInfo[] interfaces = c._getInterfaces();
- for (int i = interfaces.length - 1; i >= 0; i--) {
- forEachDeclaredAnnotationInfo(interfaces[i], filter,
action);
- forEachDeclaredMethodAnnotationInfo(interfaces[i],
filter, action);
- }
- ClassInfo[] parents = c._getParents();
- for (int i = parents.length - 1; i >= 0; i--) {
- forEachDeclaredAnnotationInfo(parents[i], filter,
action);
- forEachDeclaredMethodAnnotationInfo(parents[i], filter,
action);
- }
+ AnnotationInfo.forEachAnnotationInfo(this, filter, action);
return this;
}
@@ -362,7 +351,9 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
*
* @return A new {@link AnnotationList} object on every call.
*/
- public AnnotationList getAnnotationList() { return getAnnotationList(x
-> true); }
+ public AnnotationList getAnnotationList() {
+ return AnnotationInfo.getAnnotationList(this);
+ }
/**
* Constructs an {@link AnnotationList} of all matching annotations
found on this method.
@@ -381,9 +372,7 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
* @return A new {@link AnnotationList} object on every call.
*/
public AnnotationList getAnnotationList(Predicate<AnnotationInfo<?>>
filter) {
- var al = new AnnotationList();
- forEachAnnotationInfo(filter, x -> al.add(x));
- return al;
+ return AnnotationInfo.getAnnotationList(this, filter);
}
/**
@@ -393,9 +382,7 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
* @return A new {@link AnnotationList} object on every call.
*/
public AnnotationList
getAnnotationListMethodOnly(Predicate<AnnotationInfo<?>> filter) {
- var al = new AnnotationList();
- forEachAnnotationInfoMethodOnly(filter, x -> al.add(x));
- return al;
+ return AnnotationInfo.getAnnotationListMethodOnly(this, filter);
}
/**
@@ -687,42 +674,13 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
return test(test, this);
}
- private MethodInfo findMatchingOnClass(ClassInfo c) {
+ MethodInfo findMatchingOnClass(ClassInfo c) {
for (var m2 : c._getDeclaredMethods())
if (hasName(m2.getName()) &&
Arrays.equals(_getParameterTypes(), m2._getParameterTypes()))
return m2;
return null;
}
- private void
forEachAnnotationInfoMethodOnly(Predicate<AnnotationInfo<?>> filter,
Consumer<AnnotationInfo<?>> action) {
- ClassInfo c = this.declaringClass;
- ClassInfo[] interfaces = c._getInterfaces();
- for (int i = interfaces.length - 1; i >= 0; i--)
- forEachDeclaredMethodAnnotationInfo(interfaces[i],
filter, action);
- ClassInfo[] parents = c._getParents();
- for (int i = parents.length - 1; i >= 0; i--)
- forEachDeclaredMethodAnnotationInfo(parents[i], filter,
action);
- }
-
- private static void forEachDeclaredAnnotationInfo(ClassInfo ci,
Predicate<AnnotationInfo<?>> filter, Consumer<AnnotationInfo<?>> action) {
- if (nn(ci))
- for (var a : ci._getDeclaredAnnotations())
- AnnotationInfo.of(ci, a).accept(filter, action);
- }
-
- private static void forEachDeclaredAnnotationInfo(Package p,
Predicate<AnnotationInfo<?>> filter, Consumer<AnnotationInfo<?>> action) {
- if (nn(p))
- for (var a : p.getDeclaredAnnotations())
- AnnotationInfo.of(p, a).accept(filter, action);
- }
-
- private void forEachDeclaredMethodAnnotationInfo(ClassInfo ci,
Predicate<AnnotationInfo<?>> filter, Consumer<AnnotationInfo<?>> action) {
- MethodInfo m = findMatchingOnClass(ci);
- if (nn(m))
- for (var a : m._getDeclaredAnnotations())
- AnnotationInfo.of(m, a).accept(filter, action);
- }
-
MethodInfo[] _getMatching() {
if (matching == null) {
synchronized (this) {
