Uses of Interface
net.bytebuddy.implementation.Implementation.Target

Packages that use Implementation.Target

Package	Description
net.bytebuddy	Byte Buddy is a library for creating Java classes at runtime of a Java program.
net.bytebuddy.agent.builder	An agent builder is used to easily implement load-time class-transformations using a Java agent.
net.bytebuddy.asm	The ASM package contains classes that are meant for direct interaction with the ASM API.
net.bytebuddy.dynamic.scaffold	This package contains helper types and implementations that are responsible for the actual writing of a byte array representing a Java class.
net.bytebuddy.dynamic.scaffold.inline	All classes and types in this package are related to creating a DynamicType by enhancing a given type.
net.bytebuddy.dynamic.scaffold.subclass	All classes and types in this package are related to creating a DynamicType by creating a subclass of a given type.
net.bytebuddy.implementation	The implementation package contains any logic for intercepting method calls.
net.bytebuddy.implementation.auxiliary	Auxiliary types describe helper types that aid as a supplementary to a given InstrumentedType.
net.bytebuddy.implementation.bind	The types and classes of this package are responsible for binding a method call to calling another method.
net.bytebuddy.implementation.bind.annotation	This package contains annotations, types and classes that are responsible for binding a method to calling another method by interpreting annotations that indicate how a method should be bound to another method.

Uses of Implementation.Target in net.bytebuddy

Methods in net.bytebuddy with parameters of type Implementation.Target

Modifier and Type	Method and Description
ByteCodeAppender	ByteBuddy.EnumerationImplementation.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	ByteBuddy.RecordConstructorStrategy.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	ByteBuddy.RecordObjectMethod.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.

Uses of Implementation.Target in net.bytebuddy.agent.builder

Methods in net.bytebuddy.agent.builder with parameters of type Implementation.Target

Modifier and Type	Method and Description
ByteCodeAppender	AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.ConstructorImplementation.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.FactoryImplementation.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.LambdaMethodImplementation.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.SerializationImplementation.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.BridgeMethodImplementation.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.

Uses of Implementation.Target in net.bytebuddy.asm

Methods in net.bytebuddy.asm with parameters of type Implementation.Target

Modifier and Type	Method and Description
ByteCodeAppender	Advice.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.

Constructors in net.bytebuddy.asm with parameters of type Implementation.Target

Constructor and Description
Appender(Advice advice, Implementation.Target implementationTarget, ByteCodeAppender delegate) Creates a new appender for an advice component.

Uses of Implementation.Target in net.bytebuddy.dynamic.scaffold

Methods in net.bytebuddy.dynamic.scaffold with parameters of type Implementation.Target

Modifier and Type	Method and Description
MethodRegistry.Handler.Compiled	MethodRegistry.Handler.compile(Implementation.Target implementationTarget) Compiles this handler.
MethodRegistry.Handler.Compiled	MethodRegistry.Handler.ForAbstractMethod.compile(Implementation.Target implementationTarget) Compiles this handler.
MethodRegistry.Handler.ForVisibilityBridge.Compiled	MethodRegistry.Handler.ForVisibilityBridge.compile(Implementation.Target implementationTarget) Compiles this handler.
MethodRegistry.Handler.ForImplementation.Compiled	MethodRegistry.Handler.ForImplementation.compile(Implementation.Target implementationTarget) Compiles this handler.
MethodRegistry.Handler.Compiled	MethodRegistry.Handler.ForAnnotationValue.compile(Implementation.Target implementationTarget) Compiles this handler.

Uses of Implementation.Target in net.bytebuddy.dynamic.scaffold.inline

Classes in net.bytebuddy.dynamic.scaffold.inline that implement Implementation.Target

Modifier and Type	Class and Description
class	RebaseImplementationTarget An implementation target for redefining a given type while preserving the original methods within the instrumented type.

Methods in net.bytebuddy.dynamic.scaffold.inline that return Implementation.Target

Modifier and Type	Method and Description
Implementation.Target	RebaseImplementationTarget.Factory.make(TypeDescription instrumentedType, MethodGraph.Linked methodGraph, ClassFileVersion classFileVersion) Creates an implementation target.
protected static Implementation.Target	RebaseImplementationTarget.of(TypeDescription instrumentedType, MethodGraph.Linked methodGraph, ClassFileVersion classFileVersion, MethodRebaseResolver methodRebaseResolver) Creates a new rebase implementation target.

Uses of Implementation.Target in net.bytebuddy.dynamic.scaffold.subclass

Classes in net.bytebuddy.dynamic.scaffold.subclass that implement Implementation.Target

Modifier and Type	Class and Description
class	SubclassImplementationTarget An implementation target for creating a subclass of a given type.

Methods in net.bytebuddy.dynamic.scaffold.subclass that return Implementation.Target

Modifier and Type	Method and Description
Implementation.Target	SubclassImplementationTarget.Factory.make(TypeDescription instrumentedType, MethodGraph.Linked methodGraph, ClassFileVersion classFileVersion) Creates an implementation target.

Uses of Implementation.Target in net.bytebuddy.implementation

Classes in net.bytebuddy.implementation that implement Implementation.Target

Modifier and Type	Class and Description
static class	Implementation.Target.AbstractBase An abstract base implementation for an Implementation.Target.

Methods in net.bytebuddy.implementation that return Implementation.Target

Modifier and Type	Method and Description
Implementation.Target	Implementation.Target.Factory.make(TypeDescription instrumentedType, MethodGraph.Linked methodGraph, ClassFileVersion classFileVersion) Creates an implementation target.

Methods in net.bytebuddy.implementation with parameters of type Implementation.Target

Modifier and Type	Method and Description
ByteCodeAppender	SuperMethodCall.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	SuperMethodCall.WithoutReturn.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	DefaultMethodCall.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	MethodDelegation.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	EqualsMethod.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	HashCodeMethod.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	InvocationHandlerAdapter.ForInstance.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	InvocationHandlerAdapter.ForField.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	FieldAccessor.ForImplicitProperty.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	FieldAccessor.ForSetter.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	StubMethod.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	InvokeDynamic.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	InvokeDynamic.AbstractDelegator.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	Implementation.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	Implementation.Compound.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	Implementation.Compound.Composable.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	Implementation.Simple.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	Implementation.Simple.ForDispatcher.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	FixedValue.ForNullValue.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	FixedValue.ForOriginType.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	FixedValue.ForThisValue.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	FixedValue.ForArgument.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	FixedValue.ForPoolValue.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	FixedValue.ForValue.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	ExceptionMethod.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	MethodCall.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	MethodCall.FieldSetting.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ToStringMethod.Appender	ToStringMethod.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
StackManipulation	Implementation.Simple.Dispatcher.apply(Implementation.Target implementationTarget, MethodDescription instrumentedMethod) Creates a stack manipulation from a simple method dispatch.
MethodCall.ArgumentLoader.ArgumentProvider	MethodCall.ArgumentLoader.Factory.make(Implementation.Target implementationTarget) Creates an argument provider for the supplied implementation target.
MethodCall.ArgumentLoader.ArgumentProvider	MethodCall.ArgumentLoader.ForNullConstant.make(Implementation.Target implementationTarget) Creates an argument provider for the supplied implementation target.
MethodCall.ArgumentLoader.ArgumentProvider	MethodCall.ArgumentLoader.ForThisReference.Factory.make(Implementation.Target implementationTarget) Creates an argument provider for the supplied implementation target.
MethodCall.ArgumentLoader.ArgumentProvider	MethodCall.ArgumentLoader.ForInstrumentedType.Factory.make(Implementation.Target implementationTarget) Creates an argument provider for the supplied implementation target.
MethodCall.ArgumentLoader.ArgumentProvider	MethodCall.ArgumentLoader.ForMethodParameter.OfInstrumentedMethod.make(Implementation.Target implementationTarget) Creates an argument provider for the supplied implementation target.
MethodCall.ArgumentLoader.ArgumentProvider	MethodCall.ArgumentLoader.ForMethodParameter.Factory.make(Implementation.Target implementationTarget) Creates an argument provider for the supplied implementation target.
MethodCall.ArgumentLoader.ArgumentProvider	MethodCall.ArgumentLoader.ForMethodParameterArray.ForInstrumentedMethod.make(Implementation.Target implementationTarget) Creates an argument provider for the supplied implementation target.
MethodCall.ArgumentLoader.ArgumentProvider	MethodCall.ArgumentLoader.ForMethodParameterArrayElement.OfParameter.make(Implementation.Target implementationTarget) Creates an argument provider for the supplied implementation target.
MethodCall.ArgumentLoader.ArgumentProvider	MethodCall.ArgumentLoader.ForMethodParameterArrayElement.OfInvokedMethod.make(Implementation.Target implementationTarget) Creates an argument provider for the supplied implementation target.
MethodCall.ArgumentLoader.ArgumentProvider	MethodCall.ArgumentLoader.ForInstance.Factory.make(Implementation.Target implementationTarget) Creates an argument provider for the supplied implementation target.
MethodCall.ArgumentLoader.ArgumentProvider	MethodCall.ArgumentLoader.ForField.Factory.make(Implementation.Target implementationTarget) Creates an argument provider for the supplied implementation target.
MethodCall.ArgumentLoader.ArgumentProvider	MethodCall.ArgumentLoader.ForMethodCall.Factory.make(Implementation.Target implementationTarget) Creates an argument provider for the supplied implementation target.
MethodCall.ArgumentLoader.ArgumentProvider	MethodCall.ArgumentLoader.ForStackManipulation.make(Implementation.Target implementationTarget) Creates an argument provider for the supplied implementation target.
MethodCall.TargetHandler	MethodCall.TargetHandler.Factory.make(Implementation.Target implementationTarget) Creates a target handler for a given implementation target.
MethodCall.TargetHandler	MethodCall.TargetHandler.Simple.make(Implementation.Target implementationTarget) Creates a target handler for a given implementation target.
MethodCall.TargetHandler	MethodCall.TargetHandler.ForSelfOrStaticInvocation.Factory.make(Implementation.Target implementationTarget) Creates a target handler for a given implementation target.
MethodCall.TargetHandler	MethodCall.TargetHandler.ForValue.Factory.make(Implementation.Target implementationTarget) Creates a target handler for a given implementation target.
MethodCall.TargetHandler	MethodCall.TargetHandler.ForField.Factory.make(Implementation.Target implementationTarget) Creates a target handler for a given implementation target.
MethodCall.TargetHandler	MethodCall.TargetHandler.ForMethodParameter.make(Implementation.Target implementationTarget) Creates a target handler for a given implementation target.
MethodCall.TargetHandler	MethodCall.TargetHandler.ForMethodCall.Factory.make(Implementation.Target implementationTarget) Creates a target handler for a given implementation target.
StackManipulation	MethodCall.MethodInvoker.toStackManipulation(MethodDescription invokedMethod, Implementation.Target implementationTarget) Invokes the method.
StackManipulation	MethodCall.MethodInvoker.ForContextualInvocation.toStackManipulation(MethodDescription invokedMethod, Implementation.Target implementationTarget) Invokes the method.
StackManipulation	MethodCall.MethodInvoker.ForVirtualInvocation.toStackManipulation(MethodDescription invokedMethod, Implementation.Target implementationTarget) Invokes the method.
StackManipulation	MethodCall.MethodInvoker.ForVirtualInvocation.WithImplicitType.toStackManipulation(MethodDescription invokedMethod, Implementation.Target implementationTarget) Invokes the method.
StackManipulation	MethodCall.MethodInvoker.ForSuperMethodInvocation.toStackManipulation(MethodDescription invokedMethod, Implementation.Target implementationTarget) Invokes the method.
StackManipulation	MethodCall.MethodInvoker.ForDefaultMethodInvocation.toStackManipulation(MethodDescription invokedMethod, Implementation.Target implementationTarget) Invokes the method.

Constructors in net.bytebuddy.implementation with parameters of type Implementation.Target

Constructor and Description
Appender(Implementation.Target implementationTarget) Creates a new appender.
Appender(Implementation.Target implementationTarget, List<TypeDescription> prioritizedInterfaces) Creates a new appender for implementing a DefaultMethodCall.
Appender(Implementation.Target implementationTarget, MethodCall.TerminationHandler terminationHandler) Creates a new appender.
Appender(Implementation.Target implementationTarget, MethodDelegationBinder.Record processor, MethodDelegationBinder.TerminationHandler terminationHandler, Assigner assigner, MethodDelegation.ImplementationDelegate.Compiled compiled) Creates a new appender for a method delegation.
Appender(Implementation.Target implementationTarget, SuperMethodCall.Appender.TerminationHandler terminationHandler) Creates a new appender.

Uses of Implementation.Target in net.bytebuddy.implementation.auxiliary

Methods in net.bytebuddy.implementation.auxiliary with parameters of type Implementation.Target

Modifier and Type	Method and Description
ByteCodeAppender	TypeProxy.SilentConstruction.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	TypeProxy.MethodCall.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	MethodCallProxy.ConstructorCall.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	MethodCallProxy.MethodCall.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
Implementation.SpecialMethodInvocation	TypeProxy.InvocationFactory.invoke(Implementation.Target implementationTarget, TypeDescription proxiedType, MethodDescription instrumentedMethod) Creates a special method invocation to implement for a given method.

Constructors in net.bytebuddy.implementation.auxiliary with parameters of type Implementation.Target

Constructor and Description
ForDefaultMethod(TypeDescription proxiedType, Implementation.Target implementationTarget, boolean serializableProxy) Creates a new proxy creation for a default interface type proxy.
ForSuperMethodByConstructor(TypeDescription proxiedType, Implementation.Target implementationTarget, List<TypeDescription> constructorParameters, boolean ignoreFinalizer, boolean serializableProxy) Creates a new stack operation for creating a type proxy by calling one of its constructors.
ForSuperMethodByReflectionFactory(TypeDescription proxiedType, Implementation.Target implementationTarget, boolean ignoreFinalizer, boolean serializableProxy) Creates a new stack operation for reflectively creating a type proxy for the given arguments.
TypeProxy(TypeDescription proxiedType, Implementation.Target implementationTarget, TypeProxy.InvocationFactory invocationFactory, boolean ignoreFinalizer, boolean serializableProxy) Creates a new type proxy.

Uses of Implementation.Target in net.bytebuddy.implementation.bind

Methods in net.bytebuddy.implementation.bind with parameters of type Implementation.Target

Modifier and Type	Method and Description
MethodDelegationBinder.MethodBinding	MethodDelegationBinder.Record.bind(Implementation.Target implementationTarget, MethodDescription source, MethodDelegationBinder.TerminationHandler terminationHandler, MethodDelegationBinder.MethodInvoker methodInvoker, Assigner assigner) Attempts a binding of a source method to this compiled target.
MethodDelegationBinder.MethodBinding	MethodDelegationBinder.Record.Illegal.bind(Implementation.Target implementationTarget, MethodDescription source, MethodDelegationBinder.TerminationHandler terminationHandler, MethodDelegationBinder.MethodInvoker methodInvoker, Assigner assigner) Attempts a binding of a source method to this compiled target.
MethodDelegationBinder.MethodBinding	MethodDelegationBinder.Processor.bind(Implementation.Target implementationTarget, MethodDescription source, MethodDelegationBinder.TerminationHandler terminationHandler, MethodDelegationBinder.MethodInvoker methodInvoker, Assigner assigner) Attempts a binding of a source method to this compiled target.

Uses of Implementation.Target in net.bytebuddy.implementation.bind.annotation

Methods in net.bytebuddy.implementation.bind.annotation with parameters of type Implementation.Target

Modifier and Type	Method and Description
ByteCodeAppender	Pipe.Binder.RedirectionProxy.ConstructorCall.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	Pipe.Binder.RedirectionProxy.MethodCall.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	Morph.Binder.RedirectionProxy.StaticFieldConstructor.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	Morph.Binder.RedirectionProxy.InstanceFieldConstructor.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	Morph.Binder.RedirectionProxy.MethodCall.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	FieldProxy.Binder.StaticFieldConstructor.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	FieldProxy.Binder.InstanceFieldConstructor.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	FieldProxy.Binder.FieldGetter.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
ByteCodeAppender	FieldProxy.Binder.FieldSetter.appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
MethodDelegationBinder.ParameterBinding<?>	AllArguments.Binder.bind(AnnotationDescription.Loadable<AllArguments> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	Argument.Binder.bind(AnnotationDescription.Loadable<Argument> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	Default.Binder.bind(AnnotationDescription.Loadable<Default> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	DefaultCall.Binder.bind(AnnotationDescription.Loadable<DefaultCall> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	DefaultMethod.Binder.bind(AnnotationDescription.Loadable<DefaultMethod> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	Empty.Binder.bind(AnnotationDescription.Loadable<Empty> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	FieldValue.Binder.bind(AnnotationDescription.Loadable<FieldValue> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	Morph.Binder.bind(AnnotationDescription.Loadable<Morph> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	Origin.Binder.bind(AnnotationDescription.Loadable<Origin> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	Pipe.Binder.bind(AnnotationDescription.Loadable<Pipe> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFixedValue.bind(AnnotationDescription.Loadable<S> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFieldBinding.bind(AnnotationDescription.Loadable<S> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	StubValue.Binder.bind(AnnotationDescription.Loadable<StubValue> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	Super.Binder.bind(AnnotationDescription.Loadable<Super> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	SuperCall.Binder.bind(AnnotationDescription.Loadable<SuperCall> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	SuperMethod.Binder.bind(AnnotationDescription.Loadable<SuperMethod> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	TargetMethodAnnotationDrivenBinder.ParameterBinder.bind(AnnotationDescription.Loadable<T> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	This.Binder.bind(AnnotationDescription.Loadable<This> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing) Creates a parameter binding for the given target parameter.
protected MethodDelegationBinder.ParameterBinding<?>	FieldProxy.Binder.bind(FieldDescription fieldDescription, AnnotationDescription.Loadable<FieldProxy> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner)
protected MethodDelegationBinder.ParameterBinding<?>	FieldValue.Binder.Delegate.bind(FieldDescription fieldDescription, AnnotationDescription.Loadable<FieldValue> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner)
protected abstract MethodDelegationBinder.ParameterBinding<?>	TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFieldBinding.bind(FieldDescription fieldDescription, AnnotationDescription.Loadable<S> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner) Creates a parameter binding for the given target parameter.
MethodDelegationBinder.MethodBinding	TargetMethodAnnotationDrivenBinder.Record.bind(Implementation.Target implementationTarget, MethodDescription source, MethodDelegationBinder.TerminationHandler terminationHandler, MethodDelegationBinder.MethodInvoker methodInvoker, Assigner assigner) Attempts a binding of a source method to this compiled target.
MethodDelegationBinder.ParameterBinding<?>	TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.bind(MethodDescription source, Implementation.Target implementationTarget, Assigner assigner) Handles a parameter binding.
MethodDelegationBinder.ParameterBinding<?>	TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Unbound.bind(MethodDescription source, Implementation.Target implementationTarget, Assigner assigner) Handles a parameter binding.
MethodDelegationBinder.ParameterBinding<?>	TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Bound.bind(MethodDescription source, Implementation.Target implementationTarget, Assigner assigner) Handles a parameter binding.
protected abstract StackManipulation	Super.Instantiation.proxyFor(TypeDescription parameterType, Implementation.Target implementationTarget, AnnotationDescription.Loadable<Super> annotation) Creates a stack manipulation which loads a super-call proxy onto the stack.
Implementation.SpecialMethodInvocation	DefaultCall.Binder.DefaultMethodLocator.resolve(Implementation.Target implementationTarget, MethodDescription source) Locates the correct default method to a given source method.
Implementation.SpecialMethodInvocation	DefaultCall.Binder.DefaultMethodLocator.Implicit.resolve(Implementation.Target implementationTarget, MethodDescription source) Locates the correct default method to a given source method.
Implementation.SpecialMethodInvocation	DefaultCall.Binder.DefaultMethodLocator.Explicit.resolve(Implementation.Target implementationTarget, MethodDescription source) Locates the correct default method to a given source method.
Implementation.SpecialMethodInvocation	Morph.Binder.DefaultMethodLocator.resolve(Implementation.Target implementationTarget, MethodDescription source) Locates the correct default method to a given source method.
Implementation.SpecialMethodInvocation	Morph.Binder.DefaultMethodLocator.Implicit.resolve(Implementation.Target implementationTarget, MethodDescription source) Locates the correct default method to a given source method.
Implementation.SpecialMethodInvocation	Morph.Binder.DefaultMethodLocator.Explicit.resolve(Implementation.Target implementationTarget, MethodDescription source) Locates the correct default method to a given source method.
Implementation.SpecialMethodInvocation	DefaultMethod.Binder.MethodLocator.resolve(Implementation.Target implementationTarget, MethodDescription source) Resolves the special method invocation to this target.
Implementation.SpecialMethodInvocation	DefaultMethod.Binder.MethodLocator.ForImplicitType.resolve(Implementation.Target implementationTarget, MethodDescription source) Resolves the special method invocation to this target.
Implementation.SpecialMethodInvocation	DefaultMethod.Binder.MethodLocator.ForExplicitType.resolve(Implementation.Target implementationTarget, MethodDescription source) Resolves the special method invocation to this target.

Constructors in net.bytebuddy.implementation.bind.annotation with parameters of type Implementation.Target

Constructor and Description
Appender(Implementation.Target implementationTarget) Creates a new appender.
Appender(Implementation.Target implementationTarget) Creates a new appender.
Appender(Implementation.Target implementationTarget) Creates a new appender.
Appender(Implementation.Target implementationTarget) Creates a new appender for a setter method.
Appender(Implementation.Target implementationTarget) Creates a new appender for a setter method.