Uses of Class
net.bytebuddy.implementation.bytecode.assign.Assigner.Typing

Packages that use Assigner.Typing

Package	Description
net.bytebuddy.asm	The ASM package contains classes that are meant for direct interaction with the ASM API.
net.bytebuddy.implementation	The implementation package contains any logic for intercepting method calls.
net.bytebuddy.implementation.bind	The types and classes of this package are responsible for binding a method call to calling another method.
net.bytebuddy.implementation.bind.annotation	This package contains annotations, types and classes that are responsible for binding a method to calling another method by interpreting annotations that indicate how a method should be bound to another method.
net.bytebuddy.implementation.bytecode.assign	An Assigner is responsible for transforming a given TypeDescription into another one.
net.bytebuddy.implementation.bytecode.assign.primitive	Assigner implementations of this package are capable of handling primitive types or the void type.
net.bytebuddy.implementation.bytecode.assign.reference	Assigner implementations of this package are capable of assigning non-primitive types to each other.

Uses of Assigner.Typing in net.bytebuddy.asm

Fields in net.bytebuddy.asm declared as Assigner.Typing

Modifier and Type	Field	Description
private Assigner.Typing	Advice.AssignReturned.ToAllArguments.Handler.typing	The typing to apply when assigning the returned value to the targeted value.
private Assigner.Typing	Advice.AssignReturned.ToArguments.Handler.typing	The typing to apply when assigning the returned value to the targeted value.
private Assigner.Typing	Advice.AssignReturned.ToFields.Handler.typing	The typing to apply when assigning the returned value to the targeted value.
private Assigner.Typing	Advice.AssignReturned.ToReturned.Handler.typing	The typing to apply when assigning the returned value to the targeted value.
private Assigner.Typing	Advice.AssignReturned.ToThis.Handler.typing	The typing to apply when assigning the returned value to the targeted value.
private Assigner.Typing	Advice.AssignReturned.ToThrown.Handler.typing	The typing to apply when assigning the returned value to the targeted value.
private Assigner.Typing	Advice.OffsetMapping.ForAllArguments.typing	The typing to apply.
private Assigner.Typing	Advice.OffsetMapping.ForArgument.Resolved.Factory.typing	The typing to use.
private Assigner.Typing	Advice.OffsetMapping.ForArgument.typing	The typing to apply when assigning values.
private Assigner.Typing	Advice.OffsetMapping.ForEnterValue.typing	The typing to apply.
private Assigner.Typing	Advice.OffsetMapping.ForExitValue.typing	The typing to apply.
private Assigner.Typing	Advice.OffsetMapping.ForField.Resolved.Factory.typing	The typing to use.
private Assigner.Typing	Advice.OffsetMapping.ForField.typing	The typing to apply.
private Assigner.Typing	Advice.OffsetMapping.ForReturnValue.typing	The typing to apply.
private Assigner.Typing	Advice.OffsetMapping.ForStackManipulation.typing	The typing to apply.
private Assigner.Typing	Advice.OffsetMapping.ForThisReference.typing	The typing to apply.
private Assigner.Typing	Advice.OffsetMapping.ForThrowable.typing	The typing to apply.
private Assigner.Typing	MemberSubstitution.Substitution.Chain.Factory.typing	The typing of the assignment to use.
private Assigner.Typing	MemberSubstitution.Substitution.Chain.Step.ForArgumentSubstitution.typing	The typing to use for the argument assignment.
private Assigner.Typing	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForAllArguments.Resolved.typing	The typing to use.
private Assigner.Typing	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForAllArguments.typing	The typing to use or null if implicit typing.
private Assigner.Typing	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForArgument.Resolved.typing	The typing to use when assigning.
private Assigner.Typing	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForArgument.typing	The typing to use or null if the global typing setting should be applied.
private Assigner.Typing	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForCurrent.Resolved.typing	The typing to use.
private Assigner.Typing	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForCurrent.typing	The typing to use or null if implicit typing.
private Assigner.Typing	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForField.Resolved.Factory.typing	The typing to use.
private Assigner.Typing	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForField.typing	The typing to use or null if implicit typing.
private Assigner.Typing	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForStackManipulation.Resolved.typing	The typing to apply.
private Assigner.Typing	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForThisReference.Resolved.typing	The typing to use..
private Assigner.Typing	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForThisReference.typing	The typing to use or null if implicit typing.
protected Assigner.Typing	MemberSubstitution.Substitution.Chain.Step.ForField.typing	The typing to use when assigning.
private Assigner.Typing	MemberSubstitution.Substitution.Chain.Step.ForInvocation.typing	The typing to use when assigning.
private Assigner.Typing	MemberSubstitution.Substitution.Chain.typing	The typing of the assignment to use.

Methods in net.bytebuddy.asm that return Assigner.Typing

Modifier and Type	Method	Description
Assigner.Typing	typing()	The typing that should be applied when assigning the arguments.
Assigner.Typing	typing()	The typing that should be applied when assigning the argument.
Assigner.Typing	typing()	The typing to apply when assigning the returned value to the targeted value.
Assigner.Typing	typing()	The typing to apply when assigning the returned value to the targeted value.
Assigner.Typing	typing()	The typing to apply when assigning the returned value to the targeted value.
Assigner.Typing	typing()	The typing to apply when assigning the returned value to the targeted value.
Assigner.Typing	typing()	The typing to apply when assigning the returned value to the targeted value.
Assigner.Typing	typing()	The typing to apply when assigning the returned value to the targeted value.
Assigner.Typing	typing()	The typing that should be applied when assigning the enter value.
Assigner.Typing	typing()	The typing that should be applied when assigning the exit value.
Assigner.Typing	typing()	The typing that should be applied when assigning the field value.
Assigner.Typing	typing()	Determines the typing that is applied when assigning the return value.
Assigner.Typing	typing()	The typing that should be applied when assigning the this value.
Assigner.Typing	typing()	Determines the typing that is applied when assigning the captured Throwable to the annotated parameter.
Assigner.Typing	typing()	The typing that should be applied when assigning the arguments to an array element.
Assigner.Typing	typing()	The typing that should be applied when assigning the argument.
Assigner.Typing	typing()	The typing that should be applied when assigning the latest stack value.
Assigner.Typing	typing()	The typing that should be applied when assigning the field value.
Assigner.Typing	typing()	The typing that should be applied when assigning the this value.

Methods in net.bytebuddy.asm with parameters of type Assigner.Typing

Modifier and Type	Method	Description
MemberSubstitution.Substitution.Chain.Step<V>	MemberSubstitution.Substitution.Chain.Step.Factory.make(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Creates a substitution step for an instrumented method.
MemberSubstitution.Substitution.Chain.Step<MemberSubstitution.Target>	MemberSubstitution.Substitution.Chain.Step.ForArgumentLoading.make(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Creates a substitution step for an instrumented method.
MemberSubstitution.Substitution.Chain.Step<MemberSubstitution.Target>	MemberSubstitution.Substitution.Chain.Step.ForArgumentLoading.OfInstrumentedMethod.make(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Creates a substitution step for an instrumented method.
MemberSubstitution.Substitution.Chain.Step<MemberSubstitution.Target>	MemberSubstitution.Substitution.Chain.Step.ForArgumentLoading.OfInstrumentedMethodThis.make(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Creates a substitution step for an instrumented method.
MemberSubstitution.Substitution.Chain.Step<MemberSubstitution.Target>	MemberSubstitution.Substitution.Chain.Step.ForArgumentSubstitution.Factory.make(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Creates a substitution step for an instrumented method.
MemberSubstitution.Substitution.Chain.Step<MemberSubstitution.Target>	MemberSubstitution.Substitution.Chain.Step.ForAssignment.Factory.make(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Creates a substitution step for an instrumented method.
MemberSubstitution.Substitution.Chain.Step<MemberSubstitution.Target>	MemberSubstitution.Substitution.Chain.Step.ForDelegation.Factory.make(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Creates a substitution step for an instrumented method.
MemberSubstitution.Substitution.Chain.Step<MemberSubstitution.Target>	MemberSubstitution.Substitution.Chain.Step.ForField.Read.Factory.make(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Creates a substitution step for an instrumented method.
MemberSubstitution.Substitution.Chain.Step<MemberSubstitution.Target>	MemberSubstitution.Substitution.Chain.Step.ForField.Write.Factory.make(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Creates a substitution step for an instrumented method.
MemberSubstitution.Substitution.Chain.Step<MemberSubstitution.Target>	MemberSubstitution.Substitution.Chain.Step.ForInvocation.Factory.make(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Creates a substitution step for an instrumented method.
MemberSubstitution.Substitution.Chain.Step<MemberSubstitution.Target>	MemberSubstitution.Substitution.Chain.Step.OfOriginalExpression.make(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Creates a substitution step for an instrumented method.
MemberSubstitution.Substitution.Chain.Step<MemberSubstitution.Target>	MemberSubstitution.Substitution.Chain.Step.Simple.make(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Creates a substitution step for an instrumented method.
MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.Resolved	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForAllArguments.resolve(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Resolves an offset mapping for a given instrumented method.
MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.Resolved	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForArgument.resolve(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Resolves an offset mapping for a given instrumented method.
MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.Resolved	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForCurrent.resolve(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Resolves an offset mapping for a given instrumented method.
MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.Resolved	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForDynamicConstant.resolve(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Resolves an offset mapping for a given instrumented method.
MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.Resolved	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForField.resolve(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Resolves an offset mapping for a given instrumented method.
MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.Resolved	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForFieldHandle.resolve(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Resolves an offset mapping for a given instrumented method.
MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.Resolved	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForHandle.resolve(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Resolves an offset mapping for a given instrumented method.
MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.Resolved	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForOrigin.resolve(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Resolves an offset mapping for a given instrumented method.
MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.Resolved	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForSelfCallHandle.resolve(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Resolves an offset mapping for a given instrumented method.
MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.Resolved	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForStackManipulation.resolve(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Resolves an offset mapping for a given instrumented method.
MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.Resolved	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForStubValue.resolve(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Resolves an offset mapping for a given instrumented method.
MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.Resolved	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.ForThisReference.resolve(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Resolves an offset mapping for a given instrumented method.
MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.Resolved	MemberSubstitution.Substitution.Chain.Step.ForDelegation.OffsetMapping.resolve(Assigner assigner, Assigner.Typing typing, TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Resolves an offset mapping for a given instrumented method.
static <U extends MemberSubstitution.Target> MemberSubstitution.Substitution.Chain.Factory<U>	MemberSubstitution.Substitution.Chain.with(Assigner assigner, Assigner.Typing typing)	Creates a new substitution chain.

Constructors in net.bytebuddy.asm with parameters of type Assigner.Typing

Constructor	Description
Chain(Assigner assigner, Assigner.Typing typing, java.util.List<MemberSubstitution.Substitution.Chain.Step<? super S>> steps)	Creates a new substitution chain.
Factory(java.lang.Class<T> annotationType, ParameterDescription parameterDescription, boolean readOnly, Assigner.Typing typing)	Creates a new factory for binding a parameter of the instrumented method.
Factory(java.lang.Class<T> annotationType, FieldDescription fieldDescription, boolean readOnly, Assigner.Typing typing)	Creates a new factory for binding a specific field.
Factory(Assigner assigner, Assigner.Typing typing, java.util.List<MemberSubstitution.Substitution.Chain.Step.Factory<? super U>> steps)	Creates a new factory for a substitution chain.
Factory(java.lang.Class<T> annotationType, FieldDescription fieldDescription, Assigner.Typing typing)	Creates a factory for reading a given field.
ForAllArguments(TypeDescription.Generic target, boolean readOnly, Assigner.Typing typing, boolean includeSelf, boolean nullIfEmpty)	Creates a new offset mapping for an array containing all arguments.
ForAllArguments(TypeDescription.Generic targetComponentType, Assigner.Typing typing, MemberSubstitution.Source source, boolean includeSelf, boolean nullIfEmpty)	Creates a new offset mapping for an array containing all supplied arguments.
ForArgument(TypeDescription.Generic target, boolean readOnly, Assigner.Typing typing)	Creates a new offset mapping for a parameter of the instrumented method.
ForArgument(TypeDescription.Generic targetType, int index, Assigner.Typing typing, MemberSubstitution.Source source, boolean optional)	Creates a new offset mapping for an argument to either the substituted expression or the instrumented method.
ForArgumentSubstitution(StackManipulation substitution, TypeDescription.Generic typeDescription, int index, Assigner assigner, Assigner.Typing typing)	Creates an argument substitution step.
ForCurrent(TypeDescription.Generic targetType, Assigner.Typing typing)	Creates an offset mapping for the previous chain instruction.
ForEnterValue(TypeDescription.Generic target, TypeDescription.Generic enterType, boolean readOnly, Assigner.Typing typing)	Creates a new offset mapping for the enter type.
ForExitValue(TypeDescription.Generic target, TypeDescription.Generic exitType, boolean readOnly, Assigner.Typing typing)	Creates a new offset mapping for the enter type.
ForField(TypeDescription.Generic target, boolean readOnly, Assigner.Typing typing)	Creates an offset mapping for a field.
ForField(TypeDescription.Generic target, Assigner.Typing typing)	Creates an offset mapping for a field value.
ForField(FieldDescription fieldDescription, Assigner assigner, Assigner.Typing typing)	Creates a new step for a field access.
ForInvocation(MethodDescription methodDescription, java.util.Map<java.lang.Integer,java.lang.Integer> substitutions, Assigner assigner, Assigner.Typing typing)	Creates a new step of an invocation.
ForReturnValue(TypeDescription.Generic target, boolean readOnly, Assigner.Typing typing)	Creates a new offset mapping for a return value.
ForStackManipulation(StackManipulation stackManipulation, TypeDescription.Generic typeDescription, TypeDescription.Generic targetType, Assigner.Typing typing)	Creates an offset mapping that binds a stack manipulation.
ForThisReference(TypeDescription.Generic target, boolean readOnly, Assigner.Typing typing, boolean optional)	Creates a new offset mapping for a this reference.
ForThisReference(TypeDescription.Generic targetType, Assigner.Typing typing, MemberSubstitution.Source source, boolean optional)	Creates an offset mapping that resolves the this reference.
ForThrowable(TypeDescription.Generic target, boolean readOnly, Assigner.Typing typing)	Creates a new offset mapping for access of the exception that is thrown by the instrumented method..
Handler(int index, Assigner.Typing typing)	Creates a new handler.
Handler(int value, int index, Assigner.Typing typing)	Creates a new handler.
Handler(int index, java.lang.String name, TypeDescription declaringType, Assigner.Typing typing)	Creates a new handler for a Advice.AssignReturned.ToReturned annotation.
Handler(int index, Assigner.Typing typing)	Creates a new handler for a Advice.AssignReturned.ToReturned annotation.
Handler(int index, Assigner.Typing typing, boolean exit)	A handler for assigning the this reference.
Handler(int index, Assigner.Typing typing)	Creates a new handler to assign a Advice.AssignReturned.ToThrown annotation.
Read(FieldDescription fieldDescription, Assigner assigner, Assigner.Typing typing)	Creates a step for reading a field.
Resolved(TypeDescription.Generic target, boolean readOnly, Assigner.Typing typing, ParameterDescription parameterDescription)	Creates an offset mapping that binds a parameter of the instrumented method.
Resolved(TypeDescription.Generic target, boolean readOnly, Assigner.Typing typing, FieldDescription fieldDescription)	Creates a resolved offset mapping for a field.
Resolved(TypeDescription.Generic targetComponentType, Assigner.Typing typing, MemberSubstitution.Source source, boolean includeSelf, boolean nullIfEmpty, Assigner assigner, MethodDescription instrumentedMethod)	Creates a resolved version for an offset mapping of all arguments.
Resolved(TypeDescription.Generic targetType, int index, Assigner.Typing typing, MemberSubstitution.Source source, boolean optional, Assigner assigner, MethodDescription instrumentedMethod)	Creates a resolved offset mapping for assigning a parameter.
Resolved(TypeDescription.Generic targetType, Assigner assigner, Assigner.Typing typing)	Creates a resolved offset mapping for assigning the previous chain instruction.
Resolved(TypeDescription.Generic target, Assigner.Typing typing, FieldDescription fieldDescription)	Creates a resolved offset mapping for a field access.
Resolved(Assigner assigner, Assigner.Typing typing, StackManipulation stackManipulation, TypeDescription.Generic typeDescription, TypeDescription.Generic targetType)	Creates a resolved offset mapping for a given stack manipulation.
Resolved(TypeDescription.Generic targetType, Assigner.Typing typing, MemberSubstitution.Source source, boolean optional, Assigner assigner, MethodDescription instrumentedMethod)	Creates a resolved offset mapping for assigning the this reference.
Unresolved(TypeDescription.Generic target, boolean readOnly, Assigner.Typing typing, int index)	Creates a non-optional offset binding for a parameter with a given index.
Unresolved(TypeDescription.Generic target, boolean readOnly, Assigner.Typing typing, int index, boolean optional)	Creates a new offset binding for a parameter with a given index.
Unresolved(TypeDescription.Generic target, boolean readOnly, Assigner.Typing typing, java.lang.String name)	Creates an offset mapping for a field that is not yet resolved.
Unresolved(TypeDescription.Generic target, Assigner.Typing typing, java.lang.String name)	Creates an offset mapping for the value of an unresolved field.
WithExplicitType(TypeDescription.Generic target, boolean readOnly, Assigner.Typing typing, java.lang.String name, TypeDescription declaringType)	Creates an offset mapping for a field with an explicit declaring type.
WithExplicitType(TypeDescription.Generic target, Assigner.Typing typing, java.lang.String name, TypeDescription declaringType)	Creates an offset mapping for the value of an unresolved field with an explicit declaring type.
WithImplicitType(TypeDescription.Generic target, boolean readOnly, Assigner.Typing typing, java.lang.String name)	Creates an offset mapping for a field with an implicit declaring type.
WithImplicitType(TypeDescription.Generic target, Assigner.Typing typing, java.lang.String name)	Creates an offset mapping for the value of an unresolved field with an implicit declaring type.
Write(FieldDescription fieldDescription, Assigner assigner, Assigner.Typing typing, int index)	Creates a step for writing to a field.

Uses of Assigner.Typing in net.bytebuddy.implementation

Fields in net.bytebuddy.implementation declared as Assigner.Typing

Modifier and Type	Field	Description
protected Assigner.Typing	FieldAccessor.typing	Indicates if dynamic type castings should be attempted for incompatible assignments.
protected Assigner.Typing	FixedValue.typing	Indicates if dynamic type castings should be attempted for incompatible assignments.
protected Assigner.Typing	InvokeDynamic.typing	Indicates if dynamic type castings should be attempted for incompatible assignments.
protected Assigner.Typing	MethodCall.typing	Indicates if dynamic type castings should be attempted for incompatible assignments.

Methods in net.bytebuddy.implementation with parameters of type Assigner.Typing

Modifier and Type	Method	Description
protected InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForField.doResolve(StackManipulation access, TypeDescription.Generic type, Assigner assigner, Assigner.Typing typing)	Resolves this argument provider.
protected InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForField.WithExplicitType.doResolve(StackManipulation access, TypeDescription.Generic typeDescription, Assigner assigner, Assigner.Typing typing)	Resolves this argument provider.
protected InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter.doResolve(StackManipulation access, TypeDescription.Generic type, Assigner assigner, Assigner.Typing typing)	Resolves this argument provider.
protected InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter.WithExplicitType.doResolve(StackManipulation access, TypeDescription.Generic type, Assigner assigner, Assigner.Typing typing)	Resolves this argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ConstantPoolWrapper.WrappingArgumentProvider.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForBooleanConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForByteConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForCharacterConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForClassConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForDoubleConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForEnumerationValue.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForField.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForFloatConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForInstance.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForIntegerConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForInterceptedMethodInstanceAndParameters.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForInterceptedMethodParameters.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForJavaConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForLongConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForNullValue.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForShortConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForStringConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForThisInstance.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.Target.Resolved	InvokeDynamic.InvocationProvider.Default.Target.resolve(TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)	Resolves the target.
InvokeDynamic.InvocationProvider.Target.Resolved	InvokeDynamic.InvocationProvider.Target.resolve(TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)	Resolves the target.
protected abstract StackManipulation	InvokeDynamic.TerminationHandler.resolve(MethodDescription interceptedMethod, TypeDescription returnType, Assigner assigner, Assigner.Typing typing)	Returns a stack manipulation that handles the method return.
StackManipulation	MethodCall.ArgumentLoader.ForField.toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)	Loads the argument that is represented by this instance onto the operand stack.
StackManipulation	MethodCall.ArgumentLoader.ForInstance.toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)	Loads the argument that is represented by this instance onto the operand stack.
StackManipulation	MethodCall.ArgumentLoader.ForInstrumentedType.toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)	Loads the argument that is represented by this instance onto the operand stack.
StackManipulation	MethodCall.ArgumentLoader.ForMethodCall.toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)	Loads the argument that is represented by this instance onto the operand stack.
StackManipulation	MethodCall.ArgumentLoader.ForMethodParameter.toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)	Loads the argument that is represented by this instance onto the operand stack.
StackManipulation	MethodCall.ArgumentLoader.ForMethodParameterArray.toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)	Loads the argument that is represented by this instance onto the operand stack.
StackManipulation	MethodCall.ArgumentLoader.ForMethodParameterArrayElement.toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)	Loads the argument that is represented by this instance onto the operand stack.
StackManipulation	MethodCall.ArgumentLoader.ForNullConstant.toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)	Loads the argument that is represented by this instance onto the operand stack.
StackManipulation	MethodCall.ArgumentLoader.ForStackManipulation.toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)	Loads the argument that is represented by this instance onto the operand stack.
StackManipulation	MethodCall.ArgumentLoader.ForThisReference.toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)	Loads the argument that is represented by this instance onto the operand stack.
StackManipulation	MethodCall.ArgumentLoader.toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)	Loads the argument that is represented by this instance onto the operand stack.
StackManipulation	MethodCall.TargetHandler.ForConstructingInvocation.toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)	Creates a stack manipulation to represent this resolved target handler.
StackManipulation	MethodCall.TargetHandler.ForField.toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)	Creates a stack manipulation to represent this resolved target handler.
StackManipulation	MethodCall.TargetHandler.ForMethodCall.Resolved.toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)	Creates a stack manipulation to represent this resolved target handler.
StackManipulation	MethodCall.TargetHandler.ForMethodParameter.Resolved.toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)	Creates a stack manipulation to represent this resolved target handler.
StackManipulation	MethodCall.TargetHandler.ForSelfOrStaticInvocation.Resolved.toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)	Creates a stack manipulation to represent this resolved target handler.
StackManipulation	MethodCall.TargetHandler.ForValue.toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)	Creates a stack manipulation to represent this resolved target handler.
StackManipulation	MethodCall.TargetHandler.Resolved.toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)	Creates a stack manipulation to represent this resolved target handler.
StackManipulation	MethodCall.TargetHandler.Simple.toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)	Creates a stack manipulation to represent this resolved target handler.
StackManipulation	MethodCall.TerminationHandler.FieldSetting.toStackManipulation(MethodDescription invokedMethod, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Returns a stack manipulation that handles the method return.
StackManipulation	MethodCall.TerminationHandler.toStackManipulation(MethodDescription invokedMethod, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Returns a stack manipulation that handles the method return.
FieldAccessor.PropertyConfigurable	FieldAccessor.AssignerConfigurable.withAssigner(Assigner assigner, Assigner.Typing typing)	Returns a field accessor that is identical to this field accessor but uses the given assigner and runtime type use configuration.
FieldAccessor.PropertyConfigurable	FieldAccessor.ForImplicitProperty.withAssigner(Assigner assigner, Assigner.Typing typing)	Returns a field accessor that is identical to this field accessor but uses the given assigner and runtime type use configuration.
Implementation	FixedValue.AssignerConfigurable.withAssigner(Assigner assigner, Assigner.Typing typing)	Defines an explicit assigner to this fixed value implementation.
Implementation	FixedValue.ForArgument.withAssigner(Assigner assigner, Assigner.Typing typing)	Defines an explicit assigner to this fixed value implementation.
Implementation	FixedValue.ForConstantValue.withAssigner(Assigner assigner, Assigner.Typing typing)	Defines an explicit assigner to this fixed value implementation.
Implementation	FixedValue.ForOriginType.withAssigner(Assigner assigner, Assigner.Typing typing)	Defines an explicit assigner to this fixed value implementation.
Implementation	FixedValue.ForThisValue.withAssigner(Assigner assigner, Assigner.Typing typing)	Defines an explicit assigner to this fixed value implementation.
Implementation	FixedValue.ForValue.withAssigner(Assigner assigner, Assigner.Typing typing)	Defines an explicit assigner to this fixed value implementation.
Implementation.Composable	InvokeDynamic.AbstractDelegator.withAssigner(Assigner assigner, Assigner.Typing typing)	Instructs this implementation to use the provided assigner and decides if the assigner should apply dynamic typing.
Implementation.Composable	InvokeDynamic.withAssigner(Assigner assigner, Assigner.Typing typing)	Instructs this implementation to use the provided assigner and decides if the assigner should apply dynamic typing.
InvokeDynamic.WithImplicitArguments	InvokeDynamic.WithImplicitArguments.withAssigner(Assigner assigner, Assigner.Typing typing)	Instructs this implementation to use the provided assigner and decides if the assigner should apply dynamic typing.
Implementation.Composable	MethodCall.FieldSetting.withAssigner(Assigner assigner, Assigner.Typing typing)	Defines an assigner to be used for assigning values to the parameters of the invoked method.
Implementation.Composable	MethodCall.withAssigner(Assigner assigner, Assigner.Typing typing)	Defines an assigner to be used for assigning values to the parameters of the invoked method.

Constructors in net.bytebuddy.implementation with parameters of type Assigner.Typing

Constructor	Description
AbstractDelegator(MethodDescription.InDefinedShape bootstrap, java.util.List<? extends JavaConstant> arguments, InvokeDynamic.InvocationProvider invocationProvider, InvokeDynamic.TerminationHandler terminationHandler, Assigner assigner, Assigner.Typing typing)	Creates a new abstract delegator for a dynamic method invocation.
FieldAccessor(FieldAccessor.FieldLocation fieldLocation, Assigner assigner, Assigner.Typing typing)	Creates a new field accessor.
FixedValue(Assigner assigner, Assigner.Typing typing)	Creates a new fixed value implementation.
ForArgument(Assigner assigner, Assigner.Typing typing, int index)	Creates a new fixed value implementation that returns a method's argument.
ForConstantValue(Assigner assigner, Assigner.Typing typing, StackManipulation valueLoadInstruction, TypeDescription loadedType)	Creates a new constant pool fixed value implementation.
ForImplicitProperty(FieldAccessor.FieldLocation fieldLocation, Assigner assigner, Assigner.Typing typing)	Creates a field accessor for an implicit property.
ForOriginType(Assigner assigner, Assigner.Typing typing)	Creates a new fixed value appender for the origin type.
ForSetter(FieldAccessor.FieldLocation fieldLocation, Assigner assigner, Assigner.Typing typing, FieldAccessor.ForSetter.TerminationHandler terminationHandler)	Creates a new field accessor for a setter instrumentation.
ForThisValue(Assigner assigner, Assigner.Typing typing)	Creates an implementation that returns the instance of the instrumented type.
ForValue(Assigner assigner, Assigner.Typing typing, java.lang.Object value, java.lang.String name)	Creates a new static field fixed value implementation.
InvokeDynamic(MethodDescription.InDefinedShape bootstrap, java.util.List<? extends JavaConstant> arguments, InvokeDynamic.InvocationProvider invocationProvider, InvokeDynamic.TerminationHandler terminationHandler, Assigner assigner, Assigner.Typing typing)	Creates a new invoke dynamic implementation.
MethodCall(MethodCall.MethodLocator.Factory methodLocator, MethodCall.TargetHandler.Factory targetHandler, java.util.List<MethodCall.ArgumentLoader.Factory> argumentLoaders, MethodCall.MethodInvoker.Factory methodInvoker, MethodCall.TerminationHandler.Factory terminationHandler, Assigner assigner, Assigner.Typing typing)	Creates a new method call implementation.
OfArgument(MethodDescription.InDefinedShape bootstrap, java.util.List<? extends JavaConstant> arguments, InvokeDynamic.InvocationProvider invocationProvider, InvokeDynamic.TerminationHandler terminationHandler, Assigner assigner, Assigner.Typing typing, int index)	Creates a new invoke dynamic instance with an implicit field type for the provided value.
OfConstantValue(FieldAccessor.FieldLocation fieldLocation, Assigner assigner, Assigner.Typing typing, FieldAccessor.ForSetter.TerminationHandler terminationHandler, TypeDescription.Generic typeDescription, StackManipulation stackManipulation)	Creates a setter instrumentation for setting a constant value.
OfDefaultValue(FieldAccessor.FieldLocation fieldLocation, Assigner assigner, Assigner.Typing typing, FieldAccessor.ForSetter.TerminationHandler terminationHandler)	Creates an intrumentation that sets a field's default value.
OfField(MethodDescription.InDefinedShape bootstrap, java.util.List<? extends JavaConstant> arguments, InvokeDynamic.InvocationProvider invocationProvider, InvokeDynamic.TerminationHandler terminationHandler, Assigner assigner, Assigner.Typing typing, java.lang.String fieldName, FieldLocator.Factory fieldLocatorFactory)	Creates a new abstract delegator for a dynamic method invocation where the last argument is assigned an implicit type.
OfFieldValue(FieldAccessor.FieldLocation fieldLocation, Assigner assigner, Assigner.Typing typing, FieldAccessor.ForSetter.TerminationHandler terminationHandler, FieldAccessor.FieldLocation target)	Creates a setter that sets another field value.
OfInstance(MethodDescription.InDefinedShape bootstrap, java.util.List<? extends JavaConstant> arguments, InvokeDynamic.InvocationProvider invocationProvider, InvokeDynamic.TerminationHandler terminationHandler, Assigner assigner, Assigner.Typing typing, java.lang.Object value)	Creates a new invoke dynamic instance with an implicit field type for the provided value.
OfParameterValue(FieldAccessor.FieldLocation fieldLocation, Assigner assigner, Assigner.Typing typing, FieldAccessor.ForSetter.TerminationHandler terminationHandler, int index)	Creates a new setter instrumentation for a parameter value.
OfReferenceValue(FieldAccessor.FieldLocation fieldLocation, Assigner assigner, Assigner.Typing typing, FieldAccessor.ForSetter.TerminationHandler terminationHandler, java.lang.Object value, java.lang.String name)	Creates a setter instrumentation for setting a value stored in a static field of the instrumented type.
WithImplicitArguments(MethodDescription.InDefinedShape bootstrap, java.util.List<? extends JavaConstant> arguments, InvokeDynamic.InvocationProvider invocationProvider, InvokeDynamic.TerminationHandler terminationHandler, Assigner assigner, Assigner.Typing typing)	Creates a new dynamic method invocation with implicit arguments.
WithImplicitTarget(MethodDescription.InDefinedShape bootstrap, java.util.List<? extends JavaConstant> arguments, InvokeDynamic.InvocationProvider invocationProvider, InvokeDynamic.TerminationHandler terminationHandler, Assigner assigner, Assigner.Typing typing)	Creates a new dynamic method invocation with implicit arguments and an implicit invocation target.
WithImplicitType(MethodDescription.InDefinedShape bootstrap, java.util.List<? extends JavaConstant> arguments, InvokeDynamic.InvocationProvider invocationProvider, InvokeDynamic.TerminationHandler terminationHandler, Assigner assigner, Assigner.Typing typing)	Creates a new abstract delegator for a dynamic method invocation where the last argument is assigned an implicit type.

Uses of Assigner.Typing in net.bytebuddy.implementation.bind

Methods in net.bytebuddy.implementation.bind with parameters of type Assigner.Typing

Modifier and Type	Method	Description
StackManipulation	MethodDelegationBinder.TerminationHandler.resolve(Assigner assigner, Assigner.Typing typing, MethodDescription source, MethodDescription target)	Creates a stack manipulation that is to be applied after the method return.

Uses of Assigner.Typing in net.bytebuddy.implementation.bind.annotation

Fields in net.bytebuddy.implementation.bind.annotation declared as Assigner.Typing

Modifier and Type	Field	Description
private Assigner.Typing	TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Bound.typing	The typing to apply.
private Assigner.Typing	TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Unbound.typing	The typing to apply.
private Assigner.Typing	TargetMethodAnnotationDrivenBinder.Record.typing	The typing to apply.

Methods in net.bytebuddy.implementation.bind.annotation that return Assigner.Typing

Modifier and Type	Method	Description
static Assigner.Typing	RuntimeType.Verifier.check(AnnotationSource annotationSource)	Checks if an annotated element should be assigned a value by considering the runtime type.

Methods in net.bytebuddy.implementation.bind.annotation with parameters of type Assigner.Typing

Modifier and Type	Method	Description
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<?>	DefaultCallHandle.Binder.bind(AnnotationDescription.Loadable<DefaultCallHandle> 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<?>	DefaultMethodHandle.Binder.bind(AnnotationDescription.Loadable<DefaultMethodHandle> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing)	Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	DynamicConstant.Binder.bind(AnnotationDescription.Loadable<DynamicConstant> 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<?>	FieldGetterHandle.Binder.bind(AnnotationDescription.Loadable<FieldGetterHandle> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner, Assigner.Typing typing)	Creates a parameter binding for the given target parameter.
MethodDelegationBinder.ParameterBinding<?>	FieldSetterHandle.Binder.bind(AnnotationDescription.Loadable<FieldSetterHandle> 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<?>	Handle.Binder.bind(AnnotationDescription.Loadable<Handle> 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<?>	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<?>	SuperCallHandle.Binder.bind(AnnotationDescription.Loadable<SuperCallHandle> 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<?>	SuperMethodHandle.Binder.bind(AnnotationDescription.Loadable<SuperMethodHandle> 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<?>	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<?>	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<?>	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 abstract MethodDelegationBinder.ParameterBinding<?>	Argument.BindingMechanic.makeBinding(TypeDescription.Generic source, TypeDescription.Generic target, int sourceParameterIndex, Assigner assigner, Assigner.Typing typing, int parameterOffset)	Creates a binding that corresponds to this binding mechanic.
protected static TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler	TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Bound.of(ParameterDescription target, TargetMethodAnnotationDrivenBinder.ParameterBinder<?> parameterBinder, AnnotationDescription annotation, Assigner.Typing typing)	Creates a handler for a given annotation.

Constructors in net.bytebuddy.implementation.bind.annotation with parameters of type Assigner.Typing

Constructor	Description
Bound(ParameterDescription target, TargetMethodAnnotationDrivenBinder.ParameterBinder<T> parameterBinder, AnnotationDescription.Loadable<T> annotation, Assigner.Typing typing)	Creates a new bound handler.
Record(MethodDescription candidate, java.util.List<TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler> handlers, Assigner.Typing typing)	Creates a default compiled method delegation binder.
Unbound(ParameterDescription target, Assigner.Typing typing)	Creates a new unbound handler.

Uses of Assigner.Typing in net.bytebuddy.implementation.bytecode.assign

Methods in net.bytebuddy.implementation.bytecode.assign that return Assigner.Typing

Modifier and Type	Method	Description
static Assigner.Typing	Assigner.Typing.of(boolean dynamic)	Resolves a typing constant for the presented boolean where true indicates that dynamic typing is a legitimate choice.
static Assigner.Typing	Assigner.Typing.valueOf(java.lang.String name)	Returns the enum constant of this type with the specified name.
static Assigner.Typing[]	Assigner.Typing.values()	Returns an array containing the constants of this enum type, in the order they are declared.

Methods in net.bytebuddy.implementation.bytecode.assign with parameters of type Assigner.Typing

Modifier and Type	Method	Description
StackManipulation	Assigner.assign(TypeDescription.Generic source, TypeDescription.Generic target, Assigner.Typing typing)
StackManipulation	Assigner.Refusing.assign(TypeDescription.Generic source, TypeDescription.Generic target, Assigner.Typing typing)

Uses of Assigner.Typing in net.bytebuddy.implementation.bytecode.assign.primitive

Methods in net.bytebuddy.implementation.bytecode.assign.primitive with parameters of type Assigner.Typing

Modifier and Type	Method	Description
StackManipulation	PrimitiveTypeAwareAssigner.assign(TypeDescription.Generic source, TypeDescription.Generic target, Assigner.Typing typing)
StackManipulation	VoidAwareAssigner.assign(TypeDescription.Generic source, TypeDescription.Generic target, Assigner.Typing typing)
StackManipulation	PrimitiveBoxingDelegate.assignBoxedTo(TypeDescription.Generic target, Assigner chainedAssigner, Assigner.Typing typing)	Creates a stack manipulation that boxes the represented primitive type and applies a chained assignment to the result of this boxing operation.
StackManipulation	PrimitiveUnboxingDelegate.ExplicitlyTypedUnboxingResponsible.assignUnboxedTo(TypeDescription.Generic targetType, Assigner assigner, Assigner.Typing typing)	Attempts to unbox the represented type in order to assign the unboxed value to the given target type while using the assigner that is provided by the method call.
StackManipulation	PrimitiveUnboxingDelegate.ImplicitlyTypedUnboxingResponsible.assignUnboxedTo(TypeDescription.Generic target, Assigner assigner, Assigner.Typing typing)	Attempts to unbox the represented type in order to assign the unboxed value to the given target type while using the assigner that is provided by the method call.
StackManipulation	PrimitiveUnboxingDelegate.UnboxingResponsible.assignUnboxedTo(TypeDescription.Generic target, Assigner assigner, Assigner.Typing typing)	Attempts to unbox the represented type in order to assign the unboxed value to the given target type while using the assigner that is provided by the method call.

Uses of Assigner.Typing in net.bytebuddy.implementation.bytecode.assign.reference

Methods in net.bytebuddy.implementation.bytecode.assign.reference with parameters of type Assigner.Typing

Modifier and Type	Method	Description
StackManipulation	GenericTypeAwareAssigner.assign(TypeDescription.Generic source, TypeDescription.Generic target, Assigner.Typing typing)
StackManipulation	ReferenceTypeAwareAssigner.assign(TypeDescription.Generic source, TypeDescription.Generic target, Assigner.Typing typing)