Package net.bytebuddy.implementation.bind.annotation

This package contains annotations, types and classes that are responsible for binding a method to calling another method by interpreting annotations that indicate how a method should be bound to another method.

See: Description

Interface Summary

Interface	Description
Default.Binder.TypeLocator	Locates the type which should be the base type of the created proxy.
DefaultCall.Binder.DefaultMethodLocator	A default method locator is responsible for looking up a default method to a given source method.
FieldValue.Binder.FieldLocator.Resolution	A resolution of a field locator.
Morph.Binder.DefaultMethodLocator	A default method locator is responsible for looking up a default method to a given source method.
Super.Binder.TypeLocator	Locates the type which should be the base type of the created proxy.
TargetMethodAnnotationDrivenBinder.DefaultsProvider	Implementations of the defaults provider interface create annotations for parameters that are not annotated with a known annotation.
TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler	A handler is responsible for processing a parameter's binding.
TargetMethodAnnotationDrivenBinder.ParameterBinder<T extends Annotation>	A parameter binder is used as a delegate for binding a parameter according to a particular annotation type found on this parameter.
TargetMethodAnnotationDrivenBinder.TerminationHandler	Responsible for creating a StackManipulation that is applied after the interception method is applied.

Class Summary

Class	Description
Argument.NextUnboundAsDefaultsProvider.NextUnboundArgumentIterator	An iterator that creates Argument annotations for any non-referenced index of the source method.
Argument.NextUnboundAsDefaultsProvider.NextUnboundArgumentIterator.DefaultArgument	A default implementation of an Argument annotation.
Default.Binder.TypeLocator.ForType	A type locator that returns a given type.
DefaultCall.Binder.DefaultMethodLocator.Explicit	An explicit default method locator attempts to look up a default method in the specified interface type.
FieldProxy.Binder	A binder for the FieldProxy annotation.
FieldProxy.Binder.AccessType.Getter	Implementation for a getter method.
FieldProxy.Binder.AccessType.Setter	Implementation for a setter method.
FieldProxy.Binder.FieldLocator	A field locator is responsible for locating the type a field is defined in.
FieldProxy.Binder.FieldLocator.Illegal	Represents an illegal field locator which can impossible locate a field.
FieldProxy.Binder.FieldLocator.Legal	Represents a field locator for a field whose name could be located.
FieldProxy.Binder.FieldLocator.LookupEngine	A lookup engine is responsible for finding a specific field in a type hierarchy.
FieldProxy.Binder.FieldLocator.LookupEngine.ForExplicitType	Represents a lookup engine that tries to find a field for a given type.
FieldProxy.Binder.FieldLocator.LookupEngine.ForHierarchy	Represents a lookup engine that tries to find the most specific field in a class hierarchy.
FieldProxy.Binder.FieldLocator.LookupEngine.Illegal	Represents a lookup engine that can only produce illegal look-ups.
FieldProxy.Binder.FieldLocator.Resolution	A resolution represents the result of a field location.
FieldProxy.Binder.FieldLocator.Resolution.Resolved	A resolution for a successfully located field.
FieldProxy.Binder.FieldLocator.Resolution.Unresolved	A resolution for a non-located field.
FieldProxy.Binder.InstanceFieldConstructor	Represents an implementation for implementing a proxy type constructor when a non-static field is accessed.
FieldProxy.Binder.InstanceFieldConstructor.Appender	An appender for implementing an FieldProxy.Binder.InstanceFieldConstructor.
FieldValue.Binder.FieldLocator	Responsible for locating a field of the instrumented type.
FieldValue.Binder.FieldLocator.ForFieldInHierarchy	Attempts to locate a field within a type's hierarchy.
FieldValue.Binder.FieldLocator.ForSpecificType	Locates a field only within a given type.
FieldValue.Binder.FieldLocator.Impossible	A field locator that never locates a field.
FieldValue.Binder.FieldLocator.Resolution.Resolved	A successfully resolved field resolution.
IgnoreForBinding.Verifier	A non-instantiable type that allows to check if a method should be ignored for binding.
Morph.Binder	A binder for the Morph annotation.
Morph.Binder.DefaultMethodLocator.Explicit	An explicit default method locator attempts to look up a default method in the specified interface type.
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.
Pipe.Binder	A TargetMethodAnnotationDrivenBinder.ParameterBinder for binding the Pipe annotation.
Pipe.Binder.Redirection	An auxiliary type for performing the redirection of a method invocation as requested by the Pipe annotation.
Pipe.Binder.Redirection.MethodCall	The implementation to implement a Pipe.Binder.Redirection's forwarding method.
RuntimeType.Verifier	A non-instantiable type that allows to check if a method or parameter should consider a runtime type.
Super.Binder.TypeLocator.ForType	A type locator that returns a given type.
TargetMethodAnnotationDrivenBinder	This MethodDelegationBinder binds method by analyzing annotations found on the target method that is subject to a method binding.
TargetMethodAnnotationDrivenBinder.DelegationProcessor	A delegation processor is a helper class for a TargetMethodAnnotationDrivenBinder for performing its actual logic.
TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Bound<T extends Annotation>	A bound handler represents an unambiguous parameter binder that was located for a given array of annotations.

Enum Summary

Enum	Description
AllArguments.Assignment	A directive for how an AllArguments annotation on an array is to be interpreted.
AllArguments.Binder	A binder for handling the AllArguments annotation.
Argument.Binder	A binder for handling the Argument annotation.
Argument.BindingMechanic	Determines if a parameter binding should be considered for resolving ambiguous method bindings.
Argument.NextUnboundAsDefaultsProvider	If this defaults provider is active, a non-annotated parameter is assumed to be implicitly bound to the next source method parameter that is not bound by any other target method parameter, i.e. a target method bar(Object, String) would be equivalent to a bar(@Argument(0) Object, @Argument(1) String).
BindingPriority.Resolver	An ambiguity resolver that considers the priority of a method as defined by the BindingPriority annotation.
Default.Binder	A binder for the Default annotation.
Default.Binder.TypeLocator.ForParameterType	A type locator that yields the target parameter's type.
DefaultCall.Binder	A binder for handling the DefaultCall annotation.
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.
Empty.Binder	A binder for the Empty annotation.
FieldProxy.Binder.AccessType	Determines the way a field is to be accessed.
FieldProxy.Binder.StaticFieldConstructor	Represents an implementation for implementing a proxy type constructor when a static field is accessed.
FieldValue.Binder	Binds a FieldValue annotation.
FieldValue.Binder.FieldLocator.Resolution.Unresolved	A canonical implementation of an unresolved field resolution.
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.StaticFieldConstructor	Creates an instance of the proxy when instrumenting a static method.
Origin.Binder	A binder for binding parameters that are annotated with Origin.
Pipe.Binder.Redirection.ConstructorCall	The implementation to implement a Pipe.Binder.Redirection's constructor.
StubValue.Binder	Binds the StubValue annotation.
Super.Binder	A binder for handling the Super annotation.
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.Instantiation	Determines the instantiation of the proxy type.
SuperCall.Binder	A binder for handling the SuperCall annotation.
TargetMethodAnnotationDrivenBinder.DefaultsProvider.Empty	A defaults provider that does not supply any defaults.
TargetMethodAnnotationDrivenBinder.DefaultsProvider.Empty.EmptyIterator	A trivial iterator without any elements.
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.TerminationHandler.Dropping	A termination handler that pops the return value of the interception method.
TargetMethodAnnotationDrivenBinder.TerminationHandler.Returning	A termination handler that returns the return value of the interception method.
This.Binder	A binder for handling the This annotation.

Annotation Types Summary

Annotation Type	Description
AllArguments	Parameters that are annotated with this annotation will be assigned a collection (or an array) containing all arguments of the source method.
Argument	Parameters that are annotated with this annotation will be assigned the value of the parameter of the source method with the given parameter.
BindingPriority	Defines a binding priority for a target method.
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.
DefaultCall	A parameter with this annotation is assigned a proxy for invoking a default method that fits the intercepted method.
Empty	Binds the parameter type's default value to the annotated parameter, i.e.
FieldProxy	Using this annotation it is possible to access fields by getter and setter types.
FieldValue	Assigns the value of a field of the instrumented type to the annotated parameter.
IgnoreForBinding	Indicates that a given target method should never be considered for binding to a source method.
Morph	This annotation instructs Byte Buddy to inject a proxy class that calls a method's super method with explicit arguments.
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: If the annotated parameter is of type Method, Constructor or java.lang.reflect.Executable, the parameter is assigned a reference to the method or constructor it instruments.
Pipe	A target method parameter that is annotated with this annotation allows to forward an intercepted method invocation to another instance.
RuntimeType	Parameters that are annotated with this annotation will be assigned by also considering the runtime type of the target parameter.
StubValue	A stub value represents the (boxed) default value of the intercepted method's return type.
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.
SuperCall	Parameters that are annotated with this annotation will be assigned a proxy for calling the instrumented method's super implementation.
This	Parameters that are annotated with this annotation will be assigned a reference to the instrumented object, if the instrumented method is not static.

Package net.bytebuddy.implementation.bind.annotation Description

This package contains annotations, types and classes that are responsible for binding a method to calling another method by interpreting annotations that indicate how a method should be bound to another method.