Uses of Interface
net.bytebuddy.instrumentation.method.bytecode.stack.StackManipulation

Packages that use StackManipulation

Package	Description
net.bytebuddy.agent.builder	An agent builder is used to easily implement load-time class-transformations using a Java agent.
net.bytebuddy.dynamic.scaffold.inline	All classes and types in this package are related to creating a DynamicType by enhancing a given type.
net.bytebuddy.dynamic.scaffold.subclass	All classes and types in this package are related to creating a DynamicType by creating a subclass of a given type.
net.bytebuddy.instrumentation	The instrumentation package contains any logic for intercepting method calls.
net.bytebuddy.instrumentation.method.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.instrumentation.method.bytecode.bind	The types and classes of this package are responsible for binding a method call to calling another method.
net.bytebuddy.instrumentation.method.bytecode.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.instrumentation.method.bytecode.stack	This package offers an abstraction of creating Java byte code by only manipulating a method's operand stack.
net.bytebuddy.instrumentation.method.bytecode.stack.assign	An Assigner is responsible for transforming a given TypeDescription into another one.
net.bytebuddy.instrumentation.method.bytecode.stack.assign.primitive	Assigner implementations of this package are capable of handling primitive types or the void type.
net.bytebuddy.instrumentation.method.bytecode.stack.assign.reference	Assigner implementations of this package are capable of assigning non-primitive types to each other.
net.bytebuddy.instrumentation.method.bytecode.stack.collection	This package is dedicated to creating StackManipulations that create collections or arrays from a given number of values.
net.bytebuddy.instrumentation.method.bytecode.stack.constant	StackManipulations in this package are responsible for creating compile-time constants and pushing them onto the operand stack.
net.bytebuddy.instrumentation.method.bytecode.stack.member	StackManipulations of this package are responsible for accessing type or method members, i.e.
net.bytebuddy.instrumentation.type	This package contains types and implementations for describing a Java type, i.e.
net.bytebuddy.instrumentation.type.auxiliary	Auxiliary types describe helper types that aid as a supplementary to a given InstrumentedType.

Uses of StackManipulation in net.bytebuddy.agent.builder

Methods in net.bytebuddy.agent.builder that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	AgentBuilder.Default.InitializationStrategy.SelfInjection.Nexus.Accessor.initializerFor(TypeDescription instrumentedType) Creates a stack manipulation for a given instrumented type that injects a code block for calling the system class loader's nexus in order to apply a self-initialization.

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	RebaseInstrumentationTarget.RebasedMethodSpecialMethodInvocation A Instrumentation.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
InstrumentedType	InlineInstrumentedType.withInitializer(StackManipulation stackManipulation)

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

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

Modifier and Type	Method and Description
InstrumentedType	SubclassInstrumentedType.withInitializer(StackManipulation stackManipulation)

Uses of StackManipulation in net.bytebuddy.instrumentation

Subinterfaces of StackManipulation in net.bytebuddy.instrumentation

Modifier and Type	Interface and Description
static interface	Instrumentation.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.instrumentation that implement StackManipulation

Modifier and Type	Class and Description
static class	Instrumentation.SpecialMethodInvocation.Illegal A canonical implementation of an illegal Instrumentation.SpecialMethodInvocation.
static class	Instrumentation.SpecialMethodInvocation.Simple A canonical implementation of a Instrumentation.SpecialMethodInvocation.

Methods in net.bytebuddy.instrumentation that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	Instrumentation.Context.Default.FieldCacheEntry.getFieldValue() Returns the field value that is represented by this field cache entry.
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.InstrumentationDelegate.getPreparingStackAssignment(TypeDescription instrumentedType) Returns the stack manipulation responsible for preparing the instance representing the instrumentation.
StackManipulation	MethodDelegation.InstrumentationDelegate.ForStaticMethod.getPreparingStackAssignment(TypeDescription instrumentedType)
StackManipulation	MethodDelegation.InstrumentationDelegate.ForStaticField.getPreparingStackAssignment(TypeDescription instrumentedType)
StackManipulation	MethodDelegation.InstrumentationDelegate.ForInstanceField.getPreparingStackAssignment(TypeDescription instrumentedType)
StackManipulation	MethodDelegation.InstrumentationDelegate.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	Instrumentation.Context.ExtractableView.InjectedCode.getStackManipulation() Returns the injected code.
StackManipulation	Instrumentation.Context.ExtractableView.InjectedCode.None.getStackManipulation()
StackManipulation	MethodCall.MethodInvoker.invoke(MethodDescription methodDescription, Instrumentation.Target instrumentationTarget) Invokes the method.
StackManipulation	MethodCall.MethodInvoker.ForStandardInvocation.invoke(MethodDescription methodDescription, Instrumentation.Target instrumentationTarget)
StackManipulation	MethodCall.MethodInvoker.ForSuperMethodInvocation.invoke(MethodDescription methodDescription, Instrumentation.Target instrumentationTarget)
StackManipulation	MethodCall.MethodInvoker.ForDefaultMethodInvocation.invoke(MethodDescription methodDescription, Instrumentation.Target instrumentationTarget)
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, boolean dynamicallyTyped) Returns a stack manipulation that handles the method return.
StackManipulation	MethodCall.TerminationHandler.ForMethodReturn.resolve(MethodDescription invokedMethod, MethodDescription interceptedMethod, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.TerminationHandler.ForChainedInvocation.resolve(MethodDescription invokedMethod, MethodDescription interceptedMethod, Assigner assigner, boolean dynamicallyTyped)
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, boolean dynamicallyTyped) Returns a stack manipulation that handles the method return.
StackManipulation	InvokeDynamic.TerminationHandler.ForMethodReturn.resolve(MethodDescription interceptedMethod, TypeDescription returnType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	InvokeDynamic.TerminationHandler.ForChainedInvocation.resolve(MethodDescription interceptedMethod, TypeDescription returnType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped) 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, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.ForThisReference.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.ForMethodParameter.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.ForStaticField.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.ForInstanceField.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.ForExistingField.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.ForBooleanConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.ForByteConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.ForShortConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.ForCharacterConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.ForIntegerConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.ForLongConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.ForFloatConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.ForDoubleConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped)
StackManipulation	MethodCall.ArgumentLoader.ForTextConstant.resolve(TypeDescription instrumentedType, MethodDescription interceptedMethod, TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped)

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

Modifier and Type	Method and Description
protected ByteCodeAppender.Size	InvocationHandlerAdapter.apply(org.objectweb.asm.MethodVisitor methodVisitor, Instrumentation.Context instrumentationContext, MethodDescription instrumentedMethod, TypeDescription instrumentedType, StackManipulation preparingManipulation) Applies an instrumentation that delegates to a invocation handler.
protected ByteCodeAppender.Size	FixedValue.apply(org.objectweb.asm.MethodVisitor methodVisitor, Instrumentation.Context instrumentationContext, MethodDescription instrumentedMethod, TypeDescription fixedValueType, StackManipulation valueLoadingInstruction) Blueprint method that for applying the actual instrumentation.
FieldDescription	Instrumentation.Context.cache(StackManipulation fieldValue, TypeDescription fieldType) Caches a single value by storing it in form of a private, final and static field.
FieldDescription	Instrumentation.Context.Default.cache(StackManipulation fieldValue, TypeDescription fieldType)

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

Constructor and Description
AccessorMethodDelegation(StackManipulation accessorMethodInvocation) Creates a new accessor method delegation.
Appender(StackManipulation preparingStackAssignment, Instrumentation.Target instrumentationTarget, Iterable<? extends MethodDescription> targetMethods, 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.instrumentation.method.bytecode

Constructors in net.bytebuddy.instrumentation.method.bytecode with parameters of type StackManipulation

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

Uses of StackManipulation in net.bytebuddy.instrumentation.method.bytecode.bind

Subinterfaces of StackManipulation in net.bytebuddy.instrumentation.method.bytecode.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.instrumentation.method.bytecode.bind that implement StackManipulation

Modifier and Type	Class and Description
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.instrumentation.method.bytecode.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.instrumentation.method.bytecode.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.instrumentation.method.bytecode.bind with parameters of type StackManipulation

Constructor and Description
Anonymous(StackManipulation delegate) Creates a new, anonymous parameter binding.
Unique(StackManipulation delegate, T identificationToken) Creates a new unique parameter binding representant.

Uses of StackManipulation in net.bytebuddy.instrumentation.method.bytecode.bind.annotation

Classes in net.bytebuddy.instrumentation.method.bytecode.bind.annotation that implement StackManipulation

Modifier and Type	Class and Description
protected class	Field.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.instrumentation.method.bytecode.bind.annotation that return StackManipulation

Modifier and Type	Method and Description
protected abstract StackManipulation	Super.Instantiation.proxyFor(TypeDescription parameterType, Instrumentation.Target instrumentationTarget, 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.instrumentation.method.bytecode.stack

Classes in net.bytebuddy.instrumentation.method.bytecode.stack 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.LegalTrivial 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.instrumentation.method.bytecode.stack 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.instrumentation.method.bytecode.stack with parameters of type StackManipulation

Constructor and Description
Compound(StackManipulation... stackManipulation) Creates a new compound stack manipulation.

Uses of StackManipulation in net.bytebuddy.instrumentation.method.bytecode.stack.assign

Methods in net.bytebuddy.instrumentation.method.bytecode.stack.assign that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	Assigner.assign(TypeDescription sourceType, TypeDescription targetType, boolean dynamicallyTyped)
StackManipulation	Assigner.EqualTypesOnly.assign(TypeDescription sourceType, TypeDescription targetType, boolean dynamicallyTyped)
StackManipulation	Assigner.Refusing.assign(TypeDescription sourceType, TypeDescription targetType, boolean dynamicallyTyped)

Uses of StackManipulation in net.bytebuddy.instrumentation.method.bytecode.stack.assign.primitive

Classes in net.bytebuddy.instrumentation.method.bytecode.stack.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.instrumentation.method.bytecode.stack.assign.primitive that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	VoidAwareAssigner.assign(TypeDescription sourceType, TypeDescription targetType, boolean dynamicallyTyped)
StackManipulation	PrimitiveTypeAwareAssigner.assign(TypeDescription sourceType, TypeDescription targetType, boolean dynamicallyTyped)
StackManipulation	PrimitiveBoxingDelegate.assignBoxedTo(TypeDescription targetType, Assigner chainedAssigner, boolean dynamicallyTyped) 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, boolean dynamicallyTyped)
StackManipulation	PrimitiveUnboxingDelegate.UnboxingResponsible.assignUnboxedTo(TypeDescription targetType, Assigner assigner, boolean dynamicallyTyped) 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, boolean dynamicallyTyped)
StackManipulation	PrimitiveWideningDelegate.widenTo(TypeDescription typeDescription) Attempts to widen the represented type into another type.

Uses of StackManipulation in net.bytebuddy.instrumentation.method.bytecode.stack.assign.reference

Classes in net.bytebuddy.instrumentation.method.bytecode.stack.assign.reference that implement StackManipulation

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

Methods in net.bytebuddy.instrumentation.method.bytecode.stack.assign.reference that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	ReferenceTypeAwareAssigner.assign(TypeDescription sourceType, TypeDescription targetType, boolean dynamicallyTyped)

Uses of StackManipulation in net.bytebuddy.instrumentation.method.bytecode.stack.collection

Subinterfaces of StackManipulation in net.bytebuddy.instrumentation.method.bytecode.stack.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.instrumentation.method.bytecode.stack.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.instrumentation.method.bytecode.stack.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.instrumentation.method.bytecode.stack.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.instrumentation.method.bytecode.stack.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.instrumentation.method.bytecode.stack.constant

Subinterfaces of StackManipulation in net.bytebuddy.instrumentation.method.bytecode.stack.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.instrumentation.method.bytecode.stack.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.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.instrumentation.method.bytecode.stack.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.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(MethodDescription 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.instrumentation.method.bytecode.stack.constant with parameters of type StackManipulation

Constructor and Description
Cached(StackManipulation methodConstant) Creates a new cached MethodConstant.

Uses of StackManipulation in net.bytebuddy.instrumentation.method.bytecode.stack.member

Subinterfaces of StackManipulation in net.bytebuddy.instrumentation.method.bytecode.stack.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.instrumentation.method.bytecode.stack.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.
class	MethodReturn A stack manipulation returning a value of a given type.
protected class	MethodVariableAccess.ArgumentLoadingStackManipulation A stack manipulation for loading a variable of a method's local variable array onto the operand stack.

Methods in net.bytebuddy.instrumentation.method.bytecode.stack.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.Invocation.dynamic(String methodName, TypeDescription returnType, List<? extends TypeDescription> methodType, List<?> arguments)
static StackManipulation	MethodVariableAccess.forBridgeMethodInvocation(MethodDescription bridgeMethod, MethodDescription targetMethod) Creates a stack manipulation for loading all parameters of a Java bridge method onto the operand stack where all variables of the bridge method are casted to the parameter types of the target method.
StackManipulation	FieldAccess.Defined.getter() Creates a getter representation for a given field.
StackManipulation	FieldAccess.AccessDispatcher.getter()
static StackManipulation	MethodVariableAccess.loadArguments(MethodDescription methodDescription) Loads all method arguments for a given method onto the operand stack.
StackManipulation	MethodVariableAccess.loadOffset(int variableOffset) Creates a stack assignment for a given index of the local variable array.
static StackManipulation	MethodVariableAccess.loadThisReferenceAndArguments(MethodDescription methodDescription) Loads all method arguments for a given method onto the operand stack, including a reference to this, if the method is non-static.
StackManipulation	FieldAccess.Defined.putter() Creates a putter representation for a given field.
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.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.Invocation.virtual(TypeDescription invocationTarget)
StackManipulation	MethodVariableAccess.TypeCastingHandler.wrapNext(StackManipulation variableAccess, TypeDescription parameterType) Returns the given stack manipulation while possibly wrapping the operation by a type casting if this is required.
StackManipulation	MethodVariableAccess.TypeCastingHandler.NoOp.wrapNext(StackManipulation variableAccess, TypeDescription parameterType)
StackManipulation	MethodVariableAccess.TypeCastingHandler.ForBridgeTarget.wrapNext(StackManipulation variableAccess, TypeDescription parameterType)

Methods in net.bytebuddy.instrumentation.method.bytecode.stack.member with parameters of type StackManipulation

Modifier and Type	Method and Description
StackManipulation	MethodVariableAccess.TypeCastingHandler.wrapNext(StackManipulation variableAccess, TypeDescription parameterType) Returns the given stack manipulation while possibly wrapping the operation by a type casting if this is required.
StackManipulation	MethodVariableAccess.TypeCastingHandler.NoOp.wrapNext(StackManipulation variableAccess, TypeDescription parameterType)
StackManipulation	MethodVariableAccess.TypeCastingHandler.ForBridgeTarget.wrapNext(StackManipulation variableAccess, TypeDescription parameterType)

Uses of StackManipulation in net.bytebuddy.instrumentation.type

Methods in net.bytebuddy.instrumentation.type that return StackManipulation

Modifier and Type	Method and Description
StackManipulation	InstrumentedType.TypeInitializer.getStackManipulation() Returns the stack manipulation of this type initializer.
StackManipulation	InstrumentedType.TypeInitializer.None.getStackManipulation()
StackManipulation	InstrumentedType.TypeInitializer.Simple.getStackManipulation()

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

Modifier and Type	Method and Description
InstrumentedType.TypeInitializer	InstrumentedType.TypeInitializer.expandWith(StackManipulation stackManipulation) Expands this type initializer with a stack manipulation.
InstrumentedType.TypeInitializer	InstrumentedType.TypeInitializer.None.expandWith(StackManipulation stackManipulation)
InstrumentedType.TypeInitializer	InstrumentedType.TypeInitializer.Simple.expandWith(StackManipulation stackManipulation)
InstrumentedType	InstrumentedType.withInitializer(StackManipulation stackManipulation) Creates a new instrumented type that executes the given initializer in the instrumented type's type initializer.

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

Constructor and Description
Simple(StackManipulation stackManipulation) Creates a new simple type initializer.

Uses of StackManipulation in net.bytebuddy.instrumentation.type.auxiliary

Classes in net.bytebuddy.instrumentation.type.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.