See: Description
Interface | Description |
---|---|
ByteCodeElement |
Implementations describe an element represented in byte code, i.e.
|
ExceptionMethod.ConstructionDelegate |
A construction delegate is responsible for calling a isThrowable's constructor.
|
FieldAccessor.AssignerConfigurable |
A field accessor that can be configured to use a given assigner and runtime type use configuration.
|
FieldAccessor.FieldDefinable |
Determines a field accessor that accesses a field of a given name which might not yet be
defined.
|
FieldAccessor.FieldLocator |
A field locator allows to determine a field name for a given method.
|
FieldAccessor.FieldLocator.Factory |
A factory for creating a
FieldAccessor.FieldLocator . |
FieldAccessor.FieldNameExtractor |
A field name extractor is responsible for determining a field name to a method that is implemented
to access this method.
|
FieldAccessor.OwnerTypeLocatable |
A field accessor that can be configured to locate a field in a specific manner.
|
FixedValue.AssignerConfigurable |
Represents a fixed value instrumentation that is using a default assigner for attempting to assign
the fixed value to the return type of the instrumented method.
|
Forwarding.PreparationHandler |
A handler for preparing a
Forwarding instrumentation. |
Instrumentation |
An instrumentation is responsible for implementing (or not implementing) methods of a dynamically created type.
|
Instrumentation.Context |
The context for an instrumentation application.
|
Instrumentation.Context.Default.AuxiliaryTypeNamingStrategy |
Representation of a naming strategy for an auxiliary type.
|
Instrumentation.Context.ExtractableView |
Represents an extractable view of an
Instrumentation.Context which
allows the retrieval of any registered auxiliary type. |
Instrumentation.Context.ExtractableView.InjectedCode |
When draining an instrumentation context, a type initializer might be written to the created class
file.
|
Instrumentation.SpecialMethodInvocation |
Represents an type-specific method invocation on the current instrumented type which is not legal from outside
the type such as a super method or default method invocation.
|
Instrumentation.Target |
The target of an instrumentation.
|
Instrumentation.Target.Factory |
A factory for creating an
Instrumentation.Target . |
Instrumentation.Target.MethodLookup |
A strategy for looking up a method.
|
InvocationHandlerAdapter.AssignerConfigurable |
Allows for the configuration of an
Assigner
of an InvocationHandlerAdapter . |
InvokeDynamic.InvocationProvider |
An invocation provider is responsible for loading the arguments of the invoked method onto the operand
stack and for creating the actual invoke dynamic instruction.
|
InvokeDynamic.InvocationProvider.ArgumentProvider |
An argument provider is responsible for loading arguments to a bootstrapped method onto the operand
stack and providing the types of these arguments.
|
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved | |
InvokeDynamic.InvocationProvider.NameProvider |
Provides the name of the method that is to be bound by a dynamic method call.
|
InvokeDynamic.InvocationProvider.ReturnTypeProvider |
Provides the return type that is requested from the bootstrap method.
|
InvokeDynamic.InvocationProvider.Target |
A target for a dynamic method invocation.
|
InvokeDynamic.InvocationProvider.Target.Resolved |
Represents a resolved
InvokeDynamic.InvocationProvider.Target . |
InvokeDynamic.TerminationHandler |
A termination handler is responsible to handle the return value of a method that is invoked via a
InvokeDynamic . |
LoadedTypeInitializer |
Implementations of this interface explicitly initialize a loaded type.
|
MethodCall.ArgumentLoader |
An argument loader is responsible for loading an argument for an invoked method
onto the operand stack.
|
MethodCall.MethodInvoker |
A method invoker is responsible for creating a method invokation that is to be applied by a
MethodCall . |
MethodCall.MethodLocator |
A method locator is responsible for identifying the method that is to be invoked
by a
MethodCall . |
MethodCall.TargetHandler |
A target handler is responsible for invoking a method for a
MethodCall . |
MethodCall.TerminationHandler |
A termination handler is responsible to handle the return value of a method that is invoked via a
MethodCall . |
MethodDelegation.InstrumentationDelegate |
An instrumentation delegate is responsible for executing the actual method delegation.
|
ModifierContributor |
An element that describes a type modifier as described in the
JVMS.
|
ModifierContributor.ForField |
A marker interface for modifiers that can be applied to fields.
|
ModifierContributor.ForMethod |
A marker interface for modifiers that can be applied to methods.
|
ModifierContributor.ForType |
A marker interface for modifiers that can be applied to types.
|
ModifierReviewable |
Implementations of this interface can be described in terms of a Java modifier.
|
NamedElement |
Represents a Java element with a name.
|
Class | Description |
---|---|
DefaultMethodCall |
This
Instrumentation invokes a default method for the methods it instruments. |
DefaultMethodCall.Appender |
The appender for implementing a
DefaultMethodCall . |
ExceptionMethod |
This instrumentation causes a
Throwable to be thrown when the instrumented method is invoked. |
ExceptionMethod.ConstructionDelegate.ForDefaultConstructor |
A construction delegate that calls the default constructor.
|
ExceptionMethod.ConstructionDelegate.ForStringConstructor |
A construction delegate that calls a constructor that takes a single string as its argument.
|
FieldAccessor |
Defines a method to access a given field by following the Java bean conventions for getters and setters:
Getter: A method named
getFoo() will be instrumented to read and return the value of a field foo
or another field if one was specified explicitly. |
FieldAccessor.FieldLocator.ForGivenType |
A field locator that only looks up fields that are defined for a given type.
|
FieldAccessor.FieldLocator.ForGivenType.Factory |
A factory for a field locator locating given type.
|
FieldAccessor.FieldLocator.ForInstrumentedTypeHierarchy |
A field locator that finds a type by traversing the type hierarchy beginning with fields defined
in the most specific subclass traversing the class hierarchy down to the least specific type.
|
FieldAccessor.ForNamedField |
Implementation of a field accessor instrumentation where the field name is given explicitly.
|
FieldAccessor.ForUnnamedField |
Implementation of a field accessor instrumentation where a field is identified by a method's name following
the Java specification for bean properties.
|
FixedValue |
This instrumentation returns a fixed value for a method.
|
FixedValue.ForPoolValue |
A fixed value instrumentation that represents its fixed value as a value that is written to the instrumented
class's constant pool.
|
FixedValue.ForStaticField |
A fixed value instrumentation that represents its fixed value as a static field of the instrumented class.
|
Forwarding |
This instrumentation forwards method invocations to another instance.
|
Forwarding.PreparationHandler.ForStaticInstance |
A preparation handler for an explicit instance that is stored in a
static field. |
Instrumentation.Compound |
A compound instrumentation that allows to combine several instrumentations.
|
Instrumentation.Context.Default |
A default implementation of an
Instrumentation.Context.ExtractableView
which serves as its own AuxiliaryType.MethodAccessorFactory . |
Instrumentation.Context.Default.AccessorMethodDelegation |
An implementation of a
TypeWriter.MethodPool.Entry for implementing
an accessor method. |
Instrumentation.Context.Default.AuxiliaryTypeNamingStrategy.SuffixingRandom |
A naming strategy for an auxiliary type which returns the instrumented type's name with a fixed extension
and a random number as a suffix.
|
Instrumentation.Context.Default.FieldCacheAppender |
A byte code appender that writes the field cache entries to a given
MethodVisitor . |
Instrumentation.Context.Default.FieldCacheEntry |
A field cache entry for uniquely identifying a cached field.
|
Instrumentation.Context.Default.FieldGetter |
An implementation for a field getter.
|
Instrumentation.Context.Default.FieldSetter |
An implementation for a field setter.
|
Instrumentation.Simple |
A simple implementation of an instrumentation that does not register any members with the instrumented type.
|
Instrumentation.SpecialMethodInvocation.Simple |
A canonical implementation of a
Instrumentation.SpecialMethodInvocation . |
Instrumentation.Target.AbstractBase |
An abstract base implementation for an
Instrumentation.Target . |
InvocationHandlerAdapter |
An adapter for adapting an
InvocationHandler . |
InvocationHandlerAdapter.ForInstanceDelegation |
An implementation of an
InvocationHandlerAdapter that delegates method
invocations to an adapter that is stored in an instance field. |
InvocationHandlerAdapter.ForStaticDelegation |
An implementation of an
InvocationHandlerAdapter that delegates method
invocations to an adapter that is stored in a static field. |
InvokeDynamic |
An instrumentation that applies a
dynamic method invocation.
|
InvokeDynamic.InvocationProvider.ArgumentProvider.ForBooleanValue |
An argument provider for a
boolean value. |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForByteValue |
An argument provider for a
byte value. |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForCharacterValue |
An argument provider for a
char value. |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForDoubleValue |
An argument provider for a
double value. |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForExistingField |
Provides an argument from an existing field.
|
InvokeDynamic.InvocationProvider.ArgumentProvider.ForFloatValue |
An argument provider for a
float value. |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForInstanceField |
An argument provider that loads a value from an instance field.
|
InvokeDynamic.InvocationProvider.ArgumentProvider.ForIntegerValue |
An argument provider for a
int value. |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForLongValue |
An argument provider for a
long value. |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter |
An argument provider that loads an argument of the intercepted method.
|
InvokeDynamic.InvocationProvider.ArgumentProvider.ForNullValue |
An argument provider for the
null value. |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForShortValue |
An argument provider for a
short value. |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForStaticField |
An argument provider for a value that is stored in a randomly named static field.
|
InvokeDynamic.InvocationProvider.ArgumentProvider.ForStringValue |
An argument provider for a
String value. |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForThisInstance |
An argument provider that loads the intercepted instance.
|
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved.Simple |
A simple implementation of a resolved argument provider.
|
InvokeDynamic.InvocationProvider.Default |
An invocation provider that requests a synthetic dynamic invocation where all arguments are explicitly
provided by the user.
|
InvokeDynamic.InvocationProvider.Default.Target |
A target for a synthetically bound method call.
|
InvokeDynamic.InvocationProvider.NameProvider.ForExplicitName |
A name provider that provides an explicit name.
|
InvokeDynamic.InvocationProvider.ReturnTypeProvider.ForExplicitType |
Requests an explicit return type.
|
InvokeDynamic.InvocationProvider.Target.ForMethodDescription |
A target that requests to dynamically invoke a method to substitute for a given method.
|
InvokeDynamic.InvocationProvider.Target.Resolved.Simple |
A simple implementation of
InvokeDynamic.InvocationProvider.Target.Resolved . |
InvokeDynamic.WithImplicitArguments |
Representation of an
InvokeDynamic instrumentation where the bootstrapped
method is passed a this reference, if available, and any arguments of the instrumented method. |
InvokeDynamic.WithImplicitTarget |
Representation of an
InvokeDynamic instrumentation where the bootstrapped
method is passed a this reference, if available, and any arguments of the instrumented method and
where the invocation target is implicit. |
LoadedTypeInitializer.Compound |
A compound loaded type initializer that combines several type initializers.
|
LoadedTypeInitializer.ForStaticField<T> |
A type initializer for setting a value for a static field.
|
MethodCall |
This
Instrumentation allows the invocation of a specified method while
providing explicit arguments to this method. |
MethodCall.ArgumentLoader.ForBooleanConstant |
Loads a
boolean value onto the operand stack. |
MethodCall.ArgumentLoader.ForByteConstant |
Loads a
byte value onto the operand stack. |
MethodCall.ArgumentLoader.ForCharacterConstant |
Loads a
char value onto the operand stack. |
MethodCall.ArgumentLoader.ForDoubleConstant |
Loads a
double value onto the operand stack. |
MethodCall.ArgumentLoader.ForExistingField |
Loads the value of an existing field onto the operand stack.
|
MethodCall.ArgumentLoader.ForFloatConstant |
Loads a
float value onto the operand stack. |
MethodCall.ArgumentLoader.ForInstanceField |
Loads a value onto the operand stack that is stored in an instance field.
|
MethodCall.ArgumentLoader.ForIntegerConstant |
Loads an
int value onto the operand stack. |
MethodCall.ArgumentLoader.ForLongConstant |
Loads a
long value onto the operand stack. |
MethodCall.ArgumentLoader.ForMethodParameter |
Loads a parameter of the instrumented method onto the operand stack.
|
MethodCall.ArgumentLoader.ForShortConstant |
Loads a
short value onto the operand stack. |
MethodCall.ArgumentLoader.ForStaticField |
Loads a value onto the operand stack that is stored in a static field.
|
MethodCall.ArgumentLoader.ForTextConstant |
Loads a
String value onto the operand stack. |
MethodCall.MethodLocator.ForExplicitMethod |
Invokes a given method.
|
MethodCall.TargetHandler.ForInstanceField |
Creates a target handler that stores the instance to invoke a method on in an instance field.
|
MethodCall.TargetHandler.ForStaticField |
A target handler that invokes a method on an instance that is stored in a static field.
|
MethodCall.WithoutSpecifiedTarget |
Represents a
MethodCall that invokes a method without specifying
an invocation method. |
MethodDelegation |
This instrumentation delegates an method call to another method which can either be
static by providing
a reference to a Class or an instance method when another object is provided. |
MethodDelegation.Appender |
The appender for implementing a
MethodDelegation . |
MethodDelegation.InstrumentationDelegate.ForConstruction |
An instrumentation that creates new instances of a given type.
|
MethodDelegation.InstrumentationDelegate.ForInstanceField |
An instrumentation applied on an instance field.
|
MethodDelegation.InstrumentationDelegate.ForStaticField |
An instrumentation applied on a static field.
|
ModifierReviewable.AbstractModifierReviewable |
An abstract base implementation of a
ModifierReviewable class. |
SuperMethodCall.Appender |
An appender for implementing a
SuperMethodCall . |
Enum | Description |
---|---|
FieldAccessor.FieldLocator.ForInstrumentedType |
A factory that only looks up fields in the instrumented type.
|
FieldAccessor.FieldLocator.ForInstrumentedTypeHierarchy.Factory |
A field locator factory creating a
FieldAccessor.FieldLocator.ForInstrumentedTypeHierarchy . |
FieldAccessor.FieldNameExtractor.ForBeanProperty |
A
FieldAccessor.FieldNameExtractor that determines a field name
according to the rules of Java bean naming conventions. |
Forwarding.PreparationHandler.ForInstanceField |
A preparation handler for an unset instance that is stored in an instance field.
|
Forwarding.PreparationHandler.ForStaticField |
A preparation handler for an unset instance that is stored in a
static field. |
Instrumentation.Context.ExtractableView.InjectedCode.None |
A canonical implementation of non-applicable injected code.
|
Instrumentation.ForAbstractMethod |
An instrumentation for an abstract method that does not append any code and will throw an exception if it is
attempted to be composed with other methods that do provide an implementation.
|
Instrumentation.SpecialMethodInvocation.Illegal |
A canonical implementation of an illegal
Instrumentation.SpecialMethodInvocation . |
Instrumentation.Target.MethodLookup.Default |
Default implementations of a
Instrumentation.Target.MethodLookup . |
InvokeDynamic.InvocationProvider.ArgumentProvider.ConstantPoolWrapper |
Represents wrapper types and types that could be stored in a class's constant pool as such
constant pool values.
|
InvokeDynamic.InvocationProvider.ArgumentProvider.ForInterceptedMethodInstanceAndParameters |
An argument provider that loads a reference to the intercepted instance and all arguments of
the intercepted method.
|
InvokeDynamic.InvocationProvider.ArgumentProvider.ForInterceptedMethodParameters |
An argument provider that loads all arguments of the intercepted method.
|
InvokeDynamic.InvocationProvider.NameProvider.ForInterceptedMethod |
A name provider that provides the name of the intercepted method.
|
InvokeDynamic.InvocationProvider.ReturnTypeProvider.ForInterceptedMethod |
Requests the return type of the intercepted method.
|
InvokeDynamic.TerminationHandler.ForChainedInvocation |
Drops the return value of the dynamic invocation from the operand stack without returning from the
intercepted method.
|
InvokeDynamic.TerminationHandler.ForMethodReturn |
Returns the return value of the dynamic invocation from the intercepted method.
|
LoadedTypeInitializer.NoOp |
A loaded type initializer that does not do anything.
|
MethodCall.ArgumentLoader.ForNullConstant |
An argument loader that loads the
null value onto the operand stack. |
MethodCall.ArgumentLoader.ForThisReference |
An argument loader that assigns the
this reference to a parameter. |
MethodCall.MethodInvoker.ForDefaultMethodInvocation |
Invokes a method as a Java 8 default method.
|
MethodCall.MethodInvoker.ForStandardInvocation |
Applies a standard invocation of the provided method, i.e.
|
MethodCall.MethodInvoker.ForSuperMethodInvocation |
Applies a super method invocation of the provided method.
|
MethodCall.MethodLocator.ForInterceptedMethod |
A method locator that simply returns the intercepted method.
|
MethodCall.TargetHandler.ForConstructingInvocation |
Invokes a method in order to construct a new instance.
|
MethodCall.TargetHandler.ForSelfOrStaticInvocation |
A target handler that invokes a method either on the instance of the instrumented
type or as a static method.
|
MethodCall.TerminationHandler.ForChainedInvocation |
Drops the return value of the called method from the operand stack without returning from the intercepted
method.
|
MethodCall.TerminationHandler.ForMethodReturn |
Returns the return value of the method call from the intercepted method.
|
MethodDelegation.InstrumentationDelegate.ForStaticMethod |
An instrumentation applied to a static method.
|
StubMethod |
This instrumentation creates a method stub which does nothing but returning the default value of the return
type of the method.
|
SuperMethodCall |
This instrumentation will create a new method which simply calls its super method.
|
SuperMethodCall.Appender.TerminationHandler |
A handler that determines how to handle the method return value.
|
SuperMethodCall.WithoutReturn |
A super method invocation where the return value is dropped instead of returning from the method.
|
ExceptionMethod
: This interception allows to throw
Throwable
instances on a method call.FieldAccessor
: A field accessor allows to read or write a class's field
value according to the Java bean specification, i.e. implements setter and getter methods.InvocationHandlerAdapter
: An adapter for instrumenting methods by
delegating method calls to a InvocationHandler
which is already used for Java proxies.MethodDelegation
: Allows to delegate a method call to either a static
or to an instance method. The method delegation is determined by annotations on the target method.StubMethod
: A stub method overrides a method by an empty implementation
that only returns the method's return type's default value.SuperMethodCall
: This instrumentation calls a method's super implementation.
This instrumentation is handy when annotations should be added to a method without changing the method's
implementation.Copyright © 2014–2015. All rights reserved.