Uses of Class net.bytebuddy.implementation.bytecode.StackManipulation.AbstractBase

Packages that use StackManipulation.AbstractBase
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.implementation	The implementation package contains any logic for intercepting method calls.
net.bytebuddy.implementation.auxiliary	Auxiliary types describe helper types that aid as a supplementary to a given `InstrumentedType`.
net.bytebuddy.implementation.bind.annotation	This package contains annotations, types and classes that are responsible for binding a method to calling another method by interpreting annotations that indicate how a method should be bound to another method.
net.bytebuddy.implementation.bytecode	Types and classes in this package are responsible for creating Java byte code for a given byte code target which is represented by a `MethodDescription`.
net.bytebuddy.implementation.bytecode.assign	An `Assigner` is responsible for transforming a given `TypeDescription` into another one.
net.bytebuddy.implementation.bytecode.assign.primitive	`Assigner` implementations of this package are capable of handling primitive types or the `void` type.
net.bytebuddy.implementation.bytecode.collection	This package is dedicated to creating `StackManipulation`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.AbstractBase in net.bytebuddy.agent.builder

Subclasses of StackManipulation.AbstractBase in net.bytebuddy.agent.builder
Modifier and Type	Class	Description
`static class`	`AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.LambdaMethodImplementation.Appender.Dispatcher.UsingMethodHandle`	An invocation that is using an exact invocation of a method handle.

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

Subclasses of StackManipulation.AbstractBase in net.bytebuddy.dynamic.scaffold.inline
Modifier and Type	Class	Description
`protected static class`	`RebaseImplementationTarget.RebasedMethodInvocation`	A `Implementation.SpecialMethodInvocation` which invokes a rebased method as given by a `MethodRebaseResolver`.

Uses of StackManipulation.AbstractBase in net.bytebuddy.implementation

Subclasses of StackManipulation.AbstractBase in net.bytebuddy.implementation
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 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.
`static class`	`Implementation.SpecialMethodInvocation.AbstractBase`	An abstract base implementation of a valid special method invocation.
`static class`	`Implementation.SpecialMethodInvocation.Simple`	A canonical implementation of a `Implementation.SpecialMethodInvocation`.

Uses of StackManipulation.AbstractBase in net.bytebuddy.implementation.auxiliary

Subclasses of StackManipulation.AbstractBase in net.bytebuddy.implementation.auxiliary
Modifier and Type	Class	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.
`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.

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

Subclasses of StackManipulation.AbstractBase in net.bytebuddy.implementation.bind.annotation
Modifier and Type	Class	Description
`protected static 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.RedirectionProxy`	An auxiliary type for performing the redirection of a method invocation as requested by the `Pipe` annotation.

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

Subclasses of StackManipulation.AbstractBase in net.bytebuddy.implementation.bytecode
Modifier and Type	Class	Description
`static class`	`StackManipulation.Simple`	An implementation of `StackManipulation` that simplifies functional invocations via lambda expressions.
`class`	`TypeCreation`	A stack manipulation for creating an undefined type on which a constructor is to be called.

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

Subclasses of StackManipulation.AbstractBase in net.bytebuddy.implementation.bytecode.assign
Modifier and Type	Class	Description
`class`	`InstanceCheck`	Implements an `instanceof` check.
`class`	`TypeCasting`	A stack manipulation for a type down casting.

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

Subclasses of StackManipulation.AbstractBase in net.bytebuddy.implementation.bytecode.assign.primitive
Modifier and Type	Class	Description
`protected static class`	`PrimitiveNarrowingDelegate.NarrowingStackManipulation`	A stack manipulation that narrows a primitive type into a smaller primitive type.
`protected static class`	`PrimitiveWideningDelegate.WideningStackManipulation`	A stack manipulation that widens a primitive type into a more general primitive type.

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

Subclasses of StackManipulation.AbstractBase in net.bytebuddy.implementation.bytecode.collection
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.ForReferenceType`	An array creator implementation for reference types.

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

Subclasses of StackManipulation.AbstractBase in net.bytebuddy.implementation.bytecode.constant
Modifier and Type	Class	Description
`protected static class`	`DoubleConstant.ConstantPool`	A stack manipulation for loading a `double` value from a class's constant pool onto the operand stack.
`class`	`FieldConstant`	Represents a `Field` constant for a given type.
`protected static class`	`FloatConstant.ConstantPool`	A stack manipulation for loading a `float` value from a class's constant pool onto the operand stack.
`protected static class`	`IntegerConstant.ConstantPool`	A stack manipulation that loads a JVM-integer value from a constant pool value onto the operand stack.
`protected static class`	`IntegerConstant.SingleBytePush`	A stack manipulation that loads a JVM-integer value by a `BIPUSH` operation which is legal for single byte integer values.
`protected static class`	`IntegerConstant.TwoBytePush`	A stack manipulation that loads a JVM-integer value by a `SIPUSH` operation which is legal for up to two byte integer values.
`class`	`JavaConstantValue`	A constant representing a `JavaConstant`.
`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.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`	`SerializedConstant`	A constant that represents a value in its serialized form.
`class`	`TextConstant`	Represents a `String` value that is stored in a type's constant pool.

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

Subclasses of StackManipulation.AbstractBase in net.bytebuddy.implementation.bytecode.member
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.
`class`	`Invokedynamic`	A stack manipulation for an invokedynamic invocation.
`protected static class`	`MethodInvocation.HandleInvocation`	Performs a method invocation on a method handle with a polymorphic type signature.
`protected class`	`MethodInvocation.Invocation`	An implementation of a method invoking stack manipulation.
`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.