Uses of Interface
net.bytebuddy.implementation.bytecode.StackManipulation

Packages that use StackManipulation

Package	Description
net.bytebuddy.asm	The ASM package contains classes that are meant for direct interaction with the ASM API.
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.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.
net.bytebuddy.implementation.bytecode	Types and classes in this package are responsible for creating Java byte code for a given byte code target which is represented by a MethodDescription.
net.bytebuddy.implementation.bytecode.assign	An Assigner is responsible for transforming a given TypeDescription into another one.
net.bytebuddy.implementation.bytecode.assign.primitive	Assigner implementations of this package are capable of handling primitive types or the void type.
net.bytebuddy.implementation.bytecode.assign.reference	Assigner implementations of this package are capable of assigning non-primitive types to each other.
net.bytebuddy.implementation.bytecode.collection	This package is dedicated to creating StackManipulations that create collections or arrays from a given number of values.
net.bytebuddy.implementation.bytecode.constant	StackManipulations in this package are responsible for creating compile-time constants and pushing them onto the operand stack.
net.bytebuddy.implementation.bytecode.member	StackManipulations of this package are responsible for accessing type or method members, i.e. reading and writing of fields, invoking of methods, access of local variables within a method invocation or returning values from method invocations.
net.bytebuddy.utility	This package contains utility classes for common use within any Byte Buddy logic.

Uses of StackManipulation in net.bytebuddy.asm

Fields in net.bytebuddy.asm declared as StackManipulation

Modifier and Type	Field and Description
protected StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForDefaultValue.readAssignment A stack manipulation to apply after a read instruction.
protected StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForVariable.readAssignment An assignment to execute upon reading a value.
protected StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForField.readAssignment The stack manipulation to apply upon a read.

Fields in net.bytebuddy.asm with type parameters of type StackManipulation

Modifier and Type	Field and Description
protected List<? extends StackManipulation>	Advice.Dispatcher.OffsetMapping.Target.ForArray.valueReads The stack manipulations to apply upon reading a variable array.

Methods in net.bytebuddy.asm that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	Advice.DynamicValue.ForFieldValue.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, ParameterDescription.InDefinedShape target, AnnotationDescription.Loadable<Annotation> annotation, Assigner assigner, boolean initialized)
StackManipulation	Advice.DynamicValue.ForParameterValue.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, ParameterDescription.InDefinedShape target, AnnotationDescription.Loadable<Annotation> annotation, Assigner assigner, boolean initialized)
StackManipulation	Advice.DynamicValue.ForSerializedValue.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, ParameterDescription.InDefinedShape target, AnnotationDescription.Loadable<Annotation> annotation, Assigner assigner, boolean initialized)
StackManipulation	Advice.DynamicValue.ForFixedValue.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, ParameterDescription.InDefinedShape target, AnnotationDescription.Loadable<S> annotation, Assigner assigner, boolean initialized)
StackManipulation	Advice.DynamicValue.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, ParameterDescription.InDefinedShape target, AnnotationDescription.Loadable<T> annotation, Assigner assigner, boolean initialized) Resolves a constant value that is mapped to a parameter that is annotated with a custom bound annotation: A primitive wrapper value allow binding of the primitive which is optionally boxed but never unboxed.
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.resolveIncrement(int value) Resolves an increment instruction.
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForDefaultValue.ReadOnly.resolveIncrement(int value)
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForDefaultValue.ReadWrite.resolveIncrement(int value)
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForVariable.ReadOnly.resolveIncrement(int value)
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForVariable.ReadWrite.resolveIncrement(int value)
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForArray.resolveIncrement(int value)
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForStackManipulation.resolveIncrement(int value)
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.resolveRead() Resolves a read instruction.
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForDefaultValue.resolveRead()
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForVariable.resolveRead()
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForArray.resolveRead()
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForField.resolveRead()
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForStackManipulation.resolveRead()
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.resolveWrite() Resolves a write instruction.
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForDefaultValue.ReadOnly.resolveWrite()
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForDefaultValue.ReadWrite.resolveWrite()
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForVariable.ReadOnly.resolveWrite()
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForVariable.ReadWrite.resolveWrite()
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForArray.ReadOnly.resolveWrite()
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForArray.ReadWrite.resolveWrite()
StackManipulation	Advice.Dispatcher.OffsetMapping.Target.ForStackManipulation.resolveWrite()

Methods in net.bytebuddy.asm with parameters of type StackManipulation

Modifier and Type	Method and Description
Advice.Dispatcher.SuppressionHandler.Bound	Advice.Dispatcher.SuppressionHandler.bind(StackManipulation exceptionHandler) Binds the suppression handler for instrumenting a specific method.
Advice.Dispatcher.SuppressionHandler.Bound	Advice.Dispatcher.SuppressionHandler.NoOp.bind(StackManipulation exceptionHandler)
Advice.Dispatcher.SuppressionHandler.Bound	Advice.Dispatcher.SuppressionHandler.Suppressing.bind(StackManipulation exceptionHandler)
Advice.Dispatcher.Bound	Advice.Dispatcher.Resolved.bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler) Binds this dispatcher for resolution to a specific method.
Advice.Dispatcher.Bound.ForMethodEnter	Advice.Dispatcher.Resolved.ForMethodEnter.bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler)
Advice.Dispatcher.Bound.ForMethodExit	Advice.Dispatcher.Resolved.ForMethodExit.bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler)
Advice.Dispatcher.Inactive	Advice.Dispatcher.Inactive.bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler)
Advice.Dispatcher.Bound.ForMethodEnter	Advice.Dispatcher.Inlining.Resolved.ForMethodEnter.bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler)
Advice.Dispatcher.Bound.ForMethodExit	Advice.Dispatcher.Inlining.Resolved.ForMethodExit.bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler)
T	Advice.Dispatcher.Delegating.Resolved.bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler)
protected abstract T	Advice.Dispatcher.Delegating.Resolved.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler) Binds this dispatcher for resolution to a specific method.
protected Advice.Dispatcher.Bound.ForMethodEnter	Advice.Dispatcher.Delegating.Resolved.ForMethodEnter.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler)
protected Advice.Dispatcher.Bound.ForMethodExit	Advice.Dispatcher.Delegating.Resolved.ForMethodExit.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler)
Advice	Advice.withExceptionHandler(StackManipulation exceptionHandler) Configures this advice to execute the given stack manipulation upon a suppressed exception.

Constructors in net.bytebuddy.asm with parameters of type StackManipulation

Constructor and Description
AdviceVisitor(MethodVisitor methodVisitor, MethodVisitor delegate, Implementation.Context implementationContext, Assigner assigner, StackManipulation exceptionHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.Resolved.ForMethodEnter methodEnter, Advice.Dispatcher.Resolved.ForMethodExit methodExit, List<? extends TypeDescription> yieldedTypes, int writerFlags, int readerFlags) Creates a new advice visitor.
Bound(TypeDescription suppressedType, StackManipulation exceptionHandler) Creates a new active, bound suppression handler.
ForDefaultValue(TypeDefinition typeDefinition, StackManipulation readAssignment) Creates a new target for a default value.
ForField(FieldDescription fieldDescription, StackManipulation readAssignment) Creates a new target for a field value mapping.
ForSerializedValue(TypeDescription typeDescription, StackManipulation deserialization) Creates a new dynamic value for representing a serializable value.
ForStackManipulation(StackManipulation stackManipulation) Creates a new target for an offset mapping for a stack manipulation.
ForVariable(TypeDefinition typeDefinition, int offset, StackManipulation readAssignment) Creates a new target for a local variable mapping.
ReadOnly(ParameterDescription parameterDescription, StackManipulation readAssignment) Creates a read-only mapping for a local variable.
ReadOnly(TypeDefinition typeDefinition, int offset, StackManipulation readAssignment) Creates a read-only mapping for a local variable.
ReadOnly(TypeDefinition typeDefinition, StackManipulation readAssignment) Creates a new -writable target for a default value.
ReadWrite(ParameterDescription parameterDescription, StackManipulation readAssignment, StackManipulation writeAssignment) Creates a new target mapping for a writable local variable.
ReadWrite(TypeDefinition typeDefinition, int offset, StackManipulation readAssignment, StackManipulation writeAssignment) Creates a new target mapping for a writable local variable.
ReadWrite(TypeDefinition typeDefinition, StackManipulation readAssignment) Creates a new read-only target for a default value.
WithExceptionHandling(MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, StackManipulation exceptionHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.Resolved.ForMethodEnter methodEnter, Advice.Dispatcher.Resolved.ForMethodExit methodExit, int writerFlags, int readerFlags, TypeDescription throwable) Creates a new advice visitor that captures exception by weaving try-catch blocks around user code.
WithExitAdvice(MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, StackManipulation exceptionHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.Resolved.ForMethodEnter methodEnter, Advice.Dispatcher.Resolved.ForMethodExit methodExit, List<? extends TypeDescription> yieldedTypes, int writerFlags, int readerFlags) Creates an advice visitor that applies exit advice.
WithoutExceptionHandling(MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, StackManipulation exceptionHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.Resolved.ForMethodEnter methodEnter, Advice.Dispatcher.Resolved.ForMethodExit methodExit, int writerFlags, int readerFlags) Creates a new advice visitor that does not capture exceptions.
WithoutExitAdvice(MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, StackManipulation exceptionHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.Resolved.ForMethodEnter methodEnter, int writerFlags, int readerFlags) Creates an advice visitor that does not apply exit advice.

Constructor parameters in net.bytebuddy.asm with type arguments of type StackManipulation

Constructor and Description
ForArray(TypeDescription.Generic target, List<? extends StackManipulation> valueReads) Creates a new target mapping for an array of all local variables.
ReadOnly(TypeDescription.Generic target, List<? extends StackManipulation> valueReads) Creates a read-only target mapping for an array of all local variables.
ReadWrite(TypeDescription.Generic target, List<? extends StackManipulation> valueReads, List<? extends StackManipulation> valueWrites) Creates a writable target mapping for an array of all local variables.
ReadWrite(TypeDescription.Generic target, List<? extends StackManipulation> valueReads, List<? extends StackManipulation> valueWrites) Creates a writable target mapping for an array of all local variables.

Uses of StackManipulation in net.bytebuddy.dynamic.scaffold.inline

Classes in net.bytebuddy.dynamic.scaffold.inline that implement StackManipulation

Modifier and Type	Class and Description
protected static class	RebaseImplementationTarget.RebasedMethodInvocation A Implementation.SpecialMethodInvocation which invokes a rebased method as given by a MethodRebaseResolver.

Methods in net.bytebuddy.dynamic.scaffold.inline that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	MethodRebaseResolver.Resolution.getAdditionalArguments() A rebased method might require additional arguments in order to create a distinct signature.
StackManipulation	MethodRebaseResolver.Resolution.Preserved.getAdditionalArguments()
StackManipulation	MethodRebaseResolver.Resolution.ForRebasedMethod.getAdditionalArguments()
StackManipulation	MethodRebaseResolver.Resolution.ForRebasedConstructor.getAdditionalArguments()

Methods in net.bytebuddy.dynamic.scaffold.inline with parameters of type StackManipulation

Modifier and Type	Method and Description
protected static Implementation.SpecialMethodInvocation	RebaseImplementationTarget.RebasedMethodInvocation.of(MethodDescription resolvedMethod, TypeDescription instrumentedType, StackManipulation additionalArguments) Creates a special method invocation for the given method.

Constructors in net.bytebuddy.dynamic.scaffold.inline with parameters of type StackManipulation

Constructor and Description
RebasedMethodInvocation(MethodDescription methodDescription, TypeDescription instrumentedType, StackManipulation stackManipulation) Creates a new rebased method invocation.

Uses of StackManipulation in net.bytebuddy.implementation

Subinterfaces of StackManipulation in net.bytebuddy.implementation

Modifier and Type	Interface and Description
static interface	Implementation.SpecialMethodInvocation Represents an type-specific method invocation on the current instrumented type which is not legal from outside the type such as a super method or default method invocation.

Classes in net.bytebuddy.implementation that implement StackManipulation

Modifier and Type	Class and Description
protected static class	Implementation.Context.Default.FieldCacheEntry A field cache entry for uniquely identifying a cached field.
static class	Implementation.SpecialMethodInvocation.AbstractBase An abstract base implementation of a valid special method invocation.
static class	Implementation.SpecialMethodInvocation.Illegal A canonical implementation of an illegal Implementation.SpecialMethodInvocation.
static class	Implementation.SpecialMethodInvocation.Simple A canonical implementation of a Implementation.SpecialMethodInvocation.

Methods in net.bytebuddy.implementation that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved.getLoadInstruction() Returns a stack manipulation that loads the arguments onto the operand stack.
StackManipulation	InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved.Simple.getLoadInstruction()
StackManipulation	InvokeDynamic.InvocationProvider.Target.Resolved.getStackManipulation() Returns the stack manipulation that loads the arguments onto the operand stack.
StackManipulation	InvokeDynamic.InvocationProvider.Target.Resolved.Simple.getStackManipulation()
StackManipulation	InvokeDynamic.InvocationProvider.Target.ForMethodDescription.getStackManipulation()
protected StackManipulation	FieldAccessor.getter(FieldDescription fieldDescription, MethodDescription instrumentedMethod) Creates a getter getter.
StackManipulation	MethodCall.MethodInvoker.invoke(MethodDescription invokedMethod, Implementation.Target implementationTarget) Invokes the method.
StackManipulation	MethodCall.MethodInvoker.ForContextualInvocation.invoke(MethodDescription invokedMethod, Implementation.Target implementationTarget)
StackManipulation	MethodCall.MethodInvoker.ForVirtualInvocation.invoke(MethodDescription invokedMethod, Implementation.Target implementationTarget)
StackManipulation	MethodCall.MethodInvoker.ForVirtualInvocation.WithImplicitType.invoke(MethodDescription invokedMethod, Implementation.Target implementationTarget)
StackManipulation	MethodCall.MethodInvoker.ForSuperMethodInvocation.invoke(MethodDescription invokedMethod, Implementation.Target implementationTarget)
StackManipulation	MethodCall.MethodInvoker.ForDefaultMethodInvocation.invoke(MethodDescription invokedMethod, Implementation.Target implementationTarget)
StackManipulation	ExceptionMethod.ConstructionDelegate.make() Creates a stack manipulation that creates pushes all constructor arguments onto the operand stack and subsequently calls the constructor.
StackManipulation	ExceptionMethod.ConstructionDelegate.ForDefaultConstructor.make()
StackManipulation	ExceptionMethod.ConstructionDelegate.ForStringConstructor.make()
protected abstract StackManipulation	SuperMethodCall.Appender.TerminationHandler.of(MethodDescription methodDescription) Creates a stack manipulation that represents this handler's behavior.
StackManipulation	MethodDelegation.ImplementationDelegate.Compiled.prepare(MethodDescription instrumentedMethod) Resolves a stack manipulation that prepares the delegation invocation.
StackManipulation	MethodDelegation.ImplementationDelegate.Compiled.ForStaticCall.prepare(MethodDescription instrumentedMethod)
StackManipulation	MethodDelegation.ImplementationDelegate.Compiled.ForField.prepare(MethodDescription instrumentedMethod)
StackManipulation	MethodDelegation.ImplementationDelegate.Compiled.ForConstruction.prepare(MethodDescription instrumentedMethod)
protected abstract StackManipulation	FieldAccessor.ForParameterSetter.TerminationHandler.resolve(MethodDescription instrumentedMethod) Resolves the return instruction.
protected abstract StackManipulation	MethodCall.TerminationHandler.resolve(MethodDescription invokedMethod, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing) Returns a stack manipulation that handles the method return.
StackManipulation	MethodCall.TargetHandler.resolve(MethodDescription invokedMethod, MethodDescription instrumentedMethod, TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing) Creates a stack manipulation that represents the method's invocation.
StackManipulation	MethodCall.TargetHandler.ForSelfOrStaticInvocation.resolve(MethodDescription invokedMethod, MethodDescription instrumentedMethod, TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.TargetHandler.ForConstructingInvocation.resolve(MethodDescription invokedMethod, MethodDescription instrumentedMethod, TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.TargetHandler.ForValue.resolve(MethodDescription invokedMethod, MethodDescription instrumentedMethod, TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.TargetHandler.ForField.resolve(MethodDescription invokedMethod, MethodDescription instrumentedMethod, TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.TargetHandler.ForMethodParameter.resolve(MethodDescription invokedMethod, MethodDescription instrumentedMethod, TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)
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.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing) Loads the argument that is represented by this instance onto the operand stack.
StackManipulation	MethodCall.ArgumentLoader.ForNullConstant.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForThisReference.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForInstrumentedType.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForMethodParameter.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForInstance.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForField.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForMethodParameterArray.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForBooleanConstant.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForByteConstant.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForShortConstant.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForCharacterConstant.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForIntegerConstant.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForLongConstant.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForFloatConstant.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForDoubleConstant.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForTextConstant.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForClassConstant.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForEnumerationValue.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForJavaConstant.resolve(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
protected StackManipulation	FieldAccessor.setter(FieldDescription fieldDescription, ParameterDescription parameterDescription) Creates a setter instruction.

Methods in net.bytebuddy.implementation with parameters of type StackManipulation

Modifier and Type	Method and Description
protected ByteCodeAppender.Size	InvocationHandlerAdapter.apply(MethodVisitor methodVisitor, Implementation.Context implementationContext, MethodDescription instrumentedMethod, StackManipulation preparingManipulation, FieldDescription fieldDescription) Applies an implementation that delegates to a invocation handler.
protected ByteCodeAppender.Size	FixedValue.apply(MethodVisitor methodVisitor, Implementation.Context implementationContext, MethodDescription instrumentedMethod, TypeDescription.Generic fixedValueType, StackManipulation valueLoadingInstruction) Blueprint method that for applying the actual implementation.
FieldDescription.InDefinedShape	Implementation.Context.cache(StackManipulation fieldValue, TypeDescription fieldType) Caches a single value by storing it in form of a private, final and static field.
FieldDescription.InDefinedShape	Implementation.Context.Disabled.cache(StackManipulation fieldValue, TypeDescription fieldType)
FieldDescription.InDefinedShape	Implementation.Context.Default.cache(StackManipulation fieldValue, TypeDescription fieldType)
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)
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)

Constructors in net.bytebuddy.implementation with parameters of type StackManipulation

Constructor and Description
FieldCacheEntry(StackManipulation fieldValue, TypeDescription fieldType) Creates a new field cache entry.
ForPoolValue(StackManipulation valueLoadInstruction, Class<?> loadedType) Creates a new constant pool fixed value implementation.
ForPoolValue(StackManipulation valueLoadInstruction, TypeDescription loadedType) Creates a new constant pool fixed value implementation.
Simple(MethodDescription methodDescription, TypeDescription typeDescription, StackManipulation stackManipulation) Creates a new legal special method invocation.
Simple(StackManipulation... stackManipulation) Creates a new simple instrumentation for the given stack manipulations which are summarized in a byte code appender that defines any requested method by these manipulations.
Simple(StackManipulation stackManipulation, List<TypeDescription> loadedTypes) Creates a simple resolved argument provider.
Simple(StackManipulation stackManipulation, String internalName, TypeDescription returnType, List<TypeDescription> parameterTypes) Creates a new simple instance.
Simple(StackManipulation stackManipulation, TypeDescription loadedType) Creates a simple resolved argument provider.
WrappingArgumentProvider(StackManipulation stackManipulation) Creates a new wrapping argument provider.

Uses of StackManipulation in net.bytebuddy.implementation.auxiliary

Classes in net.bytebuddy.implementation.auxiliary that implement StackManipulation

Modifier and Type	Class and Description
static class	MethodCallProxy.AssignableSignatureCall A stack manipulation that creates a MethodCallProxy for a given method an pushes such an object onto the call stack.
protected static class	TypeProxy.AbstractMethodErrorThrow A stack manipulation that throws an abstract method error in case that a given super method cannot be invoked.
static class	TypeProxy.ForDefaultMethod Creates a type proxy which delegates its super method calls to any invokable default method of a given interface and loads an instance of this proxy onto the operand stack.
static class	TypeProxy.ForSuperMethodByConstructor Loads a type proxy onto the operand stack which is created by calling one of its constructors.
static class	TypeProxy.ForSuperMethodByReflectionFactory Loads a type proxy onto the operand stack which is created by constructing a serialization constructor using the Oracle JDK's ReflectionFactory.newConstructorForSerialization(Class, java.lang.reflect.Constructor) method which might not be available in any Java runtime.
protected class	TypeProxy.MethodCall.Appender.AccessorMethodInvocation Stack manipulation for invoking an accessor method.

Uses of StackManipulation in net.bytebuddy.implementation.bind

Subinterfaces of StackManipulation in net.bytebuddy.implementation.bind

Modifier and Type	Interface and Description
static interface	MethodDelegationBinder.MethodBinding A binding attempt created by a MethodDelegationBinder.
static interface	MethodDelegationBinder.ParameterBinding<T> A binding attempt for a single parameter.

Classes in net.bytebuddy.implementation.bind that implement StackManipulation

Modifier and Type	Class and Description
protected static class	MethodDelegationBinder.MethodBinding.Builder.Build A method binding that was created by a MethodDelegationBinder.MethodBinding.Builder.
static class	MethodDelegationBinder.MethodBinding.Illegal Representation of an attempt to bind a source method to a target method that is not applicable.
static class	MethodDelegationBinder.ParameterBinding.Anonymous An anonymous binding of a target method parameter.
static class	MethodDelegationBinder.ParameterBinding.Illegal A singleton representation of an illegal binding for a method parameter.
static class	MethodDelegationBinder.ParameterBinding.Unique<T> A uniquely identifiable parameter binding for a target method.

Methods in net.bytebuddy.implementation.bind that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	MethodDelegationBinder.MethodInvoker.invoke(MethodDescription methodDescription) Creates a method invocation for a given method.
StackManipulation	MethodDelegationBinder.MethodInvoker.Simple.invoke(MethodDescription methodDescription)
StackManipulation	MethodDelegationBinder.MethodInvoker.Virtual.invoke(MethodDescription methodDescription)
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.

Methods in net.bytebuddy.implementation.bind with parameters of type StackManipulation

Modifier and Type	Method and Description
MethodDelegationBinder.MethodBinding	MethodDelegationBinder.MethodBinding.Builder.build(StackManipulation terminatingManipulation) Creates a binding that represents the bindings collected by this Builder.
static <S> MethodDelegationBinder.ParameterBinding.Unique<S>	MethodDelegationBinder.ParameterBinding.Unique.of(StackManipulation delegate, S identificationToken) A factory method for creating a unique binding that infers the tokens type.

Constructors in net.bytebuddy.implementation.bind with parameters of type StackManipulation

Constructor and Description
Anonymous(StackManipulation delegate) Creates a new, anonymous parameter binding.
Build(MethodDescription target, Map<?,Integer> registeredTargetIndices, StackManipulation methodInvocation, List<StackManipulation> parameterStackManipulations, StackManipulation terminatingStackManipulation) Creates a new method binding.
Unique(StackManipulation delegate, T identificationToken) Creates a new unique parameter binding representant.

Constructor parameters in net.bytebuddy.implementation.bind with type arguments of type StackManipulation

Constructor and Description
Build(MethodDescription target, Map<?,Integer> registeredTargetIndices, StackManipulation methodInvocation, List<StackManipulation> parameterStackManipulations, StackManipulation terminatingStackManipulation) Creates a new method binding.

Uses of StackManipulation in net.bytebuddy.implementation.bind.annotation

Classes in net.bytebuddy.implementation.bind.annotation that implement StackManipulation

Modifier and Type	Class and Description
protected static class	DefaultMethod.Binder.DelegationMethod Loads the delegation method constant onto the stack.
protected class	FieldProxy.Binder.AccessorProxy A proxy type for accessing a field either by a getter or a setter.
protected static class	Morph.Binder.RedirectionProxy A proxy that implements the installed interface in order to allow for a morphed super method invocation.
protected static class	Pipe.Binder.Redirection An auxiliary type for performing the redirection of a method invocation as requested by the Pipe annotation.
protected static class	SuperMethod.Binder.DelegationMethod Loads the delegation method constant onto the stack.

Methods in net.bytebuddy.implementation.bind.annotation that return StackManipulation

Modifier and Type	Method and Description
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.

Uses of StackManipulation in net.bytebuddy.implementation.bytecode

Classes in net.bytebuddy.implementation.bytecode that implement StackManipulation

Modifier and Type	Class and Description
class	Addition A stack manipulation that adds to numbers on the operand stack.
class	Duplication Duplicates a value that is lying on top of the stack.
protected static class	Duplication.WithFlip A duplication that flips a value over the second value on the operand stack.
class	Removal Removes a value from the operand stack.
static class	StackManipulation.Compound An immutable stack manipulation that aggregates a sequence of other stack manipulations.
static class	StackManipulation.Illegal Canonical representation of an illegal stack manipulation.
static class	StackManipulation.Trivial Canonical representation of a legal stack manipulation which does not require any action.
class	Throw Throws a Throwable which must lie on top of the stack when this stack manipulation is called.
class	TypeCreation A stack manipulation for creating an undefined type on which a constructor is to be called.

Methods in net.bytebuddy.implementation.bytecode that return StackManipulation

Modifier and Type	Method and Description
abstract StackManipulation	Duplication.flipOver(TypeDefinition typeDefinition) Creates a duplication that flips the stack's top value over the second stack element.
static StackManipulation	Removal.of(TypeDefinition typeDefinition) Removes a value from the operand stack dependant of its size.
static StackManipulation	TypeCreation.of(TypeDescription typeDescription) Creates a type creation for the given type.

Constructors in net.bytebuddy.implementation.bytecode with parameters of type StackManipulation

Constructor and Description
Compound(StackManipulation... stackManipulation) Creates a new compound stack manipulation.
Simple(StackManipulation... stackManipulation) Creates a new simple byte code appender which represents the given stack manipulation.

Constructor parameters in net.bytebuddy.implementation.bytecode with type arguments of type StackManipulation

Constructor and Description
Compound(List<? extends StackManipulation> stackManipulations) Creates a new compound stack manipulation.
Simple(List<? extends StackManipulation> stackManipulations) Creates a new simple byte code appender which represents the given stack manipulation.

Uses of StackManipulation in net.bytebuddy.implementation.bytecode.assign

Classes in net.bytebuddy.implementation.bytecode.assign that implement StackManipulation

Modifier and Type	Class and Description
class	TypeCasting A stack manipulation for a type down casting.

Methods in net.bytebuddy.implementation.bytecode.assign that return StackManipulation

Modifier and Type	Method and 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)
static StackManipulation	TypeCasting.to(TypeDefinition typeDefinition) Creates a casting to the given, non-primitive type.

Uses of StackManipulation in net.bytebuddy.implementation.bytecode.assign.primitive

Classes in net.bytebuddy.implementation.bytecode.assign.primitive that implement StackManipulation

Modifier and Type	Class and Description
class	PrimitiveUnboxingDelegate This delegate is responsible for unboxing a wrapper type to their primitive equivalents.
protected static class	PrimitiveWideningDelegate.WideningStackManipulation A stack manipulation that widens a primitive type into a more general primitive type.

Methods in net.bytebuddy.implementation.bytecode.assign.primitive that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	VoidAwareAssigner.assign(TypeDescription.Generic source, TypeDescription.Generic target, Assigner.Typing typing)
StackManipulation	PrimitiveTypeAwareAssigner.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)
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.
StackManipulation	PrimitiveUnboxingDelegate.ImplicitlyTypedUnboxingResponsible.assignUnboxedTo(TypeDescription.Generic target, Assigner assigner, Assigner.Typing typing)
StackManipulation	PrimitiveWideningDelegate.widenTo(TypeDefinition typeDefinition) Attempts to widen the represented type into another type.

Uses of StackManipulation in net.bytebuddy.implementation.bytecode.assign.reference

Methods in net.bytebuddy.implementation.bytecode.assign.reference that return StackManipulation

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

Uses of StackManipulation in net.bytebuddy.implementation.bytecode.collection

Subinterfaces of StackManipulation in net.bytebuddy.implementation.bytecode.collection

Modifier and Type	Interface and Description
protected static interface	ArrayFactory.ArrayCreator An array creator is responsible for providing correct byte code instructions for creating an array and for storing values into it.

Classes in net.bytebuddy.implementation.bytecode.collection that implement StackManipulation

Modifier and Type	Class and Description
protected class	ArrayAccess.Loader A stack manipulation for loading an array's value.
protected class	ArrayAccess.Putter A stack manipulation for storing an array's value.
static class	ArrayFactory.ArrayCreator.ForPrimitiveType An array creator implementation for primitive types.
static class	ArrayFactory.ArrayCreator.ForReferenceType An array creator implementation for reference types.
protected class	ArrayFactory.ArrayStackManipulation A stack manipulation for creating an array as defined by the enclosing array factory.

Methods in net.bytebuddy.implementation.bytecode.collection that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	ArrayAccess.forEach(List<? extends StackManipulation> processInstructions) Applies a stack manipulation to the values of an array.
StackManipulation	ArrayAccess.load() Creates a value-loading stack manipulation.
StackManipulation	ArrayAccess.store() Creates a value-storing stack manipulation.
StackManipulation	CollectionFactory.withValues(List<? extends StackManipulation> stackManipulations) Applies this collection factory in order to build a new collection where each element is represented by the given stack manipulations.
StackManipulation	ArrayFactory.withValues(List<? extends StackManipulation> stackManipulations)

Method parameters in net.bytebuddy.implementation.bytecode.collection with type arguments of type StackManipulation

Modifier and Type	Method and Description
StackManipulation	ArrayAccess.forEach(List<? extends StackManipulation> processInstructions) Applies a stack manipulation to the values of an array.
StackManipulation	CollectionFactory.withValues(List<? extends StackManipulation> stackManipulations) Applies this collection factory in order to build a new collection where each element is represented by the given stack manipulations.
StackManipulation	ArrayFactory.withValues(List<? extends StackManipulation> stackManipulations)

Constructor parameters in net.bytebuddy.implementation.bytecode.collection with type arguments of type StackManipulation

Constructor and Description
ArrayStackManipulation(List<? extends StackManipulation> stackManipulations) Creates a new array loading instruction.

Uses of StackManipulation in net.bytebuddy.implementation.bytecode.constant

Subinterfaces of StackManipulation in net.bytebuddy.implementation.bytecode.constant

Modifier and Type	Interface and Description
static interface	MethodConstant.CanCache Represents a MethodConstant that is directly loaded onto the operand stack without caching the value.

Classes in net.bytebuddy.implementation.bytecode.constant that implement StackManipulation

Modifier and Type	Class and Description
class	ClassConstant Represents a constant representing any loaded Java Class.
protected static class	ClassConstant.ForReferenceType A class constant for a non-primitive Class.
class	DefaultValue Represents a stack assignment that loads the default value of a given type onto the stack.
class	DoubleConstant This class is responsible for loading any double constant onto the operand stack.
protected static class	DoubleConstant.ConstantPool A stack manipulation for loading a double value from a class's constant pool onto the operand stack.
class	FieldConstant Represents a Field constant for a given type.
protected static class	FieldConstant.Cached A cached version of a FieldConstant.
class	FloatConstant This class is responsible for loading any float constant onto the operand stack.
protected static class	FloatConstant.ConstantPool A stack manipulation for loading a float value from a class's constant pool onto the operand stack.
class	IntegerConstant This class is responsible for loading any int constant onto the operand stack.
protected static class	IntegerConstant.ConstantPool A stack manipulation that loads a JVM-integer value from a constant pool value onto the operand stack.
protected static class	IntegerConstant.SingleBytePush A stack manipulation that loads a JVM-integer value by a BIPUSH operation which is legal for single byte integer values.
protected static class	IntegerConstant.TwoBytePush A stack manipulation that loads a JVM-integer value by a SIPUSH operation which is legal for up to two byte integer values.
class	JavaConstantValue A constant representing a JavaConstant.
class	LongConstant This class is responsible for loading any long constant onto the operand stack.
protected static class	LongConstant.ConstantPool A stack manipulation for loading a long value from a class's constant pool onto the operand stack.
class	MethodConstant Represents the creation of a Method value which can be created from a given set of constant pool values and can therefore be considered a constant in the broader meaning.
protected static class	MethodConstant.CachedConstructor Represents a cached constructor for a MethodConstant.
protected static class	MethodConstant.CachedMethod Represents a cached method for a MethodConstant.
protected static class	MethodConstant.CanCacheIllegal Represents a method constant that cannot be represented by Java's reflection API.
protected static class	MethodConstant.ForConstructor Creates a MethodConstant for loading a Constructor instance onto the operand stack.
protected static class	MethodConstant.ForMethod Creates a MethodConstant for loading a Method instance onto the operand stack.
class	NullConstant Represents a stack manipulation to load a null pointer onto the operand stack.
class	SerializedConstant A constant that represents a value in its serialized form.
class	TextConstant Represents a String value that is stored in a type's constant pool.

Methods in net.bytebuddy.implementation.bytecode.constant that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	MethodConstant.cached() Returns a cached version of this method constant as specified by MethodConstant.CachedMethod and MethodConstant.CachedConstructor.
StackManipulation	MethodConstant.CanCacheIllegal.cached()
StackManipulation	MethodConstant.CanCache.cached() Returns this method constant as a cached version.
StackManipulation	FieldConstant.cached() Retruns a cached version of this field constant.
static StackManipulation	IntegerConstant.forValue(boolean value) Creates a stack manipulation for loading a boolean value onto the stack.
static StackManipulation	DoubleConstant.forValue(double value) Creates a stack manipulation for loading a double value onto the operand stack.
static StackManipulation	FloatConstant.forValue(float value) Creates a stack manipulation for loading a float value onto the operand stack.
static StackManipulation	IntegerConstant.forValue(int value) Creates a stack manipulation for loading an int value onto the stack.
static StackManipulation	LongConstant.forValue(long value) Creates a stack manipulation for loading a long value onto the operand stack.
static StackManipulation	SerializedConstant.of(Serializable value) Creates a new stack manipulation to load the supplied value onto the stack.
static StackManipulation	DefaultValue.of(TypeDefinition typeDefinition) Creates a stack assignment that loads the default value for a given type.
static StackManipulation	ClassConstant.of(TypeDescription typeDescription) Returns a stack manipulation that loads a Class type onto the operand stack which represents the given type.
protected abstract StackManipulation	MethodConstant.preparation() Returns a stack manipulation that loads the values that are required for loading a method constant onto the operand stack.
protected StackManipulation	MethodConstant.ForMethod.preparation()
protected StackManipulation	MethodConstant.ForConstructor.preparation()

Constructors in net.bytebuddy.implementation.bytecode.constant with parameters of type StackManipulation

Constructor and Description
Cached(StackManipulation fieldConstant) Creates a new cached version of a field constant.
CachedConstructor(StackManipulation constructorConstant) Creates a new cached MethodConstant.
CachedMethod(StackManipulation methodConstant) Creates a new cached MethodConstant.

Uses of StackManipulation in net.bytebuddy.implementation.bytecode.member

Subinterfaces of StackManipulation in net.bytebuddy.implementation.bytecode.member

Modifier and Type	Interface and Description
static interface	MethodInvocation.WithImplicitInvocationTargetType Represents a method invocation where the invocation type (static, virtual, special, interface) is derived from the given method's description.

Classes in net.bytebuddy.implementation.bytecode.member that implement StackManipulation

Modifier and Type	Class and Description
protected class	FieldAccess.AccessDispatcher.FieldGetInstruction A reading field access operation.
protected class	FieldAccess.AccessDispatcher.FieldPutInstruction A writing field access operation.
class	HandleInvocation An exact invocation of a method handle with a polymorphic signature.
protected class	MethodInvocation.DynamicInvocation Performs a dynamic method invocation of the given method.
protected static class	MethodInvocation.HandleInvocation Performs a method invocation on a method handle with a polymorphic type signature.
protected static class	MethodInvocation.IllegalInvocation An illegal implicit method invocation.
protected class	MethodInvocation.Invocation An implementation of a method invoking stack manipulation.
protected static class	MethodInvocation.OfGenericMethod A method invocation of a generically resolved method.
class	MethodReturn A stack manipulation returning a value of a given type.
static class	MethodVariableAccess.MethodLoading A stack manipulation that loads all parameters of a given method onto the operand stack.
protected static class	MethodVariableAccess.OffsetIncrementing A stack manipulation that increments an integer variable.
protected class	MethodVariableAccess.OffsetLoading A stack manipulation for loading a variable of a method's local variable array onto the operand stack.
protected class	MethodVariableAccess.OffsetWriting A stack manipulation for storing a variable into a method's local variable array.

Methods in net.bytebuddy.implementation.bytecode.member that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	MethodInvocation.IllegalInvocation.dynamic(String methodName, TypeDescription returnType, List<? extends TypeDescription> methodType, List<?> arguments)
StackManipulation	MethodInvocation.WithImplicitInvocationTargetType.dynamic(String methodName, TypeDescription returnType, List<? extends TypeDescription> methodType, List<?> arguments) Invokes the method as a bootstrap method to bind a call site with the given properties.
StackManipulation	MethodInvocation.OfGenericMethod.dynamic(String methodName, TypeDescription returnType, List<? extends TypeDescription> methodType, List<?> arguments)
StackManipulation	MethodInvocation.Invocation.dynamic(String methodName, TypeDescription returnType, List<? extends TypeDescription> methodType, List<?> arguments)
static StackManipulation	FieldAccess.forEnumeration(EnumerationDescription enumerationDescription) Creates an accessor to read an enumeration value.
StackManipulation	MethodVariableAccess.increment(int offset, int value) Creates a stack assignment for incrementing the given offset of the local variable array.
static StackManipulation	MethodVariableAccess.increment(ParameterDescription parameterDescription, int value) Increments the value of the supplied parameter.
static StackManipulation	MethodVariableAccess.load(ParameterDescription parameterDescription) Loads a parameter's value onto the operand stack.
StackManipulation	MethodVariableAccess.loadFrom(int offset) Creates a stack assignment for a reading given offset of the local variable array.
static StackManipulation	MethodVariableAccess.loadThis() Loads a reference to the this reference what is only meaningful for a non-static method.
static StackManipulation	MethodReturn.of(TypeDefinition typeDefinition) Returns a method return corresponding to a given type.
StackManipulation	MethodVariableAccess.MethodLoading.TypeCastingHandler.ofIndex(TypeDescription parameterType, int index) Yields a stack transformation to transform the given argument of the method for which the arguments are loaded onto the operand stack.
StackManipulation	MethodVariableAccess.MethodLoading.TypeCastingHandler.NoOp.ofIndex(TypeDescription parameterType, int index)
StackManipulation	MethodVariableAccess.MethodLoading.TypeCastingHandler.ForBridgeTarget.ofIndex(TypeDescription parameterType, int index)
StackManipulation	MethodInvocation.IllegalInvocation.onHandle(MethodInvocation.HandleType type)
StackManipulation	MethodInvocation.WithImplicitInvocationTargetType.onHandle(MethodInvocation.HandleType type) Invokes the method via a MethodHandle.
StackManipulation	MethodInvocation.OfGenericMethod.onHandle(MethodInvocation.HandleType type)
StackManipulation	MethodInvocation.Invocation.onHandle(MethodInvocation.HandleType type)
StackManipulation	MethodVariableAccess.MethodLoading.prependThisReference() Prepends a reference to the this instance to the loaded parameters if the represented method is non-static.
StackManipulation	FieldAccess.Defined.read() Creates a getter representation for a given field.
StackManipulation	FieldAccess.OfGenericField.read()
StackManipulation	FieldAccess.AccessDispatcher.read()
StackManipulation	MethodInvocation.IllegalInvocation.special(TypeDescription invocationTarget)
StackManipulation	MethodInvocation.WithImplicitInvocationTargetType.special(TypeDescription invocationTarget) Transforms this method invocation into a special invocation on the given type.
StackManipulation	MethodInvocation.OfGenericMethod.special(TypeDescription invocationTarget)
StackManipulation	MethodInvocation.Invocation.special(TypeDescription invocationTarget)
static StackManipulation	MethodVariableAccess.store(ParameterDescription parameterDescription) Stores the top operand stack value at the supplied parameter.
StackManipulation	MethodVariableAccess.storeAt(int offset) Creates a stack assignment for writing to a given offset of the local variable array.
StackManipulation	MethodInvocation.IllegalInvocation.virtual(TypeDescription invocationTarget)
StackManipulation	MethodInvocation.WithImplicitInvocationTargetType.virtual(TypeDescription invocationTarget) Transforms this method invocation into a virtual (or interface) method invocation on the given type.
StackManipulation	MethodInvocation.OfGenericMethod.virtual(TypeDescription invocationTarget)
StackManipulation	MethodInvocation.Invocation.virtual(TypeDescription invocationTarget)
StackManipulation	FieldAccess.Defined.write() Creates a setter representation for a given field.
StackManipulation	FieldAccess.OfGenericField.write()
StackManipulation	FieldAccess.AccessDispatcher.write()

Uses of StackManipulation in net.bytebuddy.utility

Methods in net.bytebuddy.utility that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	JavaConstant.asStackManipulation() Returns the instance as loadable onto the operand stack.
StackManipulation	JavaConstant.MethodType.asStackManipulation()
StackManipulation	JavaConstant.MethodHandle.asStackManipulation()