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

Packages that use StackManipulation

Package	Description
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.
net.bytebuddy.utility	This package contains utility classes for common use within any Byte Buddy logic.

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	MethodDelegation.ImplementationDelegate.getPreparingStackAssignment(TypeDescription instrumentedType) Returns the stack manipulation responsible for preparing the instance representing the implementation.
StackManipulation	MethodDelegation.ImplementationDelegate.ForStaticMethod.getPreparingStackAssignment(TypeDescription instrumentedType)
StackManipulation	MethodDelegation.ImplementationDelegate.ForStaticField.getPreparingStackAssignment(TypeDescription instrumentedType)
StackManipulation	MethodDelegation.ImplementationDelegate.ForInstanceField.getPreparingStackAssignment(TypeDescription instrumentedType)
StackManipulation	MethodDelegation.ImplementationDelegate.ForConstruction.getPreparingStackAssignment(TypeDescription instrumentedType)
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()
StackManipulation	MethodCall.MethodInvoker.invoke(MethodDescription methodDescription, Implementation.Target implementationTarget) Invokes the method.
StackManipulation	MethodCall.MethodInvoker.ForContextualInvocation.invoke(MethodDescription methodDescription, Implementation.Target implementationTarget)
StackManipulation	MethodCall.MethodInvoker.ForVirtualInvocation.invoke(MethodDescription methodDescription, Implementation.Target implementationTarget)
StackManipulation	MethodCall.MethodInvoker.ForSuperMethodInvocation.invoke(MethodDescription methodDescription, Implementation.Target implementationTarget)
StackManipulation	MethodCall.MethodInvoker.ForDefaultMethodInvocation.invoke(MethodDescription methodDescription, Implementation.Target implementationTarget)
StackManipulation	Forwarding.PreparationHandler.loadFieldOwner() Creates a stack manipulation for loading the field owner onto the operand stack.
StackManipulation	Forwarding.PreparationHandler.ForInstanceField.loadFieldOwner()
StackManipulation	Forwarding.PreparationHandler.ForStaticField.loadFieldOwner()
StackManipulation	Forwarding.PreparationHandler.ForStaticInstance.loadFieldOwner()
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	MethodCall.TerminationHandler.resolve(MethodDescription invokedMethod, MethodDescription interceptedMethod, Assigner assigner, Assigner.Typing typing) Returns a stack manipulation that handles the method return.
StackManipulation	MethodCall.TerminationHandler.ForMethodReturn.resolve(MethodDescription invokedMethod, MethodDescription interceptedMethod, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.TerminationHandler.ForChainedInvocation.resolve(MethodDescription invokedMethod, MethodDescription interceptedMethod, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.TargetHandler.resolve(MethodDescription methodDescription, TypeDescription instrumentedType) Creates a stack manipulation that represents the method's invocation.
StackManipulation	MethodCall.TargetHandler.ForSelfOrStaticInvocation.resolve(MethodDescription methodDescription, TypeDescription instrumentedType)
StackManipulation	MethodCall.TargetHandler.ForConstructingInvocation.resolve(MethodDescription methodDescription, TypeDescription instrumentedType)
StackManipulation	MethodCall.TargetHandler.ForStaticField.resolve(MethodDescription methodDescription, TypeDescription instrumentedType)
StackManipulation	MethodCall.TargetHandler.ForInstanceField.resolve(MethodDescription methodDescription, TypeDescription instrumentedType)
StackManipulation	InvokeDynamic.TerminationHandler.resolve(MethodDescription interceptedMethod, TypeDescription returnType, Assigner assigner, Assigner.Typing typing) Returns a stack manipulation that handles the method return.
StackManipulation	InvokeDynamic.TerminationHandler.ForMethodReturn.resolve(MethodDescription interceptedMethod, TypeDescription returnType, Assigner assigner, Assigner.Typing typing)
StackManipulation	InvokeDynamic.TerminationHandler.ForChainedInvocation.resolve(MethodDescription interceptedMethod, TypeDescription returnType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing) Loads the argument that is represented by this instance onto the operand stack.
StackManipulation	MethodCall.ArgumentLoader.ForNullConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForThisReference.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForOwnType.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForMethodParameter.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForStaticField.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForInstanceField.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForExistingField.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForBooleanConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForByteConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForShortConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForCharacterConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForIntegerConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForLongConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForFloatConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForDoubleConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForTextConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForClassConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForEnumerationValue.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.ArgumentLoader.ForJavaInstance.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	Implementation.Context.Default.FieldCacheEntry.storeIn(FieldDescription fieldDescription) Returns a stack manipulation where the represented value is stored in the given field.

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

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

Constructor and Description
AccessorMethodDelegation(MethodDescription methodDescription, StackManipulation accessorMethodInvocation) Creates a new accessor method delegation.
Appender(StackManipulation preparingStackAssignment, Implementation.Target implementationTarget, MethodList targetCandidates, MethodDelegationBinder.Processor processor) Creates a new appender.
FieldCacheEntry(StackManipulation fieldValue, TypeDescription fieldType) Creates a new field cache entry.
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)

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 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.

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.
StackManipulation	TargetMethodAnnotationDrivenBinder.TerminationHandler.resolve(Assigner assigner, MethodDescription source, MethodDescription target) Creates a stack manipulation that is to be applied after the method return.
StackManipulation	TargetMethodAnnotationDrivenBinder.TerminationHandler.Returning.resolve(Assigner assigner, MethodDescription source, MethodDescription target)
StackManipulation	TargetMethodAnnotationDrivenBinder.TerminationHandler.Dropping.resolve(Assigner assigner, MethodDescription source, MethodDescription target)

Uses of StackManipulation in net.bytebuddy.implementation.bytecode

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

Modifier and Type	Class and Description
class	Duplication Duplicates a value that is lying on top of the 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
static StackManipulation	Duplication.duplicate(TypeDescription typeDescription) Duplicates a value given its type.
static StackManipulation	TypeCreation.forType(TypeDescription typeDescription) Creates a type creation for the given type.
static StackManipulation	Removal.pop(TypeDescription typeDescription) Removes a value from the operand stack dependant of its size.

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<StackManipulation> stackManipulations) Creates a new compound 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 sourceType, TypeDescription targetType, Assigner.Typing typing)
StackManipulation	Assigner.EqualTypesOnly.assign(TypeDescription sourceType, TypeDescription targetType, Assigner.Typing typing)
StackManipulation	Assigner.Refusing.assign(TypeDescription sourceType, TypeDescription targetType, Assigner.Typing typing)
static StackManipulation	TypeCasting.to(TypeDescription typeDescription) 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 sourceType, TypeDescription targetType, Assigner.Typing typing)
StackManipulation	PrimitiveTypeAwareAssigner.assign(TypeDescription sourceType, TypeDescription targetType, Assigner.Typing typing)
StackManipulation	PrimitiveBoxingDelegate.assignBoxedTo(TypeDescription targetType, 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 targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	PrimitiveUnboxingDelegate.UnboxingResponsible.assignUnboxedTo(TypeDescription 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 targetType, Assigner assigner, Assigner.Typing typing)
StackManipulation	PrimitiveWideningDelegate.widenTo(TypeDescription typeDescription) 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 sourceType, TypeDescription targetType, 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.load() Creates a value-loading stack manipulation.
StackManipulation	ArrayAccess.store() Creates a value-storing stack manipulation.
StackManipulation	CollectionFactory.withValues(List<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<StackManipulation> stackManipulations)

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

Modifier and Type	Method and Description
StackManipulation	CollectionFactory.withValues(List<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<StackManipulation> stackManipulations)

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

Constructor and Description
ArrayStackManipulation(List<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	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	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.Cached Represents a cached 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	MethodHandleConstant A constant for a Java 7 java.lang.invoke.MethodHandle.
class	MethodTypeConstant A constant for a Java 7 java.lang.invoke.MethodType.
class	NullConstant Represents a stack manipulation to load a null pointer onto the operand stack.
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.Cached.
StackManipulation	MethodConstant.CanCacheIllegal.cached()
StackManipulation	MethodConstant.CanCache.cached() Returns this method constant as a cached version.
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	MethodHandleConstant.of(JavaInstance.MethodHandle methodHandle) Creates stack manipulation for loading the provided method handle onto the operand stack.
static StackManipulation	MethodTypeConstant.of(JavaInstance.MethodType methodType) Transforms the given method type into a stack manipulation that loads its type onto the operand stack.
static StackManipulation	MethodTypeConstant.of(MethodDescription.InDefinedShape methodDescription) Transforms the given method into a stack manipulation that loads its type onto the operand stack.
static StackManipulation	MethodHandleConstant.of(MethodDescription.InDefinedShape methodDescription) Creates a method handle for a method.
static StackManipulation	DefaultValue.of(TypeDescription typeDescription) 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.
static StackManipulation	MethodHandleConstant.ofGetter(FieldDescription fieldDescription) Creates a method handle for a field getter.
static StackManipulation	MethodHandleConstant.ofPutter(FieldDescription fieldDescription) Creates a method handle for a field putter.

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

Constructor and Description
Cached(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.
protected class	MethodInvocation.DynamicInvocation Performs a dynamic method invocation of the given method.
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 class	MethodVariableAccess.OffsetLoading A stack manipulation for loading a variable of a method's local variable array onto the operand stack.

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	FieldAccess.Defined.getter() Creates a getter representation for a given field.
StackManipulation	FieldAccess.OfGenericField.getter()
StackManipulation	FieldAccess.AccessDispatcher.getter()
StackManipulation	MethodVariableAccess.loadOffset(int variableOffset) Creates a stack assignment for a given index of the local variable array.
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	MethodVariableAccess.MethodLoading.prependThisReference() Prepends a reference to the this instance to the loaded parameters if the represented method is non-static.
StackManipulation	FieldAccess.Defined.putter() Creates a putter representation for a given field.
StackManipulation	FieldAccess.OfGenericField.putter()
StackManipulation	FieldAccess.AccessDispatcher.putter()
static StackManipulation	MethodReturn.returning(TypeDescription typeDescription) Returns a method return corresponding to a given type.
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)
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)

Uses of StackManipulation in net.bytebuddy.utility

Methods in net.bytebuddy.utility that return StackManipulation

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