Package | Description |
---|---|
net.bytebuddy |
Byte Buddy is a library for creating Java classes at runtime of a Java program.
|
net.bytebuddy.agent.builder |
An agent builder is used to easily implement load-time class-transformations using a Java agent.
|
net.bytebuddy.asm |
The ASM package contains classes that are meant for direct interaction with the ASM API.
|
net.bytebuddy.build |
A package for types that allow for applying Byte Buddy transformation during a build process.
|
net.bytebuddy.description.annotation |
Contains descriptions of annotations and annotation values.
|
net.bytebuddy.description.method |
Contains descriptions of Java methods and constructors as well as their parameters.
|
net.bytebuddy.description.modifier |
The modifier package contains high-level and type-safe descriptions of Java modifiers.
|
net.bytebuddy.description.type |
Contains descriptions of Java types and packages.
|
net.bytebuddy.dynamic |
This package contains classes and interfaces that are connected to writing the byte stream that represents a Java
type that is dynamically created and for loading this type into a running JVM process.
|
net.bytebuddy.dynamic.loading |
This package contains classes that are responsible for class loading of classes that are represented by
byte arrays. |
net.bytebuddy.dynamic.scaffold |
This package contains helper types and implementations that are responsible for the actual writing of a byte array
representing a Java class.
|
net.bytebuddy.dynamic.scaffold.inline |
All classes and types in this package are related to creating a
DynamicType by
enhancing a given type. |
net.bytebuddy.dynamic.scaffold.subclass |
All classes and types in this package are related to creating a
DynamicType by
creating a subclass of a given type. |
net.bytebuddy.implementation |
The implementation package contains any logic for intercepting method calls.
|
net.bytebuddy.implementation.attribute |
All types and classes in this package are responsible for writing attributes for a given Java byte code element,
i.e. fields, types and byte code methods.
|
net.bytebuddy.implementation.auxiliary |
Auxiliary types describe helper types that aid as a supplementary to a given
InstrumentedType . |
net.bytebuddy.implementation.bind |
The types and classes of this package are responsible for binding a method call to calling another method.
|
net.bytebuddy.implementation.bind.annotation |
This package contains annotations, types and classes that are responsible for binding a method to calling another
method by interpreting annotations that indicate how a method should be bound to another method.
|
net.bytebuddy.implementation.bytecode |
Types and classes in this package are responsible for creating Java byte code for a given byte code target
which is represented by a
MethodDescription . |
net.bytebuddy.implementation.bytecode.assign |
An
Assigner is responsible for transforming
a given TypeDescription into another one. |
net.bytebuddy.implementation.bytecode.assign.primitive |
Assigner implementations of this package
are capable of handling primitive types or the void type. |
net.bytebuddy.implementation.bytecode.assign.reference |
Assigner implementations of this package
are capable of assigning non-primitive types to each other. |
net.bytebuddy.implementation.bytecode.collection |
This package is dedicated to creating
StackManipulation s
that create collections or arrays from a given number of values. |
net.bytebuddy.implementation.bytecode.constant |
StackManipulation s in this package are responsible for
creating compile-time constants and pushing them onto the operand stack. |
net.bytebuddy.implementation.bytecode.member |
StackManipulation s of this package are responsible for
accessing type or method members, i.e. reading and writing of fields, invoking of methods, access of local variables
within a method invocation or returning values from method invocations. |
net.bytebuddy.matcher |
Contains an API for matching Java byte code entities.
|
net.bytebuddy.pool |
Classes of this package allow for the creating
TypeDescription s without
loading any classes. |
net.bytebuddy.utility |
This package contains utility classes for common use within any Byte Buddy logic.
|
net.bytebuddy.utility.dispatcher |
A package to handle dispatching of classes.
|
net.bytebuddy.utility.privilege |
A package containing
PrivilegedAction s that are used for invoking sensitive methods. |
Modifier and Type | Class and Description |
---|---|
class |
ByteBuddy
Instances of this class serve as a focus point for configuration of the library's behavior and as an entry point
to any form of code generation using the library.
|
protected static class |
ByteBuddy.EnumerationImplementation
An implementation fo the
values method of an enumeration type. |
protected static class |
ByteBuddy.EnumerationImplementation.InitializationAppender
A byte code appender for the type initializer of any enumeration type.
|
protected static class |
ByteBuddy.EnumerationImplementation.ValuesMethodAppender
A byte code appender for the
values method of any enumeration type. |
protected static class |
ByteBuddy.RecordConstructorStrategy
A constructor strategy for implementing a Java record.
|
protected static class |
ByteBuddy.RecordConstructorStrategy.Appender
A byte code appender for accessors and the record constructor.
|
protected static class |
ByteBuddy.RecordObjectMethod
Implements the object methods of the Java record type.
|
class |
ClassFileVersion
A wrapper object for representing a validated class file version in the format that is specified by the
JVMS.
|
static class |
ClassFileVersion.VersionLocator.Resolved
A version locator for a resolved class file version.
|
static class |
ClassFileVersion.VersionLocator.Unresolved
An unresolved version locator.
|
static class |
NamingStrategy.PrefixingRandom
A naming strategy that creates a name by prefixing a given class and its package with another package and
by appending a random number to the class's simple name.
|
static class |
NamingStrategy.Suffixing
A naming strategy that appends a given suffix to a name, without a randomized element.
|
static class |
NamingStrategy.Suffixing.BaseNameResolver.ForFixedValue
A base name resolver that simply returns a fixed value.
|
static class |
NamingStrategy.Suffixing.BaseNameResolver.ForGivenType
Uses a specific type's name as the resolved name.
|
static class |
NamingStrategy.SuffixingRandom
A naming strategy that creates a name by concatenating:
The super classes package and name
A given suffix string
A random number
Between all these elements, a
$ sign is included into the name to improve readability. |
Modifier and Type | Class and Description |
---|---|
static class |
AgentBuilder.CircularityLock.Global
A circularity lock that holds a global monitor and does not permit concurrent access.
|
static class |
AgentBuilder.Default
The default implementation of an
AgentBuilder . |
static class |
AgentBuilder.Default.ExecutingTransformer.Factory.ForJava9CapableVm
A factory for a class file transformer on a JVM that supports the
java.lang.Module API to override
the newly added method of the ClassFileTransformer to capture an instrumented class's module. |
protected class |
AgentBuilder.Default.ExecutingTransformer.Java9CapableVmDispatcher
A privileged action for transforming a class on a JVM that supports modules.
|
protected class |
AgentBuilder.Default.ExecutingTransformer.LegacyVmDispatcher
A privileged action for transforming a class on a JVM prior to Java 9.
|
protected class |
AgentBuilder.Default.Ignoring
A delegator transformer for further precising what types to ignore.
|
static class |
AgentBuilder.Default.NativeMethodStrategy.ForPrefix
A native method strategy that prefixes method names with a fixed value for supporting rebasing of native methods.
|
protected static class |
AgentBuilder.Default.Transformation
A transformation to apply.
|
protected static class |
AgentBuilder.Default.Transformation.DifferentialMatcher
A matcher that considers the differential of two transformers' transformations.
|
protected static class |
AgentBuilder.Default.Transformation.SimpleMatcher
A matcher that matches any type that is touched by a transformer without being ignored.
|
protected class |
AgentBuilder.Default.Transforming
A helper class that describes a
AgentBuilder.Default after supplying
a AgentBuilder.RawMatcher such that one or several
AgentBuilder.Transformer s can be supplied. |
static class |
AgentBuilder.Default.WarmupStrategy.Enabled
An enabled warmup strategy.
|
static class |
AgentBuilder.DescriptionStrategy.SuperTypeLoading
A description strategy that enforces the loading of any super type of a type description but delegates the actual type description
to another description strategy.
|
static class |
AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous
A description strategy that enforces the loading of any super type of a type description but delegates the actual type description
to another description strategy.
|
protected static class |
AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous.ThreadSwitchingClassLoadingDelegate
A class loading delegate that delegates loading of the super type to another thread.
|
protected static class |
AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous.ThreadSwitchingClassLoadingDelegate.SimpleClassLoadingAction
A class loading action that simply loads a type.
|
protected static class |
AgentBuilder.DescriptionStrategy.SuperTypeLoading.UnlockingClassLoadingDelegate
A class loading delegate that unlocks the circularity lock during class loading.
|
static class |
AgentBuilder.FallbackStrategy.ByThrowableType
A fallback strategy that discriminates by the type of the
Throwable that triggered a request. |
static class |
AgentBuilder.InitializationStrategy.SelfInjection
An initialization strategy that adds a code block to an instrumented type's type initializer which
then calls a specific class that is responsible for the explicit initialization.
|
protected static class |
AgentBuilder.InitializationStrategy.SelfInjection.Dispatcher
A dispatcher for a self-initialization strategy.
|
protected static class |
AgentBuilder.InitializationStrategy.SelfInjection.Dispatcher.InjectingInitializer
A type initializer that injects all auxiliary types of the instrumented type.
|
static class |
AgentBuilder.InjectionStrategy.UsingInstrumentation
An injection strategy that uses bootstrap injection using an
Instrumentation instance. |
static class |
AgentBuilder.InjectionStrategy.UsingUnsafe.OfFactory
An injection strategy that uses a factory for creating an unsafe injector.
|
static class |
AgentBuilder.InstallationListener.Compound
A compound installation listener.
|
static class |
AgentBuilder.InstallationListener.StreamWriting
This installation listener prints the status of any installation to a
PrintStream . |
protected static class |
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory
A factory that creates instances that represent lambda expressions.
|
protected static class |
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.BridgeMethodImplementation
Implements an explicit bridge method for a lambda expression.
|
protected static class |
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.BridgeMethodImplementation.Appender
An appender for implementing a bridge method for a lambda expression.
|
protected static class |
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.ConstructorImplementation.Appender
An appender to implement the executing transformer.
|
protected static class |
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.FactoryImplementation.Appender
An appender for a lambda expression factory.
|
protected static class |
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.LambdaMethodImplementation
Implements a lambda expression's functional method.
|
protected static class |
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.LambdaMethodImplementation.Appender
An appender for a lambda expression's functional method.
|
static class |
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.LambdaMethodImplementation.Appender.Dispatcher.UsingMethodHandle
An invocation that is using an exact invocation of a method handle.
|
protected static class |
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.SerializationImplementation
Implements the
writeReplace method for serializable lambda expressions. |
static class |
AgentBuilder.Listener.Compound
A compound listener that allows to group several listeners in one instance.
|
static class |
AgentBuilder.Listener.Filtering
A listener that filters types with a given name from being logged.
|
static class |
AgentBuilder.Listener.ModuleReadEdgeCompleting
A listener that adds read-edges to any module of an instrumented class upon its transformation and opens the class's package to the module.
|
static class |
AgentBuilder.Listener.StreamWriting
A listener that writes events to a
PrintStream . |
static class |
AgentBuilder.Listener.WithErrorsOnly
A listener that only delegates events if they are failed transformations.
|
static class |
AgentBuilder.Listener.WithTransformationsOnly
A listener that only delegates events if they are successful or failed transformations.
|
static class |
AgentBuilder.LocationStrategy.Compound
A compound location strategy that applies a list of location strategies.
|
static class |
AgentBuilder.LocationStrategy.Simple
A simple location strategy that queries a given class file locator.
|
static class |
AgentBuilder.PoolStrategy.WithTypePoolCache
A type locator that uses type pools but allows for the configuration of a custom cache provider by class loader.
|
static class |
AgentBuilder.PoolStrategy.WithTypePoolCache.Simple
An implementation of a type locator
AgentBuilder.PoolStrategy.WithTypePoolCache (note documentation of the linked class) that is based on a
ConcurrentMap . |
static class |
AgentBuilder.RawMatcher.Conjunction
A conjunction of two raw matchers.
|
static class |
AgentBuilder.RawMatcher.Disjunction
A disjunction of two raw matchers.
|
static class |
AgentBuilder.RawMatcher.ForElementMatchers
A raw matcher implementation that checks a
TypeDescription
and its ClassLoader against two suitable matchers in order to determine if the matched
type should be instrumented. |
static class |
AgentBuilder.RawMatcher.Inversion
A raw matcher that inverts a raw matcher's result.
|
static class |
AgentBuilder.RedefinitionListenable.ResubmissionImmediateMatcher.Conjunction
A matcher for immediate resubmission that matches both of the supplied delegate matchers.
|
static class |
AgentBuilder.RedefinitionListenable.ResubmissionImmediateMatcher.Disjunction
A matcher for immediate resubmission that matches either of the supplied delegate matchers.
|
static class |
AgentBuilder.RedefinitionListenable.ResubmissionImmediateMatcher.ForElementMatchers
A matcher for immediate resubmission that uses element matchers for each argument to determine a resubmission.
|
static class |
AgentBuilder.RedefinitionListenable.ResubmissionOnErrorMatcher.Conjunction
A matcher for resubmission upon an error that matches both of the supplied delegate matchers.
|
static class |
AgentBuilder.RedefinitionListenable.ResubmissionOnErrorMatcher.Disjunction
A matcher for resubmission upon an error that matches either of the supplied delegate matchers.
|
static class |
AgentBuilder.RedefinitionListenable.ResubmissionOnErrorMatcher.ForElementMatchers
A matcher for resubmission upon error that uses element matchers for each argument to determine a resubmission.
|
static class |
AgentBuilder.RedefinitionStrategy.BatchAllocator.ForFixedSize
A batch allocator that creates chunks with a fixed size as batch jobs.
|
static class |
AgentBuilder.RedefinitionStrategy.BatchAllocator.ForMatchedGrouping
A batch allocator that groups all batches by discriminating types using a type matcher.
|
static class |
AgentBuilder.RedefinitionStrategy.BatchAllocator.Partitioning
A partitioning batch allocator that splits types for redefinition into a fixed amount of parts.
|
static class |
AgentBuilder.RedefinitionStrategy.BatchAllocator.Slicing
A slicing batch allocator that assures that any batch is within a certain size range.
|
static class |
AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.Explicit
An explicit discovery strategy that only attempts the redefinition of specific types.
|
protected static class |
AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.Reiterating.ReiteratingIterable
An iterable that returns any loaded types and checks if any additional types were loaded during the last instrumentation.
|
static class |
AgentBuilder.RedefinitionStrategy.Listener.Adapter
A listener adapter that offers non-operational implementations of all listener methods.
|
static class |
AgentBuilder.RedefinitionStrategy.Listener.BatchReallocator
A batch reallocator allows to split up a failed retransformation into additional batches which are reenqueed to the
current retransformation process.
|
static class |
AgentBuilder.RedefinitionStrategy.Listener.Compound
A compound listener that delegates events to several listeners.
|
protected static class |
AgentBuilder.RedefinitionStrategy.Listener.Compound.CompoundIterable
A compound iterable.
|
static class |
AgentBuilder.RedefinitionStrategy.Listener.Pausing
A listener that invokes
Thread.sleep(long) prior to every batch but the first batch. |
static class |
AgentBuilder.RedefinitionStrategy.Listener.StreamWriting
A listener that writes events to a
PrintStream . |
static class |
AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.AtFixedRate
A resubmission scheduler that schedules jobs at a fixed rate.
|
static class |
AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.Cancelable.ForFuture
A cancelable for a
Future . |
static class |
AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.WithFixedDelay
A resubmission scheduler that schedules jobs with a fixed delay.
|
static class |
AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Enabled
An enabled resubmission strategy.
|
static class |
AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Installation
Represents an installation of a resubmission strategy.
|
static class |
AgentBuilder.Transformer.ForAdvice
A transformer for applying an
Advice where this advice class might reference types of both the agent's and the user's
class loader. |
protected static class |
AgentBuilder.Transformer.ForAdvice.Entry
An entry for an advice to apply.
|
protected static class |
AgentBuilder.Transformer.ForAdvice.Entry.ForSplitAdvice
An entry for an advice class where both entry and exit advice methods are declared by the different classes.
|
protected static class |
AgentBuilder.Transformer.ForAdvice.Entry.ForUnifiedAdvice
An entry for an advice class where both the (optional) entry and exit advice methods are declared by the same class.
|
static class |
AgentBuilder.Transformer.ForBuildPlugin
A transformer that applies a build
Plugin . |
static class |
AgentBuilder.TransformerDecorator.Compound
A compound transformer decorator.
|
static class |
AgentBuilder.TypeStrategy.ForBuildEntryPoint
A type strategy that applies a build
EntryPoint . |
class |
LambdaFactory
This class serves as a dispatcher for creating lambda expression objects when Byte Buddy is configured to instrument the
java.lang.invoke.LambdaMetafactory . |
static class |
ResettableClassFileTransformer.WithDelegation
Implements a resettable class file transformer that allows for the delegation of a transformation.
|
Modifier and Type | Class and Description |
---|---|
class |
Advice
Advice wrappers copy the code of blueprint methods to be executed before and/or after a matched method.
|
protected static class |
Advice.Appender
A byte code appender for implementing
Advice . |
protected static class |
Advice.ArgumentHandler.ForAdvice.Default.ForMethodEnter
An argument handler for an enter advice method.
|
protected static class |
Advice.ArgumentHandler.ForAdvice.Default.ForMethodExit
An argument handler for an exit advice method.
|
protected static class |
Advice.ArgumentHandler.ForInstrumentedMethod.Default.Copying
An argument handler for an instrumented method that copies all arguments before executing the instrumented method.
|
protected static class |
Advice.ArgumentHandler.ForInstrumentedMethod.Default.Simple
A simple argument handler for an instrumented method.
|
static class |
Advice.AssignReturned
A post processor that uses the return value of an advice method to define values for fields, arguments, the instrumented
method's return value or the exception being thrown.
|
protected static class |
Advice.AssignReturned.DefaultValueSkip
A stack manipulation that applies a null-check on the returned value which indicates if an assignment
should be skipped, if discovered.
|
protected static class |
Advice.AssignReturned.ExceptionHandler
An exception handler to handle exceptions during assignment.
|
static class |
Advice.AssignReturned.ExceptionHandler.Factory.Enabled
A factory that creates an exception handler for a given exception type.
|
static class |
Advice.AssignReturned.Factory
A factory to create a
Advice.AssignReturned post processor. |
protected static class |
Advice.AssignReturned.ForArray
A post processor implementation of
Advice.AssignReturned that works on the value of an array. |
protected static class |
Advice.AssignReturned.ForScalar
A post processor implementation of
Advice.AssignReturned that uses the returned value as such. |
static class |
Advice.AssignReturned.Handler.Factory.Simple<S extends Annotation>
A simple implementation of a
Advice.AssignReturned.ToArguments.Handler.Factory that resolves a given list of Handler s. |
static class |
Advice.AssignReturned.ToAllArguments.Handler
A handler for a
Advice.AssignReturned.ToAllArguments annotation. |
static class |
Advice.AssignReturned.ToArguments.Handler
A handler for a
Advice.AssignReturned.ToArguments.ToArgument annotation. |
static class |
Advice.AssignReturned.ToFields.Handler
A handler for a
Advice.AssignReturned.ToFields.ToField annotation. |
static class |
Advice.AssignReturned.ToReturned.Handler
A handler for a
Advice.AssignReturned.ToReturned annotation. |
static class |
Advice.AssignReturned.ToThis.Handler
A handler for the
Advice.AssignReturned.ToThis annotation. |
static class |
Advice.AssignReturned.ToThrown.Handler
A handler for a
Advice.AssignReturned.ToThrown annotation. |
static class |
Advice.Delegator.ForDynamicInvocation
Invokes an advice method using a dynamic method call.
|
static class |
Advice.Dispatcher.Delegating
A dispatcher for an advice method that is being invoked from the instrumented method.
|
protected static class |
Advice.Dispatcher.Delegating.Resolved.ForMethodEnter
A resolved dispatcher for implementing method enter advice.
|
protected static class |
Advice.Dispatcher.Delegating.Resolved.ForMethodExit
A resolved dispatcher for implementing method exit advice.
|
protected static class |
Advice.Dispatcher.Delegating.Resolved.ForMethodExit.WithExceptionHandler
Implementation of exit advice that handles exceptions.
|
static class |
Advice.Dispatcher.Inlining
A dispatcher for an advice method that is being inlined into the instrumented method.
|
protected static class |
Advice.Dispatcher.Inlining.Resolved.ForMethodEnter
A resolved dispatcher for implementing method enter advice.
|
protected static class |
Advice.Dispatcher.Inlining.Resolved.ForMethodExit
A resolved dispatcher for implementing method exit advice.
|
protected static class |
Advice.Dispatcher.Inlining.Resolved.ForMethodExit.WithExceptionHandler
Implementation of exit advice that handles exceptions.
|
static class |
Advice.Dispatcher.RelocationHandler.ForType
A relocation handler that is triggered if the checked value is an instance of a given type.
|
protected class |
Advice.Dispatcher.RelocationHandler.ForType.Bound
A bound relocation handler for
Advice.Dispatcher.RelocationHandler.ForType . |
protected class |
Advice.Dispatcher.RelocationHandler.ForValue.Bound
A bound relocation handler for
Advice.Dispatcher.RelocationHandler.ForValue . |
protected class |
Advice.Dispatcher.RelocationHandler.ForValue.Inverted
An inverted version of the outer relocation handler.
|
static class |
Advice.Dispatcher.RelocationHandler.Relocation.ForLabel
A relocation that unconditionally jumps to a given label.
|
static class |
Advice.Dispatcher.Resolved.AbstractBase
An abstract base implementation of a
Advice.OffsetMapping.ForArgument.Resolved dispatcher. |
static class |
Advice.Dispatcher.SuppressionHandler.Suppressing
A suppression handler that suppresses a given throwable type.
|
static class |
Advice.ExceptionHandler.Simple
A simple exception handler that returns a fixed stack manipulation.
|
static class |
Advice.OffsetMapping.Factory.Illegal<T extends Annotation>
A factory for an annotation whose use is not permitted.
|
static class |
Advice.OffsetMapping.Factory.Simple<T extends Annotation>
A simple factory that binds a constant offset mapping.
|
static class |
Advice.OffsetMapping.ForAllArguments
An offset mapping that maps an array containing all arguments of the instrumented method.
|
static class |
Advice.OffsetMapping.ForArgument
An offset mapping for a given parameter of the instrumented method.
|
static class |
Advice.OffsetMapping.ForArgument.Resolved
An offset mapping for a specific parameter of the instrumented method.
|
static class |
Advice.OffsetMapping.ForArgument.Resolved.Factory<T extends Annotation>
A factory for a parameter argument of the instrumented method.
|
static class |
Advice.OffsetMapping.ForArgument.Unresolved
An offset mapping for a parameter of the instrumented method with a specific index.
|
static class |
Advice.OffsetMapping.ForEnterValue
An offset mapping that provides access to the value that is returned by the enter advice.
|
protected static class |
Advice.OffsetMapping.ForEnterValue.Factory
A factory for creating a
Advice.OffsetMapping.ForEnterValue offset mapping. |
static class |
Advice.OffsetMapping.ForExitValue
An offset mapping that provides access to the value that is returned by the exit advice.
|
protected static class |
Advice.OffsetMapping.ForExitValue.Factory
A factory for creating a
Advice.OffsetMapping.ForExitValue offset mapping. |
static class |
Advice.OffsetMapping.ForField
An offset mapping for a field.
|
static class |
Advice.OffsetMapping.ForField.Resolved
A binding for an offset mapping that represents a specific field.
|
static class |
Advice.OffsetMapping.ForField.Resolved.Factory<T extends Annotation>
A factory that binds a field.
|
static class |
Advice.OffsetMapping.ForField.Unresolved
An offset mapping for a field that is resolved from the instrumented type by its name.
|
static class |
Advice.OffsetMapping.ForField.Unresolved.WithExplicitType
An offset mapping for a field with an explicit declaring type.
|
static class |
Advice.OffsetMapping.ForLocalValue
An offset mapping that provides access to a named local variable that is declared by the advice methods via
Advice.Local . |
protected static class |
Advice.OffsetMapping.ForLocalValue.Factory
A factory for an offset mapping for a local variable that is declared by the advice methods via
Advice.Local . |
static class |
Advice.OffsetMapping.ForOrigin
An offset mapping for the
Advice.Origin annotation. |
static class |
Advice.OffsetMapping.ForOrigin.Renderer.ForConstantValue
A renderer for a constant value.
|
static class |
Advice.OffsetMapping.ForReturnValue
An offset mapping that provides access to the value that is returned by the instrumented method.
|
static class |
Advice.OffsetMapping.ForSerializedValue
An offset mapping that loads a serialized value.
|
static class |
Advice.OffsetMapping.ForSerializedValue.Factory<T extends Annotation>
A factory for loading a deserialized value.
|
static class |
Advice.OffsetMapping.ForStackManipulation
An offset mapping for binding a stack manipulation.
|
static class |
Advice.OffsetMapping.ForStackManipulation.Factory<T extends Annotation>
A factory that binds a stack manipulation.
|
static class |
Advice.OffsetMapping.ForStackManipulation.OfAnnotationProperty<T extends Annotation>
A factory for binding an annotation's property.
|
static class |
Advice.OffsetMapping.ForStackManipulation.OfDefaultValue<T extends Annotation>
A factory for binding the annotated parameter's default value.
|
static class |
Advice.OffsetMapping.ForStackManipulation.OfDynamicInvocation<T extends Annotation>
Uses dynamic method invocation for binding an annotated parameter to a value.
|
static class |
Advice.OffsetMapping.ForThisReference
An offset mapping that provides access to the
this reference of the instrumented method. |
static class |
Advice.OffsetMapping.ForThrowable
An offset mapping for accessing a
Throwable of the instrumented method. |
static class |
Advice.OffsetMapping.ForUnusedValue
An offset mapping for a parameter where assignments are fully ignored and that always return the parameter type's default value.
|
static class |
Advice.OffsetMapping.Target.ForArray
A target mapping for an array of all local variables.
|
static class |
Advice.OffsetMapping.Target.ForArray.ReadWrite
A target mapping for a writable target mapping for an array of local variables.
|
static class |
Advice.OffsetMapping.Target.ForDefaultValue
A target for an offset mapping that represents a non-operational value.
|
static class |
Advice.OffsetMapping.Target.ForField
A target for an offset mapping that loads a field value.
|
static class |
Advice.OffsetMapping.Target.ForField.ReadWrite
A mapping for a writable field.
|
static class |
Advice.OffsetMapping.Target.ForStackManipulation
A target for an offset mapping that represents a read-only stack manipulation.
|
static class |
Advice.OffsetMapping.Target.ForStackManipulation.Writable
A constant value that can be written to.
|
static class |
Advice.OffsetMapping.Target.ForVariable
A target for an offset mapping that represents a local variable.
|
static class |
Advice.OffsetMapping.Target.ForVariable.ReadWrite
A target for a writable mapping of a local variable.
|
static class |
Advice.PostProcessor.Compound
A compound post processor.
|
static class |
Advice.PostProcessor.Factory.Compound
A compound factory for a post processor.
|
static class |
Advice.WithCustomMapping
A builder step for creating an
Advice that uses custom mappings of annotations to constant pool values. |
static class |
AsmVisitorWrapper.Compound
An ordered, immutable chain of
AsmVisitorWrapper s. |
static class |
AsmVisitorWrapper.ForDeclaredFields
An ASM visitor wrapper that allows to wrap declared fields of the instrumented type with a
AsmVisitorWrapper.ForDeclaredFields.FieldVisitorWrapper . |
protected static class |
AsmVisitorWrapper.ForDeclaredFields.Entry
An entry describing a field visitor wrapper paired with a matcher for fields to be wrapped.
|
static class |
AsmVisitorWrapper.ForDeclaredMethods
An ASM visitor wrapper that allows to wrap declared methods of the instrumented type with a
AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper . |
protected static class |
AsmVisitorWrapper.ForDeclaredMethods.Entry
An entry describing a method visitor wrapper paired with a matcher for fields to be wrapped.
|
class |
MemberAttributeExtension<T>
A visitor that adds attributes to a class member.
|
class |
MemberRemoval
A visitor wrapper that removes fields or methods that match a given
ElementMatcher . |
class |
MemberSubstitution
Substitutes field access or method invocations within a method's body.
|
static class |
MemberSubstitution.Replacement.Binding.Resolved
A binding that was resolved for an actual substitution.
|
static class |
MemberSubstitution.Replacement.Factory.Compound
A compound factory.
|
static class |
MemberSubstitution.Replacement.ForElementMatchers
A replacement that substitutes a member based on a row of element matchers.
|
protected static class |
MemberSubstitution.Replacement.ForElementMatchers.Factory
A factory for creating a replacement that chooses members based on a row of element matchers.
|
static class |
MemberSubstitution.Replacement.ForFirstBinding
A replacement that only resolves the first matching replacement of a list of replacements.
|
static class |
MemberSubstitution.Substitution.Chain
A substitution chain allows for chaining multiple substitution steps for a byte code element being replaced.
|
static class |
MemberSubstitution.Substitution.Chain.Step.Simple
A simple substitution step within a substitution chain.
|
static class |
MemberSubstitution.Substitution.ForFieldAccess
A substitution with a field access.
|
static class |
MemberSubstitution.Substitution.ForFieldAccess.FieldResolver.ForElementMatcher
A field matcher that resolves a non-static field on the first parameter type of the substituted member usage.
|
static class |
MemberSubstitution.Substitution.ForFieldAccess.FieldResolver.Simple
A simple field resolver that returns a specific field.
|
static class |
MemberSubstitution.Substitution.ForFieldAccess.OfGivenField
A factory for a substitution that substitutes with a given field.
|
static class |
MemberSubstitution.Substitution.ForFieldAccess.OfMatchedField
A factory for a substitution that locates a field on the receiver type using a matcher.
|
static class |
MemberSubstitution.Substitution.ForMethodInvocation
A substitution with a method invocation.
|
static class |
MemberSubstitution.Substitution.ForMethodInvocation.MethodResolver.Matching
A method resolver that locates a non-static method by locating it from the receiver type.
|
static class |
MemberSubstitution.Substitution.ForMethodInvocation.MethodResolver.Simple
A simple method resolver that returns a given method.
|
static class |
MemberSubstitution.Substitution.ForMethodInvocation.OfGivenMethod
A factory for a substitution that invokes a given method.
|
static class |
MemberSubstitution.Substitution.ForMethodInvocation.OfMatchedMethod
A factory for a substitution that locates a method on the receiver type using a matcher.
|
static class |
MemberSubstitution.TypePoolResolver.ForClassFileLocator
A type pool resolver that resolves the implicit pool but additionally checks another class file locator.
|
static class |
MemberSubstitution.TypePoolResolver.ForExplicitPool
A type pool resolver that returns a specific type pool.
|
static class |
MemberSubstitution.WithoutSpecification
A member substitution that lacks a specification for how to substitute the matched members references within a method body.
|
protected static class |
MemberSubstitution.WithoutSpecification.ForMatchedByteCodeElement
Describes a member substitution that requires a specification for how to replace a byte code element.
|
static class |
MemberSubstitution.WithoutSpecification.ForMatchedField
Describes a member substitution that requires a specification for how to replace a field.
|
static class |
MemberSubstitution.WithoutSpecification.ForMatchedMethod
Describes a member substitution that requires a specification for how to replace a method or constructor.
|
class |
ModifierAdjustment
A visitor wrapper that adjusts the modifiers of the instrumented type or its members.
|
protected static class |
ModifierAdjustment.Adjustment<T>
A description of a conditional adjustment.
|
class |
TypeReferenceAdjustment
Adds an attribute value for all inner classes that are referenced by the instrumented type.
|
Modifier and Type | Class and Description |
---|---|
class |
AccessControllerPlugin
A build tool plugin that instruments methods to dispatch to methods
java.security.AccessController with equal signature. |
protected static class |
AccessControllerPlugin.AccessControlWrapper
An wrapper for a method that represents a method of
AccessController which is weaved. |
protected static class |
AccessControllerPlugin.Initializer
A byte code appender to create an initializer segment that determines if
the
java.security.AccessController is available. |
protected static class |
AccessControllerPlugin.Initializer.WithoutProperty
An initializer that always uses the access controller if it is available.
|
protected static class |
AccessControllerPlugin.Initializer.WithProperty
An initializer that uses a property to determine if the access controller should be actually used even if it is available.
|
static class |
BuildLogger.Compound
A compound build logger.
|
static class |
BuildLogger.StreamWriting
A build logger that writes all statements to a
PrintStream . |
class |
CachedReturnPlugin
A plugin that caches the return value of a method in a synthetic field.
|
protected static class |
CachedReturnPlugin.CacheFieldOffsetMapping
An offset mapping for the cached field.
|
class |
DispatcherAnnotationPlugin
A plugin that adds an
HashCodeAndEqualsPlugin.Enhance annotation to any method of an
enhanced type where the annotation is not set. |
class |
HashCodeAndEqualsPlugin
A build tool plugin that adds
Object.hashCode() and Object.equals(Object) methods to a class if the
HashCodeAndEqualsPlugin.Enhance annotation is present and no explicit method declaration was added. |
protected static class |
HashCodeAndEqualsPlugin.ValueMatcher
An element matcher for a
HashCodeAndEqualsPlugin.ValueHandling annotation. |
static class |
HashCodeAndEqualsPlugin.WithNonNullableFields
A version of the
HashCodeAndEqualsPlugin that assumes that all fields are non-nullable unless they are explicitly marked. |
static class |
Plugin.Engine.Default
A default implementation of a plugin engine.
|
protected static class |
Plugin.Engine.Dispatcher.ForParallelTransformation.EagerWork
An eager materialization that does not defer processing after preprocessing.
|
static class |
Plugin.Engine.Dispatcher.ForParallelTransformation.Factory
A factory for a dispatcher that uses a given executor service for parallel dispatching.
|
static class |
Plugin.Engine.Dispatcher.ForParallelTransformation.WithThrowawayExecutorService
A parallel dispatcher that shuts down its executor service upon completion of a plugin engine's application.
|
static class |
Plugin.Engine.Dispatcher.ForParallelTransformation.WithThrowawayExecutorService.Factory
A factory for a parallel executor service that creates a new executor service on each plugin engine application.
|
static class |
Plugin.Engine.Listener.Compound
A compound listener.
|
static class |
Plugin.Engine.Listener.ForErrorHandler
A listener decorator that forwards events to an error handler if they are applicable.
|
static class |
Plugin.Engine.Listener.StreamWriting
A listener that forwards significant events of a plugin engine application to a
PrintStream . |
static class |
Plugin.Engine.Listener.WithErrorsOnly
A decorator for another listener to only print error events.
|
static class |
Plugin.Engine.Listener.WithTransformationsOnly
A decorator for another listener to only print transformation and error events.
|
static class |
Plugin.Engine.Source.Element.ForByteArray
An element representation for a byte array.
|
static class |
Plugin.Engine.Source.Element.ForFile
An element representation for a file.
|
static class |
Plugin.Engine.Source.Element.ForJarEntry
Represents a jar file entry as an element.
|
static class |
Plugin.Engine.Source.Filtering
A source that applies a filter upon iterating elements.
|
static class |
Plugin.Engine.Source.ForFolder
Represents the contents of a folder as class files.
|
static class |
Plugin.Engine.Source.ForJarFile
Represents a jar file as a source.
|
static class |
Plugin.Engine.Source.InMemory
A source that represents a collection of in-memory resources that are represented as byte arrays.
|
static class |
Plugin.Engine.Source.Origin.Filtering
An origin that forwards all invocations to a delegate where an
ElementMatcher is applied prior to iteration. |
static class |
Plugin.Engine.Target.ForFolder
Represents a folder as the target for a plugin engine's application.
|
static class |
Plugin.Engine.Target.ForJarFile
Represents a jar file as a target.
|
static class |
Plugin.Engine.Target.InMemory
A sink that stores all elements in a memory map.
|
static class |
Plugin.Engine.TypeStrategy.ForEntryPoint
A type strategy that represents a given
EntryPoint for a build tool. |
static class |
Plugin.Factory.Simple
A simple factory that returns a preconstructed plugin instance..
|
static class |
Plugin.Factory.UsingReflection
A plugin factory that uses reflection for instantiating a plugin.
|
static class |
Plugin.Factory.UsingReflection.ArgumentResolver.ForIndex
An argument resolver that resolves an argument for a specific parameter index.
|
static class |
Plugin.Factory.UsingReflection.ArgumentResolver.ForIndex.WithDynamicType
An argument resolver that resolves an argument for a specific parameter index by attempting a conversion via
invoking a static
valueOf method on the target type, if it exists. |
static class |
Plugin.Factory.UsingReflection.ArgumentResolver.ForType<T>
An argument resolver that resolves parameters for a given type.
|
static class |
Plugin.Factory.UsingReflection.ArgumentResolver.Resolution.Resolved
Represents a resolved argument resolution.
|
static class |
Plugin.Factory.UsingReflection.Instantiator.Ambiguous
Represents an ambiguously resolved instantiator.
|
static class |
Plugin.Factory.UsingReflection.Instantiator.Resolved
An instantiator that is resolved for a given constructor with arguments.
|
static class |
Plugin.Factory.UsingReflection.Instantiator.Unresolved
An instantiator that is not resolved for creating an instance.
|
static class |
Plugin.ForElementMatcher
An abstract base for a
Plugin that matches types by a given ElementMatcher . |
static class |
Plugin.NoOp
A non-operational plugin that does not instrument any type.
|
class |
RepeatedAnnotationPlugin
A plugin that allows for adding a
java.lang.annotation.Repeatable annotation even if compiled prior to
Java 8 which introduces this annotation. |
protected static class |
RepeatedAnnotationPlugin.RepeatedAnnotationAppender
A type attribute appender that adds a repeated annotation for a target type.
|
class |
ToStringPlugin
A build tool plugin that adds a
Object.toString() and method to a class if the ToStringPlugin.Enhance annotation is present and no
explicit method declaration was added. |
Modifier and Type | Class and Description |
---|---|
static class |
AnnotationDescription.Builder
A builder for pragmatically creating
AnnotationDescription . |
static class |
AnnotationSource.Explicit
An annotation source that declares a given list of annotations.
|
Modifier and Type | Class and Description |
---|---|
static class |
ParameterDescription.ForLoadedParameter.ParameterAnnotationSource.ForLoadedConstructor
A source for a loaded constructor.
|
static class |
ParameterDescription.ForLoadedParameter.ParameterAnnotationSource.ForLoadedMethod
A source for a loaded method.
|
Modifier and Type | Class and Description |
---|---|
static class |
ModifierContributor.Resolver<T extends ModifierContributor>
A resolver for Java modifiers represented by
ModifierContributor s. |
Modifier and Type | Class and Description |
---|---|
protected static class |
TypeDescription.Generic.AnnotationReader.Delegator.Chained
A chained delegator that bases its result on an underlying annotation reader.
|
static class |
TypeDescription.Generic.AnnotationReader.Delegator.ForLoadedExecutableExceptionType
A delegating annotation reader for an annotated exception variable.
|
static class |
TypeDescription.Generic.AnnotationReader.Delegator.ForLoadedExecutableParameterType
A delegating annotation reader for an annotated parameter variable.
|
static class |
TypeDescription.Generic.AnnotationReader.Delegator.ForLoadedField
A delegating annotation reader for an annotated field variable.
|
static class |
TypeDescription.Generic.AnnotationReader.Delegator.ForLoadedInterface
A delegating annotation reader for an annotated interface type.
|
static class |
TypeDescription.Generic.AnnotationReader.Delegator.ForLoadedMethodReturnType
A delegating annotation reader for an annotated return variable.
|
static class |
TypeDescription.Generic.AnnotationReader.Delegator.ForLoadedSuperClass
A delegating annotation reader for an annotated super type.
|
static class |
TypeDescription.Generic.AnnotationReader.Delegator.ForLoadedTypeVariable
A delegating annotation reader for an annotated type variable.
|
static class |
TypeDescription.Generic.AnnotationReader.Delegator.Simple
A simple delegator for a given
AnnotatedElement . |
static class |
TypeDescription.Generic.AnnotationReader.ForTypeArgument
A chained annotation reader for reading a parameterized type's type argument.
|
static class |
TypeDescription.Generic.AnnotationReader.ForTypeVariableBoundType
A chained annotation reader for reading a type variable's type argument.
|
protected static class |
TypeDescription.Generic.AnnotationReader.ForTypeVariableBoundType.OfFormalTypeVariable
A chained annotation reader for reading a formal type variable's type argument.
|
static class |
TypeDescription.Generic.AnnotationReader.ForWildcardLowerBoundType
A chained annotation reader for reading a wildcard type's lower bound type.
|
static class |
TypeDescription.Generic.AnnotationReader.ForWildcardUpperBoundType
A chained annotation reader for reading a wildcard type's upper bound type.
|
static class |
TypeDescription.Generic.Builder
A builder for creating describing a generic type as a
TypeDescription.Generic . |
protected static class |
TypeDescription.Generic.Builder.OfGenericArrayType
A generic type builder building a generic array type.
|
protected static class |
TypeDescription.Generic.Builder.OfNonGenericType
A generic type builder for building a non-generic type.
|
protected static class |
TypeDescription.Generic.Builder.OfParameterizedType
A generic type builder for building a parameterized type.
|
protected static class |
TypeDescription.Generic.Builder.OfTypeVariable
A generic type builder building a symbolic type variable.
|
static class |
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForGenericArray
A dispatcher for checking the assignability of a generic array type.
|
static class |
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForNonGenericType
A dispatcher for checking the assignability of a non-generic type.
|
static class |
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType
A dispatcher for checking the assignability of a parameterized type.
|
protected static class |
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType.ParameterAssigner.ContravariantBinding
A dispatcher for an contravariant parameter of a parameterized type, i.e. a type that is the lower bound of a wildcard.
|
protected static class |
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType.ParameterAssigner.CovariantBinding
A dispatcher for an covariant parameter of a parameterized type, i.e. a type that is the lower bound of a wildcard.
|
protected static class |
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType.ParameterAssigner.InvariantBinding
A dispatcher for an invariant parameter of a parameterized type, i.e. a type without a wildcard.
|
static class |
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForTypeVariable
A dispatcher for checking the assignability of a type variable.
|
static class |
TypeDescription.Generic.Visitor.ForSignatureVisitor
Visits a generic type and appends the discovered type to the supplied signature visitor.
|
static class |
TypeDescription.Generic.Visitor.Reducing
A visitor that reduces a detached generic type to its erasure.
|
static class |
TypeDescription.Generic.Visitor.Substitutor.ForAttachment
A substitutor that attaches type variables to a type variable source and replaces representations of
TargetType with a given declaring type. |
static class |
TypeDescription.Generic.Visitor.Substitutor.ForDetachment
A visitor for detaching a type from its declaration context by detaching type variables.
|
static class |
TypeDescription.Generic.Visitor.Substitutor.ForTokenNormalization
A substitutor that normalizes a token to represent all
TargetType by a given type and that symbolizes all type variables. |
static class |
TypeDescription.Generic.Visitor.Substitutor.ForTypeVariableBinding
A visitor for binding type variables to their values.
|
protected class |
TypeDescription.Generic.Visitor.Substitutor.ForTypeVariableBinding.TypeVariableSubstitutor
Substitutes a type variable, either with a new binding if the variable is defined by a type or with a
retained type variable if the variable is defined by a method.
|
Modifier and Type | Class and Description |
---|---|
static class |
ClassFileLocator.Compound
A compound
ClassFileLocator that chains several locators. |
static class |
ClassFileLocator.ForClassLoader
A class file locator that queries a class loader for binary representations of class files.
|
static class |
ClassFileLocator.ForFolder
A class file locator that finds files from a standardized Java folder structure with
folders donating packages and class files being saved as
<classname>.class files
within their package folder. |
static class |
ClassFileLocator.ForInstrumentation
A Java agent that allows the location of class files by emulating a retransformation.
|
static class |
ClassFileLocator.ForInstrumentation.ClassLoadingDelegate.Default
A default implementation of a class loading delegate.
|
static class |
ClassFileLocator.ForInstrumentation.ClassLoadingDelegate.Explicit
A class loading delegate that allows the location of explicitly registered classes that cannot
be located by a class loader directly.
|
static class |
ClassFileLocator.ForInstrumentation.ClassLoadingDelegate.ForDelegatingClassLoader.Dispatcher.Resolved
Represents a field that could be located.
|
static class |
ClassFileLocator.ForInstrumentation.ClassLoadingDelegate.ForDelegatingClassLoader.Dispatcher.Unresolved
Represents a field that could not be located.
|
static class |
ClassFileLocator.ForJarFile
A class file locator that locates classes within a Java jar file.
|
static class |
ClassFileLocator.ForModule
A class file locator that locates class files by querying a Java module's
getResourceAsStream method. |
static class |
ClassFileLocator.ForModuleFile
A class file locator that locates classes within a Java jmod file.
|
static class |
ClassFileLocator.ForUrl
A class file locator that reads class files from one or several URLs.
|
protected static class |
ClassFileLocator.ForUrl.ClassLoaderCreationAction
An action to create a class loader with the purpose of locating classes from an URL location.
|
static class |
ClassFileLocator.PackageDiscriminating
A class file locator that discriminates by a type's package.
|
static class |
ClassFileLocator.Resolution.Explicit
Represents a byte array as binary data.
|
static class |
ClassFileLocator.Resolution.Illegal
A canonical representation of an illegal binary representation.
|
static class |
ClassFileLocator.Simple
A simple class file locator that returns class files from a selection of given types.
|
static class |
DynamicType.Builder.AbstractBase.Adapter<U>
An adapter implementation of a dynamic type builder.
|
protected class |
DynamicType.Builder.AbstractBase.Adapter.FieldDefinitionAdapter
An adapter for defining a new field.
|
protected class |
DynamicType.Builder.AbstractBase.Adapter.FieldMatchAdapter
An adapter for matching an existing field.
|
protected class |
DynamicType.Builder.AbstractBase.Adapter.InnerTypeDefinitionForMethodAdapter
An adapter for applying an inner type definition for an outer method or constructor.
|
protected class |
DynamicType.Builder.AbstractBase.Adapter.InnerTypeDefinitionForTypeAdapter
An adapter for applying an inner type definition for an outer type.
|
protected class |
DynamicType.Builder.AbstractBase.Adapter.MethodDefinitionAdapter
An adapter for defining a new method.
|
protected class |
DynamicType.Builder.AbstractBase.Adapter.MethodDefinitionAdapter.AnnotationAdapter
An annotation adapter for a method definition.
|
protected class |
DynamicType.Builder.AbstractBase.Adapter.MethodDefinitionAdapter.ParameterAnnotationAdapter
An annotation adapter for a parameter definition.
|
protected class |
DynamicType.Builder.AbstractBase.Adapter.MethodDefinitionAdapter.SimpleParameterAnnotationAdapter
An annotation adapter for a simple parameter definition.
|
protected class |
DynamicType.Builder.AbstractBase.Adapter.MethodDefinitionAdapter.TypeVariableAnnotationAdapter
An adapter for defining a new type variable for the currently defined method.
|
protected class |
DynamicType.Builder.AbstractBase.Adapter.MethodMatchAdapter
An adapter for matching an existing method.
|
protected class |
DynamicType.Builder.AbstractBase.Adapter.MethodMatchAdapter.AnnotationAdapter
An annotation adapter for implementing annotations during a method definition.
|
protected class |
DynamicType.Builder.AbstractBase.Adapter.OptionalMethodMatchAdapter
An adapter for optionally matching methods defined by declared interfaces.
|
protected class |
DynamicType.Builder.AbstractBase.Adapter.RecordComponentDefinitionAdapter
An adapter for defining a record component.
|
protected class |
DynamicType.Builder.AbstractBase.Adapter.TypeVariableDefinitionAdapter
An adapter for defining a new type variable for the instrumented type.
|
protected static class |
DynamicType.Builder.MethodDefinition.AbstractBase.Adapter<V>
An adapter implementation of a method definition.
|
static class |
DynamicType.Default
A default implementation of a dynamic type.
|
protected static class |
DynamicType.Default.Loaded<T>
A default implementation of a loaded dynamic type.
|
static class |
DynamicType.Default.Unloaded<T>
A default implementation of an unloaded dynamic type.
|
class |
NexusAccessor
The Nexus accessor is creating a VM-global singleton
Nexus such that it can be seen by all class loaders of
a virtual machine. |
static class |
NexusAccessor.Dispatcher.Available
An enabled dispatcher for registering a type initializer in a
Nexus . |
static class |
NexusAccessor.Dispatcher.Unavailable
A disabled dispatcher where a
Nexus is not available. |
static class |
NexusAccessor.InitializationAppender
An initialization appender that looks up a loaded type initializer from Byte Buddy's
Nexus . |
static class |
Transformer.Compound<S>
A compound transformer.
|
static class |
Transformer.ForField
A transformer for a field that delegates to another transformer that transforms a
FieldDescription.Token . |
protected static class |
Transformer.ForField.FieldModifierTransformer
A transformer for a field's modifiers.
|
static class |
Transformer.ForMethod
A transformer for a field that delegates to another transformer that transforms a
MethodDescription.Token . |
protected static class |
Transformer.ForMethod.MethodModifierTransformer
A transformer for a method's modifiers.
|
protected class |
Transformer.ForMethod.TransformedMethod.AttachmentVisitor
A visitor that attaches type variables based on the transformed method's type variables and the instrumented type.
|
static class |
TypeResolutionStrategy.Active
A type resolution strategy that applies all
LoadedTypeInitializer as a part of class loading using reflection. |
protected static class |
TypeResolutionStrategy.Active.Resolved
A resolved version of an active type resolution strategy.
|
Modifier and Type | Class and Description |
---|---|
protected class |
ByteArrayClassLoader.ClassDefinitionAction
An action for defining a located class that is not yet loaded.
|
static class |
ByteArrayClassLoader.PackageLookupStrategy.ForJava9CapableVm
A package lookup strategy for Java 9 or newer.
|
protected static class |
ByteArrayClassLoader.PersistenceHandler.UrlDefinitionAction
An action to define a URL that represents a class file.
|
protected static class |
ByteArrayClassLoader.PersistenceHandler.UrlDefinitionAction.ByteArrayUrlStreamHandler
A stream handler that returns the given binary representation.
|
static class |
ByteArrayClassLoader.SynchronizationStrategy.ForJava7CapableVm
A synchronization engine for a VM that is aware of parallel-capable class loaders.
|
static class |
ByteArrayClassLoader.SynchronizationStrategy.ForJava8CapableVm
A synchronization engine for a VM that is aware of parallel-capable class loaders using method handles to respect module boundaries.
|
static class |
ClassFilePostProcessor.ForClassFileTransformer
A class file post processor that delegates to an
ClassFileTransformer . |
static class |
ClassInjector.UsingInstrumentation
A class injector using a
Instrumentation to append to either the boot classpath
or the system class path. |
static class |
ClassInjector.UsingJna
A class injector using JNA to invoke JNI's define class utility for defining a class.
|
static class |
ClassInjector.UsingJna.Dispatcher.Unavailable
An unavailable dispatcher for JNA-based class injection.
|
static class |
ClassInjector.UsingLookup
A class injector that uses a
java.lang.invoke.MethodHandles$Lookup object for defining a class. |
static class |
ClassInjector.UsingReflection
A class injector that uses reflective method calls.
|
static class |
ClassInjector.UsingReflection.Dispatcher.Direct
A class injection dispatcher that is using reflection on the
ClassLoader methods. |
protected static class |
ClassInjector.UsingReflection.Dispatcher.Direct.ForJava7CapableVm
A resolved class dispatcher for a class injector on a VM running at least Java 7.
|
static class |
ClassInjector.UsingReflection.Dispatcher.Initializable.Unavailable
Represents an unsuccessfully loaded method lookup.
|
static class |
ClassInjector.UsingReflection.Dispatcher.Unavailable
Represents an unsuccessfully loaded method lookup.
|
static class |
ClassInjector.UsingReflection.Dispatcher.UsingUnsafeInjection
An indirect dispatcher that uses a redirection accessor class that was injected into the bootstrap class loader.
|
protected static class |
ClassInjector.UsingReflection.Dispatcher.UsingUnsafeOverride.ForJava7CapableVm
A resolved class dispatcher using unsafe field injection for a class injector on a VM running at least Java 7.
|
static class |
ClassInjector.UsingUnsafe
A class injector that uses
sun.misc.Unsafe or jdk.internal.misc.Unsafe to inject classes. |
static class |
ClassInjector.UsingUnsafe.Dispatcher.Enabled
An enabled dispatcher.
|
static class |
ClassInjector.UsingUnsafe.Dispatcher.Unavailable
A disabled dispatcher.
|
static class |
ClassInjector.UsingUnsafe.Factory
A factory for creating a
ClassInjector that uses sun.misc.Unsafe if available but attempts a fallback
to using jdk.internal.misc.Unsafe if the jdk.internal module is not resolved or unavailable. |
protected static class |
ClassLoadingStrategy.Default.InjectionDispatcher
A class loading strategy which applies a class loader injection while applying a given
ProtectionDomain on class injection. |
protected static class |
ClassLoadingStrategy.Default.WrappingDispatcher
A class loading strategy which creates a wrapping class loader while applying a given
ProtectionDomain on class loading. |
static class |
ClassLoadingStrategy.ForBootstrapInjection
A class loading strategy which allows class injection into the bootstrap class loader if
appropriate.
|
static class |
ClassLoadingStrategy.ForJnaInjection
A class loading strategy that injects a class using JNA via the JNI DefineClass method.
|
static class |
ClassLoadingStrategy.ForUnsafeInjection
A class loading strategy that injects a class using
sun.misc.Unsafe or jdk.internal.misc.Unsafe . |
static class |
ClassLoadingStrategy.UsingLookup
A class loading strategy that uses a
java.lang.invoke.MethodHandles$Lookup instance for defining types. |
class |
ClassReloadingStrategy
The class reloading strategy allows to redefine loaded
Class es. |
static class |
ClassReloadingStrategy.BootstrapInjection.Enabled
An enabled bootstrap class loader injection strategy.
|
static class |
MultipleParentClassLoader.Builder
A builder to collect class loader and that creates a
MultipleParentClassLoader only if multiple or no
ClassLoader s are found in the process. |
static class |
PackageDefinitionStrategy.ManifestReading
A package definer that reads a class loader's manifest file.
|
static class |
PackageDefinitionStrategy.ManifestReading.SealBaseLocator.ForTypeResourceUrl
A seal base locator that imitates the behavior of a
URLClassLoader , i.e. tries
to deduct the base from a class's resource URL. |
Modifier and Type | Class and Description |
---|---|
static class |
FieldLocator.AbstractBase
An abstract base implementation of a field locator.
|
static class |
FieldLocator.ForClassHierarchy
A field locator that looks up fields that are declared within a class's class hierarchy.
|
static class |
FieldLocator.ForExactType
A field locator that only looks up fields that are declared by a specific type.
|
static class |
FieldLocator.ForExactType.Factory
A factory for creating a
FieldLocator.ForExactType . |
static class |
FieldLocator.Resolution.Simple
A simple implementation for a field resolution.
|
static class |
FieldRegistry.Default
An immutable default implementation of a field registry.
|
protected static class |
FieldRegistry.Default.Compiled
A compiled default field registry.
|
protected static class |
FieldRegistry.Default.Compiled.Entry
An entry of a compiled field registry.
|
protected static class |
FieldRegistry.Default.Entry
An entry of the default field registry.
|
static class |
MethodGraph.Compiler.Default<T>
A default implementation of a method graph.
|
protected static class |
MethodGraph.Compiler.Default.Key.Store<V>
A store for collected methods that are identified by keys.
|
static class |
MethodGraph.Compiler.Default.Key.Store.Entry.Ambiguous<U>
An entry representing an ambiguous node resolution.
|
protected static class |
MethodGraph.Compiler.Default.Key.Store.Entry.Ambiguous.Node
A node implementation representing an ambiguous method resolution.
|
static class |
MethodGraph.Compiler.Default.Key.Store.Entry.Resolved<U>
An entry representing a non-ambiguous node resolution.
|
protected static class |
MethodGraph.Compiler.Default.Key.Store.Entry.Resolved.Node
A node implementation representing a non-ambiguous method.
|
protected static class |
MethodGraph.Compiler.Default.Key.Store.Graph
A graph implementation based on a key store.
|
static class |
MethodGraph.Linked.Delegation
A simple implementation of a linked method graph that exposes views by delegation to given method graphs.
|
static class |
MethodGraph.Node.Simple
A simple implementation of a resolved node of a method without bridges.
|
static class |
MethodGraph.Simple
A simple implementation of a method graph.
|
static class |
MethodRegistry.Default
A default implementation of a method registry.
|
protected static class |
MethodRegistry.Default.Compiled
A compiled version of a default method registry.
|
protected static class |
MethodRegistry.Default.Compiled.Entry
An entry of a compiled method registry.
|
protected static class |
MethodRegistry.Default.Entry
An entry of a default method registry.
|
protected static class |
MethodRegistry.Default.Prepared
A prepared version of a default method registry.
|
protected static class |
MethodRegistry.Default.Prepared.Entry
An entry of a prepared method registry.
|
static class |
MethodRegistry.Handler.ForAnnotationValue
A handler for defining a default annotation value for a method.
|
static class |
MethodRegistry.Handler.ForImplementation
A handler for a method that is implemented as byte code.
|
protected static class |
MethodRegistry.Handler.ForImplementation.Compiled
A compiled handler for implementing a method.
|
protected static class |
MethodRegistry.Handler.ForVisibilityBridge.Compiled
A compiled handler for a visibility bridge handler.
|
static class |
RecordComponentRegistry.Default
An immutable default implementation of a record component registry.
|
protected static class |
RecordComponentRegistry.Default.Compiled
A compiled default record component registry.
|
protected static class |
RecordComponentRegistry.Default.Compiled.Entry
An entry of a compiled record component registry.
|
protected static class |
RecordComponentRegistry.Default.Entry
An entry of the default record component registry.
|
static class |
TypeInitializer.Drain.Default
A default implementation of a type initializer drain that creates a initializer method.
|
static class |
TypeInitializer.Simple
A simple, defined type initializer that executes a given
ByteCodeAppender . |
static class |
TypeWriter.Default<S>
A default implementation of a
TypeWriter . |
protected static class |
TypeWriter.Default.ClassDumpAction
An action to write a class file to the dumping location.
|
static class |
TypeWriter.Default.ClassDumpAction.Dispatcher.Enabled
An enabled dispatcher that dumps class files to a given folder.
|
static class |
TypeWriter.Default.ForCreation<U>
A type writer that creates a class file that is not based upon another, existing class.
|
static class |
TypeWriter.Default.ForInlining<U>
A type writer that inlines the created type into an existing class file.
|
protected static class |
TypeWriter.Default.ForInlining.WithFullProcessing<V>
A default type writer that reprocesses a type completely.
|
protected class |
TypeWriter.Default.UnresolvedType
An unresolved type.
|
static class |
TypeWriter.Default.ValidatingClassVisitor.Constraint.Compound
A constraint implementation that summarizes several constraints.
|
static class |
TypeWriter.Default.ValidatingClassVisitor.Constraint.ForClassFileVersion
Represents the constraint implied by a class file version.
|
static class |
TypeWriter.FieldPool.Record.ForExplicitField
A record for a rich field with attributes and a potential default value.
|
static class |
TypeWriter.FieldPool.Record.ForImplicitField
A record for a simple field without a default value where all of the field's declared annotations are appended.
|
static class |
TypeWriter.MethodPool.Record.AccessBridgeWrapper
A wrapper that appends accessor bridges for a method's implementation.
|
static class |
TypeWriter.MethodPool.Record.ForDefinedMethod.OfVisibilityBridge
A record for a visibility bridge.
|
static class |
TypeWriter.MethodPool.Record.ForDefinedMethod.WithAnnotationDefaultValue
Describes an entry that defines a method with a default annotation value.
|
static class |
TypeWriter.MethodPool.Record.ForDefinedMethod.WithBody
Describes an entry that defines a method as byte code.
|
static class |
TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody
Describes an entry that defines a method but without byte code and without an annotation value.
|
static class |
TypeWriter.MethodPool.Record.ForNonImplementedMethod
A canonical implementation of a method that is not declared but inherited by the instrumented type.
|
static class |
TypeWriter.RecordComponentPool.Record.ForExplicitRecordComponent
A record for a rich record component with attributes.
|
static class |
TypeWriter.RecordComponentPool.Record.ForImplicitRecordComponent
A record for a simple field without a default value where all of the record component's declared annotations are appended.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractInliningDynamicTypeBuilder<T>
An abstract base implementation of a dynamic type builder that alters an existing type.
|
class |
DecoratingDynamicTypeBuilder<T>
A type builder that decorates a type by allowing for the application of attribute changes and ASM visitor wrappers.
|
class |
InliningImplementationMatcher
A latent method matcher that identifies methods to instrument when redefining or rebasing a type.
|
static class |
MethodNameTransformer.Prefixing
A method name transformer that adds a fixed prefix to an original method name.
|
static class |
MethodNameTransformer.Suffixing
A method name transformer that adds a fixed suffix to an original method name, separated by a
$ . |
static class |
MethodRebaseResolver.Default
A default implementation of a method rebase resolver.
|
static class |
MethodRebaseResolver.Resolution.ForRebasedConstructor
A
MethodRebaseResolver.Resolution of a rebased constructor. |
static class |
MethodRebaseResolver.Resolution.ForRebasedMethod
A
MethodRebaseResolver.Resolution of a rebased method. |
static class |
MethodRebaseResolver.Resolution.Preserved
A
MethodRebaseResolver.Resolution of a non-rebased method. |
class |
RebaseDynamicTypeBuilder<T>
A type builder that rebases an instrumented type.
|
class |
RebaseImplementationTarget
An implementation target for redefining a given type while preserving the original methods within the
instrumented type.
|
static class |
RebaseImplementationTarget.Factory
A factory for creating a
RebaseImplementationTarget . |
Modifier and Type | Class and Description |
---|---|
protected static class |
ConstructorStrategy.Default.WithMethodAttributeAppenderFactory
A wrapper for a default constructor strategy which additionally applies a method attribute appender factory.
|
static class |
ConstructorStrategy.ForDefaultConstructor
A constructor strategy that creates a default constructor that invokes a super constructor with default arguments.
|
class |
SubclassDynamicTypeBuilder<T>
A type builder that creates an instrumented type as a subclass, i.e. a type that is not based on an existing class file.
|
protected static class |
SubclassDynamicTypeBuilder.InstrumentableMatcher
A matcher that locates all methods that are overridable and not ignored or that are directly defined on the instrumented type.
|
class |
SubclassImplementationTarget
An implementation target for creating a subclass of a given type.
|
Modifier and Type | Class and Description |
---|---|
class |
DefaultMethodCall
This
Implementation invokes a default method for the methods it instruments. |
protected static class |
DefaultMethodCall.Appender
The appender for implementing a
DefaultMethodCall . |
class |
EqualsMethod
An implementation of
Object.equals(Object) that takes a class's declared fields into consideration. |
protected static class |
EqualsMethod.Appender
A byte code appender to implement the
EqualsMethod . |
protected static class |
EqualsMethod.CompoundComparator
A compound comparator that compares the values of multiple fields.
|
protected static class |
EqualsMethod.ConditionalReturn
A conditional return aborts the equality computation if a given condition was reached.
|
static class |
EqualsMethod.NullValueGuard.UsingJump
A null value guard that expects a reference type and that skips the comparison if both values are
null but returns if
the invoked instance's field value is null but not the compared instance's value. |
protected class |
EqualsMethod.NullValueGuard.UsingJump.AfterInstruction
The stack manipulation to apply after the equality computation.
|
protected class |
EqualsMethod.NullValueGuard.UsingJump.BeforeInstruction
The stack manipulation to apply before the equality computation.
|
class |
ExceptionMethod
This implementation causes a
Throwable to be thrown when the instrumented method is invoked. |
static class |
ExceptionMethod.ConstructionDelegate.ForDefaultConstructor
A construction delegate that calls the default constructor.
|
static class |
ExceptionMethod.ConstructionDelegate.ForStringConstructor
A construction delegate that calls a constructor that takes a single string as its argument.
|
class |
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. |
static class |
FieldAccessor.FieldLocation.Absolute
An absolute field description representing a previously resolved field.
|
static class |
FieldAccessor.FieldLocation.Relative
A relative field location where a field is located dynamically.
|
protected static class |
FieldAccessor.FieldLocation.Relative.Prepared
A prepared version of a field location.
|
static class |
FieldAccessor.FieldNameExtractor.ForFixedValue
A field name extractor that returns a fixed value.
|
protected class |
FieldAccessor.ForImplicitProperty.Appender
An byte code appender for an field accessor implementation.
|
protected static class |
FieldAccessor.ForSetter<T>
A field accessor for a field setter.
|
protected class |
FieldAccessor.ForSetter.Appender
An appender to implement a field setter.
|
protected static class |
FieldAccessor.ForSetter.OfConstantValue
An instrumentation that sets a constant value to a field.
|
protected static class |
FieldAccessor.ForSetter.OfFieldValue
A setter that reads a value of another field and sets this value.
|
protected static class |
FieldAccessor.ForSetter.OfParameterValue
A setter instrumentation for a parameter value.
|
protected static class |
FieldAccessor.ForSetter.OfReferenceValue
An instrumentation that sets a field to a reference value that is stored in a static field of the instrumented type.
|
class |
FixedValue
This implementation returns a fixed value for a method.
|
protected static class |
FixedValue.ForArgument
A fixed value implementation that returns a method's argument.
|
protected class |
FixedValue.ForOriginType.Appender
An appender for writing the origin type.
|
protected static class |
FixedValue.ForPoolValue
A fixed value implementation that represents its fixed value as a value that is written to the instrumented
class's constant pool.
|
protected static class |
FixedValue.ForThisValue.Appender
A byte code appender for returning
this . |
protected static class |
FixedValue.ForValue
A fixed value implementation that represents its fixed value as a static field of the instrumented class.
|
class |
HashCodeMethod
An implementation of
Object.hashCode() that takes a class's declared fields into consideration. |
protected static class |
HashCodeMethod.Appender
A byte code appender to implement a hash code method.
|
static class |
HashCodeMethod.NullValueGuard.UsingJump
A null value guard that expects a reference type and that uses a jump if a field value is
null . |
protected class |
HashCodeMethod.NullValueGuard.UsingJump.AfterInstruction
The stack manipulation to apply after the hash value computation.
|
protected class |
HashCodeMethod.NullValueGuard.UsingJump.BeforeInstruction
The stack manipulation to apply before the hash value computation.
|
static class |
HashCodeMethod.OffsetProvider.ForFixedValue
An offset provider that supplies a fixed value.
|
static class |
Implementation.Compound
A compound implementation that allows to combine several implementations.
|
static class |
Implementation.Compound.Composable
A compound implementation that allows to combine several implementations and that is
Implementation.Composable . |
protected static class |
Implementation.Context.Default.AccessorMethodDelegation
An implementation of a
TypeWriter.MethodPool.Record for implementing
an accessor method. |
protected static class |
Implementation.Context.Default.DelegationRecord
An abstract method pool entry that delegates the implementation of a method to itself.
|
protected static class |
Implementation.Context.Default.FieldGetterDelegation
An implementation for a field getter.
|
protected static class |
Implementation.Context.Default.FieldSetterDelegation
An implementation for a field setter.
|
static class |
Implementation.Context.ExtractableView.AbstractBase
An abstract base implementation of an extractable view of an implementation context.
|
static class |
Implementation.Simple
A simple implementation that does not register any members with the instrumented type.
|
protected static class |
Implementation.Simple.ForDispatcher
A
ByteCodeAppender for a dispatcher. |
protected class |
Implementation.Simple.ForDispatcher.Appender
An appender for a dispatcher-based simple implementation.
|
static class |
Implementation.Target.AbstractBase
An abstract base implementation for an
Implementation.Target . |
class |
InvocationHandlerAdapter
An adapter for adapting an
InvocationHandler . |
protected static class |
InvocationHandlerAdapter.ForField
An implementation of an
InvocationHandlerAdapter that delegates method
invocations to an adapter that is stored in an instance field. |
protected class |
InvocationHandlerAdapter.ForField.Appender
An appender for implementing the
InvocationHandlerAdapter.ForField . |
protected static class |
InvocationHandlerAdapter.ForInstance
An implementation of an
InvocationHandlerAdapter that delegates method
invocations to an adapter that is stored in a static field. |
protected class |
InvocationHandlerAdapter.ForInstance.Appender
An appender for implementing the
InvocationHandlerAdapter.ForInstance . |
class |
InvokeDynamic
An implementation that applies a
dynamic method invocation.
|
protected class |
InvokeDynamic.Appender
The byte code appender to be used by the
InvokeDynamic implementation. |
protected class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ConstantPoolWrapper.WrappingArgumentProvider
An argument provider that loads a primitive value from the constant pool and wraps it.
|
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForBooleanConstant
An argument provider for a
boolean value. |
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForByteConstant
An argument provider for a
byte value. |
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForCharacterConstant
An argument provider for a
char value. |
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForClassConstant
An argument provider for a
Class constant. |
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForDoubleConstant
An argument provider for a
double value. |
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForEnumerationValue
An argument provider for an
Enum constant. |
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForField
Provides an argument from an existing field.
|
protected static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForField.WithExplicitType
An argument provider for a field value with an explicit type.
|
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForFloatConstant
An argument provider for a
float value. |
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForInstance
An argument provider for a value that is stored in a randomly named static field.
|
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForIntegerConstant
An argument provider for a
int value. |
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForJavaConstant
An argument provider for a Java instance.
|
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForLongConstant
An argument provider for a
long value. |
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter
An argument provider that loads an argument of the intercepted method.
|
protected static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter.WithExplicitType
An argument provider for a method parameter with an explicit type.
|
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForNullValue
An argument provider for the
null value. |
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForShortConstant
An argument provider for a
short value. |
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForStringConstant
An argument provider for a
String value. |
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.ForThisInstance
An argument provider that loads the intercepted instance.
|
static class |
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved.Simple
A simple implementation of a resolved argument provider.
|
static class |
InvokeDynamic.InvocationProvider.Default
An invocation provider that requests a synthetic dynamic invocation where all arguments are explicitly
provided by the user.
|
protected static class |
InvokeDynamic.InvocationProvider.Default.Target
A target for a synthetically bound method call.
|
static class |
InvokeDynamic.InvocationProvider.NameProvider.ForExplicitName
A name provider that provides an explicit name.
|
static class |
InvokeDynamic.InvocationProvider.ReturnTypeProvider.ForExplicitType
Requests an explicit return type.
|
static class |
InvokeDynamic.InvocationProvider.Target.Resolved.Simple
A simple implementation of
InvokeDynamic.InvocationProvider.Target.Resolved . |
static class |
LoadedTypeInitializer.Compound
A compound loaded type initializer that combines several type initializers.
|
static class |
LoadedTypeInitializer.ForStaticField
A type initializer for setting a value for a static field.
|
class |
MethodCall
This
Implementation allows the invocation of a specified method while
providing explicit arguments to this method. |
protected class |
MethodCall.Appender
The appender being used to implement a
MethodCall . |
static class |
MethodCall.ArgumentLoader.ForField
Loads the value of an existing field onto the operand stack.
|
protected static class |
MethodCall.ArgumentLoader.ForField.ArgumentProvider
An argument provider for a field access.
|
protected static class |
MethodCall.ArgumentLoader.ForField.Factory
A factory for an argument loaded that loads the value of an existing field as an argument.
|
static class |
MethodCall.ArgumentLoader.ForInstance
Loads a value onto the operand stack that is stored in a static field.
|
protected static class |
MethodCall.ArgumentLoader.ForInstance.Factory
A factory that supplies the value of a static field as an argument.
|
static class |
MethodCall.ArgumentLoader.ForInstrumentedType
Loads the instrumented type onto the operand stack.
|
static class |
MethodCall.ArgumentLoader.ForMethodCall
Loads the return value of a method call onto the operand stack.
|
protected static class |
MethodCall.ArgumentLoader.ForMethodCall.ArgumentProvider
An argument provider for a method call.
|
protected static class |
MethodCall.ArgumentLoader.ForMethodCall.Factory
A factory for an argument loaded that loads the return value of a method call as an argument.
|
static class |
MethodCall.ArgumentLoader.ForMethodParameter
Loads a parameter of the instrumented method onto the operand stack.
|
protected static class |
MethodCall.ArgumentLoader.ForMethodParameter.Factory
A factory for an argument loader that supplies a method parameter as an argument.
|
static class |
MethodCall.ArgumentLoader.ForMethodParameterArray
Loads an array containing all arguments of a method.
|
static class |
MethodCall.ArgumentLoader.ForMethodParameterArrayElement
An argument loader that loads an element of a parameter of an array type.
|
static class |
MethodCall.ArgumentLoader.ForMethodParameterArrayElement.OfInvokedMethod
An argument loader factory that loads an array element from a parameter for each argument of the invoked method.
|
static class |
MethodCall.ArgumentLoader.ForMethodParameterArrayElement.OfParameter
Creates an argument loader for an array element that of a specific parameter.
|
static class |
MethodCall.ArgumentLoader.ForStackManipulation
Loads a stack manipulation resulting in a specific type as an argument.
|
static class |
MethodCall.ArgumentLoader.ForThisReference
An argument loader that assigns the
this reference to a parameter. |
static class |
MethodCall.FieldSetting
A
MethodCall that sets the call's result as the value of a field. |
static class |
MethodCall.MethodInvoker.ForContextualInvocation
Applies a contextual invocation of the provided method, i.e. a static invocation for static methods,
a special invocation for constructors and private methods and a virtual invocation for any other method.
|
static class |
MethodCall.MethodInvoker.ForDefaultMethodInvocation
Invokes a method as a Java 8 default method.
|
static class |
MethodCall.MethodInvoker.ForSuperMethodInvocation
Applies a super method invocation of the provided method.
|
static class |
MethodCall.MethodInvoker.ForVirtualInvocation
Applies a virtual invocation on a given type.
|
protected static class |
MethodCall.MethodInvoker.ForVirtualInvocation.Factory
A method invoker factory for a virtual method invocation.
|
static class |
MethodCall.MethodLocator.ForElementMatcher
A method locator that identifies a unique virtual method.
|
static class |
MethodCall.MethodLocator.ForElementMatcher.Factory
A factory for a method locator that uses a matcher on the instrumented type's available methods for identifing a target method.
|
static class |
MethodCall.MethodLocator.ForExplicitMethod
Invokes a given method.
|
static class |
MethodCall.TargetHandler.ForConstructingInvocation
Invokes a method in order to construct a new instance.
|
static class |
MethodCall.TargetHandler.ForField
Creates a target handler that stores the instance to invoke a method on in an instance field.
|
protected static class |
MethodCall.TargetHandler.ForField.Factory
A factory for a field access.
|
static class |
MethodCall.TargetHandler.ForField.Location.ForExplicitField
An explicit field location.
|
static class |
MethodCall.TargetHandler.ForField.Location.ForImplicitField
An implicit field location.
|
static class |
MethodCall.TargetHandler.ForMethodCall
A target handler that executes the method and uses it's return value as the target object.
|
protected static class |
MethodCall.TargetHandler.ForMethodCall.Factory
Creates a factory for invoking a method on the return type of another method.
|
protected static class |
MethodCall.TargetHandler.ForMethodCall.Resolved
A resolved target handler for a method call.
|
static class |
MethodCall.TargetHandler.ForMethodParameter
A target handler that loads the parameter of the given index as the target object.
|
protected static class |
MethodCall.TargetHandler.ForMethodParameter.Resolved
A resolved target handler for a method parameter.
|
static class |
MethodCall.TargetHandler.ForSelfOrStaticInvocation
A target handler that invokes a method either on the instance of the instrumented
type or as a static method.
|
protected static class |
MethodCall.TargetHandler.ForSelfOrStaticInvocation.Resolved
A resolved target handler for a static or self-declared invocation.
|
static class |
MethodCall.TargetHandler.ForValue
A target handler that invokes a method on an instance that is stored in a static field.
|
protected static class |
MethodCall.TargetHandler.ForValue.Factory
A factory for a target handler that loads a specific value.
|
static class |
MethodCall.TargetHandler.Simple
A simple target handler that applies a given stack manipulation.
|
static class |
MethodCall.TerminationHandler.FieldSetting
A termination handler that sets a field.
|
protected static class |
MethodCall.TerminationHandler.FieldSetting.Explicit
A factory for a field-setting termination handler that locates a given field.
|
protected static class |
MethodCall.TerminationHandler.FieldSetting.Implicit
A factory for a field-setting termination handler that uses a matcher to locate the target field on the insturmented type.
|
class |
MethodDelegation
This implementation 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. |
protected static class |
MethodDelegation.Appender
The appender for implementing a
MethodDelegation . |
static class |
MethodDelegation.ImplementationDelegate.Compiled.ForConstruction
A compiled implementation delegate for a constructor delegation.
|
static class |
MethodDelegation.ImplementationDelegate.Compiled.ForField
A compiled implementation delegate that invokes methods on a field.
|
static class |
MethodDelegation.ImplementationDelegate.Compiled.ForMethodReturn
A compiled implementation delegate that invokes a method on an instance that is returned by another method.
|
static class |
MethodDelegation.ImplementationDelegate.Compiled.ForStaticCall
A compiled implementation delegate for invoking a static method.
|
static class |
MethodDelegation.ImplementationDelegate.ForConstruction
An implementation delegate for constructing an instance.
|
static class |
MethodDelegation.ImplementationDelegate.ForField
An implementation delegate for invoking methods on a field that is declared by the instrumented type or a super type.
|
protected static class |
MethodDelegation.ImplementationDelegate.ForField.WithInstance
An implementation target for a static field that is declared by the instrumented type and that is assigned an instance.
|
protected static class |
MethodDelegation.ImplementationDelegate.ForField.WithLookup
An implementation target for a field that is declared by the instrumented type or a super type.
|
static class |
MethodDelegation.ImplementationDelegate.ForMethodReturn
An implementation delegate for invoking a delegation target on the another methods return value.
|
static class |
MethodDelegation.ImplementationDelegate.ForStaticMethod
An implementation delegate for a static method delegation.
|
static class |
MethodDelegation.WithCustomProperties
A
MethodDelegation with custom configuration. |
protected static class |
SuperMethodCall.Appender
An appender for implementing a
SuperMethodCall . |
class |
ToStringMethod
An implementation of
Object.toString() that concatenates the String representation of all fields that are declared by a class. |
protected static class |
ToStringMethod.Appender
An appender to implement
ToStringMethod . |
static class |
ToStringMethod.PrefixResolver.ForFixedValue
A prefix resolver that returns a fixed value.
|
Modifier and Type | Class and Description |
---|---|
static class |
AnnotationAppender.Default
A default implementation for an annotation appender that writes annotations to a given byte consumer
represented by an ASM
AnnotationVisitor . |
static class |
AnnotationAppender.ForTypeAnnotations
A type visitor that visits all type annotations of a generic type and writes any discovered annotation to a
supplied
AnnotationAppender . |
static class |
AnnotationAppender.Target.OnField
Target for an annotation that is written to a Java field.
|
static class |
AnnotationAppender.Target.OnMethod
Target for an annotation that is written to a Java method or constructor.
|
static class |
AnnotationAppender.Target.OnMethodParameter
Target for an annotation that is written to a Java method or constructor parameter.
|
static class |
AnnotationAppender.Target.OnRecordComponent
Target for an annotation that is written to a Java record component.
|
static class |
AnnotationAppender.Target.OnType
Target for an annotation that is written to a Java type.
|
static class |
FieldAttributeAppender.Compound
A field attribute appender that combines several method attribute appenders to be represented as a single
field attribute appender.
|
static class |
FieldAttributeAppender.Explicit
Appends an annotation to a field.
|
static class |
FieldAttributeAppender.Factory.Compound
A field attribute appender factory that combines several field attribute appender factories to be
represented as a single factory.
|
static class |
MethodAttributeAppender.Compound
A method attribute appender that combines several method attribute appenders to be represented as a single
method attribute appender.
|
static class |
MethodAttributeAppender.Explicit
Appends an annotation to a method or method parameter.
|
static class |
MethodAttributeAppender.Explicit.Target.OnMethodParameter
A method attribute appender target for writing annotations onto a given method parameter.
|
static class |
MethodAttributeAppender.Factory.Compound
A method attribute appender factory that combines several method attribute appender factories to be
represented as a single factory.
|
static class |
MethodAttributeAppender.ForReceiverType
A method attribute appender that writes a receiver type.
|
static class |
RecordComponentAttributeAppender.Compound
A record component attribute appender that combines several method attribute appenders to be represented as a single
record component attribute appender.
|
static class |
RecordComponentAttributeAppender.Explicit
Appends an annotation to a record component.
|
static class |
RecordComponentAttributeAppender.Factory.Compound
A record component attribute appender factory that combines several record component attribute appender factories to be
represented as a single factory.
|
static class |
TypeAttributeAppender.Compound
A compound type attribute appender that concatenates a number of other attribute appenders.
|
static class |
TypeAttributeAppender.Explicit
An attribute appender that appends a single annotation to a given type.
|
static class |
TypeAttributeAppender.ForInstrumentedType.Differentiating
A type attribute appender that writes all annotations of the instrumented but excludes annotations up to
a given index.
|
Modifier and Type | Class and Description |
---|---|
static class |
AuxiliaryType.NamingStrategy.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.
|
class |
MethodCallProxy
A method call proxy represents a class that is compiled against a particular method which can then be called whenever
either its
Callable.call() or Runnable.run() method is called where the method
call proxy implements both interfaces. |
static class |
MethodCallProxy.AssignableSignatureCall
A stack manipulation that creates a
MethodCallProxy
for a given method an pushes such an object onto the call stack. |
protected static class |
MethodCallProxy.ConstructorCall.Appender
The appender for implementing the
MethodCallProxy.ConstructorCall . |
protected static class |
MethodCallProxy.MethodCall
An implementation for a method of a
MethodCallProxy . |
protected class |
MethodCallProxy.MethodCall.Appender
The appender for implementing the
MethodCallProxy.MethodCall . |
class |
TypeProxy
A type proxy creates accessor methods for all overridable methods of a given type by subclassing the given type and
delegating all method calls to accessor methods of the instrumented type it was created for.
|
static class |
TypeProxy.ForDefaultMethod
Creates a type proxy which delegates its super method calls to any invokable default method of
a given interface and loads an instance of this proxy onto the operand stack.
|
static class |
TypeProxy.ForSuperMethodByConstructor
Loads a type proxy onto the operand stack which is created by calling one of its constructors.
|
static class |
TypeProxy.ForSuperMethodByReflectionFactory
Loads a type proxy onto the operand stack which is created by constructing a serialization constructor using
the Oracle JDK's
ReflectionFactory.newConstructorForSerialization(Class, java.lang.reflect.Constructor)
method which might not be available in any Java runtime. |
protected class |
TypeProxy.MethodCall
An implementation for a method call of a
TypeProxy . |
protected class |
TypeProxy.MethodCall.Appender
Implementation of a byte code appender for a
TypeProxy.MethodCall . |
protected class |
TypeProxy.MethodCall.Appender.AccessorMethodInvocation
Stack manipulation for invoking an accessor method.
|
protected static class |
TypeProxy.SilentConstruction.Appender
The appender for implementing a
TypeProxy.SilentConstruction . |
Modifier and Type | Class and Description |
---|---|
static class |
MethodDelegationBinder.AmbiguityResolver.Compound
A chain of
MethodDelegationBinder.AmbiguityResolver s
that are applied in the given order until two bindings can be resolved. |
static class |
MethodDelegationBinder.BindingResolver.StreamWriting
Binds a method using another resolver and prints the selected binding to a
PrintStream . |
protected static class |
MethodDelegationBinder.MethodBinding.Builder.Build
A method binding that was created by a
MethodDelegationBinder.MethodBinding.Builder . |
static class |
MethodDelegationBinder.MethodInvoker.Virtual
A method invocation that enforces a virtual invocation that is dispatched on a given type.
|
static class |
MethodDelegationBinder.ParameterBinding.Anonymous
An anonymous binding of a target method parameter.
|
static class |
MethodDelegationBinder.ParameterBinding.Unique<T>
A uniquely identifiable parameter binding for a target method.
|
static class |
MethodDelegationBinder.Processor
A helper class that allows to identify a best binding for a given type and source method choosing from a list of given
target methods by using a given
MethodDelegationBinder
and an MethodDelegationBinder.AmbiguityResolver . |
Modifier and Type | Class and Description |
---|---|
static class |
Default.Binder.TypeLocator.ForType
A type locator that returns a given type.
|
static class |
DefaultCall.Binder.DefaultMethodLocator.Explicit
An explicit default method locator attempts to look up a default method in the specified interface type.
|
protected static class |
DefaultMethod.Binder.DelegationMethod
Loads the delegation method constant onto the stack.
|
static class |
DefaultMethod.Binder.MethodLocator.ForExplicitType
A method locator for an explicit target type.
|
static class |
FieldProxy.Binder
A binder for the
FieldProxy annotation. |
protected class |
FieldProxy.Binder.AccessorProxy
A proxy type for accessing a field either by a getter or a setter.
|
protected static class |
FieldProxy.Binder.FieldGetter
Implementation for a getter method.
|
protected class |
FieldProxy.Binder.FieldGetter.Appender
A byte code appender for a getter method.
|
static class |
FieldProxy.Binder.FieldResolver.Factory.Duplex
A duplex factory for a type that both sets and gets a field value.
|
static class |
FieldProxy.Binder.FieldResolver.Factory.Simplex
A simplex factory where field getters and setters both have their own type.
|
static class |
FieldProxy.Binder.FieldResolver.ForGetter
A field resolver for a getter accessor.
|
static class |
FieldProxy.Binder.FieldResolver.ForGetterSetterPair
A field resolver for an accessor that both gets and sets a field value.
|
static class |
FieldProxy.Binder.FieldResolver.ForSetter
A field resolver for a setter accessor.
|
protected static class |
FieldProxy.Binder.FieldSetter
Implementation for a setter method.
|
protected class |
FieldProxy.Binder.FieldSetter.Appender
A byte code appender for a setter method.
|
protected static class |
FieldProxy.Binder.InstanceFieldConstructor
Represents an implementation for implementing a proxy type constructor when a non-static field is accessed.
|
protected static class |
FieldProxy.Binder.InstanceFieldConstructor.Appender
An appender for implementing an
FieldProxy.Binder.InstanceFieldConstructor . |
static class |
Morph.Binder
A binder for the
Morph annotation. |
static class |
Morph.Binder.DefaultMethodLocator.Explicit
An explicit default method locator attempts to look up a default method in the specified interface type.
|
protected static class |
Morph.Binder.RedirectionProxy
A proxy that implements the installed interface in order to allow for a morphed super method invocation.
|
protected static class |
Morph.Binder.RedirectionProxy.InstanceFieldConstructor
Creates an instance of the proxy when instrumenting an instance method.
|
protected static class |
Morph.Binder.RedirectionProxy.InstanceFieldConstructor.Appender
The byte code appender that implements the constructor.
|
protected static class |
Morph.Binder.RedirectionProxy.MethodCall
Implements a the method call of the morphing method.
|
protected class |
Morph.Binder.RedirectionProxy.MethodCall.Appender
The byte code appender to implement the method.
|
static class |
Pipe.Binder
A
TargetMethodAnnotationDrivenBinder.ParameterBinder
for binding the Pipe annotation. |
protected static class |
Pipe.Binder.Redirection
An auxiliary type for performing the redirection of a method invocation as requested by the
Pipe annotation. |
protected static class |
Pipe.Binder.Redirection.MethodCall
The implementation to implement a
Pipe.Binder.Redirection 's
forwarding method. |
static class |
Super.Binder.TypeLocator.ForType
A type locator that returns a given type.
|
protected static class |
SuperMethod.Binder.DelegationMethod
Loads the delegation method constant onto the stack.
|
class |
TargetMethodAnnotationDrivenBinder
This
MethodDelegationBinder binds
method by analyzing annotations found on the target method that is subject to a method binding. |
protected static class |
TargetMethodAnnotationDrivenBinder.DelegationProcessor
A delegation processor is a helper class for a
TargetMethodAnnotationDrivenBinder
for performing its actual logic. |
static class |
TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Bound<T extends Annotation>
A bound handler represents an unambiguous parameter binder that was located for a given array of
annotations.
|
static class |
TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Unbound
An unbound handler is a fallback for returning an illegal binding for parameters for which no parameter
binder could be located.
|
static class |
TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFixedValue.OfConstant<U extends Annotation>
A parameter binder that binds a fixed value to a parameter annotation when using a
MethodDelegation . |
protected static class |
TargetMethodAnnotationDrivenBinder.Record
A compiled record of a target method annotation-driven binder.
|
Modifier and Type | Class and Description |
---|---|
static class |
ByteCodeAppender.Compound
A compound appender that combines a given number of other byte code appenders.
|
static class |
ByteCodeAppender.Simple
A simple byte code appender that only represents a given array of
StackManipulation s. |
static class |
ByteCodeAppender.Size
An immutable description of both the operand stack size and the size of the local variable array that is
required to run the code generated by this
ByteCodeAppender . |
static class |
StackManipulation.Compound
An immutable stack manipulation that aggregates a sequence of other stack manipulations.
|
static class |
StackManipulation.Simple
An implementation of
StackManipulation that simplifies functional invocations via lambda expressions. |
static class |
StackManipulation.Size
A description of the size change that is imposed by some
StackManipulation . |
class |
TypeCreation
A stack manipulation for creating an undefined type on which a constructor is to be called.
|
Modifier and Type | Class and Description |
---|---|
class |
InstanceCheck
Implements an
instanceof check. |
class |
TypeCasting
A stack manipulation for a type down casting.
|
Modifier and Type | Class and Description |
---|---|
class |
PrimitiveTypeAwareAssigner
This assigner is able to handle non-
void , primitive types. |
protected static class |
PrimitiveUnboxingDelegate.ImplicitlyTypedUnboxingResponsible
An unboxing responsible for an implicitly typed value.
|
protected static class |
PrimitiveWideningDelegate.WideningStackManipulation
A stack manipulation that widens a primitive type into a more general primitive type.
|
class |
VoidAwareAssigner
This assigner is able to handle the
void type. |
Modifier and Type | Class and Description |
---|---|
protected static class |
GenericTypeAwareAssigner.IsAssignableToVisitor
A visitor for generic types that determines assignability of such types.
|
protected static class |
GenericTypeAwareAssigner.IsAssignableToVisitor.OfManifestType
An implementation of a assignability visitor that is applicable for any non-wildcard type.
|
protected static class |
GenericTypeAwareAssigner.IsAssignableToVisitor.OfWildcard
A visitor to determine the assignability of a wildcard type.
|
Modifier and Type | Class and Description |
---|---|
protected class |
ArrayAccess.Loader
A stack manipulation for loading an array's value.
|
protected class |
ArrayAccess.Putter
A stack manipulation for storing an array's value.
|
class |
ArrayFactory
A
CollectionFactory that is capable of
creating an array of a given type with any number of given values. |
static class |
ArrayFactory.ArrayCreator.ForReferenceType
An array creator implementation for reference types.
|
protected class |
ArrayFactory.ArrayStackManipulation
A stack manipulation for creating an array as defined by the enclosing array factory.
|
Modifier and Type | Class and Description |
---|---|
protected static class |
ClassConstant.ForReferenceType
A class constant for a non-primitive
Class . |
protected static class |
DoubleConstant.ConstantPool
A stack manipulation for loading a
double value from a class's constant pool onto the operand stack. |
protected static class |
FloatConstant.ConstantPool
A stack manipulation for loading a
float value from a class's constant pool onto the operand stack. |
protected static class |
IntegerConstant.ConstantPool
A stack manipulation that loads a JVM-integer value from a constant pool value onto the operand stack.
|
protected static class |
IntegerConstant.SingleBytePush
A stack manipulation that loads a JVM-integer value by a
BIPUSH operation which is
legal for single byte integer values. |
protected static class |
IntegerConstant.TwoBytePush
A stack manipulation that loads a JVM-integer value by a
SIPUSH operation which is
legal for up to two byte integer values. |
class |
JavaConstantValue
A constant representing a
JavaConstant . |
protected static class |
LongConstant.ConstantPool
A stack manipulation for loading a
long value from a class's constant pool onto the operand stack. |
class |
SerializedConstant
A constant that represents a value in its serialized form.
|
class |
TextConstant
Represents a
String value that is stored in a type's constant pool. |
Modifier and Type | Class and Description |
---|---|
protected class |
FieldAccess.AccessDispatcher
A dispatcher for implementing a non-generic read or write access on a field.
|
protected class |
FieldAccess.AccessDispatcher.FieldGetInstruction
A reading field access operation.
|
protected class |
FieldAccess.AccessDispatcher.FieldPutInstruction
A writing field access operation.
|
protected static class |
FieldAccess.OfGenericField
A dispatcher for implementing a generic read or write access on a field.
|
class |
HandleInvocation
An exact invocation of a method handle with a polymorphic signature.
|
protected class |
MethodInvocation.DynamicInvocation
Performs a dynamic method invocation of the given method.
|
protected static class |
MethodInvocation.HandleInvocation
Performs a method invocation on a method handle with a polymorphic type signature.
|
protected class |
MethodInvocation.Invocation
An implementation of a method invoking stack manipulation.
|
protected static class |
MethodInvocation.OfGenericMethod
A method invocation of a generically resolved method.
|
static class |
MethodVariableAccess.MethodLoading
A stack manipulation that loads all parameters of a given method onto the operand stack.
|
static class |
MethodVariableAccess.MethodLoading.TypeCastingHandler.ForBridgeTarget
A type casting handler that casts all parameters of a method to the parameter types of a compatible method
with covariant parameter types.
|
protected static class |
MethodVariableAccess.OffsetIncrementing
A stack manipulation that increments an integer variable.
|
protected class |
MethodVariableAccess.OffsetLoading
A stack manipulation for loading a variable of a method's local variable array onto the operand stack.
|
protected class |
MethodVariableAccess.OffsetWriting
A stack manipulation for storing a variable into a method's local variable array.
|
Modifier and Type | Class and Description |
---|---|
class |
AccessibilityMatcher<T extends ByteCodeElement>
An element matcher that validates that a given byte code element is accessible to a given type.
|
class |
AnnotationTargetMatcher<T extends AnnotationDescription>
A matcher for annotations that target a given element type.
|
class |
AnnotationTypeMatcher<T extends AnnotationDescription>
An element matcher that matches the type of an annotation description.
|
class |
ArrayTypeMatcher<T extends TypeDefinition>
Matches an enumeration type.
|
class |
BooleanMatcher<T>
An element matcher that returns a fixed result.
|
class |
CachingMatcher<T>
A matcher that remembers the results of previously matching an equal target.
|
class |
ClassLoaderHierarchyMatcher<T extends ClassLoader>
An element matcher that matches all
ClassLoader s in the matched class loaders hierarchy
against a given matcher. |
class |
ClassLoaderParentMatcher<T extends ClassLoader>
An element matcher that matches a class loader for being a parent of the given class loader.
|
class |
CollectionElementMatcher<T>
A matcher that matches a given element of a collection.
|
class |
CollectionErasureMatcher<T extends Iterable<? extends TypeDefinition>>
An element matcher that matches a collection of types by their erasures.
|
class |
CollectionItemMatcher<T>
A list item matcher matches any element of a collection to a given matcher and assures that at least one
element matches the supplied iterable condition.
|
class |
CollectionOneToOneMatcher<T>
An element matcher that matches a given iterable collection to a list of matchers on a per-element basis.
|
class |
CollectionSizeMatcher<T extends Iterable<?>>
An element matcher that matches a collection by its size.
|
class |
DeclaringAnnotationMatcher<T extends AnnotationSource>
An element matcher that matches the list of annotations that are provided by an annotated element.
|
class |
DeclaringFieldMatcher<T extends TypeDefinition>
An element matcher that checks if a type description declares fields of a given property.
|
class |
DeclaringMethodMatcher<T extends TypeDefinition>
An element matcher that checks if a type description declares methods of a given property.
|
class |
DeclaringTypeMatcher<T extends DeclaredByType>
An element matcher that matches the declaring type of another element, only if this element is actually declared
in a type.
|
class |
DefinedShapeMatcher<T extends ByteCodeElement.TypeDependant<S,?>,S extends ByteCodeElement.TypeDependant<?,?>>
An element matcher that matches a byte code's element's token against a matcher for such a token.
|
class |
DescriptorMatcher<T extends NamedElement.WithDescriptor>
An element matcher that matches a Java descriptor.
|
static class |
ElementMatcher.Junction.Conjunction<W>
A conjunction matcher which only matches an element if both represented matchers constitute a match.
|
static class |
ElementMatcher.Junction.Disjunction<W>
A disjunction matcher which only matches an element if both represented matchers constitute a match.
|
class |
EqualityMatcher<T>
An element matcher that checks an object's equality to another object.
|
class |
ErasureMatcher<T extends TypeDefinition>
An element matcher that matches its argument's
TypeDescription.Generic raw type against the
given matcher for a TypeDescription . |
class |
FailSafeMatcher<T>
A fail-safe matcher catches exceptions that are thrown by a delegate matcher and returns an alternative value.
|
class |
FieldTypeMatcher<T extends FieldDescription>
An element matcher that matches a field's type.
|
class |
HasSuperClassMatcher<T extends TypeDescription>
An element matcher that matches a super class.
|
class |
HasSuperTypeMatcher<T extends TypeDescription>
An element matcher that matches a super type.
|
class |
InheritedAnnotationMatcher<T extends TypeDescription>
An element matcher that matches the list of inherited annotations of a type description.
|
class |
InstanceTypeMatcher<T>
An element matcher that matches an object's type.
|
class |
IsNamedMatcher<T extends NamedElement.WithOptionalName>
An element matcher that matches a named element only if is explicitly named.
|
static class |
LatentMatcher.Conjunction<S>
A matcher that computes the conjunction of all supplied latent matchers.
|
static class |
LatentMatcher.Disjunction<S>
A matcher that computes the disjunction of all supplied latent matchers.
|
static class |
LatentMatcher.ForFieldToken
A latent matcher where the field token is being attached to the supplied type description before matching.
|
protected static class |
LatentMatcher.ForFieldToken.ResolvedMatcher
A resolved matcher of a latent field matcher for a field token.
|
static class |
LatentMatcher.ForMethodToken
A latent matcher where the method token is being attached to the supplied type description before matching.
|
protected static class |
LatentMatcher.ForMethodToken.ResolvedMatcher
A resolved matcher of a latent method matcher for a method token.
|
static class |
LatentMatcher.ForRecordComponentToken
A latent matcher for a record component token.
|
static class |
LatentMatcher.Resolved<S>
A latent matcher representing an already resolved
ElementMatcher . |
class |
MethodExceptionTypeMatcher<T extends MethodDescription>
An element matcher that matches the exceptions that are declared by a method.
|
class |
MethodOverrideMatcher<T extends MethodDescription>
A matcher that checks if any super type of a type declares a method with the same shape of a matched method.
|
class |
MethodParametersMatcher<T extends MethodDescription>
An element matcher that matches a method's parameters.
|
class |
MethodParameterTypeMatcher<T extends ParameterDescription>
An element matcher that matches a method's parameter's type.
|
class |
MethodParameterTypesMatcher<T extends ParameterList<?>>
An element matcher that matches a method's parameter types.
|
class |
MethodReturnTypeMatcher<T extends MethodDescription>
An element matcher that matches its argument's return type against a given type matcher.
|
class |
MethodSortMatcher<T extends MethodDescription>
Matches a method description by its general characteristics which are represented as a
MethodSortMatcher.Sort . |
class |
ModifierMatcher<T extends ModifierReviewable>
An element matcher that matches a byte code element by its modifiers.
|
class |
NameMatcher<T extends NamedElement>
A method matcher that matches a byte code element's source code name:
The source code name of types is equal to their binary name where arrays are appended a
[] by
their arity and where inner classes are appended by dollar signs to their outer class's source name. |
class |
NegatingMatcher<T>
An element matcher that reverses the matching result of another matcher.
|
class |
NullMatcher<T>
An element matcher that matches the
null value. |
class |
PrimitiveTypeMatcher<T extends TypeDefinition>
Matches a primitive type.
|
class |
RecordMatcher<T extends TypeDefinition>
Matches a record.
|
class |
SignatureTokenMatcher<T extends MethodDescription>
Matches a method description's signature token against another matcher.
|
class |
StringMatcher
An element matcher that compares two strings by a given pattern which is characterized by a
StringMatcher.Mode . |
class |
StringSetMatcher
An element matcher which checks if a string is in a set of strings.
|
class |
SubTypeMatcher<T extends TypeDescription>
An element matcher that matches its argument for being another type's subtype.
|
class |
SuperTypeMatcher<T extends TypeDescription>
An element matcher that matches its argument for being another type's super type.
|
class |
TypeSortMatcher<T extends TypeDefinition>
An element matcher that validates that a given generic type description represents a type of a given name.
|
class |
VisibilityMatcher<T extends ByteCodeElement>
An element matcher that validates that a given byte code element is visible to a given type.
|
Modifier and Type | Class and Description |
---|---|
static class |
TypePool.AbstractBase
A base implementation of a
TypePool that is managing a cache provider and
that handles the description of array and primitive types. |
protected static class |
TypePool.AbstractBase.ArrayTypeResolution
A resolution for a type that, if resolved, represents an array type.
|
static class |
TypePool.AbstractBase.Hierarchical
Implements a hierarchical view of type pools, similarly to class loader hierarchies.
|
static class |
TypePool.ClassLoading
A type pool that attempts to load a class.
|
static class |
TypePool.Default
A default implementation of a
TypePool that models binary data in the Java byte code format
into a TypeDescription . |
static class |
TypePool.Default.ComponentTypeLocator.ForAnnotationProperty
A component type locator that lazily analyses an annotation for resolving an annotation property's
array value's component type.
|
protected class |
TypePool.Default.ComponentTypeLocator.ForAnnotationProperty.Bound
A bound representation of a
TypePool.Default.ComponentTypeLocator.ForAnnotationProperty . |
static class |
TypePool.Default.ComponentTypeLocator.ForArrayType
A component type locator that locates an array type by a method's return value from its method descriptor.
|
protected class |
TypePool.Default.GenericTypeExtractor.ForSignature.OfMethod.ExceptionTypeRegistrant
A registrant for an exception type.
|
protected class |
TypePool.Default.GenericTypeExtractor.ForSignature.OfMethod.ParameterTypeRegistrant
A registrant for a parameter type.
|
protected class |
TypePool.Default.GenericTypeExtractor.ForSignature.OfMethod.ReturnTypeTypeRegistrant
A registrant for a return type.
|
protected class |
TypePool.Default.GenericTypeExtractor.ForSignature.OfType.InterfaceTypeRegistrant
A registrant for the interface types.
|
protected class |
TypePool.Default.GenericTypeExtractor.ForSignature.OfType.SuperClassRegistrant
A registrant for the super type.
|
static class |
TypePool.Default.GenericTypeExtractor.IncompleteToken.ForInnerClass
An incomplete generic type token representing a type with an outer type.
|
static class |
TypePool.Default.GenericTypeExtractor.IncompleteToken.ForTopLevelType
An incomplete token representing a generic type without an outer type.
|
protected static class |
TypePool.Default.LazyTypeDescription.AnnotationToken
A token for representing collected data on an annotation.
|
static class |
TypePool.Default.LazyTypeDescription.AnnotationToken.Resolution.Illegal
An illegal resolution.
|
static class |
TypePool.Default.LazyTypeDescription.AnnotationToken.Resolution.Simple
A simple resolved annotation.
|
protected static class |
TypePool.Default.LazyTypeDescription.FieldToken
A token for representing collected data on a field.
|
static class |
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForGenericArray
A generic type token that represents a generic array.
|
static class |
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForLowerBoundWildcard
A generic type token for a wildcard that is bound below.
|
static class |
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType
A generic type token that represents a parameterized type.
|
static class |
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType.Nested
A generic type token to describe a parameterized type description with a generic owner type.
|
static class |
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForRawType
A generic type token that represents a non-generic type.
|
static class |
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable
A generic type token that represents a type variable.
|
protected static class |
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.Formal
A generic type token that represent a formal type variable, i.e. a type variable including its upper bounds.
|
static class |
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForUpperBoundWildcard
A generic type token for a wildcard that is bound above.
|
static class |
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForField.Tokenized
An implementation of a tokenized resolution of the generic type of a
FieldDescription . |
static class |
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForMethod.Tokenized
An implementation of a tokenized resolution of generic types of a
MethodDescription . |
static class |
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForRecordComponent.Tokenized
An implementation of a tokenized resolution of the generic type of a
RecordComponentDescription . |
static class |
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForType.Tokenized
An implementation of a tokenized resolution of generic types of a
TypeDescription . |
protected static class |
TypePool.Default.LazyTypeDescription.MethodToken
A token for representing collected data on a method.
|
protected static class |
TypePool.Default.LazyTypeDescription.MethodToken.ParameterToken
A token representing a method's parameter.
|
protected static class |
TypePool.Default.LazyTypeDescription.RecordComponentToken
A token representing a record component.
|
static class |
TypePool.Default.LazyTypeDescription.TypeContainment.WithinMethod
Describes a type that is contained within a method or constructor.
|
static class |
TypePool.Default.LazyTypeDescription.TypeContainment.WithinType
Describes a type that is contained within another type.
|
protected class |
TypePool.Default.WithLazyResolution.LazyResolution
A lazy resolution of a type that the enclosing type pool attempts to resolve.
|
static class |
TypePool.Explicit
A type pool that supplies explicitly known type descriptions.
|
static class |
TypePool.LazyFacade
A lazy facade of a type pool that delegates any lookups to another type pool only if another value than the type's name is looked up.
|
protected static class |
TypePool.LazyFacade.LazyResolution
The lazy resolution for a lazy facade for a type pool.
|
static class |
TypePool.Resolution.Illegal
A canonical representation of a non-successful resolution of a
TypePool . |
static class |
TypePool.Resolution.Simple
A simple resolution that represents a given
TypeDescription . |
Modifier and Type | Class and Description |
---|---|
protected static class |
FileSystem.ForLegacyVm
A file system representation for a VM that does not support NIO2.
|
protected static class |
FileSystem.ForNio2CapableVm
A file system representation for a VM that does support NIO2.
|
class |
StreamDrainer
A utility for draining the contents of an
InputStream into a byte array. |
Modifier and Type | Class and Description |
---|---|
class |
JavaDispatcher<T>
A dispatcher for creating a proxy that invokes methods of a type that is possibly unknown on the current VM.
|
static class |
JavaDispatcher.Dispatcher.ForConstructor
A dispatcher for invoking a constructor.
|
static class |
JavaDispatcher.Dispatcher.ForContainerCreation
A dispatcher that creates an array.
|
protected static class |
JavaDispatcher.Dispatcher.ForDefaultValue.OfNonPrimitiveArray
A dispatcher for a non-primitive array type.
|
static class |
JavaDispatcher.Dispatcher.ForInstanceCheck
A dispatcher that performs an instance check.
|
static class |
JavaDispatcher.Dispatcher.ForNonStaticMethod
A dispatcher for invoking a non-static proxied method.
|
static class |
JavaDispatcher.Dispatcher.ForStaticMethod
A dispatcher for invoking a static proxied method.
|
static class |
JavaDispatcher.Dispatcher.ForUnresolvedMethod
A dispatcher for an unresolved method.
|
static class |
JavaDispatcher.DynamicClassLoader.Resolver.ForModuleSystem
A resolver for VMs that do support the module system.
|
protected static class |
JavaDispatcher.ProxiedInvocationHandler
An invocation handler that invokes given dispatchers.
|
Modifier and Type | Class and Description |
---|---|
class |
GetMethodAction
Resolves a public method for a given type or returns
null if the type or method are not available or
if a resolution is not possible. |
class |
GetSystemPropertyAction
An action for reading a system property as a privileged action.
|
class |
SetAccessibleAction<T extends AccessibleObject>
An action for making an
AccessibleObject accessible. |
Copyright © 2014–2024. All rights reserved.