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 25fe25a67d New BeanCreator API
25fe25a67d is described below
commit 25fe25a67d566c8abf827e288e1574992940821a
Author: James Bognar <[email protected]>
AuthorDate: Wed Jan 21 09:59:14 2026 -0500
New BeanCreator API
---
AI.md | 113 +++++++++++++++-
.../annotation/AppliedAnnotationObject.java | 32 ++---
.../juneau/commons/concurrent/SimpleLock.java | 129 +++++++++++++++++-
.../commons/concurrent/SimpleReadWriteLock.java | 149 +++++++++++++++++++--
.../apache/juneau/commons/inject/BeanCreator2.java | 12 +-
.../juneau/commons/reflect/AnnotationInfo.java | 2 +-
.../juneau/commons/reflect/ConstructorInfo.java | 4 +-
.../juneau/commons/reflect/ExecutableInfo.java | 18 +--
.../apache/juneau/commons/reflect/FieldInfo.java | 2 +-
.../apache/juneau/commons/reflect/MethodInfo.java | 4 +-
.../juneau/commons/reflect/ParameterInfo.java | 4 +-
.../apache/juneau/commons/utils/StringUtils.java | 4 +-
.../src/main/java/org/apache/juneau/BeanMap.java | 2 +-
.../src/main/java/org/apache/juneau/BeanMeta.java | 8 +-
.../src/main/java/org/apache/juneau/ClassMeta.java | 4 +-
.../juneau/httppart/bean/RequestBeanMeta.java | 2 +-
.../java/org/apache/juneau/reflect/Mutaters.java | 6 +-
.../java/org/apache/juneau/rest/RestContext.java | 6 +-
.../java/org/apache/juneau/rest/RestOpInvoker.java | 2 +-
.../org/apache/juneau/rest/arg/ArgException.java | 2 +-
.../juneau/rest/debug/BasicDebugEnablement.java | 2 +-
.../apache/juneau/rest/stats/MethodInvoker.java | 2 +-
.../commons/reflect/AnnotationInfo_Test.java | 2 +-
.../juneau/commons/reflect/ClassInfo_Test.java | 4 +-
.../commons/reflect/ConstructorInfo_Test.java | 10 +-
.../commons/reflect/ExecutableInfo_Test.java | 36 ++---
.../juneau/commons/reflect/FieldInfo_Test.java | 12 +-
.../juneau/commons/reflect/MethodInfo_Test.java | 16 +--
.../juneau/commons/reflect/ParameterInfo_Test.java | 2 +-
29 files changed, 477 insertions(+), 114 deletions(-)
diff --git a/AI.md b/AI.md
index b796218777..db5b83a201 100644
--- a/AI.md
+++ b/AI.md
@@ -1051,9 +1051,10 @@ public class BeanName_Test extends TestBase {
**Key Points:**
- Use `@Nested` inner classes for major test categories
-- Each nested class name follows the pattern: `L_categoryName`
-- Tests within nested classes still use `LNN_testName` pattern
-- The letter in the nested class name matches the letter in the test method
names
+- Each nested class name follows the pattern: `L_categoryName` where L is an
uppercase letter (A, B, C, etc.)
+- Tests within nested classes use `l##_testName` pattern where l is the
lowercase letter matching the nested class (a, b, c, etc.) and ## is an
incrementing number (01, 02, 03, etc.)
+- The letter in the nested class name matches the letter in the test method
names (uppercase for class, lowercase for methods)
+- Each nested class extends `TestBase` to inherit test utilities and setup
### Common Test Categories
@@ -1246,6 +1247,112 @@ In all cases, `assertBean` should be used to validate
results.
- Use descriptive test method names
- Follow consistent test structure across all test classes
+### Test Helper Class Naming Convention
+
+**Rule**: For test helper classes that are only used by one test, prefix the
class name with the test method prefix and move it immediately above the test
that uses it.
+
+**Naming Pattern**: `LNN_ClassName` where:
+- **L** is the uppercase letter matching the test method prefix (A, B, C, etc.)
+- **NN** is the two-digit number matching the test method number (01, 02, 03,
etc.)
+- **ClassName** is the descriptive class name
+
+**Placement**: Move the helper class definition to immediately above the test
method that uses it.
+
+**Examples**:
+```java
+// WRONG - Generic name, defined far from usage
+public static class BeanWithDeprecatedGetInstance {
+ // ...
+}
+
+@Test
+void c03_createBeanIgnoresDeprecatedGetInstance() {
+ var bean = bc(BeanWithDeprecatedGetInstance.class).run();
+ // ...
+}
+
+// CORRECT - Prefixed with test name, placed above test
+@Test
+void c03_createBeanIgnoresDeprecatedGetInstance() {
+ // Bean with both deprecated and valid getInstance methods
+ public static class C03_BeanWithDeprecatedGetInstance {
+ private static final C03_BeanWithDeprecatedGetInstance INSTANCE = new
C03_BeanWithDeprecatedGetInstance();
+ // ...
+ }
+
+ var bean = bc(C03_BeanWithDeprecatedGetInstance.class).run();
+ // ...
+}
+```
+
+**Rationale**:
+- Makes it immediately clear which test uses the helper class
+- Reduces namespace pollution by scoping helper classes to their tests
+- Improves code locality by keeping related code together
+- Makes it easier to identify unused helper classes
+
+**When to Apply**:
+- Only apply this convention to helper classes used by a single test
+- Classes used by multiple tests should keep their generic names
+- Classes used across nested test classes should remain at the nested class
level
+
+### Test State Capture Utilities
+
+**Purpose**: Use proper utility classes instead of arrays for capturing
mutable state in lambdas and test scenarios.
+
+**Rules**:
+1. **Use `Flag` for boolean state**: Instead of `new boolean[]{false}`, use
`Flag.create()` for capturing boolean flags in lambdas and test hooks.
+2. **Use `IntegerValue` for integer counters**: Instead of `new int[]{0}`, use
`IntegerValue.create()` for capturing integer counts in lambdas and test hooks.
+
+**Examples**:
+```java
+// WRONG - Using arrays for state capture
+var hookCalled = new boolean[]{false};
+bc(SimpleBean.class)
+ .postCreateHook(b -> hookCalled[0] = true)
+ .run();
+assertTrue(hookCalled[0]);
+
+var callCount = new int[]{0};
+bc(SimpleBean.class)
+ .postCreateHook(b -> callCount[0]++)
+ .run();
+assertEquals(1, callCount[0]);
+
+// CORRECT - Using Flag and IntegerValue
+var hookCalled = Flag.create();
+bc(SimpleBean.class)
+ .postCreateHook(b -> hookCalled.set())
+ .run();
+assertTrue(hookCalled.isSet());
+
+var callCount = IntegerValue.create();
+bc(SimpleBean.class)
+ .postCreateHook(b -> callCount.increment())
+ .run();
+assertEquals(1, callCount.get());
+```
+
+**Flag Methods**:
+- `Flag.create()` - Creates a flag initialized to `false`
+- `flag.set()` - Sets the flag to `true`
+- `flag.isSet()` - Returns `true` if flag is set
+- `flag.isUnset()` - Returns `true` if flag is not set
+- `flag.setIf(condition)` - Sets flag if condition is `true`
+
+**IntegerValue Methods**:
+- `IntegerValue.create()` - Creates an integer initialized to `0`
+- `counter.increment()` - Increments by 1
+- `counter.get()` - Returns the current value
+- `counter.getAndIncrement()` - Returns current value then increments
+- `counter.incrementAndGet()` - Increments then returns new value
+
+**Rationale**:
+- Provides cleaner, more readable code than array access patterns
+- Better type safety and API design
+- Consistent with Apache Juneau utility class patterns
+- Makes test code more maintainable and easier to understand
+
### Documentation
- Include javadoc for test methods explaining their purpose
- Document any special test scenarios or edge cases
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/annotation/AppliedAnnotationObject.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/annotation/AppliedAnnotationObject.java
index a90dc7924c..b97ba43905 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/annotation/AppliedAnnotationObject.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/annotation/AppliedAnnotationObject.java
@@ -216,7 +216,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderC on(Constructor<?>...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(info(v).getFullName());
+ on(info(v).getNameFull());
return this;
}
@@ -229,7 +229,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderC on(ConstructorInfo...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(v.getFullName());
+ on(v.getNameFull());
return this;
}
}
@@ -276,7 +276,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderM on(Method...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(info(v).getFullName());
+ on(info(v).getNameFull());
return this;
}
@@ -289,7 +289,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderM on(MethodInfo...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(v.getFullName());
+ on(v.getNameFull());
return this;
}
}
@@ -339,7 +339,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderMF on(Field...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(info(v).getFullName());
+ on(info(v).getNameFull());
return this;
}
@@ -352,7 +352,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderMF on(FieldInfo...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(v.getFullName());
+ on(v.getNameFull());
return this;
}
@@ -365,7 +365,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderMF on(Method...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(info(v).getFullName());
+ on(info(v).getNameFull());
return this;
}
@@ -378,7 +378,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderMF on(MethodInfo...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(v.getFullName());
+ on(v.getNameFull());
return this;
}
}
@@ -516,7 +516,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderTM on(Method...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(info(v).getFullName());
+ on(info(v).getNameFull());
return this;
}
@@ -529,7 +529,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderTM on(MethodInfo...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(v.getFullName());
+ on(v.getNameFull());
return this;
}
@@ -584,7 +584,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderTMF on(Field...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(info(v).getFullName());
+ on(info(v).getNameFull());
return this;
}
@@ -597,7 +597,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderTMF on(FieldInfo...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(v.getFullName());
+ on(v.getNameFull());
return this;
}
@@ -610,7 +610,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderTMF on(Method...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(info(v).getFullName());
+ on(info(v).getNameFull());
return this;
}
@@ -623,7 +623,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderTMF on(MethodInfo...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(v.getFullName());
+ on(v.getNameFull());
return this;
}
}
@@ -667,7 +667,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderTMFC on(Constructor<?>...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(info(v).getFullName());
+ on(info(v).getNameFull());
return this;
}
@@ -680,7 +680,7 @@ public class AppliedAnnotationObject extends
AnnotationObject {
public BuilderTMFC on(ConstructorInfo...value) {
assertArgNoNulls("value", value);
for (var v : value)
- on(v.getFullName());
+ on(v.getNameFull());
return this;
}
}
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/concurrent/SimpleLock.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/concurrent/SimpleLock.java
index cb5c0fdcdb..3c6c8587a8 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/concurrent/SimpleLock.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/concurrent/SimpleLock.java
@@ -21,12 +21,84 @@ import static org.apache.juneau.commons.utils.Utils.*;
import java.util.concurrent.locks.*;
/**
- * A simple auto-closeable wrapper around a lock.
+ * A simple auto-closeable wrapper around a {@link Lock} that automatically
acquires the lock
+ * when created and releases it when closed.
+ *
+ * <p>
+ * This class wraps any {@link Lock} implementation and makes it work
seamlessly with try-with-resources
+ * statements. The lock is automatically acquired in the constructor and
released when {@link #close()}
+ * is called (either explicitly or automatically via try-with-resources).
+ *
+ * <p>
+ * This class is typically used indirectly through {@link
SimpleReadWriteLock#read()} and
+ * {@link SimpleReadWriteLock#write()}, but can also be used directly with any
{@link Lock} instance.
+ *
+ * <h5 class='section'>Example:</h5>
+ * <p class='bjava'>
+ * <jc>// Using with a ReentrantLock</jc>
+ * <jk>var</jk> <jv>lock</jv> = <jk>new</jk> ReentrantLock();
+ * <jk>try</jk> (<jk>var</jk> <jv>simpleLock</jv> = <jk>new</jk>
SimpleLock(<jv>lock</jv>)) {
+ * <jc>// Lock is automatically held - perform critical section
operations</jc>
+ * <jv>sharedResource</jv>.modify();
+ * }
+ * <jc>// Lock is automatically released when exiting try block</jc>
+ *
+ * <jc>// Using with SimpleReadWriteLock</jc>
+ * <jk>var</jk> <jv>rwLock</jv> = <jk>new</jk> SimpleReadWriteLock();
+ * <jk>try</jk> (<jk>var</jk> <jv>readLock</jv> = <jv>rwLock</jv>.read()) {
+ * <jc>// Read lock is automatically held</jc>
+ * <jv>sharedResource</jv>.read();
+ * }
+ * <jc>// Read lock is automatically released</jc>
+ * </p>
+ *
+ * <h5 class='section'>Thread Safety:</h5>
+ * <p>
+ * This class is not thread-safe itself. Each instance wraps a single {@link
Lock} and should be used
+ * by a single thread. The underlying lock's thread-safety guarantees apply to
the wrapped lock.
+ *
+ * <h5 class='section'>Notes:</h5><ul>
+ * <li class='note'>The lock is automatically acquired in the constructor
and released in {@link #close()}.
+ * <li class='note'>If <jk>null</jk> is passed to the constructor, no
locking operations are performed
+ * (useful for creating no-op locks).
+ * <li class='note'>This class implements {@link AutoCloseable}, making it
ideal for use with
+ * try-with-resources statements.
+ * <li class='note'>Multiple calls to {@link #close()} are safe -
subsequent calls have no effect if
+ * the lock has already been released.
+ * <li class='note'>The underlying lock's reentrancy behavior is preserved
- if the lock supports
+ * reentrant locking, the same thread can acquire it multiple
times.
+ * </ul>
+ *
+ * <h5 class='section'>See Also:</h5><ul>
+ * <li class='jc'>{@link SimpleReadWriteLock} - A read-write lock that
returns {@link SimpleLock} instances
+ * <li class='jc'>{@link Lock} - The underlying lock interface
+ * </ul>
*/
public class SimpleLock implements AutoCloseable {
/**
- * A simple no-op lock.
+ * A no-op lock instance that performs no actual locking operations.
+ *
+ * <p>
+ * This instance can be used when locking is conditionally disabled or
when you need a
+ * {@link SimpleLock} instance but don't want any actual
synchronization overhead.
+ * All lock operations on this instance are no-ops.
+ *
+ * <h5 class='section'>Example:</h5>
+ * <p class='bjava'>
+ * <jc>// Use NO_OP when locking is disabled</jc>
+ * <jk>var</jk> <jv>lock</jv> = isLockingEnabled() ? <jk>new</jk>
SimpleLock(<jk>new</jk> ReentrantLock()) : SimpleLock.NO_OP;
+ * <jk>try</jk> (<jk>var</jk> <jv>simpleLock</jv> = <jv>lock</jv>)
{
+ * <jc>// Code works the same whether locking is enabled
or not</jc>
+ * <jv>sharedResource</jv>.modify();
+ * }
+ * </p>
+ *
+ * <h5 class='section'>Notes:</h5><ul>
+ * <li class='note'>Calling {@link #close()} on this instance has
no effect.
+ * <li class='note'>This instance is thread-safe and can be shared
across threads.
+ * <li class='note'>This instance wraps a <jk>null</jk> lock, so
no actual locking occurs.
+ * </ul>
*/
public static final SimpleLock NO_OP = new SimpleLock(null);
@@ -35,7 +107,30 @@ public class SimpleLock implements AutoCloseable {
/**
* Constructor.
*
- * @param lock The lock being wrapped.
+ * <p>
+ * Creates a new {@link SimpleLock} wrapper around the specified {@link
Lock}. The lock is
+ * automatically acquired during construction. If <jk>null</jk> is
passed, no locking operations
+ * are performed (useful for creating no-op locks).
+ *
+ * <h5 class='section'>Example:</h5>
+ * <p class='bjava'>
+ * <jc>// Wrap a ReentrantLock</jc>
+ * <jk>var</jk> <jv>underlyingLock</jv> = <jk>new</jk>
ReentrantLock();
+ * <jk>var</jk> <jv>simpleLock</jv> = <jk>new</jk>
SimpleLock(<jv>underlyingLock</jv>);
+ * <jc>// Lock is now held - use try-with-resources to ensure
release</jc>
+ * <jk>try</jk> (<jv>simpleLock</jv>) {
+ * <jc>// Critical section</jc>
+ * }
+ * </p>
+ *
+ * <h5 class='section'>Notes:</h5><ul>
+ * <li class='note'>The lock is acquired immediately in the
constructor. This method may block
+ * if the lock is not available.
+ * <li class='note'>If <jk>null</jk> is passed, no lock is
acquired and {@link #close()} will have no effect.
+ * <li class='note'>The underlying lock's behavior (fairness,
reentrancy, etc.) is preserved.
+ * </ul>
+ *
+ * @param lock The {@link Lock} being wrapped. Can be <jk>null</jk> to
create a no-op lock.
*/
public SimpleLock(Lock lock) {
this.lock = lock;
@@ -43,6 +138,34 @@ public class SimpleLock implements AutoCloseable {
lock.lock();
}
+ /**
+ * Releases the lock.
+ *
+ * <p>
+ * This method is called automatically when used in a
try-with-resources statement, or can be
+ * called explicitly to release the lock early. If the lock was
<jk>null</jk> (no-op lock),
+ * this method has no effect.
+ *
+ * <h5 class='section'>Example:</h5>
+ * <p class='bjava'>
+ * <jk>var</jk> <jv>lock</jv> = <jk>new</jk>
SimpleLock(<jk>new</jk> ReentrantLock());
+ * <jc>// Lock is held</jc>
+ * <jv>lock</jv>.close(); <jc>// Explicitly release the lock</jc>
+ * </p>
+ *
+ * <h5 class='section'>Notes:</h5><ul>
+ * <li class='note'>This method is called automatically when
exiting a try-with-resources block.
+ * <li class='note'>Multiple calls to this method are safe -
subsequent calls have no effect if
+ * the lock has already been released.
+ * <li class='note'>If the lock was <jk>null</jk> (no-op lock),
this method returns immediately
+ * without performing any operations.
+ * <li class='note'>The underlying lock's unlock behavior is
preserved (e.g., reentrant locks
+ * must be unlocked the same number of times they were
locked).
+ * </ul>
+ *
+ * @throws IllegalMonitorStateException If the current thread does not
hold this lock
+ * (only applies to certain lock implementations).
+ */
@Override
public void close() {
if (nn(lock))
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/concurrent/SimpleReadWriteLock.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/concurrent/SimpleReadWriteLock.java
index 5d6d222c9d..146e751213 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/concurrent/SimpleReadWriteLock.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/concurrent/SimpleReadWriteLock.java
@@ -20,12 +20,84 @@ import java.util.concurrent.locks.*;
/**
* An extension of {@link ReentrantReadWriteLock} with convenience methods for
creating
- * auto-closeable locks.
+ * auto-closeable locks that work seamlessly with try-with-resources
statements.
+ *
+ * <p>
+ * This class provides a simpler API than the standard {@link
ReentrantReadWriteLock} by wrapping
+ * read and write locks in {@link SimpleLock} instances that implement {@link
AutoCloseable}.
+ * This allows locks to be automatically released when used in
try-with-resources blocks, reducing
+ * the risk of forgetting to unlock and preventing deadlocks.
+ *
+ * <p>
+ * The returned {@link SimpleLock} instances automatically acquire the lock
when created and release
+ * it when {@link SimpleLock#close()} is called (either explicitly or
automatically via try-with-resources).
+ *
+ * <h5 class='section'>Example:</h5>
+ * <p class='bjava'>
+ * <jc>// Using read lock with try-with-resources</jc>
+ * <jk>var</jk> <jv>lock</jv> = <jk>new</jk> SimpleReadWriteLock();
+ * <jk>try</jk> (<jk>var</jk> <jv>readLock</jv> = <jv>lock</jv>.read()) {
+ * <jc>// Read operations here - lock is automatically held</jc>
+ * <jv>sharedResource</jv>.read();
+ * }
+ * <jc>// Lock is automatically released when exiting try block</jc>
+ *
+ * <jc>// Using write lock with try-with-resources</jc>
+ * <jk>try</jk> (<jk>var</jk> <jv>writeLock</jv> = <jv>lock</jv>.write()) {
+ * <jc>// Write operations here - lock is automatically held</jc>
+ * <jv>sharedResource</jv>.write(<js>"new value"</js>);
+ * }
+ * <jc>// Lock is automatically released when exiting try block</jc>
+ * </p>
+ *
+ * <h5 class='section'>Thread Safety:</h5>
+ * <p>
+ * This class inherits all thread-safety guarantees from {@link
ReentrantReadWriteLock}.
+ * Multiple threads can hold read locks simultaneously, but write locks are
exclusive.
+ * Read and write locks cannot be held simultaneously by different threads.
+ *
+ * <h5 class='section'>Notes:</h5><ul>
+ * <li class='note'>The returned {@link SimpleLock} instances are not
thread-safe themselves and should
+ * not be shared between threads. Each thread should call {@link
#read()} or {@link #write()} separately.
+ * <li class='note'>Each call to {@link #read()} or {@link #write()}
returns a new {@link SimpleLock} instance.
+ * <li class='note'>The lock is automatically acquired when {@link
SimpleLock} is created and released when
+ * {@link SimpleLock#close()} is called.
+ * <li class='note'>This class supports reentrant locking - the same
thread can acquire multiple read locks
+ * or upgrade from read to write lock (if no other threads hold
read locks).
+ * <li class='note'>For fair ordering, use {@link
#SimpleReadWriteLock(boolean)} with <jk>true</jk>.
+ * </ul>
+ *
+ * <h5 class='section'>See Also:</h5><ul>
+ * <li class='jc'>{@link SimpleLock} - The auto-closeable lock wrapper
+ * <li class='jc'>{@link ReentrantReadWriteLock} - The underlying lock
implementation
+ * </ul>
*/
public class SimpleReadWriteLock extends ReentrantReadWriteLock {
private static final long serialVersionUID = 1L;
+
/**
- * A no-op lock.
+ * A no-op lock instance that performs no actual locking operations.
+ *
+ * <p>
+ * This instance can be used when locking is conditionally disabled or
when you need a
+ * {@link SimpleReadWriteLock} instance but don't want any actual
synchronization overhead.
+ * All lock operations on this instance are no-ops and return {@link
SimpleLock#NO_OP}.
+ *
+ * <h5 class='section'>Example:</h5>
+ * <p class='bjava'>
+ * <jc>// Use NO_OP when locking is disabled</jc>
+ * <jk>var</jk> <jv>lock</jv> = isLockingEnabled() ? <jk>new</jk>
SimpleReadWriteLock() : SimpleReadWriteLock.NO_OP;
+ * <jk>try</jk> (<jk>var</jk> <jv>readLock</jv> =
<jv>lock</jv>.read()) {
+ * <jc>// Code works the same whether locking is enabled
or not</jc>
+ * <jv>sharedResource</jv>.read();
+ * }
+ * </p>
+ *
+ * <h5 class='section'>Notes:</h5><ul>
+ * <li class='note'>Calling {@link #read()} or {@link #write()} on
this instance returns {@link SimpleLock#NO_OP}.
+ * <li class='note'>Closing the returned {@link SimpleLock} has no
effect.
+ * <li class='note'>This instance is thread-safe and can be shared
across threads.
+ * </ul>
*/
public static SimpleReadWriteLock NO_OP = new SimpleReadWriteLock() {
private static final long serialVersionUID = 1L;
@@ -43,31 +115,92 @@ public class SimpleReadWriteLock extends
ReentrantReadWriteLock {
/**
* Constructor.
+ *
+ * <p>
+ * Creates a new read-write lock with an unfair ordering policy. Unfair
locks generally
+ * provide better throughput under high contention but may not
guarantee fairness.
*/
public SimpleReadWriteLock() {}
/**
- * Constructor
+ * Constructor.
+ *
+ * <p>
+ * Creates a new read-write lock with the specified fairness policy.
*
- * @param fair <jk>true</jk> if this lock should use a fair ordering
policy.
+ * <h5 class='section'>Fair vs Unfair:</h5><ul>
+ * <li class='note'><b>Fair locks</b> (<jk>true</jk>): Threads
acquire locks in approximately
+ * FIFO order. Provides fairness but may have lower
throughput under high contention.
+ * <li class='note'><b>Unfair locks</b> (<jk>false</jk>): No
ordering guarantee. Generally provides
+ * better throughput but may starve some threads under
high contention.
+ * </ul>
+ *
+ * @param fair <jk>true</jk> if this lock should use a fair ordering
policy, <jk>false</jk> for unfair.
*/
public SimpleReadWriteLock(boolean fair) {
super(fair);
}
/**
- * Construct a read lock.
+ * Acquires and returns a read lock.
+ *
+ * <p>
+ * The returned {@link SimpleLock} automatically acquires the read lock
when created and releases
+ * it when {@link SimpleLock#close()} is called. Multiple threads can
hold read locks simultaneously,
+ * but a write lock cannot be acquired while any read locks are held.
*
- * @return A new closeable read lock.
+ * <h5 class='section'>Example:</h5>
+ * <p class='bjava'>
+ * <jk>var</jk> <jv>lock</jv> = <jk>new</jk> SimpleReadWriteLock();
+ * <jk>try</jk> (<jk>var</jk> <jv>readLock</jv> =
<jv>lock</jv>.read()) {
+ * <jc>// Multiple threads can hold read locks
simultaneously</jc>
+ * <jv>sharedResource</jv>.read();
+ * }
+ * <jc>// Lock is automatically released</jc>
+ * </p>
+ *
+ * <h5 class='section'>Notes:</h5><ul>
+ * <li class='note'>This method blocks until the read lock can be
acquired.
+ * <li class='note'>Multiple threads can hold read locks
concurrently.
+ * <li class='note'>Read locks cannot be acquired while a write
lock is held by another thread.
+ * <li class='note'>The same thread can acquire multiple read
locks (reentrant).
+ * <li class='note'>Each call returns a new {@link SimpleLock}
instance.
+ * </ul>
+ *
+ * @return A new {@link SimpleLock} that holds the read lock. The lock
is automatically acquired.
*/
public SimpleLock read() {
return new SimpleLock(readLock());
}
/**
- * Construct a write lock.
+ * Acquires and returns a write lock.
+ *
+ * <p>
+ * The returned {@link SimpleLock} automatically acquires the write
lock when created and releases
+ * it when {@link SimpleLock#close()} is called. Write locks are
exclusive - only one thread can
+ * hold a write lock at a time, and no read locks can be held while a
write lock is active.
+ *
+ * <h5 class='section'>Example:</h5>
+ * <p class='bjava'>
+ * <jk>var</jk> <jv>lock</jv> = <jk>new</jk> SimpleReadWriteLock();
+ * <jk>try</jk> (<jk>var</jk> <jv>writeLock</jv> =
<jv>lock</jv>.write()) {
+ * <jc>// Only one thread can hold a write lock at a
time</jc>
+ * <jv>sharedResource</jv>.write(<js>"new value"</js>);
+ * }
+ * <jc>// Lock is automatically released</jc>
+ * </p>
+ *
+ * <h5 class='section'>Notes:</h5><ul>
+ * <li class='note'>This method blocks until the write lock can be
acquired.
+ * <li class='note'>Write locks are exclusive - only one thread
can hold a write lock at a time.
+ * <li class='note'>Write locks cannot be acquired while any read
locks are held by other threads.
+ * <li class='note'>Read locks cannot be acquired while a write
lock is held.
+ * <li class='note'>The same thread can acquire multiple write
locks (reentrant).
+ * <li class='note'>Each call returns a new {@link SimpleLock}
instance.
+ * </ul>
*
- * @return A new closeable write lock.
+ * @return A new {@link SimpleLock} that holds the write lock. The lock
is automatically acquired.
*/
public SimpleLock write() {
return new SimpleLock(writeLock());
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanCreator2.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanCreator2.java
index a57e73ca4b..0c5ee1071b 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanCreator2.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanCreator2.java
@@ -1072,7 +1072,7 @@ public class BeanCreator2<T> {
.sorted(methodComparator)
.findFirst()
.map(x -> {
- log("Found builder method: %s",
x.getFullName());
+ log("Found builder method: %s",
x.getNameFull());
return (T)beanType.cast(x.inject(store,
builder));
})
.orElse((T)null);
@@ -1089,7 +1089,7 @@ public class BeanCreator2<T> {
.sorted(methodComparator)
.findFirst()
.map(x -> {
- log("Found factory method
accepting builder: %s", x.getFullName());
+ log("Found factory method
accepting builder: %s", x.getNameFull());
return
(T)beanType.cast(x.inject(store, null, builder));
})
.orElse(null);
@@ -1105,7 +1105,7 @@ public class BeanCreator2<T> {
.sorted(constructorComparator)
.findFirst()
.map(x -> {
- log("Found constructor
accepting builder: %s", x.getFullName());
+ log("Found constructor
accepting builder: %s", x.getNameFull());
return
(T)beanType.cast(x.inject(store, enclosingInstance, builder));
})
.orElse(null);
@@ -1121,7 +1121,7 @@ public class BeanCreator2<T> {
.sorted(methodComparator)
.findFirst()
.map(x -> {
- log("Found builder method: %s",
x.getFullName());
+ log("Found builder method: %s",
x.getNameFull());
return
(T)beanType.cast(x.inject(store, builder));
})
.orElse(null);
@@ -1160,7 +1160,7 @@ public class BeanCreator2<T> {
.sorted(methodComparator)
.findFirst()
.map(x -> {
- log("Found factory method: %s",
x.getFullName());
+ log("Found factory method: %s",
x.getNameFull());
return (T)beanType.cast(x.inject(store, null));
})
.orElse(null);
@@ -1175,7 +1175,7 @@ public class BeanCreator2<T> {
.sorted(constructorComparator)
.findFirst()
.map(x -> {
- log("Found constructor: %s",
x.getFullName());
+ log("Found constructor: %s",
x.getNameFull());
return (T)beanType.cast(x.inject(store,
enclosingInstance));
})
.orElse(null);
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/AnnotationInfo.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/AnnotationInfo.java
index 50da35746f..da01c79b6a 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/AnnotationInfo.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/AnnotationInfo.java
@@ -391,7 +391,7 @@ public class AnnotationInfo<T extends Annotation> {
* @return An {@link Optional} containing the method info, or empty if
method not found.
*/
public Optional<MethodInfo> getMethod(String methodName) {
- return methods.get().stream().filter(x -> eq(methodName,
x.getSimpleName())).findFirst();
+ return methods.get().stream().filter(x -> eq(methodName,
x.getNameSimple())).findFirst();
}
//-----------------------------------------------------------------------------------------------------------------
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ConstructorInfo.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ConstructorInfo.java
index b1924a5639..f2f006605c 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ConstructorInfo.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ConstructorInfo.java
@@ -142,7 +142,7 @@ public class ConstructorInfo extends ExecutableInfo
implements Comparable<Constr
@Override
public int compareTo(ConstructorInfo o) {
- int i = cmp(getSimpleName(), o.getSimpleName());
+ int i = cmp(getNameSimple(), o.getNameSimple());
if (i == 0) {
i = getParameterCount() - o.getParameterCount();
if (i == 0) {
@@ -160,7 +160,7 @@ public class ConstructorInfo extends ExecutableInfo
implements Comparable<Constr
public AnnotatableType getAnnotatableType() { return
AnnotatableType.CONSTRUCTOR_TYPE; }
@Override /* Annotatable */
- public String getLabel() { return getDeclaringClass().getNameSimple() +
"." + getShortName(); }
+ public String getLabel() { return getDeclaringClass().getNameSimple() +
"." + getNameShort(); }
/**
* Returns the wrapped constructor.
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ExecutableInfo.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ExecutableInfo.java
index c0b6db0f37..7f159df6b4 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ExecutableInfo.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ExecutableInfo.java
@@ -113,7 +113,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
this.parameterTypes = mem(() ->
getParameters().stream().map(ParameterInfo::getParameterType).toList());
this.exceptions = mem(() ->
stream(inner.getExceptionTypes()).map(ClassInfo::of).map(ClassInfo.class::cast).toList());
this.declaredAnnotations = mem(() ->
stream(inner.getDeclaredAnnotations()).flatMap(a ->
AnnotationUtils.streamRepeated(a)).map(a -> ai((Annotatable)this, a)).toList());
- this.shortName = mem(() -> f("{0}({1})", getSimpleName(),
getParameters().stream().map(p ->
p.getParameterType().getNameSimple()).collect(joining(","))));
+ this.shortName = mem(() -> f("{0}({1})", getNameSimple(),
getParameters().stream().map(p ->
p.getParameterType().getNameSimple()).collect(joining(","))));
this.fullName = mem(this::findFullName);
}
@@ -298,7 +298,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
*
* @return The underlying executable name.
*/
- public final String getFullName() { return fullName.get(); }
+ public final String getNameFull() { return fullName.get(); }
/**
* Returns parameter information at the specified index.
@@ -362,14 +362,14 @@ public abstract class ExecutableInfo extends
AccessibleInfo {
*
* @return The underlying executable name.
*/
- public final String getShortName() { return shortName.get(); }
+ public final String getNameShort() { return shortName.get(); }
/**
* Returns the simple name of the underlying method.
*
* @return The simple name of the underlying method;
*/
- public final String getSimpleName() { return isConstructor ?
cns(inner.getDeclaringClass()) : inner.getName(); }
+ public final String getNameSimple() { return isConstructor ?
cns(inner.getDeclaringClass()) : inner.getName(); }
/**
* Returns an array of {@link TypeVariable} objects that represent the
type variables declared by the generic declaration.
@@ -411,7 +411,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
* @return <jk>true</jk> if this method has one of the names.
*/
public final boolean hasAnyName(Collection<String> names) {
- return names.contains(getSimpleName());
+ return names.contains(getNameSimple());
}
/**
@@ -421,7 +421,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
* @return <jk>true</jk> if this method has one of the names.
*/
public final boolean hasAnyName(String...names) {
- return stream(names).anyMatch(n -> eq(n, getSimpleName()));
+ return stream(names).anyMatch(n -> eq(n, getNameSimple()));
}
/**
@@ -442,7 +442,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
* @return <jk>true</jk> if this method has this name.
*/
public final boolean hasName(String name) {
- return getSimpleName().equals(name);
+ return getNameSimple().equals(name);
}
/**
@@ -787,7 +787,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
@Override
public String toString() {
- return getShortName();
+ return getNameShort();
}
private void checkIndex(int index) {
@@ -806,7 +806,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
sb.append(pi.getName()).append('.');
dc.appendNameFormatted(sb, SHORT, true, '$', BRACKETS);
if (! isConstructor)
- sb.append('.').append(getSimpleName());
+ sb.append('.').append(getNameSimple());
sb.append('(');
sb.append(getParameters().stream().map(p ->
p.getParameterType().getNameFormatted(FULL, true, '$',
BRACKETS)).collect(joining(",")));
sb.append(')');
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/FieldInfo.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/FieldInfo.java
index e81bcedb2d..5c43f8bba3 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/FieldInfo.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/FieldInfo.java
@@ -260,7 +260,7 @@ public class FieldInfo extends AccessibleInfo implements
Comparable<FieldInfo>,
*
* @return The underlying executable name.
*/
- public String getFullName() { return fullName.get(); }
+ public String getNameFull() { return fullName.get(); }
@Override /* Annotatable */
public String getLabel() { return getDeclaringClass().getNameSimple() +
"." + getName(); }
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/MethodInfo.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/MethodInfo.java
index fab3fae5e6..b01fabdf56 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/MethodInfo.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/MethodInfo.java
@@ -171,7 +171,7 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
@Override
public int compareTo(MethodInfo o) {
- int i = cmp(getSimpleName(), o.getSimpleName());
+ int i = cmp(getNameSimple(), o.getNameSimple());
if (i == 0) {
var params = getParameters();
var oParams = o.getParameters();
@@ -317,7 +317,7 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
public Type getGenericReturnType() { return
inner.getGenericReturnType(); }
@Override /* Annotatable */
- public String getLabel() { return getDeclaringClass().getNameSimple() +
"." + getShortName(); }
+ public String getLabel() { return getDeclaringClass().getNameSimple() +
"." + getNameShort(); }
/**
* Returns this method and all matching methods up the hierarchy chain.
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ParameterInfo.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ParameterInfo.java
index f13ec3fdcb..f24312c370 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ParameterInfo.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ParameterInfo.java
@@ -279,7 +279,7 @@ public class ParameterInfo extends ElementInfo implements
Annotatable {
@Override /* Annotatable */
public String getLabel() {
var exec = getDeclaringExecutable();
- var label = exec.getDeclaringClass().getNameSimple() + "." +
exec.getShortName();
+ var label = exec.getDeclaringClass().getNameSimple() + "." +
exec.getNameShort();
return label + "[" + index + "]";
}
@@ -614,7 +614,7 @@ public class ParameterInfo extends ElementInfo implements
Annotatable {
@Override
public String toString() {
- return (executable.getSimpleName()) + "[" + index + "]";
+ return (executable.getNameSimple()) + "[" + index + "]";
}
private List<ParameterInfo> findMatchingParameters() {
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/StringUtils.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/StringUtils.java
index db349c516c..a89bd63605 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/StringUtils.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/StringUtils.java
@@ -8038,8 +8038,8 @@ public class StringUtils {
list.add(readifier(byte[].class, x -> toHex(x)));
list.add(readifier(Enum.class, x -> ((Enum<?>)x).name()));
list.add(readifier(Class.class, x -> cns(x)));
- list.add(readifier(Constructor.class, x ->
ConstructorInfo.of(x).getFullName()));
- list.add(readifier(Method.class, x ->
MethodInfo.of(x).getFullName()));
+ list.add(readifier(Constructor.class, x ->
ConstructorInfo.of(x).getNameFull()));
+ list.add(readifier(Method.class, x ->
MethodInfo.of(x).getNameFull()));
list.add(readifier(Field.class, x ->
FieldInfo.of(x).toString()));
list.add(readifier(Parameter.class, x ->
ParameterInfo.of(x).toString()));
list.add(readifier(ClassInfo.class, ClassInfo::toString));
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/BeanMap.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/BeanMap.java
index 157e1918d2..bd0ab696f9 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/BeanMap.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/BeanMap.java
@@ -433,7 +433,7 @@ public class BeanMap<T> extends AbstractMap<String,Object>
implements Delegate<T
propertyCache.forEach((k, v) -> put(k, v));
propertyCache = null;
} catch (IllegalArgumentException e) {
- throw bex(e, meta.getClassMeta().inner(),
"IllegalArgumentException occurred on call to class constructor ''{0}'' with
argument types ''{1}''", c.getSimpleName(),
+ throw bex(e, meta.getClassMeta().inner(),
"IllegalArgumentException occurred on call to class constructor ''{0}'' with
argument types ''{1}''", c.getNameSimple(),
Json5Serializer.DEFAULT.toString(getClasses(args)));
} catch (Exception e) {
throw bex(e);
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/BeanMeta.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/BeanMeta.java
index 0d4481245b..ff3aacc256 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/BeanMeta.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/BeanMeta.java
@@ -470,7 +470,7 @@ public class BeanMeta<T> {
if (nn(bpm.getter)) {
if (!
ap.has(Beanp.class, mi) && ap.has(Beanp.class, bpm.getter)) {
m =
bpm.getter.inner(); // @Beanp annotated method takes precedence.
- } else if
(m.getName().startsWith("is") && bpm.getter.getSimpleName().startsWith("get")) {
+ } else if
(m.getName().startsWith("is") && bpm.getter.getNameSimple().startsWith("get")) {
m =
bpm.getter.inner(); // getX() overrides isX().
}
}
@@ -964,7 +964,7 @@ public class BeanMeta<T> {
args = con.getParameters().stream().map(x ->
x.getName()).toList();
for (int i = 0; i < args.size(); i++) {
if (isBlank(args.get(i)))
- throw bex(ci, "Could not find
name for parameter #{0} of constructor ''{1}''", i, con.getFullName());
+ throw bex(ci, "Could not find
name for parameter #{0} of constructor ''{1}''", i, con.getNameFull());
}
}
return new BeanConstructor(opt(con), args);
@@ -1084,7 +1084,7 @@ public class BeanMeta<T> {
if (! (m.isVisible(v) || ne(beanps) ||
ne(names)))
continue;
- var n = m.getSimpleName();
+ var n = m.getNameSimple();
var params = m.getParameters();
var rt = m.getReturnType();
@@ -1157,7 +1157,7 @@ public class BeanMeta<T> {
n = pn.getPropertyName(n);
if ("*".equals(bpName) && methodType == UNKNOWN)
- throw bex(ci, "Found @Beanp(\"*\") but
could not determine method type on method ''{0}''.", m.getSimpleName());
+ throw bex(ci, "Found @Beanp(\"*\") but
could not determine method type on method ''{0}''.", m.getNameSimple());
if (methodType != UNKNOWN) {
if (nn(bpName) && ! bpName.isEmpty())
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/ClassMeta.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/ClassMeta.java
index 6f73df7698..3b2b9b106d 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/ClassMeta.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/ClassMeta.java
@@ -1536,7 +1536,7 @@ public class ClassMeta<T> extends ClassInfoTyped<T> {
// Try to find a corresponding getter method (even if
not annotated)
// If setter is "setName", look for "getName" or
"isName"
- var setterName = setterMethod.get().getSimpleName();
+ var setterName = setterMethod.get().getNameSimple();
if (setterName.startsWith("set") && setterName.length()
> 3) {
var propertyName = setterName.substring(3);
var getterName1 = "get" + propertyName;
@@ -1628,7 +1628,7 @@ public class ClassMeta<T> extends ClassInfoTyped<T> {
// Try to find a corresponding getter method (even if
not annotated)
// If setter is "setParent", look for "getParent" or
"isParent"
- var setterName = setterMethod.get().getSimpleName();
+ var setterName = setterMethod.get().getNameSimple();
if (setterName.startsWith("set") && setterName.length()
> 3) {
var propertyName = setterName.substring(3);
var getterName1 = "get" + propertyName;
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/httppart/bean/RequestBeanMeta.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/httppart/bean/RequestBeanMeta.java
index 8452e84c2a..c84b3d1a84 100644
---
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/httppart/bean/RequestBeanMeta.java
+++
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/httppart/bean/RequestBeanMeta.java
@@ -58,7 +58,7 @@ public class RequestBeanMeta {
var ap = cm.getBeanContext().getAnnotationProvider();
apply(ap.find(Request.class,
cm).stream().findFirst().map(x -> x.inner()).orElse(null));
cm.getPublicMethods().stream().forEach(x -> {
- var n = x.getSimpleName();
+ var n = x.getNameSimple();
if (x.hasAnnotation(Header.class)) {
assertNoArgs(x, Header.class);
assertReturnNotVoid(x, Header.class);
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/Mutaters.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/Mutaters.java
index db69c2fe4d..9052a3ea07 100644
---
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/Mutaters.java
+++
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/Mutaters.java
@@ -308,14 +308,14 @@ public class Mutaters {
return ic.getPublicMethod(
x -> x.isNotStatic()
&& x.getParameterCount() == 0
- && x.getSimpleName().startsWith("to")
- && x.getSimpleName().substring(2).equalsIgnoreCase(tn)
+ && x.getNameSimple().startsWith("to")
+ && x.getNameSimple().substring(2).equalsIgnoreCase(tn)
).orElse(null);
// @formatter:on
}
private static boolean isStaticCreateMethodName(MethodInfo mi, Class<?>
ic) {
- var n = mi.getSimpleName();
+ var n = mi.getNameSimple();
var cn = ic.getSimpleName();
// @formatter:off
return isOneOf(n,
"create","from","fromValue","parse","valueOf","builder")
diff --git
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContext.java
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContext.java
index d4de60fd64..e3dc57f604 100644
---
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContext.java
+++
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContext.java
@@ -4630,7 +4630,7 @@ public class RestContext extends Context {
if (al.size() > 0) {
try {
if (mi.isNotPublic())
- throw
servletException("@RestOp method {0}.{1} must be defined as public.",
rci.inner().getName(), mi.getSimpleName());
+ throw
servletException("@RestOp method {0}.{1} must be defined as public.",
rci.inner().getName(), mi.getNameSimple());
RestOpContext.Builder rocb =
RestOpContext.create(mi.inner(),
restContext).beanStore(beanStore).type(opContextClass);
@@ -5980,11 +5980,11 @@ public class RestContext extends Context {
if (nn(ra[i]))
break;
} catch (ExecutableException e) {
- throw new
InternalServerError(e.unwrap(), "Could not resolve parameter {0} on method
{1}.", i, mi.getFullName());
+ throw new
InternalServerError(e.unwrap(), "Could not resolve parameter {0} on method
{1}.", i, mi.getNameFull());
}
}
if (ra[i] == null)
- throw new InternalServerError("Could not
resolve parameter {0} on method {1}.", i, mi.getFullName());
+ throw new InternalServerError("Could not
resolve parameter {0} on method {1}.", i, mi.getNameFull());
}
return ra;
diff --git
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestOpInvoker.java
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestOpInvoker.java
index cecf686323..ab638f9e35 100644
---
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestOpInvoker.java
+++
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestOpInvoker.java
@@ -86,7 +86,7 @@ public class RestOpInvoker extends MethodInvoker {
res.setContent(output);
} catch (IllegalAccessException | IllegalArgumentException e) {
- throw new InternalServerError(e, "Error occurred
invoking method ''{0}''.", inner().getFullName());
+ throw new InternalServerError(e, "Error occurred
invoking method ''{0}''.", inner().getNameFull());
} catch (InvocationTargetException e) {
RestResponse res = opSession.getResponse();
Throwable e2 = e.getTargetException();
diff --git
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/arg/ArgException.java
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/arg/ArgException.java
index 3ff02899ae..65a4988286 100644
---
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/arg/ArgException.java
+++
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/arg/ArgException.java
@@ -46,7 +46,7 @@ public class ArgException extends InternalServerError {
* @param args The message args.
*/
public ArgException(ParameterInfo pi, String msg, Object...args) {
- super(f(msg, args) + " on parameter " + pi.getIndex() + " of
method " + pi.getMethod().getFullName() + ".");
+ super(f(msg, args) + " on parameter " + pi.getIndex() + " of
method " + pi.getMethod().getNameFull() + ".");
}
/**
diff --git
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/debug/BasicDebugEnablement.java
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/debug/BasicDebugEnablement.java
index b3da36e39d..0585133738 100644
---
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/debug/BasicDebugEnablement.java
+++
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/debug/BasicDebugEnablement.java
@@ -95,7 +95,7 @@ public class BasicDebugEnablement extends DebugEnablement {
.map(varResolver::resolve)
.map(Enablement::fromString)
.filter(Objects::nonNull)
- .forEach(e -> b.enable(e,
x.getFullName()))
+ .forEach(e -> b.enable(e,
x.getNameFull()))
);
// @formatter:on
diff --git
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/stats/MethodInvoker.java
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/stats/MethodInvoker.java
index 1c4976a15b..cf6f0f1c00 100644
---
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/stats/MethodInvoker.java
+++
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/stats/MethodInvoker.java
@@ -53,7 +53,7 @@ public class MethodInvoker {
*
* @return The name of the method.
*/
- public String getFullName() { return m.getFullName(); }
+ public String getFullName() { return m.getNameFull(); }
/**
* Returns the stats of this method invoker.
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/AnnotationInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/AnnotationInfo_Test.java
index 4a74d04824..d6a134c2f1 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/AnnotationInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/AnnotationInfo_Test.java
@@ -372,7 +372,7 @@ class AnnotationInfo_Test extends TestBase {
// Existing method
var method = ai.getMethod("value");
assertTrue(method.isPresent());
- assertEquals("value", method.get().getSimpleName());
+ assertEquals("value", method.get().getNameSimple());
// Non-existent method
var method2 = ai.getMethod("nonexistent");
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ClassInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ClassInfo_Test.java
index 592823741c..311900110e 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ClassInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ClassInfo_Test.java
@@ -144,9 +144,9 @@ public class ClassInfo_Test extends TestBase {
if (t instanceof ClassInfo t5)
return t5.getNameSimple();
if (t instanceof MethodInfo t6)
- return t6.getDeclaringClass().getNameSimple() + '.' +
t6.getShortName();
+ return t6.getDeclaringClass().getNameSimple() + '.' +
t6.getNameShort();
if (t instanceof ConstructorInfo t7)
- return t7.getShortName();
+ return t7.getNameShort();
if (t instanceof FieldInfo t8)
return t8.getDeclaringClass().getNameSimple() + '.' +
t8.getName();
if (t instanceof A t9)
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ConstructorInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ConstructorInfo_Test.java
index 08bfbf8217..69f93adbf0 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ConstructorInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ConstructorInfo_Test.java
@@ -50,9 +50,9 @@ class ConstructorInfo_Test extends TestBase {
if (t instanceof ClassInfo)
return ((ClassInfo)t).getNameSimple();
if (t instanceof ConstructorInfo)
- return ((ConstructorInfo)t).getShortName();
+ return ((ConstructorInfo)t).getNameShort();
if (t instanceof Constructor)
- return
ConstructorInfo.of((Constructor<?>)t).getShortName();
+ return
ConstructorInfo.of((Constructor<?>)t).getNameShort();
return t.toString();
}
};
@@ -257,7 +257,7 @@ class ConstructorInfo_Test extends TestBase {
//====================================================================================================
@Test
void a012_getFullName() {
- var fullName = b_c2.getFullName();
+ var fullName = b_c2.getNameFull();
assertNotNull(fullName);
assertTrue(fullName.contains("B"));
assertTrue(fullName.contains("String"));
@@ -330,8 +330,8 @@ class ConstructorInfo_Test extends TestBase {
//====================================================================================================
@Test
void a018_getSimpleName() {
- assertEquals("A", a.getSimpleName());
- assertEquals("B", b_c1.getSimpleName());
+ assertEquals("A", a.getNameSimple());
+ assertEquals("B", b_c1.getNameSimple());
}
//====================================================================================================
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ExecutableInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ExecutableInfo_Test.java
index d571a3d1dc..2a48480509 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ExecutableInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ExecutableInfo_Test.java
@@ -56,7 +56,7 @@ class ExecutableInfo_Test extends TestBase {
if (t instanceof ClassInfo)
return ((ClassInfo)t).getNameSimple();
if (t instanceof ConstructorInfo)
- return ((ConstructorInfo)t).getShortName();
+ return ((ConstructorInfo)t).getNameShort();
if (t instanceof ParameterInfo)
return apply(((ParameterInfo)t).toString());
return t.toString();
@@ -307,14 +307,14 @@ class ExecutableInfo_Test extends TestBase {
@Test
void a010_getFullName() throws Exception {
// Method
-
assertEquals("org.apache.juneau.commons.reflect.ExecutableInfo_Test$X.foo()",
x2.getPublicMethod(x -> x.hasName("foo") && x.getParameterCount() ==
0).get().getFullName());
-
assertEquals("org.apache.juneau.commons.reflect.ExecutableInfo_Test$X.foo(java.lang.String)",
x2.getPublicMethod(x -> x.hasName("foo") &&
x.hasParameterTypes(String.class)).get().getFullName());
-
assertEquals("org.apache.juneau.commons.reflect.ExecutableInfo_Test$X.foo(java.util.Map<java.lang.String,java.lang.Object>)",
x2.getPublicMethod(x -> x.hasName("foo") &&
x.hasParameterTypes(Map.class)).get().getFullName());
+
assertEquals("org.apache.juneau.commons.reflect.ExecutableInfo_Test$X.foo()",
x2.getPublicMethod(x -> x.hasName("foo") && x.getParameterCount() ==
0).get().getNameFull());
+
assertEquals("org.apache.juneau.commons.reflect.ExecutableInfo_Test$X.foo(java.lang.String)",
x2.getPublicMethod(x -> x.hasName("foo") &&
x.hasParameterTypes(String.class)).get().getNameFull());
+
assertEquals("org.apache.juneau.commons.reflect.ExecutableInfo_Test$X.foo(java.util.Map<java.lang.String,java.lang.Object>)",
x2.getPublicMethod(x -> x.hasName("foo") &&
x.hasParameterTypes(Map.class)).get().getNameFull());
// Constructor
-
assertEquals("org.apache.juneau.commons.reflect.ExecutableInfo_Test$X()",
x2.getPublicConstructor(cons -> cons.getParameterCount() ==
0).get().getFullName());
-
assertEquals("org.apache.juneau.commons.reflect.ExecutableInfo_Test$X(java.lang.String)",
x2.getPublicConstructor(x ->
x.hasParameterTypes(String.class)).get().getFullName());
-
assertEquals("org.apache.juneau.commons.reflect.ExecutableInfo_Test$X(java.util.Map<java.lang.String,java.lang.Object>)",
x2.getPublicConstructor(x ->
x.hasParameterTypes(Map.class)).get().getFullName());
+
assertEquals("org.apache.juneau.commons.reflect.ExecutableInfo_Test$X()",
x2.getPublicConstructor(cons -> cons.getParameterCount() ==
0).get().getNameFull());
+
assertEquals("org.apache.juneau.commons.reflect.ExecutableInfo_Test$X(java.lang.String)",
x2.getPublicConstructor(x ->
x.hasParameterTypes(String.class)).get().getNameFull());
+
assertEquals("org.apache.juneau.commons.reflect.ExecutableInfo_Test$X(java.util.Map<java.lang.String,java.lang.Object>)",
x2.getPublicConstructor(x ->
x.hasParameterTypes(Map.class)).get().getNameFull());
// Test line 752: getPackage() returns null branch
// Primitive types don't have packages, but we can't get
methods/constructors from primitives.
@@ -327,7 +327,7 @@ class ExecutableInfo_Test extends TestBase {
if (pkg == null) {
// Test the false branch of line 752: when
package is null, don't append package name
ConstructorInfo defaultPkgCtor =
defaultPkgClass.getPublicConstructor(cons -> cons.getParameterCount() ==
0).get();
- String fullName = defaultPkgCtor.getFullName();
+ String fullName = defaultPkgCtor.getNameFull();
// When package is null, getFullName() should
not include package prefix
assertTrue(fullName.startsWith("DefaultPackageTestClass("), "Full name should
start with class name when package is null: " + fullName);
// Verify no package prefix (no dots before the
class name, except for inner classes)
@@ -419,14 +419,14 @@ class ExecutableInfo_Test extends TestBase {
@Test
void a014_getShortName() {
// Method
- assertEquals("foo()", x2.getPublicMethod(x -> x.hasName("foo")
&& x.getParameterCount() == 0).get().getShortName());
- assertEquals("foo(String)", x2.getPublicMethod(x ->
x.hasName("foo") && x.hasParameterTypes(String.class)).get().getShortName());
- assertEquals("foo(Map)", x2.getPublicMethod(x ->
x.hasName("foo") && x.hasParameterTypes(Map.class)).get().getShortName());
+ assertEquals("foo()", x2.getPublicMethod(x -> x.hasName("foo")
&& x.getParameterCount() == 0).get().getNameShort());
+ assertEquals("foo(String)", x2.getPublicMethod(x ->
x.hasName("foo") && x.hasParameterTypes(String.class)).get().getNameShort());
+ assertEquals("foo(Map)", x2.getPublicMethod(x ->
x.hasName("foo") && x.hasParameterTypes(Map.class)).get().getNameShort());
// Constructor
- assertEquals("X()", x2.getPublicConstructor(cons ->
cons.getParameterCount() == 0).get().getShortName());
- assertEquals("X(String)", x2.getPublicConstructor(x ->
x.hasParameterTypes(String.class)).get().getShortName());
- assertEquals("X(Map)", x2.getPublicConstructor(x ->
x.hasParameterTypes(Map.class)).get().getShortName());
+ assertEquals("X()", x2.getPublicConstructor(cons ->
cons.getParameterCount() == 0).get().getNameShort());
+ assertEquals("X(String)", x2.getPublicConstructor(x ->
x.hasParameterTypes(String.class)).get().getNameShort());
+ assertEquals("X(Map)", x2.getPublicConstructor(x ->
x.hasParameterTypes(Map.class)).get().getNameShort());
}
//====================================================================================================
@@ -435,12 +435,12 @@ class ExecutableInfo_Test extends TestBase {
@Test
void a015_getSimpleName() {
// Method
- assertEquals("foo", x2.getPublicMethod(x -> x.hasName("foo") &&
x.getParameterCount() == 0).get().getSimpleName());
- assertEquals("foo", x2.getPublicMethod(x -> x.hasName("foo") &&
x.hasParameterTypes(String.class)).get().getSimpleName());
+ assertEquals("foo", x2.getPublicMethod(x -> x.hasName("foo") &&
x.getParameterCount() == 0).get().getNameSimple());
+ assertEquals("foo", x2.getPublicMethod(x -> x.hasName("foo") &&
x.hasParameterTypes(String.class)).get().getNameSimple());
// Constructor
- assertEquals("X", x2.getPublicConstructor(cons ->
cons.getParameterCount() == 0).get().getSimpleName());
- assertEquals("X", x2.getPublicConstructor(x ->
x.hasParameterTypes(String.class)).get().getSimpleName());
+ assertEquals("X", x2.getPublicConstructor(cons ->
cons.getParameterCount() == 0).get().getNameSimple());
+ assertEquals("X", x2.getPublicConstructor(x ->
x.hasParameterTypes(String.class)).get().getNameSimple());
}
//====================================================================================================
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/FieldInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/FieldInfo_Test.java
index 10691491ea..450f7e773c 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/FieldInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/FieldInfo_Test.java
@@ -343,8 +343,8 @@ class FieldInfo_Test extends TestBase {
//====================================================================================================
@Test
void a010_getFullName() throws Exception {
- String fullName1 = g_field1.getFullName();
- String fullName2 = g_field2.getFullName();
+ String fullName1 = g_field1.getNameFull();
+ String fullName2 = g_field2.getNameFull();
// Test line 449: getPackage() returns null (default package
class)
// A field can have a null package if its declaring class is in
the default package
@@ -356,7 +356,7 @@ class FieldInfo_Test extends TestBase {
if (pkg == null) {
// Test the false branch of line 449: when
package is null, don't append package name
FieldInfo defaultPkgField =
defaultPkgClass.getPublicField(x -> x.hasName("testField")).get();
- String fullName = defaultPkgField.getFullName();
+ String fullName = defaultPkgField.getNameFull();
// When package is null, getFullName() should
not include package prefix
assertTrue(fullName.startsWith("DefaultPackageTestClass"), "Full name should
start with class name when package is null: " + fullName);
assertTrue(fullName.endsWith(".testField"),
"Full name should end with field name: " + fullName);
@@ -374,12 +374,12 @@ class FieldInfo_Test extends TestBase {
assertTrue(fullName2.startsWith("org.apache.juneau.commons.reflect."));
// Test memoization - should return same instance
- String name1 = g_field1.getFullName();
- String name2 = g_field1.getFullName();
+ String name1 = g_field1.getNameFull();
+ String name2 = g_field1.getNameFull();
assertSame(name1, name2);
// Test with inner class
- String innerFullName = inner_field.getFullName();
+ String innerFullName = inner_field.getNameFull();
assertTrue(innerFullName.contains("FieldInfo_Test$InnerClass"));
assertTrue(innerFullName.endsWith(".innerField"));
}
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/MethodInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/MethodInfo_Test.java
index a441078eb9..4fd449cfa7 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/MethodInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/MethodInfo_Test.java
@@ -67,9 +67,9 @@ class MethodInfo_Test extends TestBase {
if (t == null)
return null;
if (t instanceof MethodInfo t2)
- return t2.getDeclaringClass().getNameSimple() +
'.' + ((MethodInfo)t).getShortName();
+ return t2.getDeclaringClass().getNameSimple() +
'.' + ((MethodInfo)t).getNameShort();
if (t instanceof Method t2)
- return t2.getDeclaringClass().getSimpleName() +
'.' + MethodInfo.of((Method)t).getShortName();
+ return t2.getDeclaringClass().getSimpleName() +
'.' + MethodInfo.of((Method)t).getNameShort();
if (t instanceof List<?> t2)
return
(t2.stream().map(this).collect(Collectors.joining(",")));
if (t instanceof AnnotationInfo t2)
@@ -697,7 +697,7 @@ class MethodInfo_Test extends TestBase {
//====================================================================================================
@Test
void a036_getFullName() {
- var fullName = e_a1.getFullName();
+ var fullName = e_a1.getNameFull();
assertNotNull(fullName);
assertTrue(fullName.contains("MethodInfo_Test$E"));
assertTrue(fullName.contains("a1"));
@@ -724,9 +724,9 @@ class MethodInfo_Test extends TestBase {
//====================================================================================================
@Test
void a038_getShortName() {
- assertEquals("m()", a_m.getShortName());
- assertEquals("a1(CharSequence)", e_a1.getShortName());
- assertEquals("a2(int,int)", e_a2.getShortName());
+ assertEquals("m()", a_m.getNameShort());
+ assertEquals("a1(CharSequence)", e_a1.getNameShort());
+ assertEquals("a2(int,int)", e_a2.getNameShort());
}
//====================================================================================================
@@ -734,8 +734,8 @@ class MethodInfo_Test extends TestBase {
//====================================================================================================
@Test
void a039_getSimpleName() {
- assertEquals("m", a_m.getSimpleName());
- assertEquals("a1", e_a1.getSimpleName());
+ assertEquals("m", a_m.getNameSimple());
+ assertEquals("a1", e_a1.getNameSimple());
}
//====================================================================================================
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ParameterInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ParameterInfo_Test.java
index e386019f21..5ab6a63a28 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ParameterInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ParameterInfo_Test.java
@@ -113,7 +113,7 @@ class ParameterInfo_Test extends TestBase {
if (isArray(t))
return StreamSupport.stream(toList(t,
Object.class).spliterator(), false).map(this).collect(Collectors.joining(","));
if (t instanceof MethodInfo)
- return
((MethodInfo)t).getDeclaringClass().getNameSimple() + '.' +
((MethodInfo)t).getShortName();
+ return
((MethodInfo)t).getDeclaringClass().getNameSimple() + '.' +
((MethodInfo)t).getNameShort();
if (t instanceof CA)
return "@CA(" + ((CA)t).value() + ")";
if (t instanceof DA)
