Modifier and Type | Field and Description |
---|---|
static Class<?>[] |
Config.CONFIG_ARGTYPES |
static Class<?>[] |
Config.NO_ARGTYPES |
Modifier and Type | Method and Description |
---|---|
Class<?> |
AnnotationProxyBase.annotationType() |
Class<?> |
Config.asClass(String v) |
Class<?> |
Config.getClass(String key) |
<T> Class<? extends T> |
Config.getClass(String key,
Class<T> type) |
Class<?>[] |
Config.getClasses(String key) |
Class<T> |
SerializationConstructor.getDeclaringClass() |
Class<?> |
Config.getEssentialClass(String key) |
Modifier and Type | Method and Description |
---|---|
<T extends Publisher> |
JPF.addPublisherExtension(Class<T> pCls,
PublisherExtension e) |
<T> Class<? extends T> |
Config.getClass(String key,
Class<T> type) |
<T> T |
Config.getEssentialInstance(String key,
Class<T> type) |
<T> T |
Config.getEssentialInstance(String key,
Class<T> type,
Class<?>[] argTypes,
Object[] args) |
<T> T |
Config.getEssentialInstance(String key,
Class<T> type,
Class<?>[] argTypes,
Object[] args) |
<T> T |
Config.getEssentialInstance(String key,
Class<T> type,
Object arg1,
Object arg2)
just a convenience method for ctor calls that take two arguments
|
<T> T[] |
Config.getGroupInstances(String keyPrefix,
String keyPostfix,
Class<T> type,
String... defaultClsNames)
this one is used to instantiate objects from a list of keys that share
the same prefix, e.g.
|
<T> T |
Config.getInstance(String key,
Class<T> type) |
<T> T |
Config.getInstance(String key,
Class<T> type,
Class<?>[] argTypes,
Object[] args) |
<T> T |
Config.getInstance(String key,
Class<T> type,
Class<?>[] argTypes,
Object[] args) |
<T> T |
Config.getInstance(String key,
Class<T> type,
Object arg1,
Object arg2) |
<T> T |
Config.getInstance(String key,
Class<T> type,
String defClsName) |
<T> T |
Config.getInstance(String id,
String clsName,
Class<T> type) |
<T> T |
Config.getInstance(String id,
String clsName,
Class<T> type,
Class<?>[] argTypes,
Object[] args) |
<T> T |
Config.getInstance(String id,
String clsName,
Class<T> type,
Class<?>[] argTypes,
Object[] args) |
<T> ArrayList<T> |
Config.getInstances(String key,
Class<T> type) |
<T> ArrayList<T> |
Config.getInstances(String key,
Class<T> type,
Class<?>[] argTypes,
Object[] args) |
<T> ArrayList<T> |
Config.getInstances(String key,
Class<T> type,
Class<?>[] argTypes,
Object[] args) |
<T> T |
JPF.getListenerOfType(Class<T> type) |
<T extends Publisher> |
JPF.setPublisherTopics(Class<T> pCls,
int category,
String[] topics) |
Constructor and Description |
---|
JPFConfigException(String key,
Class<?> cls,
String failure) |
JPFConfigException(String key,
Class<?> cls,
String failure,
Throwable cause) |
Modifier and Type | Method and Description |
---|---|
<T> T |
ReturnInstruction.getNextReturnAttr(ThreadInfo ti,
Class<T> type,
Object prev) |
<T> T |
LongReturn.getNextReturnAttr(ThreadInfo ti,
Class<T> type,
Object prev) |
<T> T |
ReturnInstruction.getReturnAttr(ThreadInfo ti,
Class<T> type)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T> T |
LongReturn.getReturnAttr(ThreadInfo ti,
Class<T> type)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
boolean |
InvokeInstruction.hasArgumentAttr(ThreadInfo ti,
Class<?> type)
check if there is any argument attr of the specified type
(use this before using any of the more expensive retrievers)
|
boolean |
InvokeInstruction.hasAttrRefArgument(ThreadInfo ti,
Class<?> type)
do we have a reference argument that has an object attribute?
less efficient, but still without object creation
|
boolean |
ReturnInstruction.hasReturnAttr(ThreadInfo ti,
Class<?> type) |
boolean |
LongReturn.hasReturnAttr(ThreadInfo ti,
Class<?> type) |
<T> Iterator<T> |
ReturnInstruction.returnAttrIterator(ThreadInfo ti,
Class<T> type) |
<T> Iterator<T> |
LongReturn.returnAttrIterator(ThreadInfo ti,
Class<T> type) |
Modifier and Type | Field and Description |
---|---|
protected static Class<?>[] |
Perturbator.argTypes |
Constructor and Description |
---|
ChoiceTracker(JPF jpf,
String traceFileName,
Class<?> cgClass) |
Modifier and Type | Method and Description |
---|---|
Class<? extends ChoiceGenerator<?>> |
OperandPerturbator.getChoiceGeneratorType() |
Class<? extends ChoiceGenerator<?>> |
GenericDataAbstractor.getChoiceGeneratorType() |
Class<? extends ChoiceGenerator<?>> |
IntOverUnder.getChoiceGeneratorType() |
Modifier and Type | Method and Description |
---|---|
<T extends Publisher> |
Reporter.addPublisherExtension(Class<T> publisherCls,
PublisherExtension e) |
<T extends Publisher> |
Reporter.setPublisherTopics(Class<T> publisherCls,
int category,
String[] topics) |
Modifier and Type | Method and Description |
---|---|
<T> T |
Search.getNextListenerOfType(Class<T> type,
T prev) |
boolean |
Search.hasListenerOfType(Class<?> listenerCls) |
Modifier and Type | Method and Description |
---|---|
protected static boolean |
Run.call(Class<?> cls,
String mthName,
Object[] args) |
Modifier and Type | Method and Description |
---|---|
<T> Class<? extends T> |
TypeRef.asNativeSubclass(Class<T> superClazz)
return the host VM class for this ref.
|
static Class<?> |
Reflection.getCallerClass() |
static <T> Class<? extends T> |
Reflection.getCallerClass(Class<T> type) |
static Class<?> |
Reflection.getCallerClass(int up)
find callers class
|
Class<?> |
TypeRef.getNativeClass() |
Modifier and Type | Method and Description |
---|---|
<T> Class<? extends T> |
TypeRef.asNativeSubclass(Class<T> superClazz)
return the host VM class for this ref.
|
static boolean |
ObjectList.containsType(Object head,
Class<?> type) |
static <T> T |
Misc.createObject(Class<T> cls,
Class<?>[] argTypes,
Object[] args) |
static <T> T |
Misc.createObject(Class<T> cls,
Class<?>[] argTypes,
Object[] args) |
static <T> Class<? extends T> |
Reflection.getCallerClass(Class<T> type) |
static <A> A |
ObjectList.getFirst(Object head,
Class<A> type) |
static <A> A |
ObjectList.getNext(Object head,
Class<A> type,
Object prevData) |
static <T,E> E |
Misc.getNextElementOfType(T[] base,
Class<E> elemType,
T prev) |
static <T> boolean |
Misc.hasElementOfType(T[] base,
Class<?> elemType) |
static int |
ObjectList.numberOfInstances(Object head,
Class<?> type) |
static boolean |
Reflection.tryCallMain(Class<?> cls,
String[] args) |
static <A> ObjectList.TypedIterator<A> |
ObjectList.typedIterator(Object head,
Class<A> type) |
Modifier and Type | Method and Description |
---|---|
abstract Class<?> |
EventGeneratorFactory.getEventType() |
Modifier and Type | Method and Description |
---|---|
protected static List<Method> |
TestJPF.getAfterClassMethods(Class<? extends TestJPF> testCls) |
protected static List<Method> |
TestJPF.getAfterMethods(Class<? extends TestJPF> testCls) |
protected static List<Method> |
TestJPF.getBeforeClassMethods(Class<? extends TestJPF> testCls) |
protected static List<Method> |
TestJPF.getBeforeMethods(Class<? extends TestJPF> testCls) |
protected static List<Method> |
TestJPF.getContextMethods(Class<? extends TestJPF> testCls,
int setModifiers,
int unsetModifiers,
String annotation) |
protected static List<Method> |
TestJPF.getMatchingMethods(Class<? extends TestJPF> testCls,
int setModifiers,
int unsetModifiers,
String[] annotationNames) |
protected static List<Method> |
TestJPF.getTestMethods(Class<? extends TestJPF> testCls,
String[] args) |
protected JPF |
TestJPF.jpfException(Class<? extends Throwable> xCls,
String... args) |
protected JPF |
TestJPF.jpfException(StackTraceElement testMethod,
Class<? extends Throwable> xCls,
String... args)
run JPF expecting it to throw an exception
NOTE - xClassName needs to be the concrete exception, not a super class
|
protected JPF |
TestJPF.propertyViolation(Class<? extends Property> propertyCls,
String... args) |
protected JPF |
TestJPF.propertyViolation(StackTraceElement testMethod,
Class<? extends Property> propertyCls,
String... args)
run JPF expecting a property violation of the SuT
|
static void |
TestJPF.runTests(Class<? extends TestJPF> testCls,
String... args)
this is the main test loop if this TestJPF instance is executed directly
or called from RunTest.
|
Modifier and Type | Method and Description |
---|---|
Class<? extends ChoiceGenerator<?>> |
FieldInfo.getChoiceGeneratorType() |
Class<? extends ChoiceGenerator<?>> |
IntegerFieldInfo.getChoiceGeneratorType() |
Class<? extends ChoiceGenerator<?>> |
FloatFieldInfo.getChoiceGeneratorType() |
Class<? extends ChoiceGenerator<?>> |
DoubleFieldInfo.getChoiceGeneratorType() |
Class<? extends ChoiceGenerator<?>> |
ReferenceFieldInfo.getChoiceGeneratorType() |
Class<? extends ChoiceGenerator<?>> |
LongFieldInfo.getChoiceGeneratorType() |
Class<T> |
ChoiceGenerator.getChoiceType() |
Class<Boolean> |
BooleanChoiceGenerator.getChoiceType() |
Class<?> |
NativePeer.getPeerClass() |
Class<? extends ChoiceGenerator<?>> |
MethodInfo.getReturnChoiceGeneratorType() |
Modifier and Type | Method and Description |
---|---|
<A> ObjectList.TypedIterator<A> |
ChoiceGenerator.attrIterator(Class<A> attrType) |
<T> ObjectList.TypedIterator<T> |
InfoObject.attrIterator(Class<T> attrType) |
<T> ObjectList.TypedIterator<T> |
ChoiceGeneratorBase.attrIterator(Class<T> attrType) |
<T> ObjectList.TypedIterator<T> |
Instruction.attrIterator(Class<T> attrType) |
static <T> T |
Verify.createFromJSON(Class<T> clazz,
String json) |
<T> ObjectList.TypedIterator<T> |
ElementInfo.elementAttrIterator(int idx,
Class<T> type) |
<T> ObjectList.TypedIterator<T> |
ElementInfo.fieldAttrIterator(FieldInfo fi,
Class<T> type) |
<T> ObjectList.TypedIterator<T> |
Fields.fieldAttrIterator(int fieldOrElementIndex,
Class<T> type) |
<T> ObjectList.TypedIterator<T> |
StackFrame.frameAttrIterator(Class<T> attrType) |
<C extends ChoiceGenerator<?>> |
ChoiceGeneratorBase.getAllOfType(Class<C> cgType)
return array with all CGs (including this one) of given 'cgType', in registration order
|
<C extends ChoiceGenerator<?>> |
ChoiceGenerator.getAllOfType(Class<C> cgType)
return array with all CGs (including this one) of given 'cgType', in registration order
|
<A> A |
ChoiceGenerator.getAttr(Class<A> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T> T |
InfoObject.getAttr(Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T> T |
ChoiceGeneratorBase.getAttr(Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T> T |
Instruction.getAttr(Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T extends ChoiceGenerator<?>> |
SystemState.getChoiceGeneratorsOfType(Class<T> cgType) |
<T extends ChoiceGenerator<?>> |
VM.getChoiceGeneratorsOfType(Class<T> cgType) |
<T extends ChoiceGenerator<?>> |
SystemState.getCurrentChoiceGenerator(String id,
Class<T> cgType) |
<T extends ChoiceGenerator<?>> |
VM.getCurrentChoiceGenerator(String id,
Class<T> cgType)
return the latest registered ChoiceGenerator used in this transition
that matches the provided 'id' and is of 'cgType'.
|
<T extends ChoiceGenerator<?>> |
SystemState.getCurrentChoiceGeneratorOfType(Class<T> cgType) |
<T> T |
ElementInfo.getElementAttr(int idx,
Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T> T |
MJIEnv.getElementAttr(int objref,
int idx,
Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T> T |
ElementInfo.getFieldAttr(FieldInfo fi,
Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T> T |
Fields.getFieldAttr(int fieldOrElementIndex,
Class<T> type)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T> T |
MJIEnv.getFieldAttr(int objref,
String fname,
Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T> T |
StackFrame.getFrameAttr(Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T extends ChoiceGenerator<?>> |
SystemState.getInsnChoiceGeneratorOfType(Class<T> cgType,
Instruction insn,
ChoiceGenerator<?> cgPrev) |
static <T> T |
NativePeer.getInstance(Class<?> cls,
Class<T> type) |
static <T> T |
NativePeer.getInstance(Class<?> cls,
Class<T> type) |
static <T> T |
NativePeer.getInstance(Class<?> cls,
Class<T> type,
Class<?>[] argTypes,
Object[] args) |
static <T> T |
NativePeer.getInstance(Class<?> cls,
Class<T> type,
Class<?>[] argTypes,
Object[] args) |
static <T> T |
NativePeer.getInstance(Class<?> cls,
Class<T> type,
Class<?>[] argTypes,
Object[] args) |
<T extends ChoiceGenerator<?>> |
SystemState.getLastChoiceGeneratorOfType(Class<T> cgType) |
<T extends ChoiceGenerator<?>> |
VM.getLastChoiceGeneratorOfType(Class<T> cgType) |
<T> T |
StackFrame.getLocalAttr(int index,
Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
int |
StackFrame.getLocalAttrIndex(Class<?> attrType,
int startIdx)
helper to quickly find out if any of the locals slots holds
an attribute of the provided type
|
<T> T |
StackFrame.getLongOperandAttr(Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<A> A |
ChoiceGenerator.getNextAttr(Class<A> attrType,
Object prev) |
<T> T |
InfoObject.getNextAttr(Class<T> attrType,
Object prev) |
<T> T |
ChoiceGeneratorBase.getNextAttr(Class<T> attrType,
Object prev) |
<T> T |
Instruction.getNextAttr(Class<T> attrType,
Object prev) |
<T> T |
ElementInfo.getNextElementAttr(int idx,
Class<T> attrType,
Object prev) |
<T> T |
ElementInfo.getNextFieldAttr(FieldInfo fi,
Class<T> attrType,
Object prev) |
<T> T |
Fields.getNextFieldAttr(int fieldOrElementIndex,
Class<T> type,
Object prev) |
<T> T |
StackFrame.getNextFrameAttr(Class<T> attrType,
Object prev) |
<T> T |
VM.getNextListenerOfType(Class<T> type,
T prev) |
<T> T |
StackFrame.getNextLocalAttr(int index,
Class<T> attrType,
Object prev) |
<T> T |
StackFrame.getNextLongOperandAttr(Class<T> attrType,
Object prev) |
<T> T |
ElementInfo.getNextObjectAttr(Class<T> attrType,
Object prev) |
<T> T |
Fields.getNextObjectAttr(Class<T> attrType,
Object prev) |
<T> T |
StackFrame.getNextOperandAttr(Class<T> attrType,
Object prev) |
<T> T |
StackFrame.getNextOperandAttr(int offset,
Class<T> attrType,
Object prev) |
<T> T |
ElementInfo.getObjectAttr(Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T> T |
Fields.getObjectAttr(Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T> T |
MJIEnv.getObjectAttr(int objref,
Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T> T |
StackFrame.getOperandAttr(Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<T> T |
StackFrame.getOperandAttr(int offset,
Class<T> attrType)
this only returns the first attr of this type, there can be more
if you don't use client private types or the provided type is too general
|
<C extends ChoiceGenerator<?>> |
ChoiceGeneratorBase.getPreviousChoiceGeneratorOfType(Class<C> cls) |
<T extends ChoiceGenerator<?>> |
ChoiceGenerator.getPreviousChoiceGeneratorOfType(Class<T> cls) |
<T> T |
AnnotationInfo.getValue(String key,
Class<T> type) |
boolean |
StackFrame.hasArgumentAttr(MethodInfo miCallee,
Class<?> attrType)
check if there is any argument attr of the provided type on the operand stack
this is far more efficient than retrieving attribute values (we don't
care for argument types)
|
boolean |
InfoObject.hasAttr(Class<?> attrType) |
boolean |
ChoiceGeneratorBase.hasAttr(Class<?> attrType) |
boolean |
ChoiceGenerator.hasAttr(Class<?> attrType) |
boolean |
Instruction.hasAttr(Class<?> attrType) |
boolean |
ElementInfo.hasElementAttr(Class<?> attrType) |
boolean |
MJIEnv.hasElementAttr(int objref,
Class<?> type) |
boolean |
ElementInfo.hasFieldAttr(Class<?> attrType) |
boolean |
Fields.hasFieldAttr(Class<?> attrType) |
boolean |
MJIEnv.hasFieldAttr(int objref,
Class<?> type) |
boolean |
Fields.hasFieldAttr(int fieldOrElementIndex,
Class<?> type) |
boolean |
StackFrame.hasFrameAttr(Class<?> attrType) |
boolean |
ClassInfo.hasInstanceFieldInfoAttr(Class<?> type) |
boolean |
VM.hasListenerOfType(Class<?> listenerCls) |
boolean |
StackFrame.hasLocalAttr(int index,
Class<?> type) |
boolean |
StackFrame.hasLongOperandAttr(Class<?> type) |
boolean |
ElementInfo.hasObjectAttr(Class<?> attrType) |
boolean |
Fields.hasObjectAttr(Class<?> attrType) |
boolean |
MJIEnv.hasObjectAttr(int objref,
Class<?> type) |
boolean |
StackFrame.hasOperandAttr(Class<?> type) |
boolean |
StackFrame.hasOperandAttr(int offset,
Class<?> type) |
protected void |
NativePeer.initialize(Class<?> peerClass,
ClassInfo ci,
boolean cacheMethods) |
protected static void |
NativePeer.initializePeerClass(Class<?> cls) |
<T> ObjectList.TypedIterator<T> |
StackFrame.localAttrIterator(int index,
Class<T> attrType) |
<T> ObjectList.TypedIterator<T> |
StackFrame.longOperandAttrIterator(Class<T> attrType) |
<T> ObjectList.TypedIterator<T> |
ElementInfo.objectAttrIterator(Class<T> type) |
<T> ObjectList.TypedIterator<T> |
Fields.objectAttrIterator(Class<T> attrType) |
<T> Iterator<T> |
StackFrame.operandAttrIterator(Class<T> attrType) |
<T> ObjectList.TypedIterator<T> |
StackFrame.operandAttrIterator(int offset,
Class<T> attrType) |
static <T> T |
Verify.readObjectFromFile(Class<T> clazz,
String fileName) |
static void |
Verify.setPeerClass(Class<?> cls) |
Modifier and Type | Method and Description |
---|---|
Class<Integer> |
TypedObjectChoice.getChoiceType() |
Class<Long> |
RandomOrderLongCG.getChoiceType() |
Class<ThreadInfo> |
BreakGenerator.getChoiceType() |
Class<Integer> |
RandomOrderIntCG.getChoiceType() |
Class<Long> |
LongChoiceFromList.getChoiceType() |
Class<Integer> |
IntChoiceFromList.getChoiceType() |
Class<Integer> |
RandomIntIntervalGenerator.getChoiceType() |
Class<Double> |
DoubleChoiceFromList.getChoiceType() |
Class<Integer> |
IntIntervalGenerator.getChoiceType() |
Class<Invocation> |
InvocationCG.getChoiceType() |
Class<Float> |
FloatChoiceFromList.getChoiceType() |
Class<Double> |
DoubleThresholdGenerator.getChoiceType() |
Class<ThreadInfo> |
ThreadChoiceFromSet.getChoiceType() |
Modifier and Type | Method and Description |
---|---|
<U> Class<? extends U> |
Class.asSubclass(Class<U> clazz) |
protected Class<?> |
ClassLoader.defineClass(byte[] b,
int off,
int len) |
protected Class<?> |
ClassLoader.defineClass(String name,
byte[] b,
int off,
int len) |
protected Class<?> |
ClassLoader.defineClass(String name,
byte[] b,
int off,
int len,
ProtectionDomain protectionDomain) |
protected Class<?> |
ClassLoader.defineClass(String name,
ByteBuffer b,
ProtectionDomain protectionDomain) |
protected Class<?> |
ClassLoader.findClass(String name)
Finds the class with a given name.
|
protected Class<?> |
ClassLoader.findLoadedClass(String name)
If the class with the given name has been already defined, it is returned.
|
protected Class<?> |
ClassLoader.findSystemClass(String name) |
static Class<?> |
Class.forName(String clsName)
this one is in JPF reflection land, it's 'native' for us
|
static Class<?> |
Class.forName(String clsName,
boolean initialize,
ClassLoader loader) |
Class<?> |
Object.getClass() |
Class<?>[] |
Class.getClasses() |
Class<?> |
Class.getComponentType() |
Class<?>[] |
Class.getDeclaredClasses() |
Class<?> |
Class.getDeclaringClass() |
Class<?> |
Class.getEnclosingClass() |
Class<?>[] |
Class.getInterfaces() |
Class<? super T> |
Class.getSuperclass() |
Class<?> |
ClassLoader.loadClass(String name) |
protected Class<?> |
ClassLoader.loadClass(String name,
boolean resolve) |
Modifier and Type | Method and Description |
---|---|
<U> Class<? extends U> |
Class.asSubclass(Class<U> clazz) |
<A extends Annotation> |
Class.getAnnotation(Class<A> annotationCls) |
Constructor<T> |
Class.getConstructor(Class<?>... argTypes) |
Constructor<T> |
Class.getDeclaredConstructor(Class<?>... paramTypes) |
Method |
Class.getDeclaredMethod(String mthName,
Class<?>... paramTypes) |
Method |
Class.getMethod(String mthName,
Class<?>... paramTypes) |
boolean |
Class.isAnnotationPresent(Class<? extends Annotation> annotationClass) |
boolean |
Class.isAssignableFrom(Class<?> clazz) |
protected void |
ClassLoader.resolveClass(Class<?> c)
All the class objects are resolved internally by JPF.
|
protected void |
ClassLoader.setSigners(Class<?> c,
Object[] signers) |
Modifier and Type | Method and Description |
---|---|
Class<?> |
Method.getDeclaringClass() |
Class<?> |
Field.getDeclaringClass() |
Class<T> |
Constructor.getDeclaringClass() |
Class<?>[] |
Method.getExceptionTypes() |
Class<?>[] |
Method.getParameterTypes() |
Class<?>[] |
Constructor.getParameterTypes() |
Class<?> |
Method.getReturnType() |
Class<?> |
Constructor.getReturnType() |
Class<?> |
Field.getType() |
Modifier and Type | Method and Description |
---|---|
<T extends Annotation> |
Method.getAnnotation(Class<T> annotationCls) |
<T extends Annotation> |
Field.getAnnotation(Class<T> annotationCls) |
<T extends Annotation> |
Constructor.getAnnotation(Class<T> annotationCls) |
<T extends Annotation> |
AccessibleObject.getAnnotation(Class<T> cls) |
boolean |
AccessibleObject.isAnnotationPresent(Class<? extends Annotation> cls) |
Modifier and Type | Method and Description |
---|---|
protected Class<?> |
URLClassLoader.findClass(String name) |
Modifier and Type | Method and Description |
---|---|
static <O,F> AtomicReferenceFieldUpdater<O,F> |
AtomicReferenceFieldUpdater.newUpdater(Class<O> objClass,
Class<F> fieldClass,
String fieldName) |
static <O,F> AtomicReferenceFieldUpdater<O,F> |
AtomicReferenceFieldUpdater.newUpdater(Class<O> objClass,
Class<F> fieldClass,
String fieldName) |
static <O> AtomicLongFieldUpdater<O> |
AtomicLongFieldUpdater.newUpdater(Class<O> objClass,
String fieldName) |
static <O> AtomicIntegerFieldUpdater<O> |
AtomicIntegerFieldUpdater.newUpdater(Class<O> objClass,
String fieldName) |
Constructor and Description |
---|
AtomicIntegerFieldUpdater(Class<T> objClass,
String fieldName) |
AtomicLongFieldUpdater(Class<T> objClass,
String fieldName) |
AtomicReferenceFieldUpdater(Class<T> objClass,
Class<V> fieldClass,
String fieldName) |
AtomicReferenceFieldUpdater(Class<T> objClass,
Class<V> fieldClass,
String fieldName) |
Modifier and Type | Method and Description |
---|---|
int |
Unsafe.arrayBaseOffset(Class<?> clazz) |
int |
Unsafe.arrayIndexScale(Class<?> clazz) |
void |
Unsafe.ensureClassInitialized(Class<?> cls) |
AnnotationType |
JavaLangAccess.getAnnotationType(Class<?> klass) |
ConstantPool |
JavaLangAccess.getConstantPool(Class<?> klass) |
<E extends Enum<E>> |
JavaLangAccess.getEnumConstantsShared(Class<E> klass) |
void |
JavaLangAccess.setAnnotationType(Class<?> klass,
AnnotationType annotationType) |
Modifier and Type | Method and Description |
---|---|
Class<?> |
ConstantPool.getClassAt(int index) |
Class<?> |
ConstantPool.getClassAtIfLoaded(int index) |
Modifier and Type | Method and Description |
---|---|
static Class<?> |
AnnotationType.invocationHandlerReturnType(Class<?> type) |
Modifier and Type | Method and Description |
---|---|
Map<String,Class<?>> |
AnnotationType.memberTypes() |
Modifier and Type | Method and Description |
---|---|
static AnnotationType |
AnnotationType.getInstance(Class<?> annotationClass) |
static Class<?> |
AnnotationType.invocationHandlerReturnType(Class<?> type) |