Uses of Interface
net.bytebuddy.dynamic.scaffold.InstrumentedType.Prepareable

Packages that use InstrumentedType.Prepareable

Package	Description
net.bytebuddy	Byte Buddy is a library for creating Java classes at runtime of a Java program.
net.bytebuddy.agent.builder	An agent builder is used to easily implement load-time class-transformations using a Java agent.
net.bytebuddy.asm	The ASM package contains classes that are meant for direct interaction with the ASM API.
net.bytebuddy.dynamic.scaffold	This package contains helper types and implementations that are responsible for the actual writing of a byte array representing a Java class.
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.

Uses of InstrumentedType.Prepareable in net.bytebuddy

Classes in net.bytebuddy that implement InstrumentedType.Prepareable

Modifier and Type	Class	Description
protected static class	ByteBuddy.EnumerationImplementation	An implementation fo the values method of an enumeration type.
protected static enum	ByteBuddy.RecordConstructorStrategy	A constructor strategy for implementing a Java record.
protected static enum	ByteBuddy.RecordObjectMethod	Implements the object methods of the Java record type.

Uses of InstrumentedType.Prepareable in net.bytebuddy.agent.builder

Classes in net.bytebuddy.agent.builder that implement InstrumentedType.Prepareable

Modifier and Type	Class	Description
protected static class	AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.BridgeMethodImplementation	Implements an explicit bridge method for a lambda expression.
protected static enum	AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.ConstructorImplementation	Implements a lambda class's executing transformer.
protected static enum	AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.FactoryImplementation	An implementation of a instance factory for a lambda expression's class.
protected static class	AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.LambdaMethodImplementation	Implements a lambda expression's functional method.
protected static class	AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.SerializationImplementation	Implements the writeReplace method for serializable lambda expressions.

Uses of InstrumentedType.Prepareable in net.bytebuddy.asm

Classes in net.bytebuddy.asm that implement InstrumentedType.Prepareable

Modifier and Type	Class	Description
class	Advice	Advice wrappers copy the code of blueprint methods to be executed before and/or after a matched method.

Uses of InstrumentedType.Prepareable in net.bytebuddy.dynamic.scaffold

Subinterfaces of InstrumentedType.Prepareable in net.bytebuddy.dynamic.scaffold

Modifier and Type	Interface	Description
static interface	MethodRegistry.Handler	A handler for implementing a method.

Classes in net.bytebuddy.dynamic.scaffold that implement InstrumentedType.Prepareable

Modifier and Type	Class	Description
static enum	InstrumentedType.Prepareable.NoOp	A prepareable that does not alter the instrumented type.
static enum	MethodRegistry.Handler.ForAbstractMethod	A handler for defining an abstract or native method.
static class	MethodRegistry.Handler.ForAnnotationValue	A handler for defining a default annotation value for a method.
static class	MethodRegistry.Handler.ForImplementation	A handler for a method that is implemented as byte code.
static enum	MethodRegistry.Handler.ForVisibilityBridge	A handler for implementing a visibility bridge.

Uses of InstrumentedType.Prepareable in net.bytebuddy.implementation

Subinterfaces of InstrumentedType.Prepareable in net.bytebuddy.implementation

Modifier and Type	Interface	Description
static interface	FieldAccessor.AssignerConfigurable	A field accessor that can be configured to use a given assigner and runtime type use configuration.
static interface	FieldAccessor.OwnerTypeLocatable	A field accessor that can be configured to locate a field in a specific manner.
static interface	FieldAccessor.PropertyConfigurable	A field accessor that allows to define the access to be a field write of a given argument.
static interface	FixedValue.AssignerConfigurable	Represents a fixed value implementation that is using a default assigner for attempting to assign the fixed value to the return type of the instrumented method.
interface	Implementation	An implementation is responsible for implementing methods of a dynamically created type as byte code.
static interface	Implementation.Composable	Represents an implementation that can be chained together with another implementation.
static interface	InvocationHandlerAdapter.AssignerConfigurable	Allows for the configuration of an Assigner of an InvocationHandlerAdapter.
static interface	InvocationHandlerAdapter.WithoutPrivilegeConfiguration	Allows the configuration of privileged lookup for the resolution of Method constants that are provided to the invocation handler.
static interface	MethodCall.ArgumentLoader.Factory	A factory that produces MethodCall.ArgumentLoaders for a given instrumented method.
static interface	MethodCall.TargetHandler.Factory	A factory for creating a target handler.
protected static interface	MethodDelegation.ImplementationDelegate	An implementation delegate is responsible for executing the actual method delegation and for resolving the target methods.

Classes in net.bytebuddy.implementation that implement InstrumentedType.Prepareable

Modifier and Type	Class	Description
class	DefaultMethodCall	This Implementation invokes a default method for the methods it instruments.
class	EqualsMethod	An implementation of Object.equals(Object) that takes a class's declared fields into consideration.
class	ExceptionMethod	This implementation causes a Throwable to be thrown when the instrumented method is invoked.
class	FieldAccessor	Defines a method to access a given field by following the Java bean conventions for getters and setters:
protected static class	FieldAccessor.ForImplicitProperty	A field accessor for an implicit property where a getter or setter property is inferred from the signature.
protected static class	FieldAccessor.ForSetter<T>	A field accessor for a field setter.
protected static class	FieldAccessor.ForSetter.OfConstantValue	An instrumentation that sets a constant value to a field.
protected static class	FieldAccessor.ForSetter.OfDefaultValue	A setter instrumentation that sets a null or a primitive type's default value.
protected static class	FieldAccessor.ForSetter.OfFieldValue	A setter that reads a value of another field and sets this value.
protected static class	FieldAccessor.ForSetter.OfParameterValue	A setter instrumentation for a parameter value.
protected static class	FieldAccessor.ForSetter.OfReferenceValue	An instrumentation that sets a field to a reference value that is stored in a static field of the instrumented type.
class	FixedValue	This implementation returns a fixed value for a method.
protected static class	FixedValue.ForArgument	A fixed value implementation that returns a method's argument.
protected static class	FixedValue.ForConstantValue	A fixed value implementation that represents its fixed value as a constant pool value or a byte code instruction.
protected static enum	FixedValue.ForNullValue	A fixed value of null.
protected static class	FixedValue.ForOriginType	A fixed value that appends the origin type of the instrumented type.
protected static class	FixedValue.ForThisValue	A fixed value of this.
protected static class	FixedValue.ForValue	A fixed value implementation that represents its fixed value as a static field of the instrumented class.
class	HashCodeMethod	An implementation of Object.hashCode() that takes a class's declared fields into consideration.
static class	Implementation.Compound	A compound implementation that allows to combine several implementations.
static class	Implementation.Compound.Composable	A compound implementation that allows to combine several implementations and that is Implementation.Composable.
static class	Implementation.Simple	A simple implementation that does not register any members with the instrumented type.
protected static class	Implementation.Simple.ForDispatcher	A ByteCodeAppender for a dispatcher.
class	InvocationHandlerAdapter	An adapter for adapting an InvocationHandler.
protected static class	InvocationHandlerAdapter.ForField	An implementation of an InvocationHandlerAdapter that delegates method invocations to an adapter that is stored in an instance field.
protected static class	InvocationHandlerAdapter.ForInstance	An implementation of an InvocationHandlerAdapter that delegates method invocations to an adapter that is stored in a static field.
class	InvokeDynamic	An implementation that applies a dynamic method invocation.
protected static class	InvokeDynamic.AbstractDelegator	An abstract delegator that allows to specify a configuration for any specification of an argument.
static class	InvokeDynamic.WithImplicitArguments	Representation of an InvokeDynamic implementation where the bootstrapped method is passed a this reference, if available, and any arguments of the instrumented method.
static class	InvokeDynamic.WithImplicitTarget	Representation of an InvokeDynamic implementation where the bootstrapped method is passed a this reference, if available, and any arguments of the instrumented method and where the invocation target is implicit.
static class	InvokeDynamic.WithImplicitType	An InvokeDynamic invocation where the last argument is assigned its implicit type.
protected static class	InvokeDynamic.WithImplicitType.OfArgument	An invoke dynamic implementation where the last argument is an implicitly typed method argument.
protected static class	InvokeDynamic.WithImplicitType.OfField	An invoke dynamic implementation where the last argument is an implicitly typed field value.
protected static class	InvokeDynamic.WithImplicitType.OfInstance	A step in the invoke dynamic domain specific language that allows to explicitly specify a field type for a reference value.
class	MethodCall	This Implementation allows the invocation of a specified method while providing explicit arguments to this method.
protected static class	MethodCall.ArgumentLoader.ForField.Factory	A factory for an argument loaded that loads the value of an existing field as an argument.
protected static class	MethodCall.ArgumentLoader.ForInstance.Factory	A factory that supplies the value of a static field as an argument.
static enum	MethodCall.ArgumentLoader.ForInstrumentedType.Factory	A factory for an argument loader that supplies the instrumented type as an argument.
protected static class	MethodCall.ArgumentLoader.ForMethodCall.Factory	A factory for an argument loaded that loads the return value of a method call as an argument.
static class	MethodCall.ArgumentLoader.ForMethodParameter.Factory	A factory for an argument loader that supplies a method parameter as an argument.
protected static enum	MethodCall.ArgumentLoader.ForMethodParameter.OfInstrumentedMethod	A factory for argument loaders that supplies all arguments of the instrumented method as arguments.
static enum	MethodCall.ArgumentLoader.ForMethodParameterArray.ForInstrumentedMethod	A factory that creates an arguments loader that loads all parameters of the instrumented method contained in an array.
static class	MethodCall.ArgumentLoader.ForMethodParameterArrayElement.OfInvokedMethod	An argument loader factory that loads an array element from a parameter for each argument of the invoked method.
static class	MethodCall.ArgumentLoader.ForMethodParameterArrayElement.OfParameter	Creates an argument loader for an array element that of a specific parameter.
static enum	MethodCall.ArgumentLoader.ForNullConstant	An argument loader that loads the null value onto the operand stack.
static class	MethodCall.ArgumentLoader.ForStackManipulation	Loads a stack manipulation resulting in a specific type as an argument.
static enum	MethodCall.ArgumentLoader.ForThisReference.Factory	A factory for an argument loader that supplies the this value as an argument.
static class	MethodCall.FieldSetting	A MethodCall that sets the call's result as the value of a field.
(package private) static enum	MethodCall.TargetHandler.ForConstructingInvocation.Factory	A target handler factory for a constructor invocation.
protected static class	MethodCall.TargetHandler.ForField.Factory	A factory for a field access.
protected static class	MethodCall.TargetHandler.ForMethodCall.Factory	Creates a factory for invoking a method on the return type of another method.
static class	MethodCall.TargetHandler.ForMethodParameter	A target handler that loads the parameter of the given index as the target object.
protected static enum	MethodCall.TargetHandler.ForSelfOrStaticInvocation.Factory	A factory for invoking a static method or a self-declared method.
protected static class	MethodCall.TargetHandler.ForValue.Factory	A factory for a target handler that loads a specific value.
static class	MethodCall.TargetHandler.Simple	A simple target handler that applies a given stack manipulation.
static class	MethodCall.WithoutSpecifiedTarget	Represents a MethodCall that invokes a method without specifying an invocation method.
class	MethodDelegation	This implementation delegates a method call to another method which can either be static by providing a reference to a Class or an instance method when another object is provided.
static class	MethodDelegation.ImplementationDelegate.ForConstruction	An implementation delegate for constructing an instance.
static class	MethodDelegation.ImplementationDelegate.ForField	An implementation delegate for invoking methods on a field that is declared by the instrumented type or a super type.
protected static class	MethodDelegation.ImplementationDelegate.ForField.WithInstance	An implementation target for a static field that is declared by the instrumented type and that is assigned an instance.
protected static class	MethodDelegation.ImplementationDelegate.ForField.WithLookup	An implementation target for a field that is declared by the instrumented type or a super type.
static class	MethodDelegation.ImplementationDelegate.ForMethodReturn	An implementation delegate for invoking a delegation target on the another methods return value.
static class	MethodDelegation.ImplementationDelegate.ForStaticMethod	An implementation delegate for a static method delegation.
enum	StubMethod	This implementation creates a method stub which does nothing but returning the default value of the return type of the method.
enum	SuperMethodCall	This implementation will create a new method which simply calls its super method.
protected static enum	SuperMethodCall.WithoutReturn	A super method invocation where the return value is dropped instead of returning from the method.
class	ToStringMethod	An implementation of Object.toString() that concatenates the String representation of all fields that are declared by a class.

Fields in net.bytebuddy.implementation declared as InstrumentedType.Prepareable

Modifier and Type	Field	Description
private final InstrumentedType.Prepareable	Implementation.Simple.ForDispatcher.prepareable	A preparation of the instrumented type.

Methods in net.bytebuddy.implementation with parameters of type InstrumentedType.Prepareable

Modifier and Type	Method	Description
static Implementation	Implementation.Simple.of(Implementation.Simple.Dispatcher dispatcher, InstrumentedType.Prepareable prepareable)	Resolves a simple implementation that applies the given dispatcher without defining additional local variables.
static Implementation	Implementation.Simple.of(Implementation.Simple.Dispatcher dispatcher, InstrumentedType.Prepareable prepareable, int additionalVariableLength)	Resolves a simple implementation that applies the given dispatcher.

Constructors in net.bytebuddy.implementation with parameters of type InstrumentedType.Prepareable

Modifier	Constructor	Description
protected	ForDispatcher(Implementation.Simple.Dispatcher dispatcher, InstrumentedType.Prepareable prepareable, int additionalVariableLength)	Creates a new byte code appender for a dispatcher.

Uses of InstrumentedType.Prepareable in net.bytebuddy.implementation.auxiliary

Classes in net.bytebuddy.implementation.auxiliary that implement InstrumentedType.Prepareable

Modifier and Type	Class	Description
protected static enum	MethodCallProxy.ConstructorCall	An implementation for a constructor of a MethodCallProxy.
protected static class	MethodCallProxy.MethodCall	An implementation for a method of a MethodCallProxy.
protected class	TypeProxy.MethodCall	An implementation for a method call of a TypeProxy.
protected static enum	TypeProxy.SilentConstruction	An implementation of a silent construction of a given type by using the non-standardized ReflectionFactory.

Uses of InstrumentedType.Prepareable in net.bytebuddy.implementation.bind.annotation

Classes in net.bytebuddy.implementation.bind.annotation that implement InstrumentedType.Prepareable

Modifier and Type	Class	Description
protected static class	FieldProxy.Binder.FieldGetter	Implementation for a getter method.
protected static class	FieldProxy.Binder.FieldSetter	Implementation for a setter method.
protected static class	FieldProxy.Binder.InstanceFieldConstructor	Represents an implementation for implementing a proxy type constructor when a non-static field is accessed.
protected static enum	FieldProxy.Binder.StaticFieldConstructor	Represents an implementation for implementing a proxy type constructor when a static field is accessed.
protected static class	Morph.Binder.RedirectionProxy.InstanceFieldConstructor	Creates an instance of the proxy when instrumenting an instance method.
protected static class	Morph.Binder.RedirectionProxy.MethodCall	Implements a the method call of the morphing method.
protected static enum	Morph.Binder.RedirectionProxy.StaticFieldConstructor	Creates an instance of the proxy when instrumenting a static method.
protected static enum	Pipe.Binder.RedirectionProxy.ConstructorCall	The implementation to implement a Pipe.Binder.RedirectionProxy's constructor.
protected static class	Pipe.Binder.RedirectionProxy.MethodCall	The implementation to implement a Pipe.Binder.RedirectionProxy's forwarding method.