Uses of Interface
net.bytebuddy.implementation.bytecode.StackManipulation
-
Packages that use StackManipulation Package Description net.bytebuddy Byte Buddy is a library for creating Java classes at runtime of a Java program.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 aDynamicType
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 givenInstrumentedType
.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 aMethodDescription
.net.bytebuddy.implementation.bytecode.assign AnAssigner
is responsible for transforming a givenTypeDescription
into another one.net.bytebuddy.implementation.bytecode.assign.primitive Assigner
implementations of this package are capable of handling primitive types or thevoid
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 creatingStackManipulation
s that create collections or arrays from a given number of values.net.bytebuddy.implementation.bytecode.constant StackManipulation
s in this package are responsible for creating compile-time constants and pushing them onto the operand stack.net.bytebuddy.implementation.bytecode.member StackManipulation
s of this package are responsible for accessing type or method members, i.e. -
-
Uses of StackManipulation in net.bytebuddy
Fields in net.bytebuddy declared as StackManipulation Modifier and Type Field Description private StackManipulation
ByteBuddy.RecordObjectMethod. stackManipulation
The stack manipulation to append to the arguments.Constructors in net.bytebuddy with parameters of type StackManipulation Constructor Description RecordObjectMethod(java.lang.String name, StackManipulation stackManipulation, java.lang.Class<?> returnType, java.lang.Class<?>... arguments)
Creates a new object method instance for a Java record. -
Uses of StackManipulation in net.bytebuddy.asm
Fields in net.bytebuddy.asm declared as StackManipulation Modifier and Type Field Description private StackManipulation
Advice.OffsetMapping.ForSerializedValue. deserialization
The stack manipulation deserializing the represented value.private StackManipulation
Advice.OffsetMapping.ForSerializedValue.Factory. deserialization
The stack manipulation that loads the represented value.private StackManipulation
Advice.Dispatcher.SuppressionHandler.Suppressing.Bound. exceptionHandler
The stack manipulation to apply within a suppression handler.protected StackManipulation
Advice.OffsetMapping.Target.ForDefaultValue. readAssignment
A stack manipulation to apply after a read instruction.protected StackManipulation
Advice.OffsetMapping.Target.ForField. readAssignment
The stack manipulation to apply upon a read.protected StackManipulation
Advice.OffsetMapping.Target.ForVariable. readAssignment
An assignment to execute upon reading a value.private StackManipulation
Advice.ExceptionHandler.Simple. stackManipulation
The stack manipulation to execute.private StackManipulation
Advice.OffsetMapping.ForStackManipulation.Factory. stackManipulation
The stack manipulation that loads the bound value.private StackManipulation
Advice.OffsetMapping.ForStackManipulation. stackManipulation
The stack manipulation that loads the bound value.private StackManipulation
Advice.OffsetMapping.Target.ForStackManipulation. stackManipulation
The represented stack manipulation.private StackManipulation
MemberSubstitution.Substitution.Chain.Step.Simple. stackManipulation
The stack manipulation to apply.private StackManipulation
Advice.OffsetMapping.Target.ForField.ReadWrite. writeAssignment
An assignment to apply prior to a field write.private StackManipulation
Advice.OffsetMapping.Target.ForVariable.ReadWrite. writeAssignment
A stack manipulation to apply upon a write to the variable.Fields in net.bytebuddy.asm with type parameters of type StackManipulation Modifier and Type Field Description protected java.util.List<? extends StackManipulation>
Advice.OffsetMapping.Target.ForArray. valueReads
The stack manipulations to apply upon reading a variable array.private java.util.List<? extends StackManipulation>
Advice.OffsetMapping.Target.ForArray.ReadWrite. valueWrites
The stack manipulations to apply upon writing to a variable array.Methods in net.bytebuddy.asm that return StackManipulation Modifier and Type Method Description StackManipulation
MemberSubstitution.Substitution.Chain.Step.Resolution. getStackManipulation()
Returns the stack manipulation to apply the substitution.StackManipulation
MemberSubstitution.Substitution.Chain.Step.Simple. getStackManipulation()
Returns the stack manipulation to apply the substitution.StackManipulation
MemberSubstitution.Replacement.Binding. make(TypeList.Generic parameters, TypeDescription.Generic result, int freeOffset)
Creates a stack manipulation that represents the substitution.StackManipulation
MemberSubstitution.Replacement.Binding.Resolved. make(TypeList.Generic parameters, TypeDescription.Generic result, int freeOffset)
Creates a stack manipulation that represents the substitution.StackManipulation
MemberSubstitution.Replacement.Binding.Unresolved. make(TypeList.Generic parameters, TypeDescription.Generic result, int freeOffset)
Creates a stack manipulation that represents the substitution.StackManipulation
Advice.ExceptionHandler. resolve(MethodDescription instrumentedMethod, TypeDescription instrumentedType)
Resolves a stack manipulation to apply.StackManipulation
Advice.ExceptionHandler.Simple. resolve(MethodDescription instrumentedMethod, TypeDescription instrumentedType)
Resolves a stack manipulation to apply.StackManipulation
Advice.PostProcessor.Compound. resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler)
Resolves this post processor for a given instrumented method.StackManipulation
Advice.PostProcessor.NoOp. resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler)
Resolves this post processor for a given instrumented method.StackManipulation
Advice.PostProcessor. resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler)
Resolves this post processor for a given instrumented method.StackManipulation
MemberSubstitution.Substitution.Chain. resolve(TypeDescription targetType, ByteCodeElement target, TypeList.Generic parameters, TypeDescription.Generic result, int freeOffset)
Resolves this substitution into a stack manipulation.StackManipulation
MemberSubstitution.Substitution.ForFieldAccess. resolve(TypeDescription targetType, ByteCodeElement target, TypeList.Generic parameters, TypeDescription.Generic result, int freeOffset)
Resolves this substitution into a stack manipulation.StackManipulation
MemberSubstitution.Substitution.ForMethodInvocation. resolve(TypeDescription targetType, ByteCodeElement target, TypeList.Generic parameters, TypeDescription.Generic result, int freeOffset)
Resolves this substitution into a stack manipulation.StackManipulation
MemberSubstitution.Substitution. resolve(TypeDescription targetType, ByteCodeElement target, TypeList.Generic parameters, TypeDescription.Generic result, int freeOffset)
Resolves this substitution into a stack manipulation.StackManipulation
MemberSubstitution.Substitution.Stubbing. resolve(TypeDescription targetType, ByteCodeElement target, TypeList.Generic parameters, TypeDescription.Generic result, int freeOffset)
Resolves this substitution into a stack manipulation.StackManipulation
Advice.OffsetMapping.Target.AbstractReadOnlyAdapter. resolveIncrement(int value)
Resolves an increment instruction.StackManipulation
Advice.OffsetMapping.Target.ForArray. resolveIncrement(int value)
Resolves an increment instruction.StackManipulation
Advice.OffsetMapping.Target.ForDefaultValue.ReadOnly. resolveIncrement(int value)
Resolves an increment instruction.StackManipulation
Advice.OffsetMapping.Target.ForDefaultValue.ReadWrite. resolveIncrement(int value)
Resolves an increment instruction.StackManipulation
Advice.OffsetMapping.Target.ForField.ReadOnly. resolveIncrement(int value)
Resolves an increment instruction.StackManipulation
Advice.OffsetMapping.Target.ForField.ReadWrite. resolveIncrement(int value)
Resolves an increment instruction.StackManipulation
Advice.OffsetMapping.Target.ForStackManipulation. resolveIncrement(int value)
Resolves an increment instruction.StackManipulation
Advice.OffsetMapping.Target.ForVariable.ReadOnly. resolveIncrement(int value)
Resolves an increment instruction.StackManipulation
Advice.OffsetMapping.Target.ForVariable.ReadWrite. resolveIncrement(int value)
Resolves an increment instruction.StackManipulation
Advice.OffsetMapping.Target. resolveIncrement(int value)
Resolves an increment instruction.StackManipulation
Advice.OffsetMapping.Target.ForArray. resolveRead()
Resolves a read instruction.StackManipulation
Advice.OffsetMapping.Target.ForDefaultValue. resolveRead()
Resolves a read instruction.StackManipulation
Advice.OffsetMapping.Target.ForField. resolveRead()
Resolves a read instruction.StackManipulation
Advice.OffsetMapping.Target.ForStackManipulation. resolveRead()
Resolves a read instruction.StackManipulation
Advice.OffsetMapping.Target.ForVariable. resolveRead()
Resolves a read instruction.StackManipulation
Advice.OffsetMapping.Target. resolveRead()
Resolves a read instruction.StackManipulation
Advice.OffsetMapping.Target.AbstractReadOnlyAdapter. resolveWrite()
Resolves a write instruction.StackManipulation
Advice.OffsetMapping.Target.ForArray.ReadOnly. resolveWrite()
Resolves a write instruction.StackManipulation
Advice.OffsetMapping.Target.ForArray.ReadWrite. resolveWrite()
Resolves a write instruction.StackManipulation
Advice.OffsetMapping.Target.ForDefaultValue.ReadOnly. resolveWrite()
Resolves a write instruction.StackManipulation
Advice.OffsetMapping.Target.ForDefaultValue.ReadWrite. resolveWrite()
Resolves a write instruction.StackManipulation
Advice.OffsetMapping.Target.ForField.ReadOnly. resolveWrite()
Resolves a write instruction.StackManipulation
Advice.OffsetMapping.Target.ForField.ReadWrite. resolveWrite()
Resolves a write instruction.StackManipulation
Advice.OffsetMapping.Target.ForStackManipulation. resolveWrite()
Resolves a write instruction.StackManipulation
Advice.OffsetMapping.Target.ForVariable.ReadOnly. resolveWrite()
Resolves a write instruction.StackManipulation
Advice.OffsetMapping.Target.ForVariable.ReadWrite. resolveWrite()
Resolves a write instruction.StackManipulation
Advice.OffsetMapping.Target. resolveWrite()
Resolves a write instruction.Methods in net.bytebuddy.asm with parameters of type StackManipulation Modifier and Type Method Description Advice.Dispatcher.Bound
Advice.Dispatcher.Delegating.Resolved. bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)
Binds this dispatcher for resolution to a specific method.Advice.Dispatcher.Bound
Advice.Dispatcher.Inactive. bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)
Binds this dispatcher for resolution to a specific method.Advice.Dispatcher.Bound
Advice.Dispatcher.Inlining.Resolved.ForMethodEnter. bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)
Binds this dispatcher for resolution to a specific method.Advice.Dispatcher.Bound
Advice.Dispatcher.Inlining.Resolved.ForMethodExit. bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)
Binds this dispatcher for resolution to a specific method.Advice.Dispatcher.Bound
Advice.Dispatcher.Resolved. bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)
Binds this dispatcher for resolution to a specific method.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)
Binds the suppression handler for instrumenting a specific method.Advice.Dispatcher.SuppressionHandler.Bound
Advice.Dispatcher.SuppressionHandler.Suppressing. bind(StackManipulation exceptionHandler)
Binds the suppression handler for instrumenting a specific method.<T extends java.lang.annotation.Annotation>
Advice.WithCustomMappingAdvice.WithCustomMapping. bind(java.lang.Class<T> type, StackManipulation stackManipulation, java.lang.reflect.Type targetType)
Binds the supplied annotation to the annotation's property of the specified name.<T extends java.lang.annotation.Annotation>
Advice.WithCustomMappingAdvice.WithCustomMapping. bind(java.lang.Class<T> type, StackManipulation stackManipulation, TypeDescription.Generic targetType)
Binds the supplied annotation to the annotation's property of the specified name.protected Advice.Dispatcher.Bound
Advice.Dispatcher.Delegating.Resolved.ForMethodEnter. resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)
protected Advice.Dispatcher.Bound
Advice.Dispatcher.Delegating.Resolved.ForMethodExit. resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)
protected abstract Advice.Dispatcher.Bound
Advice.Dispatcher.Delegating.Resolved. resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)
Binds this dispatcher for resolution to a specific method.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 Description AdviceVisitor(org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, StackManipulation exceptionHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.Resolved.ForMethodEnter methodEnter, Advice.Dispatcher.Resolved.ForMethodExit methodExit, java.util.List<? extends TypeDescription> postMethodTypes, int writerFlags, int readerFlags)
Creates a new advice visitor.Bound(TypeDescription suppressedType, StackManipulation exceptionHandler)
Creates a new active, bound suppression handler.Factory(java.lang.Class<T> annotationType, TypeDescription typeDescription, StackManipulation deserialization)
Creates a factory for loading a deserialized value.Factory(java.lang.Class<T> annotationType, StackManipulation stackManipulation, TypeDescription.Generic typeDescription)
Creates a new factory for binding a stack manipulation.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.Generic target, TypeDescription typeDescription, StackManipulation deserialization)
Creates a new offset mapping for a serialized value.ForStackManipulation(StackManipulation stackManipulation, TypeDescription.Generic typeDescription, TypeDescription.Generic targetType, Assigner.Typing typing)
Creates an offset mapping that binds a stack manipulation.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(TypeDefinition typeDefinition, StackManipulation readAssignment)
Creates a new -writable target for a default value.ReadOnly(FieldDescription fieldDescription, StackManipulation readAssignment)
Creates a new read-only mapping for a field.ReadOnly(TypeDefinition typeDefinition, int offset, StackManipulation readAssignment)
Creates a read-only mapping for a local variable.ReadWrite(TypeDefinition typeDefinition, StackManipulation readAssignment)
Creates a new read-only target for a default value.ReadWrite(FieldDescription fieldDescription, StackManipulation readAssignment, StackManipulation writeAssignment)
Creates a new target for a writable field.ReadWrite(TypeDefinition typeDefinition, int offset, StackManipulation readAssignment, StackManipulation writeAssignment)
Creates a new target mapping for a writable local variable.Simple(StackManipulation stackManipulation)
Creates a new simple exception handler.Simple(StackManipulation stackManipulation, TypeDescription.Generic resultType)
Creates a new simple substitution step.WithExceptionHandling(org.objectweb.asm.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(org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, StackManipulation exceptionHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.Resolved.ForMethodEnter methodEnter, Advice.Dispatcher.Resolved.ForMethodExit methodExit, java.util.List<? extends TypeDescription> postMethodTypes, int writerFlags, int readerFlags)
Creates an advice visitor that applies exit advice.WithoutExceptionHandling(org.objectweb.asm.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(org.objectweb.asm.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 Description ForArray(TypeDescription.Generic target, java.util.List<? extends StackManipulation> valueReads)
Creates a new target mapping for an array of all local variables.ReadOnly(TypeDescription.Generic target, java.util.List<? extends StackManipulation> valueReads)
Creates a read-only target mapping for an array of all local variables.ReadWrite(TypeDescription.Generic target, java.util.List<? extends StackManipulation> valueReads, java.util.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 Description protected static class
RebaseImplementationTarget.RebasedMethodInvocation
AImplementation.SpecialMethodInvocation
which invokes a rebased method as given by aMethodRebaseResolver
.Fields in net.bytebuddy.dynamic.scaffold.inline declared as StackManipulation Modifier and Type Field Description private StackManipulation
RebaseImplementationTarget.RebasedMethodInvocation. stackManipulation
The stack manipulation to execute in order to invoke the rebased method.Constructors in net.bytebuddy.dynamic.scaffold.inline with parameters of type StackManipulation Constructor Description RebasedMethodInvocation(MethodDescription methodDescription, TypeDescription instrumentedType, StackManipulation stackManipulation, TypeList prependedParameters)
Creates a new rebased method invocation. -
Uses of StackManipulation in net.bytebuddy.implementation
Subinterfaces of StackManipulation in net.bytebuddy.implementation Modifier and Type Interface 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 Description protected static class
EqualsMethod.ConditionalReturn
A conditional return aborts the equality computation if a given condition was reached.protected class
EqualsMethod.NullValueGuard.UsingJump.AfterInstruction
The stack manipulation to apply after the equality computation.protected class
EqualsMethod.NullValueGuard.UsingJump.BeforeInstruction
The stack manipulation to apply before the equality computation.protected static class
EqualsMethod.ValueComparator
A value comparator is responsible to compare to values of a given type.protected class
HashCodeMethod.NullValueGuard.UsingJump.AfterInstruction
The stack manipulation to apply after the hash value computation.protected class
HashCodeMethod.NullValueGuard.UsingJump.BeforeInstruction
The stack manipulation to apply before the hash value computation.protected static class
HashCodeMethod.ValueTransformer
A value transformer that is responsible for resolving a field value to anint
value.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 illegalImplementation.SpecialMethodInvocation
.static class
Implementation.SpecialMethodInvocation.Simple
A canonical implementation of aImplementation.SpecialMethodInvocation
.protected static class
ToStringMethod.ValueConsumer
A value consumer that is responsible for adding a field value to the string creatingStringBuilder
.Fields in net.bytebuddy.implementation declared as StackManipulation Modifier and Type Field Description private StackManipulation
Implementation.Context.Default.AccessorMethodDelegation. accessorMethodInvocation
The stack manipulation that represents the requested special method invocation.private StackManipulation
EqualsMethod.Appender. baseline
The baseline stack manipulation.private StackManipulation
FixedValue.ForValue.StaticFieldByteCodeAppender. fieldGetAccess
The stack manipulation that loads the fixed value onto the operand stack.private StackManipulation
Implementation.Context.Default.FieldCacheEntry. fieldValue
The field value that is represented by this field cache entry.private StackManipulation
HashCodeMethod.Appender. initialValue
Loads the initial hash code onto the operand stack.private StackManipulation
FieldAccessor.ForSetter.OfConstantValue. stackManipulation
A stack manipulation to load the constant value.private StackManipulation
Implementation.SpecialMethodInvocation.Simple. stackManipulation
A stack manipulation representing the method's invocation on the type description.private StackManipulation
InvokeDynamic.InvocationProvider.ArgumentProvider.ConstantPoolWrapper.WrappingArgumentProvider. stackManipulation
The stack manipulation that represents the loading of the primitive value.private StackManipulation
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved.Simple. stackManipulation
A stack manipulation that loads the arguments onto the operand stack.private StackManipulation
InvokeDynamic.InvocationProvider.Target.Resolved.Simple. stackManipulation
The stack manipulation that loads the arguments onto the operand stack.private StackManipulation
MethodCall.ArgumentLoader.ForStackManipulation. stackManipulation
The stack manipulation to load.private StackManipulation
MethodCall.TargetHandler.Simple. stackManipulation
The stack manipulation that loads a target for the method call.private StackManipulation
FixedValue.ForPoolValue. valueLoadInstruction
The stack manipulation which is responsible for loading the fixed value onto the operand stack.Methods in net.bytebuddy.implementation that return StackManipulation Modifier and Type Method Description StackManipulation
EqualsMethod.NullValueGuard. after()
Returns a stack manipulation to apply after computing equality.StackManipulation
EqualsMethod.NullValueGuard.NoOp. after()
Returns a stack manipulation to apply after computing equality.StackManipulation
EqualsMethod.NullValueGuard.UsingJump. after()
Returns a stack manipulation to apply after computing equality.StackManipulation
HashCodeMethod.NullValueGuard. after()
Returns a stack manipulation to apply after computing a hash value.StackManipulation
HashCodeMethod.NullValueGuard.NoOp. after()
Returns a stack manipulation to apply after computing a hash value.StackManipulation
HashCodeMethod.NullValueGuard.UsingJump. after()
Returns a stack manipulation to apply after computing a hash value.StackManipulation
EqualsMethod.NullValueGuard. before()
Returns a stack manipulation to apply before computing equality.StackManipulation
EqualsMethod.NullValueGuard.NoOp. before()
Returns a stack manipulation to apply before computing equality.StackManipulation
EqualsMethod.NullValueGuard.UsingJump. before()
Returns a stack manipulation to apply before computing equality.StackManipulation
HashCodeMethod.NullValueGuard. before()
Returns a stack manipulation to apply before computing a hash value.StackManipulation
HashCodeMethod.NullValueGuard.NoOp. before()
Returns a stack manipulation to apply before computing a hash value.StackManipulation
HashCodeMethod.NullValueGuard.UsingJump. before()
Returns a stack manipulation to apply before computing a hash value.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()
Returns a stack manipulation that loads the arguments onto the operand stack.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()
Returns the stack manipulation that loads the arguments onto the operand stack.private StackManipulation
DefaultMethodCall.Appender. locateDefault(MethodDescription methodDescription)
Locates a special method invocation to be invoked from a given method.StackManipulation
ExceptionMethod.ConstructionDelegate.ForDefaultConstructor. make()
Creates a stack manipulation that creates pushes all constructor arguments onto the operand stack and subsequently calls the constructor.StackManipulation
ExceptionMethod.ConstructionDelegate.ForStringConstructor. make()
Creates a stack manipulation that creates pushes all constructor arguments onto the operand stack and subsequently calls the constructor.StackManipulation
ExceptionMethod.ConstructionDelegate. make()
Creates a stack manipulation that creates pushes all constructor arguments onto the operand stack and subsequently calls the constructor.static StackManipulation
EqualsMethod.ValueComparator. of(TypeDefinition typeDefinition)
Resolves a type definition to a equality comparison.static StackManipulation
HashCodeMethod.ValueTransformer. of(TypeDefinition typeDefinition)
Resolves a type definition to a hash code.protected abstract StackManipulation
SuperMethodCall.Appender.TerminationHandler. of(MethodDescription methodDescription)
Creates a stack manipulation that represents this handler's behavior.protected static StackManipulation
ToStringMethod.ValueConsumer. of(TypeDescription typeDescription)
Resolves an appropriate value resolver for a given type.StackManipulation
MethodCall.TerminationHandler.FieldSetting. prepare()
Returns a preparing stack manipulation to apply prior to the method call.StackManipulation
MethodCall.TerminationHandler. prepare()
Returns a preparing stack manipulation to apply prior to the method call.StackManipulation
MethodCall.TerminationHandler.Simple. prepare()
Returns a preparing stack manipulation to apply prior to the method call.StackManipulation
MethodDelegation.ImplementationDelegate.Compiled.ForConstruction. prepare(MethodDescription instrumentedMethod)
Resolves a stack manipulation that prepares the delegation invocation.StackManipulation
MethodDelegation.ImplementationDelegate.Compiled.ForField. prepare(MethodDescription instrumentedMethod)
Resolves a stack manipulation that prepares the delegation invocation.StackManipulation
MethodDelegation.ImplementationDelegate.Compiled.ForMethodReturn. prepare(MethodDescription instrumentedMethod)
Resolves a stack manipulation that prepares the delegation invocation.StackManipulation
MethodDelegation.ImplementationDelegate.Compiled.ForStaticCall. prepare(MethodDescription instrumentedMethod)
Resolves a stack manipulation that prepares the delegation invocation.StackManipulation
MethodDelegation.ImplementationDelegate.Compiled. prepare(MethodDescription instrumentedMethod)
Resolves a stack manipulation that prepares the delegation invocation.protected abstract StackManipulation
EqualsMethod.SuperClassCheck. resolve(TypeDescription instrumentedType)
Resolves a stack manipulation for the required super class check.protected abstract StackManipulation
EqualsMethod.TypeCompatibilityCheck. resolve(TypeDescription instrumentedType)
Resolves a stack manipulation for the required type compatibility check.protected StackManipulation
FieldAccessor.ForSetter.OfConstantValue. resolve(java.lang.Void unused, FieldDescription fieldDescription, TypeDescription instrumentedType, MethodDescription instrumentedMethod)
Resolves the stack manipulation to load the value being set.protected StackManipulation
FieldAccessor.ForSetter.OfDefaultValue. resolve(java.lang.Void initialized, FieldDescription fieldDescription, TypeDescription instrumentedType, MethodDescription instrumentedMethod)
Resolves the stack manipulation to load the value being set.protected StackManipulation
FieldAccessor.ForSetter.OfFieldValue. resolve(FieldAccessor.FieldLocation.Prepared target, FieldDescription fieldDescription, TypeDescription instrumentedType, MethodDescription instrumentedMethod)
Resolves the stack manipulation to load the value being set.protected StackManipulation
FieldAccessor.ForSetter.OfParameterValue. resolve(java.lang.Void unused, FieldDescription fieldDescription, TypeDescription instrumentedType, MethodDescription instrumentedMethod)
Resolves the stack manipulation to load the value being set.protected StackManipulation
FieldAccessor.ForSetter.OfReferenceValue. resolve(FieldDescription.InDefinedShape target, FieldDescription fieldDescription, TypeDescription instrumentedType, MethodDescription instrumentedMethod)
Resolves the stack manipulation to load the value being set.protected abstract StackManipulation
FieldAccessor.ForSetter. resolve(T initialized, FieldDescription fieldDescription, TypeDescription instrumentedType, MethodDescription instrumentedMethod)
Resolves the stack manipulation to load the value being set.protected abstract StackManipulation
FieldAccessor.ForSetter.TerminationHandler. resolve(MethodDescription instrumentedMethod)
Resolves the return instruction.StackManipulation
HashCodeMethod.OffsetProvider.ForFixedValue. resolve(TypeDescription instrumentedType)
Resolves this offset provider for a given instrumented type.StackManipulation
HashCodeMethod.OffsetProvider.ForSuperMethodCall. resolve(TypeDescription instrumentedType)
Resolves this offset provider for a given instrumented type.StackManipulation
HashCodeMethod.OffsetProvider. resolve(TypeDescription instrumentedType)
Resolves this offset provider for a given instrumented type.protected abstract StackManipulation
InvokeDynamic.TerminationHandler. resolve(MethodDescription interceptedMethod, TypeDescription returnType, Assigner assigner, Assigner.Typing typing)
Returns a stack manipulation that handles the method return.protected StackManipulation
EqualsMethod.ConditionalReturn. returningTrue()
Returns a new stack manipulation that returnstrue
for the given condition.protected StackManipulation
MethodCall.Appender. toStackManipulation(MethodDescription instrumentedMethod, MethodDescription invokedMethod, MethodCall.TargetHandler.Resolved targetHandler)
Resolves this appender to a stack manipulation.StackManipulation
MethodCall.ArgumentLoader.ForField. toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
Loads the argument that is represented by this instance onto the operand stack.StackManipulation
MethodCall.ArgumentLoader.ForInstance. toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
Loads the argument that is represented by this instance onto the operand stack.StackManipulation
MethodCall.ArgumentLoader.ForInstrumentedType. toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
Loads the argument that is represented by this instance onto the operand stack.StackManipulation
MethodCall.ArgumentLoader.ForMethodCall. toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
Loads the argument that is represented by this instance onto the operand stack.StackManipulation
MethodCall.ArgumentLoader.ForMethodParameter. toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
Loads the argument that is represented by this instance onto the operand stack.StackManipulation
MethodCall.ArgumentLoader.ForMethodParameterArray. toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
Loads the argument that is represented by this instance onto the operand stack.StackManipulation
MethodCall.ArgumentLoader.ForMethodParameterArrayElement. toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
Loads the argument that is represented by this instance onto the operand stack.StackManipulation
MethodCall.ArgumentLoader.ForNullConstant. toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
Loads the argument that is represented by this instance onto the operand stack.StackManipulation
MethodCall.ArgumentLoader.ForStackManipulation. toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
Loads the argument that is represented by this instance onto the operand stack.StackManipulation
MethodCall.ArgumentLoader.ForThisReference. toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
Loads the argument that is represented by this instance onto the operand stack.StackManipulation
MethodCall.ArgumentLoader. toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing)
Loads the argument that is represented by this instance onto the operand stack.StackManipulation
MethodCall.MethodInvoker.ForContextualInvocation. toStackManipulation(MethodDescription invokedMethod, Implementation.Target implementationTarget)
Invokes the method.StackManipulation
MethodCall.MethodInvoker.ForDefaultMethodInvocation. toStackManipulation(MethodDescription invokedMethod, Implementation.Target implementationTarget)
Invokes the method.StackManipulation
MethodCall.MethodInvoker.ForSuperMethodInvocation. toStackManipulation(MethodDescription invokedMethod, Implementation.Target implementationTarget)
Invokes the method.StackManipulation
MethodCall.MethodInvoker.ForVirtualInvocation. toStackManipulation(MethodDescription invokedMethod, Implementation.Target implementationTarget)
Invokes the method.StackManipulation
MethodCall.MethodInvoker.ForVirtualInvocation.WithImplicitType. toStackManipulation(MethodDescription invokedMethod, Implementation.Target implementationTarget)
Invokes the method.StackManipulation
MethodCall.MethodInvoker. toStackManipulation(MethodDescription invokedMethod, Implementation.Target implementationTarget)
Invokes the method.StackManipulation
MethodCall.TargetHandler.ForConstructingInvocation. toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)
Creates a stack manipulation to represent this resolved target handler.StackManipulation
MethodCall.TargetHandler.ForField. toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)
Creates a stack manipulation to represent this resolved target handler.StackManipulation
MethodCall.TargetHandler.ForMethodCall.Resolved. toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)
Creates a stack manipulation to represent this resolved target handler.StackManipulation
MethodCall.TargetHandler.ForMethodParameter.Resolved. toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)
Creates a stack manipulation to represent this resolved target handler.StackManipulation
MethodCall.TargetHandler.ForSelfOrStaticInvocation.Resolved. toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)
Creates a stack manipulation to represent this resolved target handler.StackManipulation
MethodCall.TargetHandler.ForValue. toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)
Creates a stack manipulation to represent this resolved target handler.StackManipulation
MethodCall.TargetHandler.Resolved. toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)
Creates a stack manipulation to represent this resolved target handler.StackManipulation
MethodCall.TargetHandler.Simple. toStackManipulation(MethodDescription invokedMethod, Assigner assigner, Assigner.Typing typing)
Creates a stack manipulation to represent this resolved target handler.StackManipulation
MethodCall.TerminationHandler.FieldSetting. toStackManipulation(MethodDescription invokedMethod, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
Returns a stack manipulation that handles the method return.StackManipulation
MethodCall.TerminationHandler. toStackManipulation(MethodDescription invokedMethod, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
Returns a stack manipulation that handles the method return.Methods in net.bytebuddy.implementation that return types with arguments of type StackManipulation Modifier and Type Method Description private java.util.List<StackManipulation>
InvocationHandlerAdapter. argumentValuesOf(MethodDescription instrumentedMethod)
Returns a list of stack manipulations that loads all arguments of an instrumented method.Methods in net.bytebuddy.implementation with parameters of type StackManipulation Modifier and Type Method Description protected ByteCodeAppender.Size
FixedValue. apply(org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, MethodDescription instrumentedMethod, TypeDescription.Generic fixedValueType, StackManipulation valueLoadingInstruction)
Blueprint method that for applying the actual implementation.protected ByteCodeAppender.Size
InvocationHandlerAdapter. apply(org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, MethodDescription instrumentedMethod, StackManipulation preparingManipulation, FieldDescription fieldDescription)
Applies an implementation that delegates to a invocation handler.FieldDescription.InDefinedShape
Implementation.Context. cache(StackManipulation fieldValue, TypeDescription fieldType)
Caches a single value by storing it in form of aprivate
,final
andstatic
field.FieldDescription.InDefinedShape
Implementation.Context.Default. cache(StackManipulation fieldValue, TypeDescription fieldType)
Caches a single value by storing it in form of aprivate
,final
andstatic
field.FieldDescription.InDefinedShape
Implementation.Context.Disabled. cache(StackManipulation fieldValue, TypeDescription fieldType)
Caches a single value by storing it in form of aprivate
,final
andstatic
field.protected InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved
InvokeDynamic.InvocationProvider.ArgumentProvider.ForField. doResolve(StackManipulation access, TypeDescription.Generic type, Assigner assigner, Assigner.Typing typing)
Resolves this argument provider.protected InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved
InvokeDynamic.InvocationProvider.ArgumentProvider.ForField.WithExplicitType. doResolve(StackManipulation access, TypeDescription.Generic typeDescription, Assigner assigner, Assigner.Typing typing)
Resolves this argument provider.protected InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved
InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter. doResolve(StackManipulation access, TypeDescription.Generic type, Assigner assigner, Assigner.Typing typing)
Resolves this argument provider.protected InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved
InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter.WithExplicitType. doResolve(StackManipulation access, TypeDescription.Generic type, Assigner assigner, Assigner.Typing typing)
Resolves this argument provider.MethodCall
MethodCall.WithoutSpecifiedTarget. on(StackManipulation stackManipulation, java.lang.Class<?> type)
Invokes the specified method on an instance that is loaded by the provided stack manipulation.MethodCall
MethodCall.WithoutSpecifiedTarget. on(StackManipulation stackManipulation, TypeDescription typeDescription)
Invokes the specified method on an instance that is loaded by the provided stack manipulation.Implementation.Composable
FieldAccessor.ForImplicitProperty. setsValue(StackManipulation stackManipulation, java.lang.reflect.Type type)
Defines a setter of a value that is represented by a stack manipulation.Implementation.Composable
FieldAccessor.ForImplicitProperty. setsValue(StackManipulation stackManipulation, TypeDescription.Generic typeDescription)
Defines a setter of a value that is represented by a stack manipulation.Implementation.Composable
FieldAccessor.PropertyConfigurable. setsValue(StackManipulation stackManipulation, java.lang.reflect.Type type)
Defines a setter of a value that is represented by a stack manipulation.Implementation.Composable
FieldAccessor.PropertyConfigurable. setsValue(StackManipulation stackManipulation, TypeDescription.Generic typeDescription)
Defines a setter of a value that is represented by a stack manipulation.MethodCall
MethodCall. with(StackManipulation stackManipulation, java.lang.reflect.Type type)
Adds a stack manipulation as an assignment to the next parameter.MethodCall
MethodCall. with(StackManipulation stackManipulation, TypeDefinition typeDefinition)
Adds a stack manipulation as an assignment to the next parameter.Constructors in net.bytebuddy.implementation with parameters of type StackManipulation Constructor Description AccessorMethodDelegation(MethodDescription.InDefinedShape methodDescription, Visibility visibility, StackManipulation accessorMethodInvocation)
Creates a delegation to an accessor method.Appender(TypeDescription instrumentedType, StackManipulation baseline, java.util.List<FieldDescription.InDefinedShape> fieldDescriptions, ElementMatcher<? super FieldDescription.InDefinedShape> nonNullable)
Creates a new appender.Appender(StackManipulation initialValue, int multiplier, java.util.List<FieldDescription.InDefinedShape> fieldDescriptions, ElementMatcher<? super FieldDescription.InDefinedShape> nonNullable)
Creates a new appender for implementing a hash code method.FieldCacheEntry(StackManipulation fieldValue, TypeDescription fieldType)
Creates a new field cache entry.ForPoolValue(Assigner assigner, Assigner.Typing typing, StackManipulation valueLoadInstruction, TypeDescription loadedType)
Creates a new constant pool fixed value implementation.ForPoolValue(StackManipulation valueLoadInstruction, java.lang.Class<?> loadedType)
Creates a new constant pool fixed value implementation.ForPoolValue(StackManipulation valueLoadInstruction, TypeDescription loadedType)
Creates a new constant pool fixed value implementation.ForStackManipulation(StackManipulation stackManipulation, java.lang.reflect.Type type)
Creates an argument loader that loads a stack manipulation as an argument.ForStackManipulation(StackManipulation stackManipulation, TypeDefinition typeDefinition)
Creates an argument loader that loads a stack manipulation as an argument.OfConstantValue(FieldAccessor.FieldLocation fieldLocation, Assigner assigner, Assigner.Typing typing, FieldAccessor.ForSetter.TerminationHandler terminationHandler, TypeDescription.Generic typeDescription, StackManipulation stackManipulation)
Creates a setter instrumentation for setting a constant value.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(MethodDescription methodDescription, TypeDescription typeDescription, StackManipulation stackManipulation)
Creates a new legal special method invocation.Simple(StackManipulation stackManipulation, java.util.List<TypeDescription> loadedTypes)
Creates a simple resolved argument provider.Simple(StackManipulation stackManipulation, TypeDescription loadedType)
Creates a simple resolved argument provider.Simple(StackManipulation stackManipulation, java.lang.String internalName, TypeDescription returnType, java.util.List<TypeDescription> parameterTypes)
Creates a new simple instance.Simple(TypeDescription typeDescription, StackManipulation stackManipulation)
Creates a simple target handler.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 Description static class
MethodCallProxy.AssignableSignatureCall
A stack manipulation that creates aMethodCallProxy
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'sReflectionFactory.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.Fields in net.bytebuddy.implementation.auxiliary declared as StackManipulation Modifier and Type Field Description private StackManipulation
TypeProxy.MethodCall.Appender. fieldLoadingInstruction
The stack manipulation for loading the proxied instance onto the stack.private StackManipulation
TypeProxy.AbstractMethodErrorThrow. implementation
The stack manipulation that throws the abstract method error. -
Uses of StackManipulation in net.bytebuddy.implementation.bind
Subinterfaces of StackManipulation in net.bytebuddy.implementation.bind Modifier and Type Interface Description static interface
MethodDelegationBinder.MethodBinding
A binding attempt created by aMethodDelegationBinder
.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 Description protected static class
MethodDelegationBinder.MethodBinding.Builder.Build
A method binding that was created by aMethodDelegationBinder.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.Fields in net.bytebuddy.implementation.bind declared as StackManipulation Modifier and Type Field Description private StackManipulation
MethodDelegationBinder.ParameterBinding.Anonymous. delegate
The stack manipulation that represents the loading of the parameter binding onto the stack.private StackManipulation
MethodDelegationBinder.ParameterBinding.Unique. delegate
The stack manipulation that represents the loading of the parameter binding onto the stack.private StackManipulation
MethodDelegationBinder.MethodBinding.Builder.Build. methodInvocation
A stack manipulation that represents the actual method invocation.private StackManipulation
MethodDelegationBinder.MethodBinding.Builder.Build. terminatingStackManipulation
The stack manipulation that is applied after the method invocation.Fields in net.bytebuddy.implementation.bind with type parameters of type StackManipulation Modifier and Type Field Description private java.util.List<StackManipulation>
MethodDelegationBinder.MethodBinding.Builder.Build. parameterStackManipulations
A list of manipulations that each represent the loading of a parameter value onto the operand stack.private java.util.List<StackManipulation>
MethodDelegationBinder.MethodBinding.Builder. parameterStackManipulations
The current list of stack manipulations for loading values for each parameter onto the operand stack.Methods in net.bytebuddy.implementation.bind that return StackManipulation Modifier and Type Method Description StackManipulation
MethodDelegationBinder.MethodInvoker. invoke(MethodDescription methodDescription)
Creates a method invocation for a given method.StackManipulation
MethodDelegationBinder.MethodInvoker.Simple. invoke(MethodDescription methodDescription)
Creates a method invocation for a given method.StackManipulation
MethodDelegationBinder.MethodInvoker.Virtual. invoke(MethodDescription methodDescription)
Creates a method invocation for a given method.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 Description MethodDelegationBinder.MethodBinding
MethodDelegationBinder.MethodBinding.Builder. build(StackManipulation terminatingManipulation)
Creates a binding that represents the bindings collected by thisBuilder
.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 Description Anonymous(StackManipulation delegate)
Creates a new, anonymous parameter binding.Build(MethodDescription target, java.util.Map<?,java.lang.Integer> registeredTargetIndices, StackManipulation methodInvocation, java.util.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 Description Build(MethodDescription target, java.util.Map<?,java.lang.Integer> registeredTargetIndices, StackManipulation methodInvocation, java.util.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 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 thePipe
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 Description private static StackManipulation
Origin.Binder. methodConstant(Origin origin, MethodDescription.InDefinedShape methodDescription)
Loads a method constant onto the operand stack.protected abstract StackManipulation
Super.Instantiation. proxyFor(TypeDescription parameterType, Implementation.Target implementationTarget, AnnotationDescription.Loadable<Super> annotation)
Creates a stack manipulation which loads asuper
-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 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
Multiplication
A stack manipulation that multiplies two numbers 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 aThrowable
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.Fields in net.bytebuddy.implementation.bytecode declared as StackManipulation Modifier and Type Field Description private StackManipulation
ByteCodeAppender.Simple. stackManipulation
A compound stack manipulation to be applied for this byte code appender.Fields in net.bytebuddy.implementation.bytecode with type parameters of type StackManipulation Modifier and Type Field Description private java.util.List<StackManipulation>
StackManipulation.Compound. stackManipulations
The stack manipulations this compound operation represents in their application order.Methods in net.bytebuddy.implementation.bytecode that return StackManipulation Modifier and Type Method 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 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 Description Compound(java.util.List<? extends StackManipulation> stackManipulations)
Creates a new compound stack manipulation.Simple(java.util.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 Description class
InstanceCheck
Implements aninstanceof
check.class
TypeCasting
A stack manipulation for a type down casting.Methods in net.bytebuddy.implementation.bytecode.assign that return StackManipulation Modifier and Type Method Description StackManipulation
Assigner. assign(TypeDescription.Generic source, TypeDescription.Generic target, Assigner.Typing typing)
StackManipulation
Assigner.Refusing. assign(TypeDescription.Generic source, TypeDescription.Generic target, Assigner.Typing typing)
static StackManipulation
InstanceCheck. of(TypeDescription typeDescription)
Creates a new instance check.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 Description private class
PrimitiveBoxingDelegate.BoxingStackManipulation
A stack manipulation for boxing a primitive type into its wrapper type.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.Fields in net.bytebuddy.implementation.bytecode.assign.primitive declared as StackManipulation Modifier and Type Field Description private StackManipulation
PrimitiveBoxingDelegate.BoxingStackManipulation. stackManipulation
A stack manipulation that is applied after the boxing of the top-most value on the operand stack.private StackManipulation
PrimitiveWideningDelegate. toBooleanStackManipulation
A stack manipulation that widens the type that is represented by this instance to aboolean
.private StackManipulation
PrimitiveWideningDelegate. toByteStackManipulation
A stack manipulation that widens the type that is represented by this instance to abyte
.private StackManipulation
PrimitiveWideningDelegate. toCharacterStackManipulation
A stack manipulation that widens the type that is represented by this instance to achar
.private StackManipulation
PrimitiveWideningDelegate. toDoubleStackManipulation
A stack manipulation that widens the type that is represented by this instance to adouble
.private StackManipulation
PrimitiveWideningDelegate. toFloatStackManipulation
A stack manipulation that widens the type that is represented by this instance to afloat
.private StackManipulation
PrimitiveWideningDelegate. toIntegerStackManipulation
A stack manipulation that widens the type that is represented by this instance to aint
.private StackManipulation
PrimitiveWideningDelegate. toLongStackManipulation
A stack manipulation that widens the type that is represented by this instance to along
.private StackManipulation
PrimitiveWideningDelegate. toShortStackManipulation
A stack manipulation that widens the type that is represented by this instance to ashort
.Methods in net.bytebuddy.implementation.bytecode.assign.primitive that return StackManipulation Modifier and Type Method Description StackManipulation
PrimitiveTypeAwareAssigner. assign(TypeDescription.Generic source, TypeDescription.Generic target, Assigner.Typing typing)
StackManipulation
VoidAwareAssigner. assign(TypeDescription.Generic source, TypeDescription.Generic target, Assigner.Typing typing)
StackManipulation
PrimitiveBoxingDelegate. assignBoxedTo(TypeDescription.Generic target, Assigner chainedAssigner, Assigner.Typing typing)
Creates a stack manipulation that boxes the represented primitive type and applies a chained assignment to the result of this boxing operation.StackManipulation
PrimitiveUnboxingDelegate.ExplicitlyTypedUnboxingResponsible. assignUnboxedTo(TypeDescription.Generic targetType, Assigner assigner, Assigner.Typing typing)
Attempts to unbox the represented type in order to assign the unboxed value to the given target type while using the assigner that is provided by the method call.StackManipulation
PrimitiveUnboxingDelegate.ImplicitlyTypedUnboxingResponsible. assignUnboxedTo(TypeDescription.Generic target, Assigner assigner, Assigner.Typing typing)
Attempts to unbox the represented type in order to assign the unboxed value to the given target type while using the assigner that is provided by the method call.StackManipulation
PrimitiveUnboxingDelegate.UnboxingResponsible. assignUnboxedTo(TypeDescription.Generic target, Assigner assigner, Assigner.Typing typing)
Attempts to unbox the represented type in order to assign the unboxed value to the given target type while using the assigner that is provided by the method call.StackManipulation
PrimitiveWideningDelegate. widenTo(TypeDefinition typeDefinition)
Attempts to widen the represented type into another type.Constructors in net.bytebuddy.implementation.bytecode.assign.primitive with parameters of type StackManipulation Constructor Description BoxingStackManipulation(StackManipulation stackManipulation)
Creates a new boxing stack manipulation.PrimitiveWideningDelegate(StackManipulation toBooleanStackManipulation, StackManipulation toByteStackManipulation, StackManipulation toShortStackManipulation, StackManipulation toCharacterStackManipulation, StackManipulation toIntegerStackManipulation, StackManipulation toLongStackManipulation, StackManipulation toFloatStackManipulation, StackManipulation toDoubleStackManipulation)
Creates a new primitive widening delegate. -
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 Description StackManipulation
GenericTypeAwareAssigner. assign(TypeDescription.Generic source, TypeDescription.Generic target, Assigner.Typing typing)
StackManipulation
ReferenceTypeAwareAssigner. assign(TypeDescription.Generic source, TypeDescription.Generic target, Assigner.Typing typing)
-
Uses of StackManipulation in net.bytebuddy.implementation.bytecode.collection
Subinterfaces of StackManipulation in net.bytebuddy.implementation.bytecode.collection Modifier and Type Interface 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 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.Fields in net.bytebuddy.implementation.bytecode.collection with type parameters of type StackManipulation Modifier and Type Field Description private java.util.List<? extends StackManipulation>
ArrayFactory.ArrayStackManipulation. stackManipulations
A list of value load instructions that are to be stored inside the created array.Methods in net.bytebuddy.implementation.bytecode.collection that return StackManipulation Modifier and Type Method Description StackManipulation
ArrayAccess. forEach(java.util.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
ArrayFactory. withValues(java.util.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
CollectionFactory. withValues(java.util.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.Method parameters in net.bytebuddy.implementation.bytecode.collection with type arguments of type StackManipulation Modifier and Type Method Description StackManipulation
ArrayAccess. forEach(java.util.List<? extends StackManipulation> processInstructions)
Applies a stack manipulation to the values of an array.StackManipulation
ArrayFactory. withValues(java.util.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
CollectionFactory. withValues(java.util.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.Constructor parameters in net.bytebuddy.implementation.bytecode.collection with type arguments of type StackManipulation Constructor Description ArrayStackManipulation(java.util.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 Description static interface
MethodConstant.CanCache
Represents aMethodConstant
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 Description class
ClassConstant
Represents a constant representing any loaded JavaClass
.protected static class
ClassConstant.ForReferenceType
A class constant for a non-primitiveClass
.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 anydouble
constant onto the operand stack.protected static class
DoubleConstant.ConstantPool
A stack manipulation for loading adouble
value from a class's constant pool onto the operand stack.class
FieldConstant
Represents aField
constant for a given type.protected static class
FieldConstant.Cached
A cached version of aFieldConstant
.class
FloatConstant
This class is responsible for loading anyfloat
constant onto the operand stack.protected static class
FloatConstant.ConstantPool
A stack manipulation for loading afloat
value from a class's constant pool onto the operand stack.class
IntegerConstant
This class is responsible for loading anyint
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 aBIPUSH
operation which is legal for single byte integer values.protected static class
IntegerConstant.TwoBytePush
A stack manipulation that loads a JVM-integer value by aSIPUSH
operation which is legal for up to two byte integer values.class
JavaConstantValue
A constant representing aJavaConstant
.class
LongConstant
This class is responsible for loading anylong
constant onto the operand stack.protected static class
LongConstant.ConstantPool
A stack manipulation for loading along
value from a class's constant pool onto the operand stack.class
MethodConstant
Represents the creation of aMethod
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 aMethodConstant
.protected static class
MethodConstant.CachedMethod
Represents a cached method for aMethodConstant
.protected static class
MethodConstant.CanCacheIllegal
Represents a method constant that cannot be represented by Java's reflection API.protected static class
MethodConstant.ForConstructor
Creates aMethodConstant
for loading aConstructor
instance onto the operand stack.protected static class
MethodConstant.ForMethod
Creates aMethodConstant
for loading aMethod
instance onto the operand stack.protected static class
MethodConstant.PrivilegedLookup
Performs a privileged lookup of a method constant by using anAccessController
.class
NullConstant
Represents a stack manipulation to load anull
pointer onto the operand stack.class
SerializedConstant
A constant that represents a value in its serialized form.class
TextConstant
Represents aString
value that is stored in a type's constant pool.Fields in net.bytebuddy.implementation.bytecode.constant declared as StackManipulation Modifier and Type Field Description private StackManipulation
MethodConstant.CachedConstructor. constructorConstant
The stack manipulation that is represented by this caching wrapper.private StackManipulation
FieldConstant.Cached. fieldConstant
The field constant stack manipulation.private StackManipulation
MethodConstant.CachedMethod. methodConstant
The stack manipulation that is represented by this caching wrapper.private StackManipulation
MethodConstant.PrivilegedLookup. methodName
The stack manipulation for locating the method name.private StackManipulation
DefaultValue. stackManipulation
The stack manipulation that represents the loading of a given default value onto the operand stack.Methods in net.bytebuddy.implementation.bytecode.constant that return StackManipulation Modifier and Type Method Description StackManipulation
FieldConstant. cached()
Returns a cached version of this field constant.StackManipulation
MethodConstant.CanCache. cached()
Returns this method constant as a cached version.StackManipulation
MethodConstant.CanCacheIllegal. cached()
Returns this method constant as a cached version.StackManipulation
MethodConstant.ForConstructor. cached()
Returns this method constant as a cached version.StackManipulation
MethodConstant.ForMethod. cached()
Returns this method constant as a cached version.StackManipulation
MethodConstant.PrivilegedLookup. cached()
Returns this method constant as a cached version.static StackManipulation
DoubleConstant. forValue(double value)
Creates a stack manipulation for loading adouble
value onto the operand stack.static StackManipulation
FloatConstant. forValue(float value)
Creates a stack manipulation for loading afloat
value onto the operand stack.static StackManipulation
IntegerConstant. forValue(boolean value)
Creates a stack manipulation for loading a boolean value onto the stack.static StackManipulation
IntegerConstant. forValue(int value)
Creates a stack manipulation for loading anint
value onto the stack.static StackManipulation
LongConstant. forValue(long value)
Creates a stack manipulation for loading along
value onto the operand stack.protected StackManipulation
MethodConstant.ForConstructor. methodName()
protected StackManipulation
MethodConstant.ForMethod. methodName()
protected abstract StackManipulation
MethodConstant. methodName()
Returns a stack manipulation that loads the method name onto the operand stack if this is required.static StackManipulation
ClassConstant. of(TypeDescription typeDescription)
Returns a stack manipulation that loads aClass
type onto the operand stack which represents the given type.static StackManipulation
DefaultValue. of(TypeDefinition typeDefinition)
Creates a stack assignment that loads the default value for a given type.static StackManipulation
SerializedConstant. of(java.io.Serializable value)
Creates a new stack manipulation to load the supplied value onto the stack.Methods in net.bytebuddy.implementation.bytecode.constant that return types with arguments of type StackManipulation Modifier and Type Method Description protected static java.util.List<StackManipulation>
MethodConstant. typeConstantsFor(java.util.List<TypeDescription> parameterTypes)
Returns a list of type constant load operations for the given list of parameters.Constructors in net.bytebuddy.implementation.bytecode.constant with parameters of type StackManipulation Constructor Description Cached(StackManipulation fieldConstant)
Creates a new cached version of a field constant.CachedConstructor(StackManipulation constructorConstant)
Creates a new cachedMethodConstant
.CachedMethod(StackManipulation methodConstant)
Creates a new cachedMethodConstant
.DefaultValue(StackManipulation stackManipulation)
Creates a new default value load operation.PrivilegedLookup(MethodDescription.InDefinedShape methodDescription, StackManipulation methodName)
Creates a new privileged lookup. -
Uses of StackManipulation in net.bytebuddy.implementation.bytecode.member
Subinterfaces of StackManipulation in net.bytebuddy.implementation.bytecode.member Modifier and Type Interface 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 Description private class
FieldAccess.AccessDispatcher.AbstractFieldInstruction
An abstract base implementation for accessing a field value.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 Description StackManipulation
MethodInvocation.IllegalInvocation. dynamic(java.lang.String methodName, TypeDescription returnType, java.util.List<? extends TypeDescription> methodType, java.util.List<?> arguments)
Invokes the method as a bootstrap method to bind a call site with the given properties.StackManipulation
MethodInvocation.Invocation. dynamic(java.lang.String methodName, TypeDescription returnType, java.util.List<? extends TypeDescription> methodType, java.util.List<?> arguments)
Invokes the method as a bootstrap method to bind a call site with the given properties.StackManipulation
MethodInvocation.OfGenericMethod. dynamic(java.lang.String methodName, TypeDescription returnType, java.util.List<? extends TypeDescription> methodType, java.util.List<?> arguments)
Invokes the method as a bootstrap method to bind a call site with the given properties.StackManipulation
MethodInvocation.WithImplicitInvocationTargetType. dynamic(java.lang.String methodName, TypeDescription returnType, java.util.List<? extends TypeDescription> methodType, java.util.List<?> arguments)
Invokes the method as a bootstrap method to bind a call site with the given properties.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 thethis
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.ForBridgeTarget. 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)
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. 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
MethodInvocation.IllegalInvocation. onHandle(MethodInvocation.HandleType type)
Invokes the method via aMethodHandle
.StackManipulation
MethodInvocation.Invocation. onHandle(MethodInvocation.HandleType type)
Invokes the method via aMethodHandle
.StackManipulation
MethodInvocation.OfGenericMethod. onHandle(MethodInvocation.HandleType type)
Invokes the method via aMethodHandle
.StackManipulation
MethodInvocation.WithImplicitInvocationTargetType. onHandle(MethodInvocation.HandleType type)
Invokes the method via aMethodHandle
.StackManipulation
MethodVariableAccess.MethodLoading. prependThisReference()
Prepends a reference to thethis
instance to the loaded parameters if the represented method is non-static.StackManipulation
FieldAccess.AccessDispatcher. read()
Creates a getter representation for a given field.StackManipulation
FieldAccess.Defined. read()
Creates a getter representation for a given field.StackManipulation
FieldAccess.OfGenericField. read()
Creates a getter representation for a given field.StackManipulation
MethodInvocation.IllegalInvocation. special(TypeDescription invocationTarget)
Transforms this method invocation into a special invocation on the given type.StackManipulation
MethodInvocation.Invocation. special(TypeDescription invocationTarget)
Transforms this method invocation into a special invocation on the given type.StackManipulation
MethodInvocation.OfGenericMethod. special(TypeDescription invocationTarget)
Transforms this method invocation into a special invocation on the given type.StackManipulation
MethodInvocation.WithImplicitInvocationTargetType. special(TypeDescription invocationTarget)
Transforms this method invocation into a special invocation on the given type.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)
Transforms this method invocation into a virtual (or interface) method invocation on the given type.StackManipulation
MethodInvocation.Invocation. virtual(TypeDescription invocationTarget)
Transforms this method invocation into a virtual (or interface) method invocation on the given type.StackManipulation
MethodInvocation.OfGenericMethod. virtual(TypeDescription invocationTarget)
Transforms this method invocation into a virtual (or interface) method invocation on the given type.StackManipulation
MethodInvocation.WithImplicitInvocationTargetType. virtual(TypeDescription invocationTarget)
Transforms this method invocation into a virtual (or interface) method invocation on the given type.StackManipulation
FieldAccess.AccessDispatcher. write()
Creates a setter representation for a given field.StackManipulation
FieldAccess.Defined. write()
Creates a setter representation for a given field.StackManipulation
FieldAccess.OfGenericField. write()
Creates a setter representation for a given field.
-