All Classes Interface Summary Class Summary Enum Summary Annotation Types Summary
| Class |
Description |
| AbstractInliningDynamicTypeBuilder<T> |
An abstract base implementation of a dynamic type builder that alters an existing type.
|
| AbstractUserConfiguration |
An abstract base class for a user configuration implying a Maven coordinate.
|
| AccessibilityMatcher<T extends ByteCodeElement> |
An element matcher that validates that a given byte code element is accessible to a given type.
|
| Addition |
A stack manipulation that adds to numbers on the operand stack.
|
| Advice |
Advice wrappers copy the code of blueprint methods to be executed before and/or after a matched method.
|
| Advice.AdviceVisitor |
A method visitor that weaves the advice methods' byte codes.
|
| Advice.AdviceVisitor.WithExitAdvice |
An advice visitor that applies exit advice.
|
| Advice.AdviceVisitor.WithExitAdvice.WithExceptionHandling |
An advice visitor that captures exceptions by weaving try-catch blocks around user code.
|
| Advice.AdviceVisitor.WithExitAdvice.WithoutExceptionHandling |
An advice visitor that does not capture exceptions.
|
| Advice.AdviceVisitor.WithoutExitAdvice |
An advice visitor that does not apply exit advice.
|
| Advice.AllArguments |
Assigns an array containing all arguments of the instrumented method to the annotated parameter.
|
| Advice.Appender |
A byte code appender for implementing Advice. |
| Advice.Appender.EmulatingMethodVisitor |
A method visitor that allows for the emulation of a full method visitor invocation circle without delegating initial
and ending visitations to the underlying visitor.
|
| Advice.Argument |
Indicates that the annotated parameter should be mapped to the parameter with index Advice.Argument.value() of
the instrumented method. |
| Advice.ArgumentHandler |
An argument handler is responsible for resolving offsets of the local variable array in the context of the applied instrumentation.
|
| Advice.ArgumentHandler.Factory |
A factory for creating an argument handler.
|
| Advice.ArgumentHandler.ForAdvice |
An argument handler that is used for resolving an advice method.
|
| Advice.ArgumentHandler.ForAdvice.ForMethodEnter |
An argument handler for an enter advice method.
|
| Advice.ArgumentHandler.ForAdvice.ForMethodExit |
An argument handler for an exit advice method.
|
| Advice.ArgumentHandler.ForInstrumentedMethod |
An argument handler that is used for resolving the instrumented method.
|
| Advice.ArgumentHandler.ForInstrumentedMethod.Copying |
An argument handler for an instrumented method that copies all arguments before executing the instrumented method.
|
| Advice.ArgumentHandler.ForInstrumentedMethod.Simple |
A simple argument handler for an instrumented method.
|
| Advice.Dispatcher |
A dispatcher for implementing advice.
|
| Advice.Dispatcher.Bound |
A bound resolution of an advice method.
|
| Advice.Dispatcher.Delegating |
A dispatcher for an advice method that is being invoked from the instrumented method.
|
| Advice.Dispatcher.Delegating.Resolved |
A resolved version of a dispatcher.
|
| Advice.Dispatcher.Delegating.Resolved.AdviceMethodWriter |
A bound advice method that copies the code by first extracting the exception table and later appending the
code of the method without copying any meta data.
|
| Advice.Dispatcher.Delegating.Resolved.AdviceMethodWriter.ForMethodEnter |
An advice method writer for a method enter.
|
| Advice.Dispatcher.Delegating.Resolved.AdviceMethodWriter.ForMethodExit |
An advice method writer for a method exit.
|
| Advice.Dispatcher.Delegating.Resolved.ForMethodEnter |
A resolved dispatcher for implementing method enter advice.
|
| Advice.Dispatcher.Delegating.Resolved.ForMethodEnter.WithDiscardedEnterType |
Implementation of an advice that does not expose an enter type.
|
| Advice.Dispatcher.Delegating.Resolved.ForMethodEnter.WithRetainedEnterType |
Implementation of an advice that does expose an enter type.
|
| Advice.Dispatcher.Delegating.Resolved.ForMethodExit |
A resolved dispatcher for implementing method exit advice.
|
| Advice.Dispatcher.Delegating.Resolved.ForMethodExit.WithExceptionHandler |
Implementation of exit advice that handles exceptions.
|
| Advice.Dispatcher.Delegating.Resolved.ForMethodExit.WithoutExceptionHandler |
Implementation of exit advice that ignores exceptions.
|
| Advice.Dispatcher.Inactive |
An implementation for inactive devise that does not write any byte code.
|
| Advice.Dispatcher.Inlining |
A dispatcher for an advice method that is being inlined into the instrumented method.
|
| Advice.Dispatcher.Inlining.CodeTranslationVisitor |
A visitor for translating an advice method's byte code for inlining into the instrumented method.
|
| Advice.Dispatcher.Inlining.CodeTranslationVisitor.ForMethodEnter |
A code translation visitor that retains the return value of the represented advice method.
|
| Advice.Dispatcher.Inlining.CodeTranslationVisitor.ForMethodExit |
A code translation visitor that discards the return value of the represented advice method.
|
| Advice.Dispatcher.Inlining.Resolved |
A resolved version of a dispatcher.
|
| Advice.Dispatcher.Inlining.Resolved.ForMethodEnter |
A resolved dispatcher for implementing method enter advice.
|
| Advice.Dispatcher.Inlining.Resolved.ForMethodEnter.WithDiscardedEnterType |
Implementation of an advice that does not expose an enter type.
|
| Advice.Dispatcher.Inlining.Resolved.ForMethodEnter.WithRetainedEnterType |
Implementation of an advice that does expose an enter type.
|
| Advice.Dispatcher.Inlining.Resolved.ForMethodExit |
A resolved dispatcher for implementing method exit advice.
|
| Advice.Dispatcher.Inlining.Resolved.ForMethodExit.WithExceptionHandler |
Implementation of exit advice that handles exceptions.
|
| Advice.Dispatcher.Inlining.Resolved.ForMethodExit.WithoutExceptionHandler |
Implementation of exit advice that ignores exceptions.
|
| Advice.Dispatcher.RelocationHandler |
A relocation handler is responsible for chaning the usual control flow of an instrumented method.
|
| Advice.Dispatcher.RelocationHandler.Bound |
|
| Advice.Dispatcher.RelocationHandler.Disabled |
A disabled relocation handler that does never trigger a relocation.
|
| Advice.Dispatcher.RelocationHandler.ForType |
A relocation handler that is triggered if the checked value is an instance of a given type.
|
| Advice.Dispatcher.RelocationHandler.ForType.Bound |
|
| Advice.Dispatcher.RelocationHandler.ForValue |
A relocation handler that triggers a relocation for a default or non-default value.
|
| Advice.Dispatcher.RelocationHandler.Relocation |
A relocator is responsible for triggering a relocation if a relocation handler triggers a relocating condition.
|
| Advice.Dispatcher.RelocationHandler.Relocation.Illegal |
A relocator that does not allow for relocation.
|
| Advice.Dispatcher.Resolved |
Represents a resolved dispatcher.
|
| Advice.Dispatcher.Resolved.AbstractBase |
|
| Advice.Dispatcher.Resolved.ForMethodEnter |
Represents a resolved dispatcher for entering a method.
|
| Advice.Dispatcher.Resolved.ForMethodExit |
Represents a resolved dispatcher for exiting a method.
|
| Advice.Dispatcher.SuppressionHandler |
A suppression handler for optionally suppressing exceptions.
|
| Advice.Dispatcher.SuppressionHandler.Bound |
A bound version of a suppression handler that must not be reused.
|
| Advice.Dispatcher.SuppressionHandler.NoOp |
A non-operational suppression handler that does not suppress any method.
|
| Advice.Dispatcher.SuppressionHandler.ReturnValueProducer |
A producer for a default return value if this is applicable.
|
| Advice.Dispatcher.SuppressionHandler.Suppressing |
A suppression handler that suppresses a given throwable type.
|
| Advice.Dispatcher.SuppressionHandler.Suppressing.Bound |
An active, bound suppression handler.
|
| Advice.Dispatcher.Unresolved |
A dispatcher that is not yet resolved.
|
| Advice.Enter |
Indicates that the annotated parameter should be mapped to the value that is returned by the advice method that is annotated
by Advice.OnMethodEnter. |
| Advice.FieldValue |
Indicates that the annotated parameter should be mapped to a field in the scope of the instrumented method.
|
| Advice.MethodSizeHandler |
A handler for computing the instrumented method's size.
|
| Advice.MethodSizeHandler.Default |
A default implementation for a method size handler.
|
| Advice.MethodSizeHandler.Default.WithCopiedArguments |
A method size handler that expects that the original arguments were copied.
|
| Advice.MethodSizeHandler.Default.WithRetainedArguments |
A method size handler that expects that the original arguments are retained.
|
| Advice.MethodSizeHandler.ForAdvice |
A method size handler for an advice method.
|
| Advice.MethodSizeHandler.ForInstrumentedMethod |
A method size handler for the instrumented method.
|
| Advice.MethodSizeHandler.NoOp |
A non-operational method size handler.
|
| Advice.OffsetMapping |
Represents an offset mapping for an advice method to an alternative offset.
|
| Advice.OffsetMapping.Factory<T extends java.lang.annotation.Annotation> |
Represents a factory for creating a Advice.OffsetMapping for a given parameter for a given annotation. |
| Advice.OffsetMapping.Factory.AdviceType |
Describes the type of advice being applied.
|
| Advice.OffsetMapping.Factory.Illegal<T extends java.lang.annotation.Annotation> |
A factory for an annotation whose use is not permitted.
|
| Advice.OffsetMapping.Factory.Simple<T extends java.lang.annotation.Annotation> |
A simple factory that binds a constant offset mapping.
|
| Advice.OffsetMapping.ForAllArguments |
An offset mapping that maps an array containing all arguments of the instrumented method.
|
| Advice.OffsetMapping.ForAllArguments.Factory |
A factory for an offset mapping that maps all arguments values of the instrumented method.
|
| Advice.OffsetMapping.ForArgument |
An offset mapping for a given parameter of the instrumented method.
|
| Advice.OffsetMapping.ForArgument.Resolved |
An offset mapping for a specific parameter of the instrumented method.
|
| Advice.OffsetMapping.ForArgument.Resolved.Factory<T extends java.lang.annotation.Annotation> |
A factory for a parameter argument of the instrumented method.
|
| Advice.OffsetMapping.ForArgument.Unresolved |
An offset mapping for a parameter of the instrumented method with a specific index.
|
| Advice.OffsetMapping.ForArgument.Unresolved.Factory |
A factory for a mapping of a parameter of the instrumented method.
|
| Advice.OffsetMapping.ForEnterValue |
An offset mapping that provides access to the value that is returned by the enter advice.
|
| Advice.OffsetMapping.ForEnterValue.Factory |
|
| Advice.OffsetMapping.ForField |
An offset mapping for a field.
|
| Advice.OffsetMapping.ForField.Resolved |
A binding for an offset mapping that represents a specific field.
|
| Advice.OffsetMapping.ForField.Resolved.Factory<T extends java.lang.annotation.Annotation> |
A factory that binds a field.
|
| Advice.OffsetMapping.ForField.Unresolved |
An offset mapping for a field that is resolved from the instrumented type by its name.
|
| Advice.OffsetMapping.ForField.Unresolved.Factory |
|
| Advice.OffsetMapping.ForField.Unresolved.WithExplicitType |
An offset mapping for a field with an explicit declaring type.
|
| Advice.OffsetMapping.ForField.Unresolved.WithImplicitType |
An offset mapping for a field with an implicit declaring type.
|
| Advice.OffsetMapping.ForInstrumentedMethod |
Maps a constant representing the instrumented method.
|
| Advice.OffsetMapping.ForInstrumentedType |
Maps the declaring type of the instrumented method.
|
| Advice.OffsetMapping.ForOrigin |
|
| Advice.OffsetMapping.ForOrigin.Factory |
A factory for a method origin.
|
| Advice.OffsetMapping.ForOrigin.Renderer |
A renderer for an origin pattern element.
|
| Advice.OffsetMapping.ForOrigin.Renderer.ForConstantValue |
A renderer for a constant value.
|
| Advice.OffsetMapping.ForOrigin.Renderer.ForDescriptor |
A renderer for a method descriptor.
|
| Advice.OffsetMapping.ForOrigin.Renderer.ForJavaSignature |
A renderer for a method's Java signature in binary form.
|
| Advice.OffsetMapping.ForOrigin.Renderer.ForMethodName |
A renderer for a method's internal name.
|
| Advice.OffsetMapping.ForOrigin.Renderer.ForReturnTypeName |
A renderer for a method's return type in binary form.
|
| Advice.OffsetMapping.ForOrigin.Renderer.ForStringRepresentation |
A renderer for a method's Object.toString() representation.
|
| Advice.OffsetMapping.ForOrigin.Renderer.ForTypeName |
A renderer for a method declaring type's binary name.
|
| Advice.OffsetMapping.ForReturnValue |
An offset mapping that provides access to the value that is returned by the instrumented method.
|
| Advice.OffsetMapping.ForReturnValue.Factory |
|
| Advice.OffsetMapping.ForSerializedValue |
An offset mapping that loads a serialized value.
|
| Advice.OffsetMapping.ForSerializedValue.Factory<T extends java.lang.annotation.Annotation> |
A factory for loading a deserialized value.
|
| Advice.OffsetMapping.ForStackManipulation |
An offset mapping for binding a stack manipulation.
|
| Advice.OffsetMapping.ForStackManipulation.Factory<T extends java.lang.annotation.Annotation> |
A factory that binds a stack manipulation.
|
| Advice.OffsetMapping.ForStackManipulation.OfAnnotationProperty<T extends java.lang.annotation.Annotation> |
A factory for binding an annotation's property.
|
| Advice.OffsetMapping.ForStackManipulation.OfDefaultValue<T extends java.lang.annotation.Annotation> |
A factory for binding the annotated parameter's default value.
|
| Advice.OffsetMapping.ForStubValue |
An offset mapping for a parameter where assignments are fully ignored and that is assigned a boxed version of the instrumented
method's return value or null if the return type is not primitive or void.
|
| Advice.OffsetMapping.ForThisReference |
An offset mapping that provides access to the this reference of the instrumented method.
|
| Advice.OffsetMapping.ForThisReference.Factory |
|
| Advice.OffsetMapping.ForThrowable |
An offset mapping for accessing a Throwable of the instrumented method.
|
| Advice.OffsetMapping.ForThrowable.Factory |
A factory for accessing an exception that was thrown by the instrumented method.
|
| Advice.OffsetMapping.ForUnusedValue |
An offset mapping for a parameter where assignments are fully ignored and that always return the parameter type's default value.
|
| Advice.OffsetMapping.ForUnusedValue.Factory |
A factory for an offset mapping for an unused value.
|
| Advice.OffsetMapping.Sort |
Describes the sort of the executed advice.
|
| Advice.OffsetMapping.Target |
A target offset of an offset mapping.
|
| Advice.OffsetMapping.Target.AbstractReadOnlyAdapter |
An adapter class for a target that only can be read.
|
| Advice.OffsetMapping.Target.ForArray |
A target mapping for an array of all local variables.
|
| Advice.OffsetMapping.Target.ForArray.ReadOnly |
A target mapping for a read-only target mapping for an array of local variables.
|
| Advice.OffsetMapping.Target.ForArray.ReadWrite |
A target mapping for a writable target mapping for an array of local variables.
|
| Advice.OffsetMapping.Target.ForDefaultValue |
A target for an offset mapping that represents a non-operational value.
|
| Advice.OffsetMapping.Target.ForDefaultValue.ReadOnly |
A read-only target for a default value.
|
| Advice.OffsetMapping.Target.ForDefaultValue.ReadWrite |
A read-write target for a default value.
|
| Advice.OffsetMapping.Target.ForField |
A target for an offset mapping that loads a field value.
|
| Advice.OffsetMapping.Target.ForField.ReadOnly |
A read-only mapping for a field value.
|
| Advice.OffsetMapping.Target.ForField.ReadWrite |
A mapping for a writable field.
|
| Advice.OffsetMapping.Target.ForStackManipulation |
A target for an offset mapping that represents a read-only stack manipulation.
|
| Advice.OffsetMapping.Target.ForVariable |
A target for an offset mapping that represents a local variable.
|
| Advice.OffsetMapping.Target.ForVariable.ReadOnly |
A target for a read-only mapping of a local variable.
|
| Advice.OffsetMapping.Target.ForVariable.ReadWrite |
A target for a writable mapping of a local variable.
|
| Advice.OnDefaultValue |
|
| Advice.OnMethodEnter |
Indicates that this method should be inlined before the matched method is invoked.
|
| Advice.OnMethodExit |
Indicates that this method should be executed before exiting the instrumented method.
|
| Advice.OnNonDefaultValue |
|
| Advice.Origin |
Indicates that the annotated parameter should be mapped to a string representation of the instrumented method,
a constant representing the Class declaring the adviced method or a Method, Constructor
or java.lang.reflect.Executable representing this method.
|
| Advice.Return |
Indicates that the annotated parameter should be mapped to the return value of the instrumented method.
|
| Advice.StackMapFrameHandler |
A handler for computing and translating stack map frames.
|
| Advice.StackMapFrameHandler.Default |
A default implementation of a stack map frame handler for an instrumented method.
|
| Advice.StackMapFrameHandler.Default.TranslationMode |
A translation mode that determines how the fixed frames of the instrumented method are written.
|
| Advice.StackMapFrameHandler.Default.Trivial |
A trivial stack map frame handler that applies a trivial translation for the instrumented method's stack map frames.
|
| Advice.StackMapFrameHandler.Default.WithPreservedArguments |
A stack map frame handler that requires the original arguments of the instrumented method to be preserved in their original form.
|
| Advice.StackMapFrameHandler.Default.WithPreservedArguments.RequiringConsistentShape |
A stack map frame handler that expects that the original argument frames remain preserved throughout the original invocation.
|
| Advice.StackMapFrameHandler.Default.WithPreservedArguments.UsingArgumentCopy |
A stack map frame handler that expects that an argument copy of the original method arguments was made.
|
| Advice.StackMapFrameHandler.ForAdvice |
A stack map frame handler for an advice method.
|
| Advice.StackMapFrameHandler.ForInstrumentedMethod |
A stack map frame handler for an instrumented method.
|
| Advice.StackMapFrameHandler.NoOp |
A non-operational stack map frame handler.
|
| Advice.StubValue |
Indicates that the annotated parameter should always return a default a boxed version of the instrumented methods return value
(i.e.
|
| Advice.This |
Indicates that the annotated parameter should be mapped to the this reference of the instrumented method.
|
| Advice.Thrown |
Indicates that the annotated parameter should be mapped to the Throwable thrown by the instrumented method or to null
if the method returned regularly.
|
| Advice.Unused |
Indicates that the annotated parameter should always return a default value (i.e.
|
| Advice.WithCustomMapping |
A builder step for creating an Advice that uses custom mappings of annotations to constant pool values. |
| AgentBuilder |
An agent builder provides a convenience API for defining a
Java agent. |
| AgentBuilder.CircularityLock |
A circularity lock is responsible for preventing that a ClassFileLocator is used recursively. |
| AgentBuilder.CircularityLock.Default |
A default implementation of a circularity lock.
|
| AgentBuilder.CircularityLock.Global |
A circularity lock that holds a global monitor and does not permit concurrent access.
|
| AgentBuilder.CircularityLock.Inactive |
An inactive circularity lock which is always acquirable.
|
| AgentBuilder.Default |
|
| AgentBuilder.Default.BootstrapInjectionStrategy |
An injection strategy for injecting classes into the bootstrap class loader.
|
| AgentBuilder.Default.BootstrapInjectionStrategy.Disabled |
A disabled bootstrap injection strategy.
|
| AgentBuilder.Default.BootstrapInjectionStrategy.Enabled |
An enabled bootstrap injection strategy.
|
| AgentBuilder.Default.BootstrapInjectionStrategy.Unsafe |
A bootstrap injection strategy relying on sun.misc.Unsafe.
|
| AgentBuilder.Default.ExecutingTransformer |
A ClassFileTransformer that implements the enclosing agent builder's
configuration.
|
| AgentBuilder.Default.ExecutingTransformer.Factory |
A factory for creating a ClassFileTransformer for the current VM.
|
| AgentBuilder.Default.ExecutingTransformer.Factory.CreationAction |
|
| 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.
|
| AgentBuilder.Default.ExecutingTransformer.Factory.ForLegacyVm |
A factory for a ClassFileTransformer on a VM that does not support the java.lang.Module API.
|
| AgentBuilder.Default.NativeMethodStrategy |
A strategy for determining if a native method name prefix should be used when rebasing methods.
|
| AgentBuilder.Default.NativeMethodStrategy.Disabled |
A native method strategy that suffixes method names with a random suffix and disables native method rebasement.
|
| AgentBuilder.Default.NativeMethodStrategy.ForPrefix |
A native method strategy that prefixes method names with a fixed value for supporting rebasing of native methods.
|
| AgentBuilder.Default.Redefining |
An implementation of a default agent builder that allows for refinement of the redefinition strategy.
|
| AgentBuilder.Default.Transformation |
A transformation serves as a handler for modifying a class.
|
| AgentBuilder.Default.Transformation.Compound |
A compound transformation that applied several transformation in the given order and applies the first active transformation.
|
| AgentBuilder.Default.Transformation.Ignored |
A transformation that does not attempt to transform any type.
|
| AgentBuilder.Default.Transformation.Resolution |
A resolution to a transformation.
|
| AgentBuilder.Default.Transformation.Resolution.Decoratable |
A resolution that can be decorated by a transformer.
|
| AgentBuilder.Default.Transformation.Resolution.Sort |
|
| AgentBuilder.Default.Transformation.Resolution.Unresolved |
A canonical implementation of a non-resolved resolution.
|
| AgentBuilder.Default.Transformation.Simple |
A simple, active transformation.
|
| AgentBuilder.Default.Transformation.Simple.Resolution |
A resolution that performs a type transformation.
|
| AgentBuilder.Default.Transformation.Simple.Resolution.BootstrapClassLoaderCapableInjectorFactory |
An injector factory that resolves to a bootstrap class loader injection if this is necessary and enabled.
|
| AgentBuilder.DescriptionStrategy |
A description strategy is responsible for resolving a TypeDescription when transforming or retransforming/-defining a type. |
| AgentBuilder.DescriptionStrategy.Default |
|
| 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.
|
| 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.
|
| AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous.ThreadSwitchingClassLoadingDelegate |
A class loading delegate that delegates loading of the super type to another thread.
|
| AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous.ThreadSwitchingClassLoadingDelegate.NotifyingClassLoadingAction |
A class loading action that notifies the class loader's lock after the type was loaded.
|
| AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous.ThreadSwitchingClassLoadingDelegate.SimpleClassLoadingAction |
A class loading action that simply loads a type.
|
| AgentBuilder.DescriptionStrategy.SuperTypeLoading.UnlockingClassLoadingDelegate |
A class loading delegate that unlocks the circularity lock during class loading.
|
| AgentBuilder.FallbackStrategy |
A fallback strategy allows to reattempt a transformation or a consideration for redefinition/retransformation in case an exception
occurs.
|
| AgentBuilder.FallbackStrategy.ByThrowableType |
A fallback strategy that discriminates by the type of the Throwable that triggered a request.
|
| AgentBuilder.FallbackStrategy.Simple |
A simple fallback strategy that either always reattempts a transformation or never does so.
|
| AgentBuilder.Identified |
|
| AgentBuilder.Identified.Extendable |
This interface is used to allow for optionally providing several
AgentBuilder.Transformer to applied when a matcher identifies a type
to be instrumented. |
| AgentBuilder.Identified.Narrowable |
Allows to specify a type matcher for a type to instrument.
|
| AgentBuilder.Ignored |
Allows to further specify ignored types.
|
| AgentBuilder.InitializationStrategy |
An initialization strategy which determines the handling of LoadedTypeInitializers
and the loading of auxiliary types. |
| AgentBuilder.InitializationStrategy.Dispatcher |
A dispatcher for changing a class file to adapt a self-initialization strategy.
|
| AgentBuilder.InitializationStrategy.Dispatcher.InjectorFactory |
|
| AgentBuilder.InitializationStrategy.Minimal |
An initialization strategy that loads auxiliary types before loading the instrumented type.
|
| AgentBuilder.InitializationStrategy.NoOp |
A non-initializing initialization strategy.
|
| 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.
|
| AgentBuilder.InitializationStrategy.SelfInjection.Dispatcher |
A dispatcher for a self-initialization strategy.
|
| AgentBuilder.InitializationStrategy.SelfInjection.Dispatcher.InjectingInitializer |
A type initializer that injects all auxiliary types of the instrumented type.
|
| AgentBuilder.InitializationStrategy.SelfInjection.Eager |
A form of self-injection where any auxiliary type is loaded eagerly.
|
| AgentBuilder.InitializationStrategy.SelfInjection.Eager.Dispatcher |
|
| AgentBuilder.InitializationStrategy.SelfInjection.Lazy |
A form of self-injection where any auxiliary type is loaded lazily.
|
| AgentBuilder.InitializationStrategy.SelfInjection.Lazy.Dispatcher |
|
| AgentBuilder.InitializationStrategy.SelfInjection.Split |
A form of self-injection where auxiliary types that are annotated by
AuxiliaryType.SignatureRelevant of the instrumented type are loaded lazily and
any other auxiliary type is loaded eagerly. |
| AgentBuilder.InitializationStrategy.SelfInjection.Split.Dispatcher |
|
| AgentBuilder.InstallationListener |
A listener that is notified during the installation and the resetting of a class file transformer.
|
| AgentBuilder.InstallationListener.Adapter |
An adapter implementation for an installation listener that serves as a convenience.
|
| AgentBuilder.InstallationListener.Compound |
A compound installation listener.
|
| AgentBuilder.InstallationListener.ErrorSuppressing |
A listener that suppresses any installation error.
|
| AgentBuilder.InstallationListener.NoOp |
A non-operational listener that does not do anything.
|
| AgentBuilder.InstallationListener.StreamWriting |
This installation listener prints the status of any installation to a PrintStream.
|
| AgentBuilder.LambdaInstrumentationStrategy |
Implements the instrumentation of the LambdaMetafactory if this feature is enabled.
|
| AgentBuilder.LambdaInstrumentationStrategy.AlternativeMetaFactoryRedirection |
Implements the alternative lambda meta factory.
|
| AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory |
A factory that creates instances that represent lambda expressions.
|
| AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.BridgeMethodImplementation |
Implements an explicit bridge method for a lambda expression.
|
| AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.BridgeMethodImplementation.Appender |
An appender for implementing a bridge method for a lambda expression.
|
| AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.ConstructorImplementation |
Implements a lambda class's executing transformer.
|
| AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.ConstructorImplementation.Appender |
An appender to implement the executing transformer.
|
| AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.FactoryImplementation |
An implementation of a instance factory for a lambda expression's class.
|
| AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.FactoryImplementation.Appender |
An appender for a lambda expression factory.
|
| AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.LambdaMethodImplementation |
Implements a lambda expression's functional method.
|
| AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.LambdaMethodImplementation.Appender |
An appender for a lambda expression's functional method.
|
| AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.SerializationImplementation |
Implements the writeReplace method for serializable lambda expressions.
|
| AgentBuilder.LambdaInstrumentationStrategy.MetaFactoryRedirection |
Implements the regular lambda meta factory.
|
| AgentBuilder.Listener |
A listener that is informed about events that occur during an instrumentation process.
|
| AgentBuilder.Listener.Adapter |
An adapter for a listener where all methods are implemented as non-operational.
|
| AgentBuilder.Listener.Compound |
A compound listener that allows to group several listeners in one instance.
|
| AgentBuilder.Listener.Filtering |
A listener that filters types with a given name from being logged.
|
| AgentBuilder.Listener.ModuleReadEdgeCompleting |
A listener that adds read-edges to any module of an instrumented class upon its transformation.
|
| AgentBuilder.Listener.NoOp |
|
| AgentBuilder.Listener.StreamWriting |
A listener that writes events to a PrintStream.
|
| AgentBuilder.Listener.WithErrorsOnly |
A listener that only delegates events if they are failed transformations.
|
| AgentBuilder.Listener.WithTransformationsOnly |
A listener that only delegates events if they are successful or failed transformations.
|
| AgentBuilder.LocationStrategy |
|
| AgentBuilder.LocationStrategy.Compound |
A compound location strategy that applies a list of location strategies.
|
| AgentBuilder.LocationStrategy.ForClassLoader |
A location strategy that locates class files by querying an instrumented type's ClassLoader.
|
| AgentBuilder.LocationStrategy.NoOp |
A location strategy that never locates any byte code.
|
| AgentBuilder.LocationStrategy.Simple |
A simple location strategy that queries a given class file locator.
|
| AgentBuilder.Matchable<T extends AgentBuilder.Matchable<T>> |
An abstraction for extending a matcher.
|
| AgentBuilder.Matchable.AbstractBase<S extends AgentBuilder.Matchable<S>> |
An abstract base implementation of a matchable.
|
| AgentBuilder.PoolStrategy |
|
| AgentBuilder.PoolStrategy.ClassLoading |
A type locator that attempts loading a type if it cannot be located by the underlying lazy type pool.
|
| AgentBuilder.PoolStrategy.Default |
A default type locator that resolves types only if any property that is not the type's name is requested.
|
| AgentBuilder.PoolStrategy.Eager |
A type locator that resolves all type descriptions eagerly.
|
| AgentBuilder.PoolStrategy.WithTypePoolCache |
A type locator that uses type pools but allows for the configuration of a custom cache provider by class loader.
|
| AgentBuilder.PoolStrategy.WithTypePoolCache.Simple |
|
| AgentBuilder.RawMatcher |
|
| AgentBuilder.RawMatcher.Conjunction |
A conjunction of two raw matchers.
|
| AgentBuilder.RawMatcher.Disjunction |
A disjunction of two raw matchers.
|
| 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. |
| AgentBuilder.RawMatcher.ForLoadState |
A raw matcher indicating the state of a type's class loading.
|
| AgentBuilder.RawMatcher.ForResolvableTypes |
Only matches loaded types that can be fully resolved.
|
| AgentBuilder.RawMatcher.Inversion |
A raw matcher that inverts a raw matcher's result.
|
| AgentBuilder.RawMatcher.Trivial |
A matcher that always or never matches a type.
|
| AgentBuilder.RedefinitionListenable |
An agent builder configuration that allows the registration of listeners to the redefinition process.
|
| AgentBuilder.RedefinitionListenable.WithImplicitDiscoveryStrategy |
An agent builder configuration strategy that allows the definition of a discovery strategy.
|
| AgentBuilder.RedefinitionListenable.WithoutBatchStrategy |
An agent builder configuration that allows the configuration of a batching strategy.
|
| AgentBuilder.RedefinitionStrategy |
A redefinition strategy regulates how already loaded classes are modified by a built agent.
|
| AgentBuilder.RedefinitionStrategy.BatchAllocator |
A batch allocator which is responsible for applying a redefinition in a batches.
|
| AgentBuilder.RedefinitionStrategy.BatchAllocator.ForFixedSize |
A batch allocator that creates chunks with a fixed size as batch jobs.
|
| AgentBuilder.RedefinitionStrategy.BatchAllocator.ForMatchedGrouping |
A batch allocator that groups all batches by discriminating types using a type matcher.
|
| AgentBuilder.RedefinitionStrategy.BatchAllocator.ForTotal |
A batch allocator that includes all types in a single batch.
|
| AgentBuilder.RedefinitionStrategy.BatchAllocator.Partitioning |
A partitioning batch allocator that splits types for redefinition into a fixed amount of parts.
|
| AgentBuilder.RedefinitionStrategy.BatchAllocator.Slicing |
A slicing batch allocator that assures that any batch is within a certain size range.
|
| AgentBuilder.RedefinitionStrategy.BatchAllocator.Slicing.SlicingIterable |
An iterable that slices batches into parts of a minimum and maximum size.
|
| AgentBuilder.RedefinitionStrategy.BatchAllocator.Slicing.SlicingIterable.SlicingIterator |
An iterator that slices batches into parts of a minimum and maximum size.
|
| AgentBuilder.RedefinitionStrategy.Collector |
A collector is responsible for collecting classes that are to be considered for modification.
|
| AgentBuilder.RedefinitionStrategy.Collector.ForRedefinition |
A collector that applies a redefinition of already loaded classes.
|
| AgentBuilder.RedefinitionStrategy.Collector.ForRetransformation |
A collector that applies a retransformation of already loaded classes.
|
| AgentBuilder.RedefinitionStrategy.Collector.PrependableIterator |
An iterator that allows prepending of iterables to be applied previous to another iterator.
|
| AgentBuilder.RedefinitionStrategy.DiscoveryStrategy |
A strategy for discovering types to redefine.
|
| AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.Explicit |
An explicit discovery strategy that only attempts the redefinition of specific types.
|
| AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.Reiterating |
A discovery strategy that considers all loaded types supplied by Instrumentation.getAllLoadedClasses().
|
| AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.Reiterating.ReiteratingIterable |
An iterable that returns any loaded types and checks if any additional types were loaded during the last instrumentation.
|
| AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.Reiterating.ReiteratingIterator |
A reiterating iterator that considers types that were loaded during an instrumentation.
|
| AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.SinglePass |
A discovery strategy that considers all loaded types supplied by Instrumentation.getAllLoadedClasses().
|
| AgentBuilder.RedefinitionStrategy.Listener |
A listener to be applied during a redefinition.
|
| AgentBuilder.RedefinitionStrategy.Listener.Adapter |
A listener adapter that offers non-operational implementations of all listener methods.
|
| 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.
|
| AgentBuilder.RedefinitionStrategy.Listener.Compound |
A compound listener that delegates events to several listeners.
|
| AgentBuilder.RedefinitionStrategy.Listener.Compound.CompoundIterable |
A compound iterable.
|
| AgentBuilder.RedefinitionStrategy.Listener.Compound.CompoundIterable.CompoundIterator |
A compound iterator that combines several iterables.
|
| AgentBuilder.RedefinitionStrategy.Listener.ErrorEscalating |
A listener that halts a retransformation process upon an exception.
|
| AgentBuilder.RedefinitionStrategy.Listener.NoOp |
A non-operational listener.
|
| AgentBuilder.RedefinitionStrategy.Listener.Pausing |
A listener that invokes Thread.sleep(long) prior to every batch but the first batch.
|
| AgentBuilder.RedefinitionStrategy.Listener.StreamWriting |
A listener that writes events to a PrintStream.
|
| AgentBuilder.RedefinitionStrategy.Listener.Yielding |
A listener that invokes Thread.yield() prior to every batch but the first batch.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionScheduler |
A resubmission scheduler is responsible for scheduling a job that is resubmitting unloaded types that failed during retransformation.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.AtFixedRate |
A resubmission scheduler that schedules jobs at a fixed rate.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.Cancelable |
A cancelable allows to discontinue a resubmission job.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.Cancelable.ForFuture |
A cancelable for a Future.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.Cancelable.NoOp |
A non-operational cancelable.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.NoOp |
A resubmission scheduler that does not apply any scheduling.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.WithFixedDelay |
A resubmission scheduler that schedules jobs with a fixed delay.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionStrategy |
A resubmission strategy is responsible for enabling resubmission of types that failed to resubmit.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Disabled |
A disabled resubmission strategy.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Enabled |
An enabled resubmission strategy.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Enabled.LookupKey |
A key for a class loader that can only be used for looking up a preexisting value but avoids reference management.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Enabled.ResubmissionInstallationListener |
A job that resubmits any matched type that previously failed during transformation.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Enabled.ResubmissionListener |
A listener that registers types for resubmission that failed during transformations.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Enabled.StorageKey |
A key for a class loader that only weakly references the class loader.
|
| AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Installation |
Represents an installation of a resubmission strategy.
|
| AgentBuilder.Transformer |
A transformer allows to apply modifications to a DynamicType. |
| AgentBuilder.Transformer.Compound |
|
| 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. |
| AgentBuilder.Transformer.ForAdvice.Entry |
An entry for an advice to apply.
|
| AgentBuilder.Transformer.ForAdvice.Entry.ForSplitAdvice |
An entry for an advice class where both entry and exit advice methods are declared by the different classes.
|
| 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.
|
| AgentBuilder.Transformer.ForBuildPlugin |
A transformer that applies a build Plugin. |
| AgentBuilder.Transformer.NoOp |
|
| AgentBuilder.TypeStrategy |
A type strategy is responsible for creating a type builder for a type that is being instrumented.
|
| AgentBuilder.TypeStrategy.Default |
Default implementations of type strategies.
|
| AgentBuilder.TypeStrategy.ForBuildEntryPoint |
|
| AllArguments |
Parameters that are annotated with this annotation will be assigned a collection (or an array) containing
all arguments of the source method.
|
| AllArguments.Assignment |
A directive for how an AllArguments
annotation on an array is to be interpreted. |
| AllArguments.Binder |
|
| AnnotationAppender |
Annotation appenders are capable of writing annotations to a specified target.
|
| AnnotationAppender.Default |
A default implementation for an annotation appender that writes annotations to a given byte consumer
represented by an ASM AnnotationVisitor.
|
| AnnotationAppender.ForTypeAnnotations |
A type visitor that visits all type annotations of a generic type and writes any discovered annotation to a
supplied AnnotationAppender. |
| AnnotationAppender.Target |
Represents a target for an annotation writing process.
|
| AnnotationAppender.Target.OnField |
Target for an annotation that is written to a Java field.
|
| AnnotationAppender.Target.OnMethod |
Target for an annotation that is written to a Java method or constructor.
|
| AnnotationAppender.Target.OnMethodParameter |
Target for an annotation that is written to a Java method or constructor parameter.
|
| AnnotationAppender.Target.OnType |
Target for an annotation that is written to a Java type.
|
| AnnotationDescription |
An annotation description describes Annotation meta data of a class without this class
being required to be loaded.
|
| AnnotationDescription.AbstractBase |
An adapter implementation of an annotation.
|
| AnnotationDescription.AbstractBase.ForPrepared<S extends java.lang.annotation.Annotation> |
An abstract implementation of a loadable annotation description.
|
| AnnotationDescription.AnnotationInvocationHandler<T extends java.lang.annotation.Annotation> |
An InvocationHandler for implementing annotations.
|
| AnnotationDescription.AnnotationInvocationHandler.MissingValue |
Represents a missing annotation property which is not represented by a default value.
|
| AnnotationDescription.Builder |
|
| AnnotationDescription.ForLoadedAnnotation<S extends java.lang.annotation.Annotation> |
A description of an already loaded annotation.
|
| AnnotationDescription.Latent |
A latent description of an annotation value that is defined explicitly.
|
| AnnotationDescription.Loadable<S extends java.lang.annotation.Annotation> |
An annotation description that is linked to a given loaded annotation type which allows its representation
as a fully loaded instance.
|
| AnnotationList |
Defines a list of annotation instances.
|
| AnnotationList.AbstractBase |
An abstract base implementation of an annotation list.
|
| AnnotationList.Empty |
Represents an empty annotation list.
|
| AnnotationList.Explicit |
Represents a list of explicitly provided annotation descriptions.
|
| AnnotationList.ForLoadedAnnotations |
Describes an array of loaded Annotations as an annotation list.
|
| AnnotationRetention |
An annotation retention strategy decides if annotations that are contained within a class file are preserved upon redefining
or rebasing a method.
|
| AnnotationSource |
Describes a declaration source for annotations.
|
| AnnotationSource.Empty |
An annotation source that does not declare any annotations.
|
| AnnotationSource.Explicit |
An annotation source that declares a given list of annotations.
|
| AnnotationTypeMatcher<T extends AnnotationDescription> |
An element matcher that matches the type of an annotation description.
|
| AnnotationValue<T,S> |
Representation of an unloaded annotation value where all values represent either:
Primitive values (as their wrappers), Strings or arrays of primitive types or strings.
A TypeDescription or an array of such a descriptions.
An EnumerationDescription or an array of such a description.
An AnnotationDescription or an array of such a description.
The represented values are not necessarily resolvable, i.e. |
| AnnotationValue.AbstractBase<U,V> |
An abstract base implementation of an unloaded annotation value.
|
| AnnotationValue.ForAnnotationDescription<U extends java.lang.annotation.Annotation> |
A description of an Annotation as a value of another annotation.
|
| AnnotationValue.ForAnnotationDescription.IncompatibleRuntimeType |
Represents an annotation value which was attempted to ba loaded by a type that does not represent
an annotation value.
|
| AnnotationValue.ForAnnotationDescription.Loaded<V extends java.lang.annotation.Annotation> |
A loaded version of the described annotation.
|
| AnnotationValue.ForConstant<U> |
Represents a primitive value, a String or an array of the latter types.
|
| AnnotationValue.ForConstant.Loaded<V> |
Represents a trivial loaded value.
|
| AnnotationValue.ForConstant.PropertyDelegate |
A property delegate for a constant annotation value.
|
| AnnotationValue.ForConstant.PropertyDelegate.ForArrayType |
A property delegate for an array type of a constant value.
|
| AnnotationValue.ForConstant.PropertyDelegate.ForNonArrayType |
A property delegate for a non-array type.
|
| AnnotationValue.ForDescriptionArray<U,V> |
Describes a complex array that is the value of an annotation.
|
| AnnotationValue.ForDescriptionArray.Loaded<W> |
Represents a loaded complex array.
|
| AnnotationValue.ForEnumerationDescription<U extends java.lang.Enum<U>> |
A description of an Enum as a value of an annotation.
|
| AnnotationValue.ForEnumerationDescription.IncompatibleRuntimeType |
Represents an annotation's enumeration value for a runtime type that is not an enumeration type.
|
| AnnotationValue.ForEnumerationDescription.Loaded<V extends java.lang.Enum<V>> |
A loaded representation of an enumeration value.
|
| AnnotationValue.ForEnumerationDescription.UnknownRuntimeEnumeration |
Represents an annotation's enumeration value for a constant that does not exist for the runtime
enumeration type.
|
| AnnotationValue.ForTypeDescription<U extends java.lang.Class<U>> |
A description of a Class as a value of an annotation.
|
| AnnotationValue.ForTypeDescription.Loaded<U extends java.lang.Class<U>> |
A loaded annotation value for a given type.
|
| AnnotationValue.Loaded<U> |
|
| AnnotationValue.Loaded.AbstractBase<W> |
An abstract base implementation of a loaded annotation value.
|
| AnnotationValue.Loaded.State |
|
| AnnotationValue.RenderingDispatcher |
A rendering dispatcher is responsible for resolving annotation values to String representations.
|
| AnnotationValueFilter |
An annotation value filter is responsible for determining which values should be skipped and rather be represented as an
annotation type's default values when writing an annotation to a class file.
|
| AnnotationValueFilter.Default |
A default implementation of an annotation value filter that applies the same strategy for any type, field or method.
|
| AnnotationValueFilter.Factory |
A factory for creating an annotation value filter for an annotation's target.
|
| Argument |
Parameters that are annotated with this annotation will be assigned the value of the parameter of the source method
with the given parameter.
|
| Argument.Binder |
A binder for handling the
Argument
annotation. |
| Argument.BindingMechanic |
Determines if a parameter binding should be considered for resolving ambiguous method bindings.
|
| ArgumentTypeResolver |
Implementation of an
MethodDelegationBinder.AmbiguityResolver
that resolves two conflicting bindings by considering most-specific types of target method parameters in the same manner
as the Java compiler resolves bindings of overloaded method. |
| ArgumentTypeResolver.ParameterIndexToken |
This token is used to mark a one-to-one binding of a source method parameter to a target method parameter.
|
| ArgumentTypeResolver.PrimitiveTypePrecedence |
A representation of the precedence of a most specific primitive type in the Java programming language.
|
| ArrayAccess |
Allows accessing array values.
|
| ArrayFactory |
A CollectionFactory that is capable of
creating an array of a given type with any number of given values. |
| ArrayFactory.ArrayCreator |
An array creator is responsible for providing correct byte code instructions for creating an array
and for storing values into it.
|
| ArrayFactory.ArrayCreator.ForPrimitiveType |
An array creator implementation for primitive types.
|
| ArrayFactory.ArrayCreator.ForReferenceType |
An array creator implementation for reference types.
|
| AsmVisitorWrapper |
A class visitor wrapper is used in order to register an intermediate ASM ClassVisitor which
is applied to the main type created by a DynamicType.Builder but not
to any AuxiliaryTypes, if any. |
| AsmVisitorWrapper.AbstractBase |
An abstract base implementation of an ASM visitor wrapper that does not set any flags.
|
| AsmVisitorWrapper.Compound |
|
| AsmVisitorWrapper.ForDeclaredFields |
|
| AsmVisitorWrapper.ForDeclaredFields.Entry |
An entry describing a field visitor wrapper paired with a matcher for fields to be wrapped.
|
| AsmVisitorWrapper.ForDeclaredFields.FieldVisitorWrapper |
A field visitor wrapper that allows for wrapping a FieldVisitor defining a declared field.
|
| AsmVisitorWrapper.ForDeclaredMethods |
|
| AsmVisitorWrapper.ForDeclaredMethods.Entry |
An entry describing a method visitor wrapper paired with a matcher for fields to be wrapped.
|
| AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper |
A method visitor wrapper that allows for wrapping a MethodVisitor defining a declared method.
|
| AsmVisitorWrapper.NoOp |
A class visitor wrapper that does not apply any changes.
|
| Assigner |
An assigner is responsible for converting some type A to another type B if possible.
|
| Assigner.EqualTypesOnly |
An assigner that only allows to assign types if they are equal to another.
|
| Assigner.Refusing |
An assigner that does not allow any assignments.
|
| Assigner.Typing |
Indicates for a type assignment, if a type casting should be applied in case that two types are not statically assignable.
|
| Attacher |
A Java program that attaches a Java agent to an external process.
|
| AuxiliaryType |
An auxiliary type that provides services to the instrumentation of another type.
|
| AuxiliaryType.NamingStrategy |
Representation of a naming strategy for an auxiliary type.
|
| 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.
|
| AuxiliaryType.SignatureRelevant |
A marker to indicate that an auxiliary type is part of the instrumented types signature.
|
| BindingPriority |
Defines a binding priority for a target method.
|
| BindingPriority.Resolver |
An ambiguity resolver that considers the priority of a method as defined by the
BindingPriority
annotation. |
| BooleanMatcher<T> |
An element matcher that returns a fixed result.
|
| ByteArrayClassLoader |
A ClassLoader that is capable of loading explicitly defined classes.
|
| ByteArrayClassLoader.ChildFirst |
|
| ByteArrayClassLoader.ChildFirst.PrependingEnumeration |
An enumeration that prepends an element to another enumeration and skips the last element of the provided enumeration.
|
| ByteArrayClassLoader.EmptyEnumeration |
An enumeration without any elements.
|
| ByteArrayClassLoader.PackageLookupStrategy |
A package lookup strategy for locating a package by name.
|
| ByteArrayClassLoader.PackageLookupStrategy.CreationAction |
A creation action for a package lookup strategy.
|
| ByteArrayClassLoader.PackageLookupStrategy.ForJava9CapableVm |
A package lookup strategy for Java 9 or newer.
|
| ByteArrayClassLoader.PackageLookupStrategy.ForLegacyVm |
A package lookup strategy for a VM prior to Java 9.
|
| ByteArrayClassLoader.PersistenceHandler |
A persistence handler decides on whether the byte array that represents a loaded class is exposed by
the ClassLoader.getResourceAsStream(String) method.
|
| ByteArrayClassLoader.PersistenceHandler.UrlDefinitionAction |
An action to define a URL that represents a class file.
|
| ByteArrayClassLoader.PersistenceHandler.UrlDefinitionAction.ByteArrayUrlStreamHandler |
A stream handler that returns the given binary representation.
|
| ByteArrayClassLoader.PersistenceHandler.UrlDefinitionAction.ByteArrayUrlStreamHandler.ByteArrayUrlConnection |
A URL connection for a given byte array.
|
| ByteArrayClassLoader.SingletonEnumeration |
An enumeration that contains a single element.
|
| ByteArrayClassLoader.SynchronizationStrategy |
An engine for receiving a class loading lock when loading a class.
|
| ByteArrayClassLoader.SynchronizationStrategy.CreationAction |
A creation action for a synchronization strategy.
|
| ByteArrayClassLoader.SynchronizationStrategy.ForJava7CapableVm |
A synchronization engine for a VM that is aware of parallel-capable class loaders.
|
| ByteArrayClassLoader.SynchronizationStrategy.ForLegacyVm |
A synchronization engine for a VM that is not aware of parallel-capable class loaders.
|
| ByteArrayClassLoader.SynchronizationStrategy.Initializable |
An uninitialized synchronization strategy.
|
| 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.
|
| ByteBuddy.EnumerationImplementation |
An implementation fo the values method of an enumeration type.
|
| ByteBuddy.EnumerationImplementation.InitializationAppender |
A byte code appender for the type initializer of any enumeration type.
|
| ByteBuddy.EnumerationImplementation.ValuesMethodAppender |
A byte code appender for the values method of any enumeration type.
|
| ByteBuddyAgent |
The Byte Buddy agent provides a JVM Instrumentation in order to allow Byte Buddy the
redefinition of already loaded classes.
|
| ByteBuddyAgent.AgentProvider |
An agent provider is responsible for handling and providing the jar file of an agent that is being attached.
|
| ByteBuddyAgent.AgentProvider.ForByteBuddyAgent |
An agent provider for a temporary Byte Buddy agent.
|
| ByteBuddyAgent.AgentProvider.ForExistingAgent |
An agent provider that supplies an existing agent that is not deleted after attachment.
|
| ByteBuddyAgent.AttachmentProvider |
An attachment provider is responsible for making the Java attachment API available.
|
| ByteBuddyAgent.AttachmentProvider.Accessor |
An accessor for a JVM's attachment API.
|
| ByteBuddyAgent.AttachmentProvider.Accessor.ExternalAttachment |
Describes an external attachment to a Java virtual machine.
|
| ByteBuddyAgent.AttachmentProvider.Accessor.Simple |
A simple implementation of an accessible accessor.
|
| ByteBuddyAgent.AttachmentProvider.Accessor.Simple.WithExternalAttachment |
A simple implementation of an accessible accessor that allows for external attachment.
|
| ByteBuddyAgent.AttachmentProvider.Accessor.Simple.WithoutExternalAttachment |
A simple implementation of an accessible accessor that does not allow for external attachment.
|
| ByteBuddyAgent.AttachmentProvider.Accessor.Unavailable |
A canonical implementation of an unavailable accessor.
|
| ByteBuddyAgent.AttachmentProvider.Compound |
A compound attachment provider that attempts the attachment by delegation to other providers.
|
| ByteBuddyAgent.AttachmentProvider.ForJ9Vm |
An attachment provider that locates the attach API directly from the system class loader expecting
an IBM J9 VM.
|
| ByteBuddyAgent.AttachmentProvider.ForJigsawVm |
An attachment provider that locates the attach API directly from the system class loader.
|
| ByteBuddyAgent.AttachmentProvider.ForToolsJarVm |
An attachment provider that is dependant on the existence of a tools.jar file on the local
file system.
|
| ByteBuddyAgent.AttachmentProvider.ForUnixHotSpotVm |
An attachment provider using a custom protocol implementation for HotSpot on Unix.
|
| ByteBuddyAgent.AttachmentTypeEvaluator |
An attachment evaluator is responsible for deciding if an agent can be attached from the current process.
|
| ByteBuddyAgent.AttachmentTypeEvaluator.Disabled |
An attachment type evaluator that never requires external attachment.
|
| ByteBuddyAgent.AttachmentTypeEvaluator.ForJava9CapableVm |
An attachment type evaluator that checks a process id against the current process id.
|
| ByteBuddyAgent.AttachmentTypeEvaluator.InstallationAction |
An installation action for creating an attachment type evaluator.
|
| ByteBuddyAgent.ProcessProvider |
A process provider is responsible for providing the process id of the current VM.
|
| ByteBuddyAgent.ProcessProvider.ForCurrentVm |
Supplies the current VM's process id.
|
| ByteBuddyAgent.ProcessProvider.ForCurrentVm.ForJava9CapableVm |
A process provider for a Java 9 capable VM with access to the introduced process API.
|
| ByteBuddyAgent.ProcessProvider.ForCurrentVm.ForLegacyVm |
A process provider for a legacy VM that reads the process id from its JMX properties.
|
| ByteBuddyMojo |
A Maven plugin for applying Byte Buddy transformations during a build.
|
| ByteBuddyMojo.ForProductionTypes |
A Byte Buddy plugin that transforms a project's production class files.
|
| ByteBuddyMojo.ForTestTypes |
A Byte Buddy plugin that transforms a project's test class files.
|
| ByteCodeAppender |
An appender that generates the byte code for a given method.
|
| ByteCodeAppender.Compound |
A compound appender that combines a given number of other byte code appenders.
|
| ByteCodeAppender.Simple |
A simple byte code appender that only represents a given array of
StackManipulations. |
| 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.
|
| ByteCodeElement |
Implementations describe an element represented in byte code, i.e.
|
| ByteCodeElement.Token<T extends ByteCodeElement.Token<T>> |
A token representing a byte code element.
|
| ByteCodeElement.Token.TokenList<S extends ByteCodeElement.Token<S>> |
A list of tokens.
|
| ByteCodeElement.TypeDependant<T extends ByteCodeElement.TypeDependant<?,S>,S extends ByteCodeElement.Token<S>> |
A type dependant describes an element that is an extension of a type definition, i.e.
|
| CachingMatcher<T> |
A matcher that remembers the results of previously matching an equal target.
|
| CachingMatcher.WithInlineEviction<S> |
A caching matcher with inline cache eviction.
|
| ClassConstant |
Represents a constant representing any loaded Java Class.
|
| ClassConstant.ForReferenceType |
A class constant for a non-primitive Class.
|
| ClassFileLocator |
Locates a class file or its byte array representation when it is given its type description.
|
| ClassFileLocator.AgentBased |
A Java agent that allows the location of class files by emulating a retransformation.
|
| ClassFileLocator.AgentBased.ClassLoadingDelegate |
A delegate that is queried for loading a class.
|
| ClassFileLocator.AgentBased.ClassLoadingDelegate.Default |
A default implementation of a class loading delegate.
|
| ClassFileLocator.AgentBased.ClassLoadingDelegate.Explicit |
A class loading delegate that allows the location of explicitly registered classes that cannot
be located by a class loader directly.
|
| ClassFileLocator.AgentBased.ClassLoadingDelegate.ForDelegatingClassLoader |
A class loading delegate that accounts for a sun.reflect.DelegatingClassLoader which
cannot load its own classes by name.
|
| ClassFileLocator.AgentBased.ClassLoadingDelegate.ForDelegatingClassLoader.Dispatcher |
Representation of a Java Field.
|
| ClassFileLocator.AgentBased.ClassLoadingDelegate.ForDelegatingClassLoader.Dispatcher.CreationAction |
An action for creating a dispatcher.
|
| ClassFileLocator.AgentBased.ClassLoadingDelegate.ForDelegatingClassLoader.Dispatcher.Initializable |
An uninitialized version of a dispatcher for extracting a class loader's loaded classes.
|
| ClassFileLocator.AgentBased.ClassLoadingDelegate.ForDelegatingClassLoader.Dispatcher.Resolved |
Represents a field that could be located.
|
| ClassFileLocator.AgentBased.ClassLoadingDelegate.ForDelegatingClassLoader.Dispatcher.Unresolved |
Represents a field that could not be located.
|
| ClassFileLocator.AgentBased.ExtractionClassFileTransformer |
A non-operational class file transformer that remembers the binary format of a given class.
|
| ClassFileLocator.Compound |
|
| ClassFileLocator.ForClassLoader |
A class file locator that queries a class loader for binary representations of class files.
|
| ClassFileLocator.ForClassLoader.WeaklyReferenced |
A class file locator that queries a class loader for binary representations of class files.
|
| 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.
|
| ClassFileLocator.ForJarFile |
A class file locator that locates classes within a Java jar file.
|
| ClassFileLocator.ForModule |
A class file locator that locates class files by querying a Java module's getResourceAsStream method.
|
| ClassFileLocator.ForModule.WeaklyReferenced |
A class file locator for a Java module that only references this module weakly.
|
| ClassFileLocator.ForModuleFile |
A class file locator that locates classes within a Java jmod file.
|
| ClassFileLocator.NoOp |
A class file locator that cannot locate any class files.
|
| ClassFileLocator.PackageDiscriminating |
A class file locator that discriminates by a type's package.
|
| ClassFileLocator.Resolution |
Represents a class file as binary data.
|
| ClassFileLocator.Resolution.Explicit |
Represents a byte array as binary data.
|
| ClassFileLocator.Resolution.Illegal |
A canonical representation of an illegal binary representation.
|
| ClassFileLocator.Simple |
A simple class file locator that returns class files from a selection of given types.
|
| ClassFileVersion |
A wrapper object for representing a validated class file version in the format that is specified by the
JVMS. |
| ClassFileVersion.VersionExtractor |
A simple visitor that extracts the class file version of a class file.
|
| ClassFileVersion.VersionLocator |
A locator for the executing VM's Java version.
|
| ClassFileVersion.VersionLocator.CreationAction |
A creation action for a version locator.
|
| ClassFileVersion.VersionLocator.ForJava9CapableVm |
A version locator for a JVM of at least version 9.
|
| ClassFileVersion.VersionLocator.ForLegacyVm |
A version locator for a JVM that does not provide the java.lang.Runtime.Version class.
|
| ClassInjector |
A class injector is capable of injecting classes into a ClassLoader without
requiring the class loader to being able to explicitly look up these classes.
|
| ClassInjector.UsingInstrumentation |
A class injector using a Instrumentation to append to either the boot classpath
or the system class path.
|
| ClassInjector.UsingInstrumentation.Target |
A representation of the target to which Java classes should be appended to.
|
| ClassInjector.UsingLookup |
A class injector that uses a java.lang.invoke.MethodHandles$Lookup object for defining a class.
|
| ClassInjector.UsingLookup.Dispatcher |
A dispatcher for interacting with a method handle lookup.
|
| ClassInjector.UsingLookup.Dispatcher.Creator |
An action for defining a dispatcher.
|
| ClassInjector.UsingLookup.Dispatcher.ForJava9CapableVm |
A dispatcher for a Java 9 capable VM that supports class definition via method handles.
|
| ClassInjector.UsingLookup.Dispatcher.ForLegacyVm |
A dispatcher for a legacy VM that does not support class definition via method handles.
|
| ClassInjector.UsingReflection |
A class injector that uses reflective method calls.
|
| ClassInjector.UsingReflection.Dispatcher |
A dispatcher for accessing a ClassLoader reflectively.
|
| ClassInjector.UsingReflection.Dispatcher.CreationAction |
A creation action for a dispatcher.
|
| ClassInjector.UsingReflection.Dispatcher.Direct |
A class injection dispatcher that is using reflection on the ClassLoader methods.
|
| ClassInjector.UsingReflection.Dispatcher.Direct.ForJava7CapableVm |
A resolved class dispatcher for a class injector on a VM running at least Java 7.
|
| ClassInjector.UsingReflection.Dispatcher.Direct.ForLegacyVm |
A resolved class dispatcher for a class injector prior to Java 7.
|
| ClassInjector.UsingReflection.Dispatcher.Indirect |
An indirect dispatcher that uses a redirection accessor class that was injected into the bootstrap class loader.
|
| ClassInjector.UsingReflection.Dispatcher.Initializable |
Initializes a dispatcher to make non-accessible APIs accessible.
|
| ClassInjector.UsingReflection.Dispatcher.Unavailable |
Represents an unsuccessfully loaded method lookup.
|
| ClassInjector.UsingUnsafe |
A class injector that uses sun.misc.Unsafe to inject classes.
|
| ClassLoaderHierarchyMatcher<T extends java.lang.ClassLoader> |
An element matcher that matches all ClassLoaders in the matched class loaders hierarchy
against a given matcher.
|
| ClassLoaderParentMatcher<T extends java.lang.ClassLoader> |
An element matcher that matches a class loader for being a parent of the given class loader.
|
| ClassLoaderResolver |
A resolver that transforms a Maven coordinate into a class loader that can view the dependencies implied by this coordinate.
|
| ClassLoadingStrategy<T extends java.lang.ClassLoader> |
A strategy for loading a collection of types.
|
| ClassLoadingStrategy.Configurable<S extends java.lang.ClassLoader> |
|
| ClassLoadingStrategy.Default |
This class contains implementations of default class loading strategies.
|
| ClassLoadingStrategy.Default.InjectionDispatcher |
A class loading strategy which applies a class loader injection while applying a given
ProtectionDomain on class injection.
|
| ClassLoadingStrategy.Default.WrappingDispatcher |
A class loading strategy which creates a wrapping class loader while applying a given
ProtectionDomain on class loading.
|
| ClassLoadingStrategy.ForBootstrapInjection |
A class loading strategy which allows class injection into the bootstrap class loader if
appropriate.
|
| ClassLoadingStrategy.ForUnsafeInjection |
A class loading strategy that injects a class using sun.misc.Unsafe.
|
| ClassLoadingStrategy.UsingLookup |
A class loading strategy that uses a java.lang.invoke.MethodHandles$Lookup instance for defining types.
|
| ClassReloadingStrategy |
The class reloading strategy allows to redefine loaded Classes.
|
| ClassReloadingStrategy.BootstrapInjection |
A strategy to apply for injecting classes into the bootstrap class loader.
|
| ClassReloadingStrategy.BootstrapInjection.Disabled |
A disabled bootstrap injection strategy.
|
| ClassReloadingStrategy.BootstrapInjection.Enabled |
An enabled bootstrap class loader injection strategy.
|
| ClassReloadingStrategy.Strategy |
A strategy which performs the actual redefinition of a Class.
|
| ClassReloadingStrategy.Strategy.ClassRedefinitionTransformer |
A class file transformer that applies a given ClassDefinition.
|
| ClassReloadingStrategy.Strategy.ClassResettingTransformer |
A transformer that indicates that a class file should not be transformed.
|
| CollectionElementMatcher<T> |
A matcher that matches a given element of a collection.
|
| CollectionErasureMatcher<T extends java.lang.Iterable<? extends TypeDefinition>> |
An element matcher that matches a collection of types by their erasures.
|
| CollectionFactory |
Implementations of this interface are able to create collection types (including arrays) by sequentially
storing given values that must be compatible to the collection factory's component type.
|
| 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.
|
| CollectionOneToOneMatcher<T> |
An element matcher that matches a given iterable collection to a list of matchers on a per-element basis.
|
| CollectionSizeMatcher<T extends java.lang.Iterable<?>> |
An element matcher that matches a collection by its size.
|
| CompoundList |
Creates a list representation of two lists as a single, compound list.
|
| ConstructorStrategy |
|
| ConstructorStrategy.Default |
Default implementations of constructor strategies.
|
| ConstructorStrategy.Default.WithMethodAttributeAppenderFactory |
A wrapper for a default constructor strategy which additionally applies a method attribute appender factory.
|
| ConstructorStrategy.ForDefaultConstructor |
A constructor strategy that creates a default constructor that invokes a super constructor with default arguments.
|
| DeclaredByType |
This interface represents all elements that can be declared within a type, i.e.
|
| DeclaringAnnotationMatcher<T extends AnnotationSource> |
An element matcher that matches the list of annotations that are provided by an annotated element.
|
| DeclaringFieldMatcher<T extends TypeDefinition> |
An element matcher that checks if a type description declares fields of a given property.
|
| DeclaringMethodMatcher<T extends TypeDefinition> |
An element matcher that checks if a type description declares methods of a given property.
|
| 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.
|
| DeclaringTypeResolver |
This ambiguity resolver matches that method out of two methods that is declared by the more specific type.
|
| Default |
Parameters that are annotated with this annotation are assigned an instance of an auxiliary proxy type that allows calling
any default method of an interface of the instrumented type where the parameter type must be an interface that is
directly implemented by the instrumented type.
|
| Default.Binder |
A binder for the Default annotation. |
| Default.Binder.TypeLocator |
Locates the type which should be the base type of the created proxy.
|
| Default.Binder.TypeLocator.ForParameterType |
A type locator that yields the target parameter's type.
|
| Default.Binder.TypeLocator.ForType |
A type locator that returns a given type.
|
| DefaultCall |
A parameter with this annotation is assigned a proxy for invoking a default method that fits the intercepted method.
|
| DefaultCall.Binder |
|
| DefaultCall.Binder.DefaultMethodLocator |
A default method locator is responsible for looking up a default method to a given source method.
|
| DefaultCall.Binder.DefaultMethodLocator.Explicit |
An explicit default method locator attempts to look up a default method in the specified interface type.
|
| DefaultCall.Binder.DefaultMethodLocator.Implicit |
An implicit default method locator that only permits the invocation of a default method if the source
method itself represents a method that was defined on a default method interface.
|
| DefaultMethod |
A parameter with this annotation is assigned an instance of Method which invokes a default method implementation of this method.
|
| DefaultMethod.Binder |
|
| DefaultMethod.Binder.DelegationMethod |
Loads the delegation method constant onto the stack.
|
| DefaultMethod.Binder.MethodLocator |
A method locator is responsible for creating the super method call.
|
| DefaultMethod.Binder.MethodLocator.ForExplicitType |
A method locator for an explicit target type.
|
| DefaultMethod.Binder.MethodLocator.ForImplicitType |
A method locator for an implicit target type.
|
| DefaultMethodCall |
This Implementation invokes a default method for the methods it instruments. |
| DefaultMethodCall.Appender |
|
| DefaultValue |
Represents a stack assignment that loads the default value of a given type onto the stack.
|
| 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.
|
| DescriptorMatcher<T extends ByteCodeElement> |
An element matcher that matches a Java descriptor.
|
| DoubleConstant |
This class is responsible for loading any double constant onto the operand stack.
|
| DoubleConstant.ConstantPool |
A stack manipulation for loading a double value from a class's constant pool onto the operand stack.
|
| Duplication |
Duplicates a value that is lying on top of the stack.
|
| Duplication.WithFlip |
A duplication that flips a value over the second value on the operand stack.
|
| DynamicType |
|
| DynamicType.Builder<T> |
A builder for creating a dynamic type.
|
| DynamicType.Builder.AbstractBase<S> |
An abstract base implementation of a dynamic type builder.
|
| DynamicType.Builder.AbstractBase.Adapter<U> |
An adapter implementation of a dynamic type builder.
|
| DynamicType.Builder.AbstractBase.Delegator<U> |
A delegator for a dynamic type builder delegating all invocations to another dynamic type builder.
|
| DynamicType.Builder.FieldDefinition<S> |
A builder for a field definition.
|
| DynamicType.Builder.FieldDefinition.Optional<U> |
A builder for an optional field definition.
|
| DynamicType.Builder.FieldDefinition.Optional.AbstractBase<U> |
An abstract base implementation for an optional field definition.
|
| DynamicType.Builder.FieldDefinition.Optional.Valuable<V> |
A builder for an optional field definition that allows for defining a value.
|
| DynamicType.Builder.FieldDefinition.Optional.Valuable.AbstractBase<U> |
An abstract base implementation of an optional field definition that allows for defining a value.
|
| DynamicType.Builder.FieldDefinition.Optional.Valuable.AbstractBase.Adapter<V> |
An adapter for an optional field definition that allows for defining a value.
|
| DynamicType.Builder.FieldDefinition.Valuable<U> |
A builder for a field definition that allows for defining a value.
|
| DynamicType.Builder.MethodDefinition<S> |
A builder for a method definition.
|
| DynamicType.Builder.MethodDefinition.AbstractBase<U> |
An abstract base implementation of a method definition.
|
| DynamicType.Builder.MethodDefinition.AbstractBase.Adapter<V> |
An adapter implementation of a method definition.
|
| DynamicType.Builder.MethodDefinition.ExceptionDefinition<U> |
A builder for defining an implementation of a method and optionally defining a type variable or thrown exception.
|
| DynamicType.Builder.MethodDefinition.ExceptionDefinition.AbstractBase<V> |
An abstract base implementation for defining an implementation of a method and optionally defining a type variable or thrown exception.
|
| DynamicType.Builder.MethodDefinition.ImplementationDefinition<U> |
A builder for defining an implementation of a method.
|
| DynamicType.Builder.MethodDefinition.ImplementationDefinition.AbstractBase<V> |
An abstract base implementation for a builder optionally defining an implementation of a method.
|
| DynamicType.Builder.MethodDefinition.ImplementationDefinition.Optional<V> |
A builder for optionally defining an implementation of a method.
|
| DynamicType.Builder.MethodDefinition.ParameterDefinition<U> |
A builder for defining an implementation of a method and optionally defining a type variable, thrown exception or method parameter.
|
| DynamicType.Builder.MethodDefinition.ParameterDefinition.AbstractBase<V> |
An abstract base implementation for defining an implementation of a method and optionally defining a type variable, thrown exception or parameter type.
|
| DynamicType.Builder.MethodDefinition.ParameterDefinition.Annotatable<V> |
A builder for optionally defining an annotation on a parameter.
|
| DynamicType.Builder.MethodDefinition.ParameterDefinition.Annotatable.AbstractBase<W> |
An abstract base implementation for defining an annotation on a parameter.
|
| DynamicType.Builder.MethodDefinition.ParameterDefinition.Annotatable.AbstractBase.Adapter<X> |
An adapter implementation for defining an annotation on a parameter.
|
| DynamicType.Builder.MethodDefinition.ParameterDefinition.Initial<V> |
A builder for defining an implementation of a method and optionally defining a type variable, thrown exception or method parameter.
|
| DynamicType.Builder.MethodDefinition.ParameterDefinition.Initial.AbstractBase<W> |
An abstract base implementation for an initial parameter definition.
|
| DynamicType.Builder.MethodDefinition.ParameterDefinition.Simple<V> |
A builder for defining an implementation of a method and optionally defining a type variable, thrown exception or a parameter type.
|
| DynamicType.Builder.MethodDefinition.ParameterDefinition.Simple.AbstractBase<W> |
An abstract base implementation of an exception definition.
|
| DynamicType.Builder.MethodDefinition.ParameterDefinition.Simple.Annotatable<V> |
A builder for optionally defining an annotation on a parameter.
|
| DynamicType.Builder.MethodDefinition.ParameterDefinition.Simple.Annotatable.AbstractBase<W> |
An abstract base implementation of a simple parameter definition.
|
| DynamicType.Builder.MethodDefinition.ParameterDefinition.Simple.Annotatable.AbstractBase.Adapter<X> |
An adapter implementation of a simple parameter definition.
|
| DynamicType.Builder.MethodDefinition.ReceiverTypeDefinition<U> |
A builder for a method definition with a receiver type.
|
| DynamicType.Builder.MethodDefinition.ReceiverTypeDefinition.AbstractBase<V> |
An abstract base implementation of a method definition that can accept a receiver type.
|
| DynamicType.Builder.MethodDefinition.TypeVariableDefinition<U> |
A builder for defining an implementation of a method and optionally defining a type variable.
|
| DynamicType.Builder.MethodDefinition.TypeVariableDefinition.AbstractBase<V> |
An abstract base implementation for defining an implementation of a method and optionally defining a type variable.
|
| DynamicType.Builder.MethodDefinition.TypeVariableDefinition.Annotatable<V> |
A builder for optionally defining an annotation for a type variable.
|
| DynamicType.Builder.MethodDefinition.TypeVariableDefinition.Annotatable.AbstractBase<W> |
An abstract base implementation for defining an annotation on a parameter.
|
| DynamicType.Builder.MethodDefinition.TypeVariableDefinition.Annotatable.AbstractBase.Adapter<X> |
An adapter implementation for an annotatable type variable definition.
|
| DynamicType.Builder.TypeVariableDefinition<S> |
A builder for a type variable definition.
|
| DynamicType.Builder.TypeVariableDefinition.AbstractBase<U> |
An abstract base implementation of a type variable definition.
|
| DynamicType.Default |
A default implementation of a dynamic type.
|
| DynamicType.Default.Loaded<T> |
A default implementation of a loaded dynamic type.
|
| DynamicType.Default.Unloaded<T> |
A default implementation of an unloaded dynamic type.
|
| DynamicType.Loaded<T> |
A dynamic type that has been loaded into the running instance of the Java virtual machine.
|
| DynamicType.Unloaded<T> |
A dynamic type that has not yet been loaded by a given ClassLoader.
|
| ElementMatcher<T> |
An element matcher is used as a predicate for identifying code elements such as types, methods, fields or
annotations.
|
| ElementMatcher.Junction<S> |
A junctions allows to chain different ElementMatchers in a readable manner. |
| ElementMatcher.Junction.AbstractBase<V> |
|
| ElementMatcher.Junction.Conjunction<W> |
A conjunction matcher which only matches an element if both represented matchers constitute a match.
|
| ElementMatcher.Junction.Disjunction<W> |
A disjunction matcher which only matches an element if both represented matchers constitute a match.
|
| ElementMatchers |
A utility class that contains a human-readable language for creating ElementMatchers. |
| Empty |
Binds the parameter type's default value to the annotated parameter, i.e.
|
| Empty.Binder |
A binder for the Empty annotation. |
| EntryPoint |
An entry point for a build tool which is responsible for the transformation's configuration.
|
| EntryPoint.Default |
Default implementations for an entry point.
|
| EnumerationDescription |
Describes an enumeration value.
|
| EnumerationDescription.AbstractBase |
An adapter implementation of an enumeration description.
|
| EnumerationDescription.ForLoadedEnumeration |
An enumeration description representing a loaded enumeration.
|
| EnumerationDescription.Latent |
A latent description of an enumeration value.
|
| EnumerationState |
Determines if a type describes an enumeration.
|
| EqualityMatcher<T> |
An element matcher that checks an object's equality to another object.
|
| EqualsMethod |
An implementation of Object.equals(Object) that takes a class's declared fields into consideration.
|
| EqualsMethod.Appender |
|
| EqualsMethod.ConditionalReturn |
A conditional return aborts the equality computation if a given condition was reached.
|
| EqualsMethod.NullValueGuard |
Guards a field value against a potential null value.
|
| EqualsMethod.NullValueGuard.NoOp |
A non-operational null value guard.
|
| 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.
|
| EqualsMethod.NullValueGuard.UsingJump.AfterInstruction |
The stack manipulation to apply after the equality computation.
|
| EqualsMethod.NullValueGuard.UsingJump.BeforeInstruction |
The stack manipulation to apply before the equality computation.
|
| EqualsMethod.SuperClassCheck |
Checks the equality contract against the super class.
|
| EqualsMethod.TypeCompatibilityCheck |
Checks the overall type of the provided argument.
|
| EqualsMethod.ValueComparator |
A value comparator is responsible to compare to values of a given type.
|
| ErasureMatcher<T extends TypeDefinition> |
|
| ExceptionMethod |
This implementation causes a Throwable to be thrown when the instrumented method is invoked.
|
| ExceptionMethod.ConstructionDelegate |
A construction delegate is responsible for calling a Throwable's constructor.
|
| ExceptionMethod.ConstructionDelegate.ForDefaultConstructor |
A construction delegate that calls the default constructor.
|
| ExceptionMethod.ConstructionDelegate.ForStringConstructor |
A construction delegate that calls a constructor that takes a single string as its argument.
|
| ExceptionTableSensitiveMethodVisitor |
A MethodVisitor that adds a callback after visiting the exception table of a method.
|
| FailSafeMatcher<T> |
A fail-safe matcher catches exceptions that are thrown by a delegate matcher and returns an alternative value.
|
| FieldAccess |
An access representation to a given field.
|
| FieldAccess.Defined |
Representation of a field access for which a getter and a setter can be created.
|
| FieldAccess.OfGenericField |
A dispatcher for implementing a generic read or write access on a field.
|
| FieldAccessor |
Defines a method to access a given field by following the Java bean conventions for getters and setters:
|
| FieldAccessor.AssignerConfigurable |
A field accessor that can be configured to use a given assigner and runtime type use configuration.
|
| FieldAccessor.FieldLocation |
A field location represents an identified field description which depends on the instrumented type and method.
|
| FieldAccessor.FieldLocation.Absolute |
An absolute field description representing a previously resolved field.
|
| FieldAccessor.FieldLocation.Prepared |
A prepared field location.
|
| FieldAccessor.FieldLocation.Relative |
A relative field location where a field is located dynamically.
|
| FieldAccessor.FieldLocation.Relative.Prepared |
A prepared version of a field location.
|
| FieldAccessor.FieldNameExtractor |
A field name extractor is responsible for determining a field name to a method that is implemented
to access this method.
|
| FieldAccessor.FieldNameExtractor.ForBeanProperty |
|
| FieldAccessor.FieldNameExtractor.ForFixedValue |
A field name extractor that returns a fixed value.
|
| FieldAccessor.ForImplicitProperty |
A field accessor for an implicit property where a getter or setter property is inferred from the signature.
|
| FieldAccessor.ForParameterSetter |
A field accessor that sets a parameters value of a given index.
|
| FieldAccessor.ForParameterSetter.TerminationHandler |
A termination handler is responsible for handling a field accessor's return.
|
| FieldAccessor.OwnerTypeLocatable |
A field accessor that can be configured to locate a field in a specific manner.
|
| FieldAccessor.PropertyConfigurable |
A field accessor that allows to define the access to be a field write of a given argument.
|
| FieldAttributeAppender |
An appender that writes attributes or annotations to a given ASM FieldVisitor.
|
| FieldAttributeAppender.Compound |
A field attribute appender that combines several method attribute appenders to be represented as a single
field attribute appender.
|
| FieldAttributeAppender.Explicit |
Appends an annotation to a field.
|
| FieldAttributeAppender.Factory |
A factory that creates field attribute appenders for a given type.
|
| FieldAttributeAppender.Factory.Compound |
A field attribute appender factory that combines several field attribute appender factories to be
represented as a single factory.
|
| FieldAttributeAppender.ForInstrumentedField |
An attribute appender that writes all annotations that are declared on a field.
|
| FieldAttributeAppender.NoOp |
A field attribute appender that does not append any attributes.
|
| FieldConstant |
Represents a Field constant for a given type.
|
| FieldConstant.Cached |
|
| FieldDescription |
Implementations of this interface describe a Java field.
|
| FieldDescription.AbstractBase |
An abstract base implementation of a field description.
|
| FieldDescription.ForLoadedField |
An implementation of a field description for a loaded field.
|
| FieldDescription.InDefinedShape |
Represents a field in its defined shape, i.e.
|
| FieldDescription.InDefinedShape.AbstractBase |
An abstract base implementation of a field description in its defined shape.
|
| FieldDescription.InGenericShape |
Represents a field description in its generic shape, i.e.
|
| FieldDescription.Latent |
A latent field description describes a field that is not attached to a declaring
TypeDescription. |
| FieldDescription.SignatureToken |
A token that uniquely identifies a field by its name and type erasure.
|
| FieldDescription.Token |
A token representing a field's properties detached from a type.
|
| FieldDescription.TypeSubstituting |
A field description that represents a given field but with a substituted field type.
|
| FieldList<T extends FieldDescription> |
Implementations represent a list of field descriptions.
|
| FieldList.AbstractBase<S extends FieldDescription> |
An abstract base implementation of a FieldList. |
| FieldList.Empty<S extends FieldDescription> |
An implementation of an empty field list.
|
| FieldList.Explicit<S extends FieldDescription> |
A wrapper implementation of a field list for a given list of field descriptions.
|
| FieldList.ForLoadedFields |
An implementation of a field list for an array of loaded fields.
|
| FieldList.ForTokens |
A list of field descriptions for a list of detached tokens.
|
| FieldList.TypeSubstituting |
|
| FieldLocator |
A field locator offers an interface for locating a field that is declared by a specified type.
|
| FieldLocator.AbstractBase |
An abstract base implementation of a field locator.
|
| FieldLocator.Factory |
|
| FieldLocator.ForClassHierarchy |
A field locator that looks up fields that are declared within a class's class hierarchy.
|
| FieldLocator.ForClassHierarchy.Factory |
|
| FieldLocator.ForExactType |
A field locator that only looks up fields that are declared by a specific type.
|
| FieldLocator.ForExactType.Factory |
|
| FieldLocator.ForTopLevelType |
A field locator that only locates fields in the top-level type.
|
| FieldLocator.ForTopLevelType.Factory |
A factory for locating a field in a top-level type.
|
| FieldLocator.NoOp |
A field locator that never discovers a field.
|
| FieldLocator.Resolution |
A resolution for a field lookup.
|
| FieldLocator.Resolution.Illegal |
An illegal resolution.
|
| FieldLocator.Resolution.Simple |
A simple implementation for a field resolution.
|
| FieldManifestation |
Describes the manifestation of a class's field, i.e.
|
| FieldPersistence |
Describes the persistence of a field, i.e.
|
| FieldProxy |
Using this annotation it is possible to access fields by getter and setter types.
|
| FieldProxy.Binder |
|
| FieldProxy.Binder.FieldGetter |
Implementation for a getter method.
|
| FieldProxy.Binder.FieldResolver |
A resolver for creating an instrumentation for a field access.
|
| FieldProxy.Binder.FieldResolver.Factory |
A factory for creating a field resolver.
|
| FieldProxy.Binder.FieldResolver.Factory.Duplex |
A duplex factory for a type that both sets and gets a field value.
|
| FieldProxy.Binder.FieldResolver.Factory.Simplex |
A simplex factory where field getters and setters both have their own type.
|
| FieldProxy.Binder.FieldResolver.ForGetter |
A field resolver for a getter accessor.
|
| FieldProxy.Binder.FieldResolver.ForGetterSetterPair |
A field resolver for an accessor that both gets and sets a field value.
|
| FieldProxy.Binder.FieldResolver.ForSetter |
A field resolver for a setter accessor.
|
| FieldProxy.Binder.FieldResolver.Unresolved |
An unresolved field resolver.
|
| FieldProxy.Binder.FieldSetter |
Implementation for a setter method.
|
| FieldProxy.Binder.InstanceFieldConstructor |
Represents an implementation for implementing a proxy type constructor when a non-static field is accessed.
|
| FieldProxy.Binder.InstanceFieldConstructor.Appender |
|
| FieldProxy.Binder.StaticFieldConstructor |
Represents an implementation for implementing a proxy type constructor when a static field is accessed.
|
| FieldRegistry |
A field registry represents an extendable collection of fields which are identified by their names that are mapped
to a given FieldAttributeAppender. |
| FieldRegistry.Compiled |
Represents a compiled field registry.
|
| FieldRegistry.Compiled.NoOp |
A no-op field registry that does not register annotations for any field.
|
| FieldRegistry.Default |
An immutable default implementation of a field registry.
|
| FieldRegistry.Default.Compiled |
A compiled default field registry.
|
| FieldRegistry.Default.Compiled.Entry |
An entry of a compiled field registry.
|
| FieldRegistry.Default.Entry |
An entry of the default field registry.
|
| FieldTypeMatcher<T extends FieldDescription> |
An element matcher that matches a field's type.
|
| FieldValue |
Assigns the value of a field of the instrumented type to the annotated parameter.
|
| FieldValue.Binder |
|
| FieldValue.Binder.Delegate |
|
| FilterableList<T,S extends FilterableList<T,S>> |
A filterable list allows to use an ElementMatcher to reduce a lists to elements
that are matched by this matcher in this list. |
| FilterableList.AbstractBase<T,S extends FilterableList<T,S>> |
|
| FilterableList.Empty<T,S extends FilterableList<T,S>> |
|
| FixedValue |
This implementation returns a fixed value for a method.
|
| FixedValue.AssignerConfigurable |
Represents a fixed value implementation that is using a default assigner for attempting to assign
the fixed value to the return type of the instrumented method.
|
| FixedValue.ForArgument |
A fixed value implementation that returns a method's argument.
|
| FixedValue.ForNullValue |
A fixed value of null.
|
| FixedValue.ForOriginType |
A fixed value that appends the origin type of the instrumented type.
|
| FixedValue.ForPoolValue |
A fixed value implementation that represents its fixed value as a value that is written to the instrumented
class's constant pool.
|
| FixedValue.ForThisValue |
A fixed value of this.
|
| FixedValue.ForThisValue.Appender |
A byte code appender for returning this.
|
| FixedValue.ForValue |
A fixed value implementation that represents its fixed value as a static field of the instrumented class.
|
| FloatConstant |
This class is responsible for loading any float constant onto the operand stack.
|
| FloatConstant.ConstantPool |
A stack manipulation for loading a float value from a class's constant pool onto the operand stack.
|
| GetSystemPropertyAction |
An action for reading a system property as a privileged action.
|
| HandleInvocation |
An exact invocation of a method handle with a polymorphic signature.
|
| 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. |
| HashCodeAndEqualsPlugin.Enhance |
Instructs the HashCodeAndEqualsPlugin to generate Object.hashCode() and Object.equals(Object) for the annotated
class unless these methods are already declared explicitly. |
| HashCodeAndEqualsPlugin.Enhance.InvokeSuper |
A strategy for determining the base value of a hash code or equality contract.
|
| HashCodeAndEqualsPlugin.ValueHandling |
Determines how a field should be used within generated hash code and equality methods.
|
| HashCodeAndEqualsPlugin.ValueHandling.Sort |
Determines how a field should be handled.
|
| HashCodeAndEqualsPlugin.ValueMatcher |
|
| HashCodeAndEqualsPlugin.WithNonNullableFields |
A version of the HashCodeAndEqualsPlugin that assumes that all fields are non-nullable unless they are explicitly marked. |
| HashCodeMethod |
An implementation of Object.hashCode() that takes a class's declared fields into consideration.
|
| HashCodeMethod.Appender |
A byte code appender to implement a hash code method.
|
| HashCodeMethod.NullValueGuard |
A guard against null values for fields with reference types.
|
| HashCodeMethod.NullValueGuard.NoOp |
A non-operational null value guard.
|
| HashCodeMethod.NullValueGuard.UsingJump |
A null value guard that expects a reference type and that uses a jump if a field value is null.
|
| HashCodeMethod.NullValueGuard.UsingJump.AfterInstruction |
The stack manipulation to apply after the hash value computation.
|
| HashCodeMethod.NullValueGuard.UsingJump.BeforeInstruction |
The stack manipulation to apply before the hash value computation.
|
| HashCodeMethod.OffsetProvider |
An offset provider is responsible for supplying the initial hash code.
|
| HashCodeMethod.OffsetProvider.ForFixedValue |
An offset provider that supplies a fixed value.
|
| HashCodeMethod.OffsetProvider.ForSuperMethodCall |
An offset provider that invokes the super class's Object.hashCode() implementation.
|
| HashCodeMethod.ValueTransformer |
A value transformer that is responsible for resolving a field value to an int value.
|
| HasSuperTypeMatcher<T extends TypeDescription> |
An element matcher that matches a super type.
|
| IgnoreForBinding |
Indicates that a given target method should never be considered for binding to a source method.
|
| IgnoreForBinding.Verifier |
A non-instantiable type that allows to check if a method should be ignored for binding.
|
| Implementation |
An implementation is responsible for implementing methods of a dynamically created type as byte code.
|
| Implementation.Composable |
Represents an implementation that can be chained together with another implementation.
|
| Implementation.Compound |
A compound implementation that allows to combine several implementations.
|
| Implementation.Context |
The context for an implementation application.
|
| Implementation.Context.Default |
|
| Implementation.Context.Default.AbstractPropertyAccessorMethod |
A base implementation of a method that accesses a property of an instrumented type.
|
| Implementation.Context.Default.AccessorMethod |
A description of an accessor method to access another method from outside the instrumented type.
|
| Implementation.Context.Default.AccessorMethodDelegation |
|
| Implementation.Context.Default.CacheValueField |
A description of a field that stores a cached value.
|
| Implementation.Context.Default.DelegationRecord |
An abstract method pool entry that delegates the implementation of a method to itself.
|
| Implementation.Context.Default.Factory |
|
| Implementation.Context.Default.FieldCacheEntry |
A field cache entry for uniquely identifying a cached field.
|
| Implementation.Context.Default.FieldGetter |
A description of a field getter method.
|
| Implementation.Context.Default.FieldGetterDelegation |
An implementation for a field getter.
|
| Implementation.Context.Default.FieldSetter |
A description of a field setter method.
|
| Implementation.Context.Default.FieldSetterDelegation |
An implementation for a field setter.
|
| Implementation.Context.Disabled |
An implementation context that does not allow for any injections into the static initializer block.
|
| Implementation.Context.Disabled.Factory |
|
| Implementation.Context.ExtractableView |
Represents an extractable view of an Implementation.Context which
allows the retrieval of any registered auxiliary type. |
| Implementation.Context.ExtractableView.AbstractBase |
An abstract base implementation of an extractable view of an implementation context.
|
| Implementation.Context.Factory |
A factory for creating a new implementation context.
|
| Implementation.Simple |
A simple implementation that does not register any members with the instrumented type.
|
| Implementation.SpecialMethodInvocation |
Represents an type-specific method invocation on the current instrumented type which is not legal from outside
the type such as a super method or default method invocation.
|
| Implementation.SpecialMethodInvocation.AbstractBase |
An abstract base implementation of a valid special method invocation.
|
| Implementation.SpecialMethodInvocation.Illegal |
|
| Implementation.SpecialMethodInvocation.Simple |
|
| Implementation.Target |
The target of an implementation.
|
| Implementation.Target.AbstractBase |
|
| Implementation.Target.AbstractBase.DefaultMethodInvocation |
Determines if default method invocations are possible.
|
| Implementation.Target.Factory |
|
| InheritedAnnotationMatcher<T extends TypeDescription> |
An element matcher that matches the list of inherited annotations of a type description.
|
| Initialization |
Defines a configuration for a Maven build's type transformation.
|
| InjectionClassLoader |
An injection class loader allows for the injection of a class after the class loader was created.
|
| InjectionClassLoader.Strategy |
A class loading strategy for adding a type to an injection class loader.
|
| InliningImplementationMatcher |
A latent method matcher that identifies methods to instrument when redefining or rebasing a type.
|
| Installer |
An installer class which defined the hook-in methods that are required by the Java agent specification.
|
| InstanceCheck |
Implements an instanceof check.
|
| InstanceTypeMatcher<T> |
An element matcher that matches an object's type.
|
| InstrumentedType |
Implementations of this interface represent an instrumented type that is subject to change.
|
| InstrumentedType.Default |
A default implementation of an instrumented type.
|
| InstrumentedType.Factory |
|
| InstrumentedType.Factory.Default |
Default implementations of instrumented type factories.
|
| InstrumentedType.Frozen |
A frozen representation of an instrumented type of which the structure must not be modified.
|
| InstrumentedType.Prepareable |
|
| InstrumentedType.WithFlexibleName |
|
| IntegerConstant |
This class is responsible for loading any int constant onto the operand stack.
|
| IntegerConstant.ConstantPool |
A stack manipulation that loads a JVM-integer value from a constant pool value onto the operand stack.
|
| IntegerConstant.SingleBytePush |
A stack manipulation that loads a JVM-integer value by a BIPUSH operation which is
legal for single byte integer values.
|
| 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.
|
| InvocationHandlerAdapter |
An adapter for adapting an InvocationHandler.
|
| InvocationHandlerAdapter.AssignerConfigurable |
|
| InvocationHandlerAdapter.ForField |
An implementation of an InvocationHandlerAdapter that delegates method
invocations to an adapter that is stored in an instance field. |
| InvocationHandlerAdapter.ForInstance |
An implementation of an InvocationHandlerAdapter that delegates method
invocations to an adapter that is stored in a static field. |
| InvokeDynamic |
|
| InvokeDynamic.AbstractDelegator |
An abstract delegator that allows to specify a configuration for any specification of an argument.
|
| InvokeDynamic.InvocationProvider |
An invocation provider is responsible for loading the arguments of the invoked method onto the operand
stack and for creating the actual invoke dynamic instruction.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider |
An argument provider is responsible for loading arguments to a bootstrapped method onto the operand
stack and providing the types of these arguments.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ConstantPoolWrapper |
Represents wrapper types and types that could be stored in a class's constant pool as such
constant pool values.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForBooleanConstant |
An argument provider for a boolean value.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForByteConstant |
An argument provider for a byte value.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForCharacterConstant |
An argument provider for a char value.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForClassConstant |
An argument provider for a Class constant.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForDoubleConstant |
An argument provider for a double value.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForEnumerationValue |
An argument provider for an Enum constant.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForField |
Provides an argument from an existing field.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForField.WithExplicitType |
An argument provider for a field value with an explicit type.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForFloatConstant |
An argument provider for a float value.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForInstance |
An argument provider for a value that is stored in a randomly named static field.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForIntegerConstant |
An argument provider for a int value.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForInterceptedMethodInstanceAndParameters |
An argument provider that loads a reference to the intercepted instance and all arguments of
the intercepted method.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForInterceptedMethodParameters |
An argument provider that loads all arguments of the intercepted method.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForJavaConstant |
An argument provider for a Java instance.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForLongConstant |
An argument provider for a long value.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter |
An argument provider that loads an argument of the intercepted method.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter.WithExplicitType |
An argument provider for a method parameter with an explicit type.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForNullValue |
An argument provider for the null value.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForShortConstant |
An argument provider for a short value.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForStringConstant |
An argument provider for a String value.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.ForThisInstance |
An argument provider that loads the intercepted instance.
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved |
|
| InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved.Simple |
A simple implementation of a resolved argument provider.
|
| InvokeDynamic.InvocationProvider.Default |
An invocation provider that requests a synthetic dynamic invocation where all arguments are explicitly
provided by the user.
|
| InvokeDynamic.InvocationProvider.Default.Target |
A target for a synthetically bound method call.
|
| InvokeDynamic.InvocationProvider.NameProvider |
Provides the name of the method that is to be bound by a dynamic method call.
|
| InvokeDynamic.InvocationProvider.NameProvider.ForExplicitName |
A name provider that provides an explicit name.
|
| InvokeDynamic.InvocationProvider.NameProvider.ForInterceptedMethod |
A name provider that provides the name of the intercepted method.
|
| InvokeDynamic.InvocationProvider.ReturnTypeProvider |
Provides the return type that is requested from the bootstrap method.
|
| InvokeDynamic.InvocationProvider.ReturnTypeProvider.ForExplicitType |
Requests an explicit return type.
|
| InvokeDynamic.InvocationProvider.ReturnTypeProvider.ForInterceptedMethod |
Requests the return type of the intercepted method.
|
| InvokeDynamic.InvocationProvider.Target |
A target for a dynamic method invocation.
|
| InvokeDynamic.InvocationProvider.Target.ForMethodDescription |
A target that requests to dynamically invoke a method to substitute for a given method.
|
| InvokeDynamic.InvocationProvider.Target.Resolved |
|
| InvokeDynamic.InvocationProvider.Target.Resolved.Simple |
|
| InvokeDynamic.TerminationHandler |
A termination handler is responsible to handle the return value of a method that is invoked via a
InvokeDynamic. |
| InvokeDynamic.WithImplicitArguments |
Representation of an InvokeDynamic implementation where the bootstrapped
method is passed a this reference, if available, and any arguments of the instrumented method. |
| InvokeDynamic.WithImplicitTarget |
Representation of an InvokeDynamic implementation where the bootstrapped
method is passed a this reference, if available, and any arguments of the instrumented method and
where the invocation target is implicit. |
| InvokeDynamic.WithImplicitType |
An InvokeDynamic invocation where the last argument is assigned its implicit type. |
| InvokeDynamic.WithImplicitType.OfArgument |
An invoke dynamic implementation where the last argument is an implicitly typed method argument.
|
| InvokeDynamic.WithImplicitType.OfField |
An invoke dynamic implementation where the last argument is an implicitly typed field value.
|
| InvokeDynamic.WithImplicitType.OfInstance |
A step in the invoke dynamic domain specific language that allows to explicitly specify a field type for a reference value.
|
| IsNamedMatcher<T extends NamedElement.WithOptionalName> |
An element matcher that matches a named element only if is explicitly named.
|
| JavaConstant |
Returns a Java instance of an object that has a special meaning to the Java virtual machine and that is not
available to Java in versions 6.
|
| JavaConstant.MethodHandle |
Represents a java.lang.invoke.MethodHandle object.
|
| JavaConstant.MethodHandle.Dispatcher |
A dispatcher for analyzing a java.lang.invoke.MethodHandle instance.
|
| JavaConstant.MethodHandle.Dispatcher.AbstractBase |
An abstract base implementation of a dispatcher.
|
| JavaConstant.MethodHandle.Dispatcher.CreationAction |
A creation action for a dispatcher.
|
| JavaConstant.MethodHandle.Dispatcher.ForJava7CapableVm |
A dispatcher that extracts the information of a method handle by using private APIs that are available in Java 7+.
|
| JavaConstant.MethodHandle.Dispatcher.ForJava8CapableVm |
A dispatcher for introspecting a java.lang.invoke.MethodHandle instance on a virtual machine that officially supports this
introspection, i.e.
|
| JavaConstant.MethodHandle.Dispatcher.ForLegacyVm |
A dispatcher that does not support method handles at all.
|
| JavaConstant.MethodHandle.Dispatcher.Initializable |
An initializable version of a dispatcher that is not yet made accessible.
|
| JavaConstant.MethodHandle.HandleType |
A representation of a method handle's type.
|
| JavaConstant.MethodType |
Represents a java.lang.invoke.MethodType object.
|
| JavaConstant.MethodType.Dispatcher |
A dispatcher for extracting information from a java.lang.invoke.MethodType instance.
|
| JavaConstant.MethodType.Dispatcher.CreationAction |
A creation action for a dispatcher.
|
| JavaConstant.MethodType.Dispatcher.ForJava7CapableVm |
A dispatcher for virtual machines that are aware of the java.lang.invoke.MethodType type that was added in Java version 7.
|
| JavaConstant.MethodType.Dispatcher.ForLegacyVm |
A dispatcher for virtual machines that are not aware of the java.lang.invoke.MethodType type that was added in Java version 7.
|
| JavaConstantValue |
|
| JavaModule |
Type-safe representation of a java.lang.Module.
|
| JavaModule.Dispatcher |
A dispatcher for accessing the java.lang.Module API if it is available on the current VM.
|
| JavaModule.Dispatcher.CreationAction |
A creation action for a dispatcher.
|
| JavaModule.Dispatcher.Disabled |
A disabled dispatcher for a VM that does not support the java.lang.Module API.
|
| JavaModule.Dispatcher.Enabled |
A dispatcher for a VM that does support the java.lang.Module API.
|
| JavaType |
Representations of Java types that do not exist in Java 6 but that have a special meaning to the JVM.
|
| LambdaFactory |
This class serves as a dispatcher for creating lambda expression objects when Byte Buddy is configured to instrument the
java.lang.invoke.LambdaMetafactory.
|
| LatentMatcher<T> |
A latent matcher that resolves an ElementMatcher after supplying a type description. |
| LatentMatcher.Conjunction<S> |
A matcher that computes the conjunction of all supplied latent matchers.
|
| LatentMatcher.Disjunction<S> |
A matcher that computes the disjunction of all supplied latent matchers.
|
| LatentMatcher.ForFieldToken |
A latent matcher where the field token is being attached to the supplied type description before matching.
|
| LatentMatcher.ForFieldToken.ResolvedMatcher |
A resolved matcher of a latent field matcher for a field token.
|
| LatentMatcher.ForMethodToken |
A latent matcher where the method token is being attached to the supplied type description before matching.
|
| LatentMatcher.ForMethodToken.ResolvedMatcher |
A resolved matcher of a latent method matcher for a method token.
|
| LatentMatcher.ForSelfDeclaredMethod |
A latent matching methods that are declared by the resolved type.
|
| LatentMatcher.Resolved<S> |
|
| LineNumberPrependingMethodVisitor |
A method visitor that maps the first available line number information, if available, to the beginning of the method.
|
| LoadedTypeInitializer |
Implementations of this interface explicitly initialize a loaded type.
|
| LoadedTypeInitializer.Compound |
A compound loaded type initializer that combines several type initializers.
|
| LoadedTypeInitializer.ForStaticField |
A type initializer for setting a value for a static field.
|
| LoadedTypeInitializer.NoOp |
A loaded type initializer that does not do anything.
|
| LongConstant |
This class is responsible for loading any long constant onto the operand stack.
|
| LongConstant.ConstantPool |
A stack manipulation for loading a long value from a class's constant pool onto the operand stack.
|
| MavenCoordinate |
A Maven coordinate.
|
| MemberRemoval |
A visitor wrapper that removes fields or methods that match a given ElementMatcher. |
| MemberRemoval.MemberRemovingClassVisitor |
A class visitor that removes members based on element matchers.
|
| MemberSubstitution |
Substitutes field access or method invocations within a method's body.
|
| MemberSubstitution.SubstitutingMethodVisitor |
A method visitor that applies a substitution for matched methods.
|
| MemberSubstitution.Substitution |
Resolves an actual substitution.
|
| MemberSubstitution.Substitution.Compound |
A compound substitution.
|
| MemberSubstitution.Substitution.ForElementMatchers |
A substitution that uses element matchers for determining if a byte code element should be substituted.
|
| MemberSubstitution.Substitution.InvocationType |
Determines a method's invocation type.
|
| MemberSubstitution.Substitution.NoOp |
A substitution that does not substitute any byte code elements.
|
| MemberSubstitution.Substitution.Resolver |
A resolver supplies an implementation for a substitution.
|
| MemberSubstitution.Substitution.Resolver.FieldAccessing |
A resolver that replaces an interaction with a byte code element with a field access.
|
| MemberSubstitution.Substitution.Resolver.MethodInvoking |
A resolver that invokes a method.
|
| MemberSubstitution.Substitution.Resolver.Stubbing |
A resolver that stubs any interaction with a byte code element.
|
| MemberSubstitution.Substitution.Resolver.Unresolved |
An unresolved resolver that does not apply a substitution.
|
| MemberSubstitution.TypePoolResolver |
A type pool resolver is responsible for resolving a TypePool for locating substituted members. |
| MemberSubstitution.TypePoolResolver.ForClassFileLocator |
A type pool resolver that resolves the implicit pool but additionally checks another class file locator.
|
| MemberSubstitution.TypePoolResolver.ForExplicitPool |
A type pool resolver that returns a specific type pool.
|
| MemberSubstitution.TypePoolResolver.OfImplicitPool |
Returns the implicit type pool.
|
| MemberSubstitution.WithoutSpecification |
A member substitution that lacks a specification for how to substitute the matched members references within a method body.
|
| MemberSubstitution.WithoutSpecification.ForMatchedByteCodeElement |
Describes a member substitution that requires a specification for how to replace a byte code element.
|
| MemberSubstitution.WithoutSpecification.ForMatchedField |
Describes a member substitution that requires a specification for how to replace a field.
|
| MemberSubstitution.WithoutSpecification.ForMatchedMethod |
Describes a member substitution that requires a specification for how to replace a method or constructor.
|
| MethodAccessorFactory |
A factory for creating method proxies for an auxiliary type.
|
| MethodAccessorFactory.AccessType |
Indicates the type of access to an accessor method.
|
| MethodAccessorFactory.Illegal |
A method accessor factory that forbids any accessor registration.
|
| MethodArguments |
Describes if a method allows varargs arguments.
|
| MethodAttributeAppender |
An appender that writes attributes or annotations to a given ASM MethodVisitor.
|
| MethodAttributeAppender.Compound |
A method attribute appender that combines several method attribute appenders to be represented as a single
method attribute appender.
|
| MethodAttributeAppender.Explicit |
Appends an annotation to a method or method parameter.
|
| MethodAttributeAppender.Explicit.Target |
Represents the target on which this method attribute appender should write its annotations to.
|
| MethodAttributeAppender.Explicit.Target.OnMethod |
A method attribute appender target for writing annotations directly onto the method.
|
| MethodAttributeAppender.Explicit.Target.OnMethodParameter |
A method attribute appender target for writing annotations onto a given method parameter.
|
| MethodAttributeAppender.Factory |
A factory that creates method attribute appenders for a given type.
|
| MethodAttributeAppender.Factory.Compound |
A method attribute appender factory that combines several method attribute appender factories to be
represented as a single factory.
|
| MethodAttributeAppender.ForInstrumentedMethod |
Implementation of a method attribute appender that writes all annotations of the instrumented method to the
method that is being created.
|
| MethodAttributeAppender.ForReceiverType |
A method attribute appender that writes a receiver type.
|
| MethodAttributeAppender.NoOp |
A method attribute appender that does not append any attributes.
|
| MethodCall |
This Implementation allows the invocation of a specified method while
providing explicit arguments to this method. |
| MethodCall.ArgumentLoader |
An argument loader is responsible for loading an argument for an invoked method
onto the operand stack.
|
| MethodCall.ArgumentLoader.Factory |
|
| MethodCall.ArgumentLoader.ForField |
Loads the value of an existing field onto the operand stack.
|
| MethodCall.ArgumentLoader.ForField.Factory |
A factory for an argument loaded that loads the value of an existing field as an argument.
|
| MethodCall.ArgumentLoader.ForInstance |
Loads a value onto the operand stack that is stored in a static field.
|
| MethodCall.ArgumentLoader.ForInstance.Factory |
A factory that supplies the value of a static field as an argument.
|
| MethodCall.ArgumentLoader.ForInstrumentedType |
Loads the instrumented type onto the operand stack.
|
| MethodCall.ArgumentLoader.ForInstrumentedType.Factory |
A factory for an argument loader that supplies the instrumented type as an argument.
|
| MethodCall.ArgumentLoader.ForMethodParameter |
Loads a parameter of the instrumented method onto the operand stack.
|
| MethodCall.ArgumentLoader.ForMethodParameter.Factory |
A factory for an argument loader that supplies a method parameter as an argument.
|
| MethodCall.ArgumentLoader.ForMethodParameter.OfInstrumentedMethod |
A factory for argument loaders that supplies all arguments of the instrumented method as arguments.
|
| MethodCall.ArgumentLoader.ForMethodParameterArray |
Loads an array containing all arguments of a method.
|
| MethodCall.ArgumentLoader.ForMethodParameterArray.ForInstrumentedMethod |
A factory that creates an arguments loader that loads all parameters of the instrumented method contained in an array.
|
| MethodCall.ArgumentLoader.ForMethodParameterArrayElement |
An argument loader that loads an element of a parameter of an array type.
|
| MethodCall.ArgumentLoader.ForMethodParameterArrayElement.OfInvokedMethod |
An argument loader factory that loads an array element from a parameter for each argument of the invoked method.
|
| MethodCall.ArgumentLoader.ForMethodParameterArrayElement.OfParameter |
Creates an argument loader for an array element that of a specific parameter.
|
| MethodCall.ArgumentLoader.ForNullConstant |
An argument loader that loads the null value onto the operand stack.
|
| MethodCall.ArgumentLoader.ForStackManipulation |
Loads a stack manipulation resulting in a specific type as an argument.
|
| MethodCall.ArgumentLoader.ForThisReference |
An argument loader that assigns the this reference to a parameter.
|
| MethodCall.ArgumentLoader.ForThisReference.Factory |
A factory for an argument loader that supplies the this value as an argument.
|
| MethodCall.MethodInvoker |
A method invoker is responsible for creating a method invocation that is to be applied by a
MethodCall. |
| MethodCall.MethodInvoker.ForContextualInvocation |
Applies a contextual invocation of the provided method, i.e.
|
| MethodCall.MethodInvoker.ForDefaultMethodInvocation |
Invokes a method as a Java 8 default method.
|
| MethodCall.MethodInvoker.ForSuperMethodInvocation |
Applies a super method invocation of the provided method.
|
| MethodCall.MethodInvoker.ForVirtualInvocation |
Applies a virtual invocation on a given type.
|
| MethodCall.MethodInvoker.ForVirtualInvocation.WithImplicitType |
A method invoker for a virtual method that uses an implicit target type.
|
| MethodCall.MethodLocator |
A method locator is responsible for identifying the method that is to be invoked
by a MethodCall. |
| MethodCall.MethodLocator.ForElementMatcher |
A method locator that identifies a unique virtual method.
|
| MethodCall.MethodLocator.ForExplicitMethod |
Invokes a given method.
|
| MethodCall.MethodLocator.ForInstrumentedMethod |
A method locator that simply returns the intercepted method.
|
| MethodCall.TargetHandler |
A target handler is responsible for invoking a method for a
MethodCall. |
| MethodCall.TargetHandler.ForConstructingInvocation |
Invokes a method in order to construct a new instance.
|
| MethodCall.TargetHandler.ForField |
Creates a target handler that stores the instance to invoke a method on in an instance field.
|
| MethodCall.TargetHandler.ForMethodParameter |
A target handler that loads the parameter of the given index as the target object.
|
| MethodCall.TargetHandler.ForSelfOrStaticInvocation |
A target handler that invokes a method either on the instance of the instrumented
type or as a static method.
|
| MethodCall.TargetHandler.ForValue |
A target handler that invokes a method on an instance that is stored in a static field.
|
| MethodCall.TerminationHandler |
A termination handler is responsible to handle the return value of a method that is invoked via a
MethodCall. |
| MethodCall.WithoutSpecifiedTarget |
Represents a MethodCall that invokes a method without specifying
an invocation method. |
| 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.
|
| MethodCallProxy.AssignableSignatureCall |
A stack manipulation that creates a MethodCallProxy
for a given method an pushes such an object onto the call stack. |
| MethodCallProxy.ConstructorCall |
|
| MethodCallProxy.ConstructorCall.Appender |
|
| MethodCallProxy.MethodCall |
|
| MethodCallProxy.PrecomputedMethodGraph |
A precomputed method graph that only displays the methods that are relevant for creating a method call proxy.
|
| MethodConstant |
Represents the creation of a Method value which can be created from a given
set of constant pool values and can therefore be considered a constant in the broader meaning.
|
| MethodConstant.CachedConstructor |
|
| MethodConstant.CachedMethod |
|
| MethodConstant.CanCache |
Represents a MethodConstant that is
directly loaded onto the operand stack without caching the value. |
| MethodConstant.CanCacheIllegal |
Represents a method constant that cannot be represented by Java's reflection API.
|
| MethodConstant.ForConstructor |
Creates a MethodConstant for loading
a Constructor instance onto the operand stack. |
| MethodConstant.ForMethod |
Creates a MethodConstant for loading
a Method instance onto the operand stack. |
| 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.
|
| MethodDelegation.Appender |
|
| MethodDelegation.ImplementationDelegate |
An implementation delegate is responsible for executing the actual method delegation and for resolving the target methods.
|
| MethodDelegation.ImplementationDelegate.Compiled |
A compiled implementation delegate.
|
| MethodDelegation.ImplementationDelegate.Compiled.ForConstruction |
A compiled implementation delegate for a constructor delegation.
|
| MethodDelegation.ImplementationDelegate.Compiled.ForField |
A compiled implementation delegate that invokes methods on a field.
|
| MethodDelegation.ImplementationDelegate.Compiled.ForStaticCall |
A compiled implementation delegate for invoking a static method.
|
| MethodDelegation.ImplementationDelegate.ForConstruction |
An implementation delegate for constructing an instance.
|
| MethodDelegation.ImplementationDelegate.ForField |
An implementation delegate for invoking methods on a field that is declared by the instrumented type or a super type.
|
| MethodDelegation.ImplementationDelegate.ForField.WithInstance |
An implementation target for a static field that is declared by the instrumented type and that is assigned an instance.
|
| MethodDelegation.ImplementationDelegate.ForField.WithLookup |
An implementation target for a field that is declared by the instrumented type or a super type.
|
| MethodDelegation.ImplementationDelegate.ForStaticMethod |
An implementation delegate for a static method delegation.
|
| MethodDelegation.WithCustomProperties |
|
| MethodDelegationBinder |
A method delegation binder is responsible for creating a method binding for a source method to a
target method.
|
| MethodDelegationBinder.AmbiguityResolver |
Implementations of this interface are able to attempt the resolution of two successful bindings of a method
to two different target methods in order to identify a dominating binding.
|
| MethodDelegationBinder.AmbiguityResolver.Compound |
|
| MethodDelegationBinder.AmbiguityResolver.Directional |
An ambiguity resolver that always resolves in the specified direction.
|
| MethodDelegationBinder.AmbiguityResolver.NoOp |
An ambiguity resolver that does not attempt to resolve a conflicting binding.
|
| MethodDelegationBinder.AmbiguityResolver.Resolution |
A resolution state of an attempt to resolve two conflicting bindings.
|
| MethodDelegationBinder.BindingResolver |
A binding resolver is responsible to choose a method binding between several possible candidates.
|
| MethodDelegationBinder.BindingResolver.Default |
|
| MethodDelegationBinder.BindingResolver.StreamWriting |
Binds a method using another resolver and prints the selected binding to a PrintStream.
|
| MethodDelegationBinder.BindingResolver.Unique |
A binding resolver that only binds a method if it has a unique binding.
|
| MethodDelegationBinder.MethodBinding |
|
| MethodDelegationBinder.MethodBinding.Builder |
|
| MethodDelegationBinder.MethodBinding.Builder.Build |
|
| MethodDelegationBinder.MethodBinding.Illegal |
Representation of an attempt to bind a source method to a target method that is not applicable.
|
| MethodDelegationBinder.MethodInvoker |
|
| MethodDelegationBinder.MethodInvoker.Simple |
A simple method invocation that merely uses the most general form of method invocation as provided by
MethodInvocation. |
| MethodDelegationBinder.MethodInvoker.Virtual |
A method invocation that enforces a virtual invocation that is dispatched on a given type.
|
| MethodDelegationBinder.ParameterBinding<T> |
A binding attempt for a single parameter.
|
| MethodDelegationBinder.ParameterBinding.Anonymous |
An anonymous binding of a target method parameter.
|
| MethodDelegationBinder.ParameterBinding.Illegal |
A singleton representation of an illegal binding for a method parameter.
|
| MethodDelegationBinder.ParameterBinding.Unique<T> |
A uniquely identifiable parameter binding for a target method.
|
| MethodDelegationBinder.Processor |
|
| MethodDelegationBinder.Record |
A method delegation that was compiled to a target method.
|
| MethodDelegationBinder.Record.Illegal |
A compiled method delegation binder that only yields illegal bindings.
|
| MethodDelegationBinder.TerminationHandler |
A termination handler is responsible for terminating a method delegation.
|
| MethodDelegationBinder.TerminationHandler.Default |
Responsible for creating a StackManipulation
that is applied after the interception method is applied. |
| MethodDescription |
Implementations of this interface describe a Java method, i.e.
|
| MethodDescription.AbstractBase |
An abstract base implementation of a method description.
|
| MethodDescription.ForLoadedConstructor |
An implementation of a method description for a loaded constructor.
|
| MethodDescription.ForLoadedMethod |
An implementation of a method description for a loaded method.
|
| MethodDescription.InDefinedShape |
Represents a method in its defined shape, i.e.
|
| MethodDescription.InDefinedShape.AbstractBase |
An abstract base implementation of a method description in its defined shape.
|
| MethodDescription.InGenericShape |
Represents a method description in its generic shape, i.e.
|
| MethodDescription.Latent |
A latent method description describes a method that is not attached to a declaring
TypeDescription. |
| MethodDescription.Latent.TypeInitializer |
A method description that represents the type initializer.
|
| MethodDescription.SignatureToken |
A token representing a method's name and raw return and parameter types.
|
| MethodDescription.Token |
A token representing a method's properties detached from a type.
|
| MethodDescription.TypeSubstituting |
A method description that represents a given method but with substituted method types.
|
| MethodDescription.TypeToken |
A token representing a method's erased return and parameter types.
|
| MethodExceptionTypeMatcher<T extends MethodDescription> |
An element matcher that matches the exceptions that are declared by a method.
|
| MethodGraph |
A method graph represents a view on a set of methods as they are seen from a given type.
|
| MethodGraph.Compiler |
|
| MethodGraph.Compiler.AbstractBase |
An abstract base implementation of a method graph compiler.
|
| MethodGraph.Compiler.Default<T> |
A default implementation of a method graph.
|
| MethodGraph.Compiler.Default.Harmonizer<S> |
A harmonizer is responsible for creating a token that identifies a method's relevant attributes for considering
two methods of being equal or not.
|
| MethodGraph.Compiler.Default.Harmonizer.ForJavaMethod |
A harmonizer for the Java programming language that identifies a method by its parameter types only.
|
| MethodGraph.Compiler.Default.Harmonizer.ForJavaMethod.Token |
A token that identifies a Java method's type by its parameter types only.
|
| MethodGraph.Compiler.Default.Harmonizer.ForJVMMethod |
A harmonizer for the Java virtual machine's method dispatching rules that identifies a method by its parameter types and return type.
|
| MethodGraph.Compiler.Default.Harmonizer.ForJVMMethod.Token |
A token that identifies a Java method's type by its parameter types and return type.
|
| MethodGraph.Compiler.Default.Key<S> |
A key represents a collection of methods within a method graph to later yield a node representing a collection of methods,
i.e.
|
| MethodGraph.Compiler.Default.Key.Detached |
A detached version of a key that identifies methods by their JVM signature, i.e.
|
| MethodGraph.Compiler.Default.Key.Harmonized<V> |
|
| MethodGraph.Compiler.Default.Key.Store<V> |
A store for collected methods that are identified by keys.
|
| MethodGraph.Compiler.Default.Key.Store.Entry<W> |
An entry of a key store.
|
| MethodGraph.Compiler.Default.Key.Store.Entry.Ambiguous<U> |
An entry representing an ambiguous node resolution.
|
| MethodGraph.Compiler.Default.Key.Store.Entry.Ambiguous.Node |
A node implementation representing an ambiguous method resolution.
|
| MethodGraph.Compiler.Default.Key.Store.Entry.Initial<U> |
An entry in its initial state before registering any method as a representative.
|
| MethodGraph.Compiler.Default.Key.Store.Entry.Resolved<U> |
An entry representing a non-ambiguous node resolution.
|
| MethodGraph.Compiler.Default.Key.Store.Entry.Resolved.Node |
A node implementation representing a non-ambiguous method.
|
| MethodGraph.Compiler.Default.Key.Store.Graph |
A graph implementation based on a key store.
|
| MethodGraph.Compiler.Default.Merger |
Implementations are responsible for identifying a representative method for a MethodGraph.Node
between several ambiguously resolved methods. |
| MethodGraph.Compiler.Default.Merger.Directional |
A directional merger that always returns either the left or right method description.
|
| MethodGraph.Compiler.ForDeclaredMethods |
A flat compiler that simply returns the methods that are declared by the instrumented type.
|
| MethodGraph.Empty |
A canonical implementation of an empty method graph.
|
| MethodGraph.Linked |
A linked method graph represents a view that additionally exposes information of a given type's super type view and a
view on this graph's directly implemented interfaces.
|
| MethodGraph.Linked.Delegation |
A simple implementation of a linked method graph that exposes views by delegation to given method graphs.
|
| MethodGraph.Node |
Represents a node within a method graph.
|
| MethodGraph.Node.Simple |
A simple implementation of a resolved node of a method without bridges.
|
| MethodGraph.Node.Sort |
|
| MethodGraph.Node.Unresolved |
A canonical implementation of an unresolved node.
|
| MethodGraph.NodeList |
A list of nodes.
|
| MethodGraph.Simple |
A simple implementation of a method graph.
|
| MethodInvocation |
A builder for a method invocation.
|
| MethodInvocation.HandleInvocation |
Performs a method invocation on a method handle with a polymorphic type signature.
|
| MethodInvocation.HandleType |
The type of method handle invocation.
|
| MethodInvocation.IllegalInvocation |
An illegal implicit method invocation.
|
| MethodInvocation.OfGenericMethod |
A method invocation of a generically resolved method.
|
| MethodInvocation.WithImplicitInvocationTargetType |
Represents a method invocation where the invocation type (static, virtual, special, interface) is derived
from the given method's description.
|
| MethodList<T extends MethodDescription> |
Implementations represent a list of method descriptions.
|
| MethodList.AbstractBase<S extends MethodDescription> |
|
| MethodList.Empty<S extends MethodDescription> |
An implementation of an empty method list.
|
| MethodList.Explicit<S extends MethodDescription> |
A method list that is a wrapper for a given list of method descriptions.
|
| MethodList.ForLoadedMethods |
A method list implementation that returns all loaded byte code methods (methods and constructors) that
are declared for a given type.
|
| MethodList.ForTokens |
A list of method descriptions for a list of detached tokens.
|
| MethodList.TypeSubstituting |
|
| MethodManifestation |
Describes the manifestation of a method, i.e.
|
| MethodNameEqualityResolver |
|
| MethodNameTransformer |
A method name transformer provides a unique mapping of a method's name to an alternative name.
|
| MethodNameTransformer.Prefixing |
A method name transformer that adds a fixed prefix to an original method name.
|
| MethodNameTransformer.Suffixing |
A method name transformer that adds a fixed suffix to an original method name, separated by a $.
|
| 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.
|
| MethodParametersMatcher<T extends MethodDescription> |
An element matcher that matches a method's parameters.
|
| MethodParameterTypeMatcher<T extends ParameterDescription> |
An element matcher that matches a method's parameter's type.
|
| MethodParameterTypesMatcher<T extends ParameterList<?>> |
An element matcher that matches a method's parameter types.
|
| MethodRebaseResolver |
A method rebase resolver is responsible for mapping methods of an instrumented type to an alternative signature.
|
| MethodRebaseResolver.Default |
A default implementation of a method rebase resolver.
|
| MethodRebaseResolver.Disabled |
A method rebase resolver that preserves any method in its original form.
|
| MethodRebaseResolver.Resolution |
|
| MethodRebaseResolver.Resolution.ForRebasedConstructor |
|
| MethodRebaseResolver.Resolution.ForRebasedConstructor.RebasedConstructor |
An description of a rebased constructor.
|
| MethodRebaseResolver.Resolution.ForRebasedMethod |
|
| MethodRebaseResolver.Resolution.ForRebasedMethod.RebasedMethod |
A description of a rebased method.
|
| MethodRebaseResolver.Resolution.Preserved |
|
| MethodRegistry |
A method registry is responsible for storing information on how a method is intercepted.
|
| MethodRegistry.Compiled |
A compiled version of a method registry.
|
| MethodRegistry.Default |
A default implementation of a method registry.
|
| MethodRegistry.Default.Compiled |
A compiled version of a default method registry.
|
| MethodRegistry.Default.Compiled.Entry |
An entry of a compiled method registry.
|
| MethodRegistry.Default.Entry |
An entry of a default method registry.
|
| MethodRegistry.Default.Prepared |
A prepared version of a default method registry.
|
| MethodRegistry.Default.Prepared.Entry |
An entry of a prepared method registry.
|
| MethodRegistry.Handler |
A handler for implementing a method.
|
| MethodRegistry.Handler.Compiled |
A compiled handler for implementing a method.
|
| MethodRegistry.Handler.ForAbstractMethod |
A handler for defining an abstract or native method.
|
| MethodRegistry.Handler.ForAnnotationValue |
A handler for defining a default annotation value for a method.
|
| MethodRegistry.Handler.ForImplementation |
A handler for a method that is implemented as byte code.
|
| MethodRegistry.Handler.ForImplementation.Compiled |
A compiled handler for implementing a method.
|
| MethodRegistry.Handler.ForVisibilityBridge |
A handler for implementing a visibility bridge.
|
| MethodRegistry.Handler.ForVisibilityBridge.Compiled |
A compiled handler for a visibility bridge handler.
|
| MethodRegistry.Prepared |
A method registry that fully prepared the instrumented type.
|
| MethodReturn |
A stack manipulation returning a value of a given type.
|
| MethodReturnTypeMatcher<T extends MethodDescription> |
An element matcher that matches its argument's return type against a given type matcher.
|
| MethodSortMatcher<T extends MethodDescription> |
Matches a method description by its general characteristics which are represented as a
MethodSortMatcher.Sort. |
| MethodSortMatcher.Sort |
Represents a specific characteristic of a method description.
|
| MethodStrictness |
A modifier contributor to determine the use of strictfp on a method.
|
| MethodVariableAccess |
A stack assignment that loads a method variable from a given index of the local variable array.
|
| MethodVariableAccess.MethodLoading |
A stack manipulation that loads all parameters of a given method onto the operand stack.
|
| MethodVariableAccess.MethodLoading.TypeCastingHandler |
A type casting handler allows a type transformation of all arguments of a method after loading them onto the operand stack.
|
| 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.
|
| MethodVariableAccess.MethodLoading.TypeCastingHandler.NoOp |
A non-operative type casting handler.
|
| MethodVariableAccess.OffsetIncrementing |
A stack manipulation that increments an integer variable.
|
| ModifierAdjustment |
A visitor wrapper that adjusts the modifiers of the instrumented type or its members.
|
| ModifierAdjustment.Adjustment<T> |
A description of a conditional adjustment.
|
| ModifierAdjustment.ModifierAdjustingClassVisitor |
A class visitor that enforces a collection of modifier adjustments.
|
| ModifierContributor |
An element that describes a type modifier as described in the
JVMS. |
| ModifierContributor.ForField |
A marker interface for modifiers that can be applied to fields.
|
| ModifierContributor.ForMethod |
A marker interface for modifiers that can be applied to methods.
|
| ModifierContributor.ForParameter |
A marker interface for modifiers that can be applied to method parameters.
|
| ModifierContributor.ForType |
A marker interface for modifiers that can be applied to types.
|
| ModifierContributor.Resolver<T extends ModifierContributor> |
|
| ModifierMatcher<T extends ModifierReviewable> |
An element matcher that matches a byte code element by its modifiers.
|
| ModifierMatcher.Mode |
|
| ModifierReviewable |
Implementations of this interface can be described in terms of a Java modifier.
|
| ModifierReviewable.AbstractBase |
|
| ModifierReviewable.ForFieldDescription |
|
| ModifierReviewable.ForMethodDescription |
|
| ModifierReviewable.ForParameterDescription |
|
| ModifierReviewable.ForTypeDefinition |
|
| ModifierReviewable.OfAbstraction |
A modifier reviewable for a byte code element that can be abstract, i.e.
|
| ModifierReviewable.OfByteCodeElement |
|
| ModifierReviewable.OfEnumeration |
A modifier reviewable for a byte code element that can represent an enumeration, i.e.
|
| Morph |
This annotation instructs Byte Buddy to inject a proxy class that calls a method's super method with
explicit arguments.
|
| Morph.Binder |
A binder for the Morph annotation. |
| Morph.Binder.DefaultMethodLocator |
A default method locator is responsible for looking up a default method to a given source method.
|
| Morph.Binder.DefaultMethodLocator.Explicit |
An explicit default method locator attempts to look up a default method in the specified interface type.
|
| Morph.Binder.DefaultMethodLocator.Implicit |
An implicit default method locator that only permits the invocation of a default method if the source
method itself represents a method that was defined on a default method interface.
|
| Morph.Binder.RedirectionProxy |
A proxy that implements the installed interface in order to allow for a morphed super method invocation.
|
| Morph.Binder.RedirectionProxy.InstanceFieldConstructor |
Creates an instance of the proxy when instrumenting an instance method.
|
| Morph.Binder.RedirectionProxy.InstanceFieldConstructor.Appender |
The byte code appender that implements the constructor.
|
| Morph.Binder.RedirectionProxy.MethodCall |
Implements a the method call of the morphing method.
|
| Morph.Binder.RedirectionProxy.StaticFieldConstructor |
Creates an instance of the proxy when instrumenting a static method.
|
| MultipleParentClassLoader |
This ClassLoader is capable of loading classes from multiple parents.
|
| MultipleParentClassLoader.Builder |
A builder to collect class loader and that creates a
MultipleParentClassLoader only if multiple or no
ClassLoaders are found in the process. |
| MultipleParentClassLoader.CompoundEnumeration |
A compound URL enumeration.
|
| Multiplication |
A stack manipulation that multiplies to numbers on the operand stack.
|
| NamedElement |
Represents a Java element with a name.
|
| NamedElement.WithGenericName |
A named element with a generic type name.
|
| NamedElement.WithOptionalName |
Describes a named element where naming the element is optional and an alternative default name is provided if no explicit name is given.
|
| NamedElement.WithRuntimeName |
A named element with a name that has a particular meaning to the Java runtime.
|
| 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 dots to their outer class's source name.
Constructors and the type initializer methods are represented by the empty string as they do not
represent a source code name.
Fields are named as in the source code.
|
| NamingStrategy |
A naming strategy for determining a fully qualified name for a dynamically created Java type.
|
| NamingStrategy.AbstractBase |
An abstract base implementation where the names of redefined and rebased types are retained.
|
| 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.
|
| 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.
|
| NamingStrategy.SuffixingRandom.BaseNameResolver |
A base name resolver is responsible for resolving a name onto which the suffix is appended.
|
| NamingStrategy.SuffixingRandom.BaseNameResolver.ForFixedValue |
A base name resolver that simply returns a fixed value.
|
| NamingStrategy.SuffixingRandom.BaseNameResolver.ForGivenType |
Uses a specific type's name as the resolved name.
|
| NamingStrategy.SuffixingRandom.BaseNameResolver.ForUnnamedType |
Uses the unnamed type's super type's name as the resolved name.
|
| NegatingMatcher<T> |
An element matcher that reverses the matching result of another matcher.
|
| Nexus |
|
| 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. |
| NexusAccessor.Dispatcher |
A dispatcher for registering type initializers in the Nexus. |
| NexusAccessor.Dispatcher.Available |
An enabled dispatcher for registering a type initializer in a Nexus. |
| NexusAccessor.Dispatcher.CreationAction |
Creates a new dispatcher for accessing a Nexus. |
| NexusAccessor.Dispatcher.Unavailable |
A disabled dispatcher where a Nexus is not available. |
| NexusAccessor.InitializationAppender |
An initialization appender that looks up a loaded type initializer from Byte Buddy's Nexus. |
| NoOpClassFileTransformer |
A class file transformer that does not apply a transformation.
|
| NullConstant |
Represents a stack manipulation to load a null pointer onto the operand stack.
|
| NullMatcher<T> |
An element matcher that matches the null value.
|
| Origin |
The origin annotation provides some meta information about the source method that is bound to this method where
the binding is dependant of the parameter's type:
|
| Origin.Binder |
A binder for binding parameters that are annotated with
Origin. |
| Ownership |
Determines the ownership of a field or method, i.e.
|
| PackageDefinitionStrategy |
A package definer is responsible for defining a package's properties when a class of a new package is loaded.
|
| PackageDefinitionStrategy.Definition |
A definition of a package.
|
| PackageDefinitionStrategy.Definition.Simple |
A simple package definition where any property is represented by a value.
|
| PackageDefinitionStrategy.Definition.Trivial |
A package definer that defines packages without any meta data.
|
| PackageDefinitionStrategy.Definition.Undefined |
A canonical implementation of an undefined package.
|
| PackageDefinitionStrategy.ManifestReading |
A package definer that reads a class loader's manifest file.
|
| PackageDefinitionStrategy.ManifestReading.SealBaseLocator |
A locator for a seal base URL.
|
| PackageDefinitionStrategy.ManifestReading.SealBaseLocator.ForFixedValue |
A seal base locator that seals all packages with a fixed URL.
|
| PackageDefinitionStrategy.ManifestReading.SealBaseLocator.ForTypeResourceUrl |
A seal base locator that imitates the behavior of a URLClassLoader, i.e.
|
| PackageDefinitionStrategy.ManifestReading.SealBaseLocator.NonSealing |
A seal base locator that never seals a package.
|
| PackageDefinitionStrategy.NoOp |
A package definer that does not define any package.
|
| PackageDefinitionStrategy.Trivial |
A package definer that only defines packages without any meta data.
|
| PackageDescription |
A package description represents a Java package.
|
| PackageDescription.AbstractBase |
An abstract base implementation of a package description.
|
| PackageDescription.ForLoadedPackage |
|
| PackageDescription.Simple |
A simple implementation of a package without annotations.
|
| ParameterDescription |
Description of the parameter of a Java method or constructor.
|
| ParameterDescription.AbstractBase |
A base implementation of a method parameter description.
|
| ParameterDescription.ForLoadedParameter<T extends java.lang.reflect.AccessibleObject> |
Description of a loaded parameter with support for the information exposed by java.lang.reflect.Parameter.
|
| ParameterDescription.ForLoadedParameter.Dispatcher |
A dispatcher creating parameter descriptions based on the API that is available for the current JVM.
|
| ParameterDescription.ForLoadedParameter.Dispatcher.CreationAction |
A creation action for a dispatcher.
|
| ParameterDescription.ForLoadedParameter.Dispatcher.ForJava8CapableVm |
A dispatcher for VMs that support the java.lang.reflect.Parameter API for Java 8+.
|
| ParameterDescription.ForLoadedParameter.Dispatcher.ForLegacyVm |
A dispatcher for a legacy VM that does not know the java.lang.reflect.Parameter type that only throws
exceptions on any property extraction.
|
| ParameterDescription.ForLoadedParameter.OfConstructor |
A description of a loaded Constructor parameter for a modern VM.
|
| ParameterDescription.ForLoadedParameter.OfLegacyVmConstructor |
Description of a loaded constructor's parameter on a virtual machine where java.lang.reflect.Parameter
is not available.
|
| ParameterDescription.ForLoadedParameter.OfLegacyVmMethod |
Description of a loaded method's parameter on a virtual machine where java.lang.reflect.Parameter
is not available.
|
| ParameterDescription.ForLoadedParameter.OfMethod |
A description of a loaded Method parameter for a modern VM.
|
| ParameterDescription.InDefinedShape |
Represents a parameter in its defined shape, i.e.
|
| ParameterDescription.InDefinedShape.AbstractBase |
An abstract base implementation of a parameter description in its defined shape.
|
| ParameterDescription.InGenericShape |
Represents a parameter description in its generic shape, i.e.
|
| ParameterDescription.Latent |
A latent description of a parameter that is not attached to a method or constructor.
|
| ParameterDescription.Token |
A token representing a parameter's properties detached from a type.
|
| ParameterDescription.Token.TypeList |
A list of types represented as a list of parameter tokens.
|
| ParameterDescription.TypeSubstituting |
A parameter description that represents a given parameter but with a substituted parameter type.
|
| ParameterLengthResolver |
|
| ParameterList<T extends ParameterDescription> |
Represents a list of parameters of a method or a constructor.
|
| ParameterList.AbstractBase<S extends ParameterDescription> |
|
| ParameterList.Empty<S extends ParameterDescription> |
An empty list of parameters.
|
| ParameterList.Explicit<S extends ParameterDescription> |
A list of explicitly provided parameter descriptions.
|
| ParameterList.Explicit.ForTypes |
A parameter list representing parameters without meta data or annotations.
|
| ParameterList.ForLoadedExecutable<T> |
Represents a list of parameters for an executable, i.e.
|
| ParameterList.ForLoadedExecutable.Dispatcher |
A dispatcher for creating descriptions of parameter lists and for evaluating the size of an java.lang.reflect.Executable's parameters.
|
| ParameterList.ForLoadedExecutable.Dispatcher.CreationAction |
A creation action for a dispatcher.
|
| ParameterList.ForLoadedExecutable.Dispatcher.ForJava8CapableVm |
A dispatcher for a legacy VM that does support the java.lang.reflect.Parameter type.
|
| ParameterList.ForLoadedExecutable.Dispatcher.ForLegacyVm |
A dispatcher for a legacy VM that does not support the java.lang.reflect.Parameter type.
|
| ParameterList.ForLoadedExecutable.OfConstructor |
Describes the list of Constructor parameters on a modern VM.
|
| ParameterList.ForLoadedExecutable.OfLegacyVmConstructor |
Represents a list of constructor parameters on virtual machines where the java.lang.reflect.Parameter
type is not available.
|
| ParameterList.ForLoadedExecutable.OfLegacyVmMethod |
Represents a list of method parameters on virtual machines where the java.lang.reflect.Parameter
type is not available.
|
| ParameterList.ForLoadedExecutable.OfMethod |
Describes the list of Method parameters on a modern VM.
|
| ParameterList.ForTokens |
A list of parameter descriptions for a list of detached tokens.
|
| ParameterList.TypeSubstituting |
|
| ParameterManifestation |
Indicates whether a parameter was denoted as final or not.
|
| Pipe |
A target method parameter that is annotated with this annotation allows to forward an intercepted method
invocation to another instance.
|
| Pipe.Binder |
|
| Pipe.Binder.Redirection |
An auxiliary type for performing the redirection of a method invocation as requested by the
Pipe annotation. |
| Pipe.Binder.Redirection.ConstructorCall |
|
| Pipe.Binder.Redirection.MethodCall |
|
| Plugin |
A plugin that allows for the application of Byte Buddy transformations during a build process.
|
| PrimitiveBoxingDelegate |
This delegate is responsible for boxing a primitive types to their wrapper equivalents.
|
| PrimitiveTypeAwareAssigner |
This assigner is able to handle non-void, primitive types.
|
| PrimitiveUnboxingDelegate |
This delegate is responsible for unboxing a wrapper type to their primitive equivalents.
|
| PrimitiveUnboxingDelegate.ExplicitlyTypedUnboxingResponsible |
An explicitly types unboxing responsible is applied for directly unboxing a wrapper type.
|
| PrimitiveUnboxingDelegate.ImplicitlyTypedUnboxingResponsible |
An unboxing responsible for an implicitly typed value.
|
| PrimitiveUnboxingDelegate.UnboxingResponsible |
Implementations represent an unboxing delegate that is able to perform the unboxing operation.
|
| PrimitiveWideningDelegate |
This delegate is responsible for widening a primitive type to represent a larger primitive type.
|
| PrimitiveWideningDelegate.WideningStackManipulation |
A stack manipulation that widens a primitive type into a more general primitive type.
|
| ProvisioningState |
Describes if a method parameter is mandated, i.e.
|
| RandomString |
A provider of randomized String values.
|
| RebaseDynamicTypeBuilder<T> |
A type builder that rebases an instrumented type.
|
| RebaseDynamicTypeBuilder.RebaseableMatcher |
A matcher that filters any method that should not be rebased, i.e.
|
| RebaseImplementationTarget |
An implementation target for redefining a given type while preserving the original methods within the
instrumented type.
|
| RebaseImplementationTarget.Factory |
|
| RebaseImplementationTarget.RebasedMethodInvocation |
|
| RedefinitionDynamicTypeBuilder<T> |
A type builder that redefines an instrumented type.
|
| ReferenceTypeAwareAssigner |
A simple assigner that is capable of handling the casting of reference types.
|
| Removal |
Removes a value from the operand stack.
|
| ResettableClassFileTransformer |
A class file transformer that can reset its transformation.
|
| ResettableClassFileTransformer.AbstractBase |
|
| RuntimeType |
Parameters that are annotated with this annotation will be assigned by also considering the runtime type of the
target parameter.
|
| RuntimeType.Verifier |
A non-instantiable type that allows to check if a method or parameter should consider a runtime type.
|
| SerializedConstant |
A constant that represents a value in its serialized form.
|
| SetAccessibleAction<T extends java.lang.reflect.AccessibleObject> |
An action for making an AccessibleObject accessible.
|
| SignatureTokenMatcher<T extends MethodDescription> |
Matches a method description's signature token against another matcher.
|
| StackAwareMethodVisitor |
A method visitor that is aware of the current size of the operand stack at all times.
|
| StackManipulation |
Describes a manipulation of a method's operand stack that does not affect the frame's variable array.
|
| StackManipulation.Compound |
An immutable stack manipulation that aggregates a sequence of other stack manipulations.
|
| StackManipulation.Illegal |
Canonical representation of an illegal stack manipulation.
|
| StackManipulation.Size |
|
| StackManipulation.Trivial |
Canonical representation of a legal stack manipulation which does not require any action.
|
| StackSize |
Represents the size of a Java type on the operand stack.
|
| StreamDrainer |
A utility for draining the contents of an InputStream into a byte array.
|
| StringMatcher |
An element matcher that compares two strings by a given pattern which is characterized by a
StringMatcher.Mode. |
| StringMatcher.Mode |
|
| StubMethod |
This implementation creates a method stub which does nothing but returning the default value of the return
type of the method.
|
| StubValue |
A stub value represents the (boxed) default value of the intercepted method's return type.
|
| StubValue.Binder |
|
| SubclassDynamicTypeBuilder<T> |
A type builder that creates an instrumented type as a subclass, i.e.
|
| SubclassDynamicTypeBuilder.InstrumentableMatcher |
A matcher that locates all methods that are overridable and not ignored or that are directly defined on the instrumented type.
|
| SubclassImplementationTarget |
An implementation target for creating a subclass of a given type.
|
| SubclassImplementationTarget.Factory |
|
| SubclassImplementationTarget.OriginTypeResolver |
|
| SubTypeMatcher<T extends TypeDescription> |
An element matcher that matches its argument for being another type's subtype.
|
| Super |
Parameters that are annotated with this annotation are assigned an instance of an auxiliary proxy type that allows calling
any super methods of the instrumented type where the parameter type must be a super type of the instrumented type.
|
| Super.Binder |
A binder for handling the
Super
annotation. |
| Super.Binder.TypeLocator |
Locates the type which should be the base type of the created proxy.
|
| Super.Binder.TypeLocator.ForInstrumentedType |
A type locator that yields the instrumented type.
|
| Super.Binder.TypeLocator.ForParameterType |
A type locator that yields the target parameter's type.
|
| Super.Binder.TypeLocator.ForType |
A type locator that returns a given type.
|
| Super.Instantiation |
Determines the instantiation of the proxy type.
|
| SuperCall |
Parameters that are annotated with this annotation will be assigned a proxy for calling the instrumented method's
super implementation.
|
| SuperCall.Binder |
A binder for handling the
SuperCall
annotation. |
| SuperMethod |
A parameter with this annotation is assigned an instance of Method which invokes the super implementation of this method.
|
| SuperMethod.Binder |
|
| SuperMethod.Binder.DelegationMethod |
Loads the delegation method constant onto the stack.
|
| SuperMethodCall |
This implementation will create a new method which simply calls its super method.
|
| SuperMethodCall.Appender |
|
| SuperMethodCall.Appender.TerminationHandler |
A handler that determines how to handle the method return value.
|
| SuperMethodCall.WithoutReturn |
A super method invocation where the return value is dropped instead of returning from the method.
|
| SuperTypeMatcher<T extends TypeDescription> |
An element matcher that matches its argument for being another type's super type.
|
| SynchronizationState |
Describes if a method is supposed to be synchronized.
|
| SyntheticState |
Defines if a type or member is supposed to be marked as synthetic.
|
| TargetMethodAnnotationDrivenBinder |
This MethodDelegationBinder binds
method by analyzing annotations found on the target method that is subject to a method binding. |
| TargetMethodAnnotationDrivenBinder.DelegationProcessor |
|
| TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler |
A handler is responsible for processing a parameter's binding.
|
| TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Bound<T extends java.lang.annotation.Annotation> |
A bound handler represents an unambiguous parameter binder that was located for a given array of
annotations.
|
| 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.
|
| TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Unbound.DefaultArgument |
A default implementation of an Argument annotation. |
| TargetMethodAnnotationDrivenBinder.ParameterBinder<T extends java.lang.annotation.Annotation> |
A parameter binder is used as a delegate for binding a parameter according to a particular annotation type found
on this parameter.
|
| TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFieldBinding<S extends java.lang.annotation.Annotation> |
A parameter binder that binds a field's value.
|
| TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFixedValue<S extends java.lang.annotation.Annotation> |
Implements a parameter binder that binds a fixed value to a parameter with a given annotation.
|
| TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFixedValue.OfConstant<U extends java.lang.annotation.Annotation> |
A parameter binder that binds a fixed value to a parameter annotation when using a MethodDelegation. |
| TargetMethodAnnotationDrivenBinder.Record |
A compiled record of a target method annotation-driven binder.
|
| TargetType |
This type is used as a place holder for creating methods or fields that refer to the type that currently subject
of creation within a DynamicType.Builder. |
| TextConstant |
Represents a String value that is stored in a type's constant pool.
|
| This |
Parameters that are annotated with this annotation will be assigned a reference to the instrumented object, if
the instrumented method is not static.
|
| This.Binder |
A binder for handling the
This
annotation. |
| Throw |
Throws a Throwable which must lie on top of the stack when this stack manipulation is called.
|
| ToStringMethod |
An implementation of Object.toString() that concatenates the String representation of all fields that are declared by a class.
|
| ToStringMethod.Appender |
|
| ToStringMethod.PrefixResolver |
A prefix resolver is responsible for providing a value that is preprended to a Object.toString() implementation.
|
| ToStringMethod.PrefixResolver.Default |
Default implementations for a prefix resolver.
|
| ToStringMethod.PrefixResolver.ForFixedValue |
A prefix resolver that returns a fixed value.
|
| ToStringMethod.ValueConsumer |
A value consumer that is responsible for adding a field value to the string creating StringBuilder.
|
| 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. |
| ToStringPlugin.Enhance |
Instructs the ToStringPlugin to generate a Object.toString() method for the annotated class unless this method
is already declared explicitly. |
| ToStringPlugin.Enhance.Prefix |
A strategy for defining a prefix.
|
| ToStringPlugin.Exclude |
Determines that the annotated field is excluded from a string representation of the ToStringPlugin. |
| Transformation |
A transformation specification to apply during the plugin's execution.
|
| Transformer<T> |
A transformer is responsible for transforming an object into a compatible instance of the same type.
|
| Transformer.Compound<S> |
A compound transformer.
|
| Transformer.ForField |
|
| Transformer.ForField.FieldModifierTransformer |
A transformer for a field's modifiers.
|
| Transformer.ForField.TransformedField |
An implementation of a transformed field.
|
| Transformer.ForMethod |
|
| Transformer.ForMethod.MethodModifierTransformer |
A transformer for a method's modifiers.
|
| Transformer.ForMethod.TransformedMethod |
The transformed method.
|
| Transformer.NoOp |
A non-operational transformer that returns the received instance.
|
| TrivialType |
A trivial type that extends Object without defining any fields, methods or constructors.
|
| TypeAttributeAppender |
An appender that writes attributes or annotations to a given ASM ClassVisitor.
|
| TypeAttributeAppender.Compound |
A compound type attribute appender that concatenates a number of other attribute appenders.
|
| TypeAttributeAppender.Explicit |
An attribute appender that appends a single annotation to a given type.
|
| TypeAttributeAppender.ForInstrumentedType |
An attribute appender that writes all annotations that are found on a given target type to the
instrumented type this type attribute appender is applied onto.
|
| TypeAttributeAppender.ForInstrumentedType.Differentiating |
A type attribute appender that writes all annotations of the instrumented but excludes annotations up to
a given index.
|
| TypeAttributeAppender.NoOp |
A type attribute appender that does not append any attributes.
|
| TypeCache<T> |
A cache for storing types without strongly referencing any class loader or type.
|
| TypeCache.LookupKey |
A key used for looking up a previously inserted class loader cache.
|
| TypeCache.SimpleKey |
A simple key based on a collection of types where no type is strongly referenced.
|
| TypeCache.Sort |
Determines the storage format for a cached type.
|
| TypeCache.StorageKey |
A key used for storing a class loader cache reference.
|
| TypeCache.WithInlineExpunction<S> |
An implementation of a TypeCache where obsolete references are cleared upon any call. |
| TypeCasting |
A stack manipulation for a type down casting.
|
| TypeConstantAdjustment |
This class visitor wrapper ensures that class files of a version previous to Java 5 do not store class entries in the generated class's constant pool.
|
| TypeConstantAdjustment.TypeConstantDissolvingClassVisitor |
A class visitor that checks a class file version for its support of storing class constants in the constant pool and remaps such constants
on discovery if that is not the case.
|
| TypeConstantAdjustment.TypeConstantDissolvingClassVisitor.TypeConstantDissolvingMethodVisitor |
A method visitor that remaps class constants to invocations of Class.forName(String).
|
| TypeCreation |
A stack manipulation for creating an undefined type on which a constructor is to be called.
|
| TypeDefinition |
|
| TypeDefinition.Sort |
|
| TypeDefinition.SuperClassIterator |
An iterator that iterates over a type's class hierarchy.
|
| TypeDescription |
Implementations of this interface represent a Java type, i.e.
|
| TypeDescription.AbstractBase |
An abstract base implementation of a type description.
|
| TypeDescription.AbstractBase.OfSimpleType |
An adapter implementation of a TypeDescription that
describes any type that is not an array or a primitive type. |
| TypeDescription.AbstractBase.OfSimpleType.WithDelegation |
An implementation of a type description that delegates all properties but the type's name to a delegate.
|
| TypeDescription.ArrayProjection |
|
| TypeDescription.ForLoadedType |
A type description implementation that represents a loaded type.
|
| TypeDescription.ForPackageDescription |
A type representation of a package description.
|
| TypeDescription.Generic |
Represents a generic type of the Java programming language.
|
| TypeDescription.Generic.AbstractBase |
An abstract base implementation of a generic type description.
|
| TypeDescription.Generic.AnnotationReader |
An annotation reader is responsible for lazily evaluating type annotations if this language
feature is available on the current JVM.
|
| TypeDescription.Generic.AnnotationReader.Delegator |
A delegating annotation reader that delegates all invocations to an annotation reader that wraps the previous one.
|
| TypeDescription.Generic.AnnotationReader.Delegator.Chained |
A chained delegator that bases its result on an underlying annotation reader.
|
| TypeDescription.Generic.AnnotationReader.Dispatcher |
A dispatcher that represents the type annotation API via reflective calls if the language feature is available on the current JVM.
|
| TypeDescription.Generic.AnnotationReader.Dispatcher.CreationAction |
A creation action for a dispatcher.
|
| TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm |
A dispatcher for a modern JVM that supports type annotations.
|
| TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm.AnnotatedTypeVariableType |
A delegating annotation reader for an annotated type variable.
|
| TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm.Resolved |
A delegator for an existing java.lang.reflect.Annotatedelement.
|
| TypeDescription.Generic.AnnotationReader.Dispatcher.ForLegacyVm |
|
| TypeDescription.Generic.AnnotationReader.ForComponentType |
A chained annotation reader for reading a component type.
|
| TypeDescription.Generic.AnnotationReader.ForOwnerType |
A chained annotation reader for reading an owner type.
|
| TypeDescription.Generic.AnnotationReader.ForTypeArgument |
A chained annotation reader for reading a parameterized type's type argument.
|
| TypeDescription.Generic.AnnotationReader.ForTypeVariableBoundType |
A chained annotation reader for reading a type variable's type argument.
|
| TypeDescription.Generic.AnnotationReader.ForTypeVariableBoundType.OfFormalTypeVariable |
A chained annotation reader for reading a formal type variable's type argument.
|
| TypeDescription.Generic.AnnotationReader.ForWildcardLowerBoundType |
A chained annotation reader for reading a wildcard type's lower bound type.
|
| TypeDescription.Generic.AnnotationReader.ForWildcardUpperBoundType |
A chained annotation reader for reading a wildcard type's upper bound type.
|
| TypeDescription.Generic.AnnotationReader.NoOp |
A non-operational annotation reader.
|
| TypeDescription.Generic.Builder |
|
| TypeDescription.Generic.Builder.OfGenericArrayType |
A generic type builder building a generic array type.
|
| TypeDescription.Generic.Builder.OfNonGenericType |
A generic type builder for building a non-generic type.
|
| TypeDescription.Generic.Builder.OfParameterizedType |
A generic type builder for building a parameterized type.
|
| TypeDescription.Generic.Builder.OfTypeVariable |
A generic type builder building a symbolic type variable.
|
| TypeDescription.Generic.LazyProjection |
A lazy projection of a generic type.
|
| TypeDescription.Generic.LazyProjection.ForLoadedFieldType |
A lazy projection of a field's type.
|
| TypeDescription.Generic.LazyProjection.ForLoadedReturnType |
A lazy projection of a method's generic return type.
|
| TypeDescription.Generic.LazyProjection.ForLoadedSuperClass |
A lazy projection of a generic super type.
|
| TypeDescription.Generic.LazyProjection.OfConstructorParameter |
A lazy projection of the parameter type of a Constructor.
|
| TypeDescription.Generic.LazyProjection.OfMethodParameter |
A lazy projection of the parameter type of a Method.
|
| TypeDescription.Generic.LazyProjection.WithEagerNavigation |
A lazy projection of a type that resolves super class and interface types eagerly.
|
| TypeDescription.Generic.LazyProjection.WithEagerNavigation.OfAnnotatedElement |
A description of an annotated lazy type with eager navigation.
|
| TypeDescription.Generic.LazyProjection.WithLazyNavigation |
A lazy projection of a type with a lazy resolution of super class and interface types.
|
| TypeDescription.Generic.LazyProjection.WithLazyNavigation.LazyInterfaceList |
A lazy representation of a lazy projection's interfaces.
|
| TypeDescription.Generic.LazyProjection.WithLazyNavigation.LazyInterfaceType |
A lazy interface type description for a lazy projection.
|
| TypeDescription.Generic.LazyProjection.WithLazyNavigation.LazySuperClass |
A lazy super class description for a lazy projection.
|
| TypeDescription.Generic.LazyProjection.WithLazyNavigation.OfAnnotatedElement |
A description of an annotated lazy type with lazy navigation.
|
| TypeDescription.Generic.LazyProjection.WithResolvedErasure |
A lazy projection that applies a visitor only when resolving the generic type but not when reading the erasure.
|
| TypeDescription.Generic.OfGenericArray |
A base implementation of a generic type description that represents a potentially generic array.
|
| TypeDescription.Generic.OfGenericArray.ForLoadedType |
A description of a loaded generic array type.
|
| TypeDescription.Generic.OfGenericArray.Latent |
A latent implementation of a generic array type.
|
| TypeDescription.Generic.OfNonGenericType |
A raw type representation of a non-generic type.
|
| TypeDescription.Generic.OfNonGenericType.ForErasure |
A type description for a type erasure.
|
| TypeDescription.Generic.OfNonGenericType.ForLoadedType |
Represents a non-generic type for a loaded Class.
|
| TypeDescription.Generic.OfNonGenericType.ForReifiedErasure |
A representation of a raw type that preserves its generic super types' generic information with a minimum
but erases all of their members' types.
|
| TypeDescription.Generic.OfNonGenericType.Latent |
A latent description of a non-generic type.
|
| TypeDescription.Generic.OfParameterizedType |
A base implementation of a generic type description that represents a parameterized type.
|
| TypeDescription.Generic.OfParameterizedType.ForGenerifiedErasure |
Represents an erasure as a generic type where all type variables are representing their own arguments.
|
| TypeDescription.Generic.OfParameterizedType.ForLoadedType |
Description of a loaded parameterized type.
|
| TypeDescription.Generic.OfParameterizedType.ForLoadedType.ParameterArgumentTypeList |
A type list that represents a loaded parameterized type's parameter types.
|
| TypeDescription.Generic.OfParameterizedType.ForReifiedType |
A representation of a parameterized type that is a super type of a raw type but preserves the minimal type information
that is required for allowing creating correct erasures for overridden methods.
|
| TypeDescription.Generic.OfParameterizedType.Latent |
A latent description of a parameterized type.
|
| TypeDescription.Generic.OfParameterizedType.RenderingDelegate |
A rendering delegate for resolving a parameterized type's Object.toString() representation.
|
| TypeDescription.Generic.OfTypeVariable |
A base implementation of a generic type description that represents a type variable.
|
| TypeDescription.Generic.OfTypeVariable.ForLoadedType |
Description of a loaded type variable.
|
| TypeDescription.Generic.OfTypeVariable.ForLoadedType.TypeVariableBoundList |
A list of type variable bounds for a loaded TypeVariable that resolves annotations..
|
| TypeDescription.Generic.OfTypeVariable.Symbolic |
Implementation of a symbolic type variable.
|
| TypeDescription.Generic.OfTypeVariable.WithAnnotationOverlay |
A type variable with explicit annotations that replace the annotations that are declared by the provided type variable.
|
| TypeDescription.Generic.OfWildcardType |
A base implementation of a generic type description that represents a wildcard type.
|
| TypeDescription.Generic.OfWildcardType.ForLoadedType |
Description of a loaded wildcard.
|
| TypeDescription.Generic.OfWildcardType.ForLoadedType.WildcardLowerBoundTypeList |
A type list representing an upper-bound type variable's bound types.
|
| TypeDescription.Generic.OfWildcardType.ForLoadedType.WildcardUpperBoundTypeList |
A type list representing an upper-bound type variable's bound types.
|
| TypeDescription.Generic.OfWildcardType.Latent |
A latent description of a wildcard type.
|
| TypeDescription.Generic.Visitor<T> |
|
| TypeDescription.Generic.Visitor.AnnotationStripper |
A visitor that strips all type annotations of all types.
|
| TypeDescription.Generic.Visitor.AnnotationStripper.NonAnnotatedTypeVariable |
Representation of a type variable without annotations.
|
| TypeDescription.Generic.Visitor.Assigner |
A visitor that determines the direct assignability of a type to another generic type.
|
| TypeDescription.Generic.Visitor.Assigner.Dispatcher |
A dispatcher that allows to check if the visited generic type is assignable to the supplied type.
|
| TypeDescription.Generic.Visitor.Assigner.Dispatcher.AbstractBase |
An abstract base implementation of a dispatcher that forwards the decision to a visitor implementation.
|
| TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForGenericArray |
A dispatcher for checking the assignability of a generic array type.
|
| TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForNonGenericType |
A dispatcher for checking the assignability of a non-generic type.
|
| TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType |
A dispatcher for checking the assignability of a parameterized type.
|
| TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType.ParameterAssigner |
An assigner for a parameter of a parameterized type.
|
| TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType.ParameterAssigner.ContravariantBinding |
A dispatcher for an contravariant parameter of a parameterized type, i.e.
|
| TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType.ParameterAssigner.CovariantBinding |
A dispatcher for an covariant parameter of a parameterized type, i.e.
|
| TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType.ParameterAssigner.InvariantBinding |
A dispatcher for an invariant parameter of a parameterized type, i.e.
|
| TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForTypeVariable |
A dispatcher for checking the assignability of a type variable.
|
| TypeDescription.Generic.Visitor.ForRawType |
A visitor that transforms any type into a raw type if declaring type is generified.
|
| TypeDescription.Generic.Visitor.ForSignatureVisitor |
Visits a generic type and appends the discovered type to the supplied signature visitor.
|
| TypeDescription.Generic.Visitor.ForSignatureVisitor.OfTypeArgument |
Visits a parameter while visiting a generic type for delegating discoveries to a signature visitor.
|
| TypeDescription.Generic.Visitor.NoOp |
A non-operational generic type visitor.
|
| TypeDescription.Generic.Visitor.Reducing |
A visitor that reduces a detached generic type to its erasure.
|
| TypeDescription.Generic.Visitor.Reifying |
A visitor that reifies type descriptions if they represent raw types.
|
| TypeDescription.Generic.Visitor.Substitutor |
An abstract implementation of a visitor that substitutes generic types by replacing (nested)
type variables and/or non-generic component types.
|
| 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. |
| TypeDescription.Generic.Visitor.Substitutor.ForDetachment |
A visitor for detaching a type from its declaration context by detaching type variables.
|
| 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. |
| TypeDescription.Generic.Visitor.Substitutor.ForTypeVariableBinding |
A visitor for binding type variables to their values.
|
| TypeDescription.Generic.Visitor.Substitutor.WithoutTypeSubstitution |
|
| TypeDescription.Generic.Visitor.TypeErasing |
A visitor that returns the erasure of any visited type.
|
| TypeDescription.Generic.Visitor.Validator |
A validator for Java types that are defined for a specified type use within a Java class file.
|
| TypeDescription.Generic.Visitor.Validator.ForTypeAnnotations |
A type validator for checking type annotations.
|
| TypeDescription.Latent |
A latent type description for a type without methods or fields.
|
| TypeDescription.SuperTypeLoading |
A delegating type description that always attempts to load the super types of a delegate type.
|
| TypeDescription.SuperTypeLoading.ClassLoadingDelegate |
A class loading delegate is responsible for resolving a type given a class loader and a type name.
|
| TypeDescription.SuperTypeLoading.ClassLoadingDelegate.Simple |
A simple class loading delegate that simply loads a type.
|
| TypeDescription.SuperTypeLoading.ClassLoadingTypeList |
A type list that attempts loading any type.
|
| TypeDescription.SuperTypeLoading.ClassLoadingTypeProjection |
A type projection that attempts to load any super type of the delegate type.
|
| TypeInitializer |
A type initializer is responsible for defining a type's static initialization block.
|
| TypeInitializer.Drain |
A drain for writing a type initializer.
|
| TypeInitializer.Drain.Default |
A default implementation of a type initializer drain that creates a initializer method.
|
| TypeInitializer.None |
Canonical implementation of a non-defined type initializer.
|
| TypeInitializer.Simple |
|
| TypeList |
Implementations represent a list of type descriptions.
|
| TypeList.AbstractBase |
An abstract base implementation of a type list.
|
| TypeList.Empty |
An implementation of an empty type list.
|
| TypeList.Explicit |
A wrapper implementation of an explicit list of types.
|
| TypeList.ForLoadedTypes |
Implementation of a type list for an array of loaded types.
|
| TypeList.Generic |
A list containing descriptions of generic types.
|
| TypeList.Generic.AbstractBase |
An abstract base implementation of a generic type list.
|
| TypeList.Generic.Empty |
An empty list of generic types.
|
| TypeList.Generic.Explicit |
An explicit list of generic types.
|
| TypeList.Generic.ForDetachedTypes |
A list of detached types that are attached on reception.
|
| TypeList.Generic.ForDetachedTypes.OfTypeVariables |
A list of attached type variables represented by a list of type variable tokens.
|
| TypeList.Generic.ForDetachedTypes.OfTypeVariables.AttachedTypeVariable |
A wrapper for representing a type variable in its attached state.
|
| TypeList.Generic.ForDetachedTypes.WithResolvedErasure |
A list of detached types that are attached on reception but not when computing an erasure.
|
| TypeList.Generic.ForLoadedTypes |
A list of loaded generic types.
|
| TypeList.Generic.ForLoadedTypes.OfTypeVariables |
A type list that represents loaded type variables.
|
| TypeList.Generic.OfConstructorExceptionTypes |
A lazy projection of a constructor's exception types.
|
| TypeList.Generic.OfLoadedInterfaceTypes |
A lazy projection of a type's generic interface types.
|
| TypeList.Generic.OfMethodExceptionTypes |
A lazy projection of a method's exception types.
|
| TypeManifestation |
Describes a type's manifestation, i.e.
|
| TypePool |
|
| TypePool.AbstractBase |
A base implementation of a TypePool that is managing a cache provider and
that handles the description of array and primitive types. |
| TypePool.AbstractBase.ArrayTypeResolution |
A resolution for a type that, if resolved, represents an array type.
|
| TypePool.AbstractBase.Hierarchical |
Implements a hierarchical view of type pools, similarly to class loader hierarchies.
|
| TypePool.AbstractBase.RawAnnotationValue |
Represents a nested annotation value.
|
| TypePool.AbstractBase.RawDescriptionArray |
Represents an array that is referenced by an annotation which does not contain primitive values or Strings.
|
| TypePool.AbstractBase.RawDescriptionArray.ComponentTypeReference |
A lazy representation of the component type of an array.
|
| TypePool.AbstractBase.RawDescriptionArray.Loaded |
Represents a loaded annotation property representing a complex array.
|
| TypePool.AbstractBase.RawEnumerationValue |
Represents an enumeration value of an annotation.
|
| TypePool.AbstractBase.RawTypeValue |
Represents a type value of an annotation.
|
| TypePool.AbstractBase.RawTypeValue.Loaded |
Represents a loaded annotation property that represents a type.
|
| TypePool.CacheProvider |
|
| TypePool.CacheProvider.NoOp |
A non-operational cache that does not store any type descriptions.
|
| TypePool.CacheProvider.Simple |
A simple, thread-safe type cache based on a ConcurrentHashMap.
|
| TypePool.ClassLoading |
A type pool that attempts to load a class.
|
| TypePool.Default |
A default implementation of a TypePool that models binary data in the Java byte code format
into a TypeDescription. |
| TypePool.Default.AnnotationRegistrant |
An annotation registrant implements a visitor pattern for reading an unknown amount of values of annotations.
|
| TypePool.Default.AnnotationRegistrant.AbstractBase |
An abstract base implementation of an annotation registrant.
|
| TypePool.Default.AnnotationRegistrant.AbstractBase.ForTypeVariable |
A base implementation for a collector for a type variable.
|
| TypePool.Default.AnnotationRegistrant.AbstractBase.ForTypeVariable.WithIndex |
A base implementation for a collector for a type variable with an index.
|
| TypePool.Default.AnnotationRegistrant.AbstractBase.ForTypeVariable.WithIndex.DoubleIndexed |
A base implementation for a collector for a type variable with two indices.
|
| TypePool.Default.AnnotationRegistrant.ForByteCodeElement |
An annotation collector for a byte code element.
|
| TypePool.Default.AnnotationRegistrant.ForByteCodeElement.WithIndex |
An annotation collector for a byte code element with an index.
|
| TypePool.Default.AnnotationRegistrant.ForTypeVariable |
An annotation collector for a type variable.
|
| TypePool.Default.AnnotationRegistrant.ForTypeVariable.WithIndex |
An annotation collector for a type variable with an index.
|
| TypePool.Default.AnnotationRegistrant.ForTypeVariable.WithIndex.DoubleIndexed |
An annotation collector for a type variable with two indices.
|
| TypePool.Default.ComponentTypeLocator |
A component type locator allows for the lazy location of an array's component type.
|
| TypePool.Default.ComponentTypeLocator.ForAnnotationProperty |
A component type locator that lazily analyses an annotation for resolving an annotation property's
array value's component type.
|
| TypePool.Default.ComponentTypeLocator.ForArrayType |
A component type locator that locates an array type by a method's return value from its method descriptor.
|
| TypePool.Default.ComponentTypeLocator.Illegal |
A component type locator which cannot legally resolve an array's component type.
|
| TypePool.Default.GenericTypeExtractor |
A generic type extractor allows for an iterative extraction of generic type information.
|
| TypePool.Default.GenericTypeExtractor.ForSignature<T extends TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution> |
A signature visitor for extracting a generic type resolution.
|
| TypePool.Default.GenericTypeExtractor.ForSignature.OfField |
A parser for a generic field signature.
|
| TypePool.Default.GenericTypeExtractor.ForSignature.OfMethod |
A parser for a generic method signature.
|
| TypePool.Default.GenericTypeExtractor.ForSignature.OfType |
A parser for a generic type signature.
|
| TypePool.Default.GenericTypeExtractor.IncompleteToken |
|
| TypePool.Default.GenericTypeExtractor.IncompleteToken.AbstractBase |
An abstract base implementation of an incomplete token.
|
| TypePool.Default.GenericTypeExtractor.IncompleteToken.ForInnerClass |
An incomplete generic type token representing a type with an outer type.
|
| TypePool.Default.GenericTypeExtractor.IncompleteToken.ForTopLevelType |
An incomplete token representing a generic type without an outer type.
|
| TypePool.Default.GenericTypeRegistrant |
A type registrant allows to register a generic type token.
|
| TypePool.Default.GenericTypeRegistrant.RejectingSignatureVisitor |
A signature visitor that rejects any discovered generic type.
|
| TypePool.Default.LazyTypeDescription |
|
| TypePool.Default.LazyTypeDescription.AnnotationToken |
A token for representing collected data on an annotation.
|
| TypePool.Default.LazyTypeDescription.AnnotationToken.Resolution |
A resolution for an annotation tokens.
|
| TypePool.Default.LazyTypeDescription.AnnotationToken.Resolution.Illegal |
An illegal resolution.
|
| TypePool.Default.LazyTypeDescription.AnnotationToken.Resolution.Simple |
A simple resolved annotation.
|
| TypePool.Default.LazyTypeDescription.FieldToken |
A token for representing collected data on a field.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken |
A token that represents a generic Java type.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForGenericArray |
A generic type token that represents a generic array.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForGenericArray.LazyGenericArray |
A generic type representation of a generic array.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForLowerBoundWildcard |
A generic type token for a wildcard that is bound below.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForLowerBoundWildcard.LazyLowerBoundWildcard |
A generic type representation of a lower bound wildcard.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType |
A generic type token that represents a parameterized type.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType.LazyParameterizedType |
A generic type description that represents a parameterized type without an enclosing generic owner type.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType.Nested |
A generic type token to describe a parameterized type description with a generic owner type.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType.Nested.LazyParameterizedType |
A lazy description of a parameterized type with an owner type.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForPrimitiveType |
A generic type token that represents a primitive type.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForPrimitiveType.LazyPrimitiveType |
A representation of a lazy primitive type.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForRawType |
A generic type token that represents a non-generic type.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable |
A generic type token that represents a type variable.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.AnnotatedTypeVariable |
An annotated representation of a formal type variable.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.Formal |
A generic type token that represent a formal type variable, i.e.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.Formal.LazyTypeVariable |
A type description that represents a type variable with bounds that are resolved lazily.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.Formal.LazyTypeVariable.LazyBoundTokenList |
A list representing a formal type variable's bounds.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.UnresolvedTypeVariable |
Represents a type variable that a type references but that does not exist.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForUnboundWildcard |
A generic type token that represents an unbound wildcard.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForUnboundWildcard.LazyUnboundWildcard |
A generic type representation of a generic unbound wildcard.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForUpperBoundWildcard |
A generic type token for a wildcard that is bound above.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.ForUpperBoundWildcard.LazyUpperBoundWildcard |
A generic type representation of a tokenized wildcard with an upper bound.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.LazyTokenList |
A lazy list of type tokens.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.LazyTokenList.ForWildcardBound |
A generic type description representing a tokenized wildcard bound.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.OfFormalTypeVariable |
Represents a generic type token for a formal type variable.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution |
A resolution of a type's, method's or field's generic types.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForField |
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForField.Tokenized |
An implementation of a tokenized resolution of the generic type of a FieldDescription. |
| TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForMethod |
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForMethod.Tokenized |
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForType |
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForType.Tokenized |
An implementation of a tokenized resolution of generic types of a TypeDescription. |
| TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Malformed |
A resolution of a type's, method's or field's generic types if its generic signature is malformed.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw |
A resolution of a type's, method's or field's generic types if all of the represented element's are raw.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.RawAnnotatedType |
Represents a non-generic type that defines type annotations.
|
| TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.RawAnnotatedType.LazyRawAnnotatedTypeList |
A generic type list representing raw types.
|
| TypePool.Default.LazyTypeDescription.MethodToken |
A token for representing collected data on a method.
|
| TypePool.Default.LazyTypeDescription.MethodToken.ParameterToken |
A token representing a method's parameter.
|
| TypePool.Default.LazyTypeDescription.TypeContainment |
A declaration context encapsulates information about whether a type was declared within another type
or within a method of another type.
|
| TypePool.Default.LazyTypeDescription.TypeContainment.SelfContained |
Describes a type that is not contained within another type, a method or a constructor.
|
| TypePool.Default.LazyTypeDescription.TypeContainment.WithinMethod |
Describes a type that is contained within a method or constructor.
|
| TypePool.Default.LazyTypeDescription.TypeContainment.WithinType |
Describes a type that is contained within another type.
|
| TypePool.Default.ParameterBag |
A bag for collecting parameter meta information that is stored as debug information for implemented
methods.
|
| TypePool.Default.ReaderMode |
Determines the granularity of the class file parsing that is conducted by a TypePool.Default. |
| TypePool.Default.WithLazyResolution |
|
| TypePool.Empty |
An empty type pool that cannot describe any type.
|
| TypePool.Explicit |
A type pool that supplies explicitly known type descriptions.
|
| 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.
|
| TypePool.LazyFacade.LazyResolution |
The lazy resolution for a lazy facade for a type pool.
|
| TypePool.LazyFacade.LazyTypeDescription |
A description of a type that delegates to another type pool once a property that is not the name is resolved.
|
| TypePool.Resolution |
A resolution of a TypePool which was queried for a description. |
| TypePool.Resolution.Illegal |
A canonical representation of a non-successful resolution of a TypePool. |
| TypePool.Resolution.Simple |
|
| 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.
|
| TypeProxy.AbstractMethodErrorThrow |
A stack manipulation that throws an abstract method error in case that a given super method cannot be invoked.
|
| 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.
|
| TypeProxy.ForSuperMethodByConstructor |
Loads a type proxy onto the operand stack which is created by calling one of its constructors.
|
| 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.
|
| TypeProxy.InvocationFactory |
An invocation factory is responsible for creating a special method invocation for any method that is to be
invoked.
|
| TypeProxy.InvocationFactory.Default |
|
| TypeProxy.SilentConstruction |
An implementation of a silent construction of a given type by using the non-standardized
ReflectionFactory.
|
| TypeProxy.SilentConstruction.Appender |
|
| TypeResolutionStrategy |
A type resolution strategy is responsible for loading a class and for initializing its LoadedTypeInitializers. |
| TypeResolutionStrategy.Active |
A type resolution strategy that applies all LoadedTypeInitializer as a part of class loading using reflection. |
| TypeResolutionStrategy.Active.Resolved |
A resolved version of an active type resolution strategy.
|
| TypeResolutionStrategy.Disabled |
A type resolution strategy that does not allow for explicit loading of a class and that does not inject any code into the type initializer.
|
| TypeResolutionStrategy.Lazy |
|
| TypeResolutionStrategy.Passive |
|
| TypeResolutionStrategy.Resolved |
|
| TypeSortMatcher<T extends TypeDefinition> |
An element matcher that validates that a given generic type description represents a type of a given name.
|
| TypeValidation |
If type validation is enabled, Byte Buddy performs several checks to ensure that a generated
class file is specified in a valid manner.
|
| TypeVariableSource |
A type variable source represents a code element that can declare type variables.
|
| TypeVariableSource.AbstractBase |
An abstract base implementation of a type variable source.
|
| TypeVariableSource.Visitor<T> |
A visitor that can be applied to a type variable source.
|
| TypeVariableSource.Visitor.NoOp |
A none-operational implementation of a type variable visitor that simply returns the visited source.
|
| TypeVariableToken |
A tokenized representation of a type variable.
|
| TypeWriter<T> |
A type writer is a utility for writing an actual class file using the ASM library.
|
| TypeWriter.Default<S> |
|
| TypeWriter.Default.ClassDumpAction |
An action to write a class file to the dumping location.
|
| TypeWriter.Default.ForCreation<U> |
A type writer that creates a class file that is not based upon another, existing class.
|
| TypeWriter.Default.ForInlining<U> |
A type writer that inlines the created type into an existing class file.
|
| TypeWriter.Default.ForInlining.ContextRegistry |
A context registry allows to extract auxiliary types from a lazily created implementation context.
|
| TypeWriter.Default.ForInlining.InitializationHandler |
An initialization handler is responsible for handling the creation of the type initializer.
|
| TypeWriter.Default.ForInlining.InitializationHandler.Appending |
An initialization handler that appends code to a previously visited type initializer.
|
| TypeWriter.Default.ForInlining.InitializationHandler.Appending.FrameWriter |
A frame writer is responsible for adding empty frames on jump instructions.
|
| TypeWriter.Default.ForInlining.InitializationHandler.Appending.FrameWriter.Active |
An active frame writer that creates the most efficient frame.
|
| TypeWriter.Default.ForInlining.InitializationHandler.Appending.FrameWriter.Expanding |
A frame writer that creates an expanded frame.
|
| TypeWriter.Default.ForInlining.InitializationHandler.Appending.FrameWriter.NoOp |
A non-operational frame writer.
|
| TypeWriter.Default.ForInlining.InitializationHandler.Appending.WithDrain |
An initialization handler that appends code to a previously visited type initializer with allowing active
TypeInitializer registrations. |
| TypeWriter.Default.ForInlining.InitializationHandler.Appending.WithDrain.WithActiveRecord |
A code appending initialization handler with a drain that applies an explicit record.
|
| TypeWriter.Default.ForInlining.InitializationHandler.Appending.WithDrain.WithoutActiveRecord |
A code appending initialization handler with a drain that does not apply an explicit record.
|
| TypeWriter.Default.ForInlining.InitializationHandler.Appending.WithoutDrain |
An initialization handler that appends code to a previously visited type initializer without allowing active
TypeInitializer registrations. |
| TypeWriter.Default.ForInlining.InitializationHandler.Appending.WithoutDrain.WithActiveRecord |
An initialization handler that appends code to a previously visited type initializer without allowing active
TypeInitializer registrations and with an active record. |
| TypeWriter.Default.ForInlining.InitializationHandler.Appending.WithoutDrain.WithoutActiveRecord |
An initialization handler that appends code to a previously visited type initializer without allowing active
TypeInitializer registrations and without an active record. |
| TypeWriter.Default.ForInlining.InitializationHandler.Creating |
An initialization handler that creates a new type initializer.
|
| TypeWriter.Default.FrameComputingClassWriter |
A class writer that piggy-backs on Byte Buddy's ClassFileLocator to avoid class loading or look-up errors when redefining a class. |
| TypeWriter.Default.ValidatingClassVisitor |
A class validator that validates that a class only defines members that are appropriate for the sort of the generated class.
|
| TypeWriter.Default.ValidatingClassVisitor.Constraint |
A constraint for members that are legal for a given type.
|
| TypeWriter.Default.ValidatingClassVisitor.Constraint.Compound |
A constraint implementation that summarizes several constraints.
|
| TypeWriter.Default.ValidatingClassVisitor.Constraint.ForAnnotation |
Represents the constraint of an annotation type.
|
| TypeWriter.Default.ValidatingClassVisitor.Constraint.ForClass |
Represents the constraint of a class type.
|
| TypeWriter.Default.ValidatingClassVisitor.Constraint.ForClassFileVersion |
Represents the constraint implied by a class file version.
|
| TypeWriter.Default.ValidatingClassVisitor.Constraint.ForInterface |
Represents the constraint of an interface type.
|
| TypeWriter.Default.ValidatingClassVisitor.Constraint.ForPackageType |
Represents the constraint of a package type.
|
| TypeWriter.FieldPool |
An field pool that allows a lookup for how to implement a field.
|
| TypeWriter.FieldPool.Record |
An entry of a field pool that describes how a field is implemented.
|
| TypeWriter.FieldPool.Record.ForExplicitField |
A record for a rich field with attributes and a potential default value.
|
| TypeWriter.FieldPool.Record.ForImplicitField |
A record for a simple field without a default value where all of the field's declared annotations are appended.
|
| TypeWriter.MethodPool |
An method pool that allows a lookup for how to implement a method.
|
| TypeWriter.MethodPool.Record |
An entry of a method pool that describes how a method is implemented.
|
| TypeWriter.MethodPool.Record.AccessBridgeWrapper |
A wrapper that appends accessor bridges for a method's implementation.
|
| TypeWriter.MethodPool.Record.AccessBridgeWrapper.AccessorBridge |
A method representing an accessor bridge method.
|
| TypeWriter.MethodPool.Record.AccessBridgeWrapper.BridgeTarget |
A method representing a bridge's target method in its defined shape.
|
| TypeWriter.MethodPool.Record.ForDefinedMethod |
A base implementation of an abstract entry that defines a method.
|
| TypeWriter.MethodPool.Record.ForDefinedMethod.OfVisibilityBridge |
A record for a visibility bridge.
|
| TypeWriter.MethodPool.Record.ForDefinedMethod.OfVisibilityBridge.VisibilityBridge |
A method describing a visibility bridge.
|
| TypeWriter.MethodPool.Record.ForDefinedMethod.WithAnnotationDefaultValue |
Describes an entry that defines a method with a default annotation value.
|
| TypeWriter.MethodPool.Record.ForDefinedMethod.WithBody |
Describes an entry that defines a method as byte code.
|
| TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody |
Describes an entry that defines a method but without byte code and without an annotation value.
|
| TypeWriter.MethodPool.Record.ForNonImplementedMethod |
A canonical implementation of a method that is not declared but inherited by the instrumented type.
|
| TypeWriter.MethodPool.Record.Sort |
The sort of an entry.
|
| VirtualMachine |
An implementation for attachment on a virtual machine.
|
| VirtualMachine.ForHotSpot |
A virtual machine implementation for a HotSpot VM or any compatible VM.
|
| VirtualMachine.ForHotSpot.OnUnix |
A virtual machine implementation for a HotSpot VM running on Unix.
|
| Visibility |
Describes a type's, field's or a method's visibility.
|
| VisibilityMatcher<T extends ByteCodeElement> |
An element matcher that validates that a given byte code element is visible to a given type.
|
| VoidAwareAssigner |
This assigner is able to handle the void type.
|