Uses of Class
net.bytebuddy.build.HashCodeAndEqualsPlugin.Enhance
-
Packages that use HashCodeAndEqualsPlugin.Enhance 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.build A package for types that allow for applying Byte Buddy transformation during a build process.net.bytebuddy.description.annotation Contains descriptions of annotations and annotation values.net.bytebuddy.description.method Contains descriptions of Java methods and constructors as well as their parameters.net.bytebuddy.description.modifier The modifier package contains high-level and type-safe descriptions of Java modifiers.net.bytebuddy.description.type Contains descriptions of Java types and packages.net.bytebuddy.dynamic This package contains classes and interfaces that are connected to writing the byte stream that represents a Java type that is dynamically created and for loading this type into a running JVM process.net.bytebuddy.dynamic.loading This package contains classes that are responsible for class loading of classes that are represented bybyte
arrays.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.dynamic.scaffold.inline All classes and types in this package are related to creating aDynamicType
by enhancing a given type.net.bytebuddy.dynamic.scaffold.subclass All classes and types in this package are related to creating aDynamicType
by creating a subclass of a given type.net.bytebuddy.implementation The implementation package contains any logic for intercepting method calls.net.bytebuddy.implementation.attribute All types and classes in this package are responsible for writing attributes for a given Java byte code element, i.e.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.net.bytebuddy.matcher Contains an API for matching Java byte code entities.net.bytebuddy.pool Classes of this package allow for the creatingTypeDescription
s without loading any classes.net.bytebuddy.utility This package contains utility classes for common use within any Byte Buddy logic.net.bytebuddy.utility.privilege A package containingPrivilegedAction
s that are used for invoking sensitive methods. -
-
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy
Classes in net.bytebuddy with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description class
ByteBuddy
Instances of this class serve as a focus point for configuration of the library's behavior and as an entry point to any form of code generation using the library.protected static class
ByteBuddy.EnumerationImplementation
An implementation fo thevalues
method of an enumeration type.protected static class
ByteBuddy.EnumerationImplementation.InitializationAppender
A byte code appender for the type initializer of any enumeration type.protected static class
ByteBuddy.EnumerationImplementation.ValuesMethodAppender
A byte code appender for thevalues
method of any enumeration type.protected static class
ByteBuddy.RecordConstructorStrategy
A constructor strategy for implementing a Java record.protected static class
ByteBuddy.RecordConstructorStrategy.Appender
A byte code appender for accessors and the record constructor.protected static class
ByteBuddy.RecordObjectMethod
Implements the object methods of the Java record type.class
ClassFileVersion
A wrapper object for representing a validated class file version in the format that is specified by the JVMS.static class
ClassFileVersion.VersionLocator.ForJava9CapableVm
A version locator for a JVM of at least version 9.static class
NamingStrategy.PrefixingRandom
A naming strategy that creates a name by prefixing a given class and its package with another package and by appending a random number to the class's simple name.static class
NamingStrategy.SuffixingRandom
A naming strategy that creates a name by concatenating: The super classes package and name A given suffix string A random number Between all these elements, a$
sign is included into the name to improve readability.static class
NamingStrategy.SuffixingRandom.BaseNameResolver.ForFixedValue
A base name resolver that simply returns a fixed value.static class
NamingStrategy.SuffixingRandom.BaseNameResolver.ForGivenType
Uses a specific type's name as the resolved name. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.agent.builder
Classes in net.bytebuddy.agent.builder with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
AgentBuilder.CircularityLock.Global
A circularity lock that holds a global monitor and does not permit concurrent access.static class
AgentBuilder.Default
The default implementation of anAgentBuilder
.static class
AgentBuilder.Default.Dispatcher.ForJava6CapableVm
A dispatcher for a Java 6 capable VM.static class
AgentBuilder.Default.ExecutingTransformer.Factory.ForJava9CapableVm
A factory for a class file transformer on a JVM that supports thejava.lang.Module
API to override the newly added method of theClassFileTransformer
to capture an instrumented class's module.protected class
AgentBuilder.Default.ExecutingTransformer.Java9CapableVmDispatcher
A privileged action for transforming a class on a JVM that supports modules.protected class
AgentBuilder.Default.ExecutingTransformer.LegacyVmDispatcher
A privileged action for transforming a class on a JVM prior to Java 9.protected class
AgentBuilder.Default.Ignoring
A delegator transformer for further precising what types to ignore.static class
AgentBuilder.Default.NativeMethodStrategy.ForPrefix
A native method strategy that prefixes method names with a fixed value for supporting rebasing of native methods.protected static class
AgentBuilder.Default.Transformation
A transformation to apply.protected static class
AgentBuilder.Default.Transformation.DifferentialMatcher
A matcher that considers the differential of two transformers' transformations.protected static class
AgentBuilder.Default.Transformation.SimpleMatcher
A matcher that matches any type that is touched by a transformer without being ignored.protected class
AgentBuilder.Default.Transforming
A helper class that describes aAgentBuilder.Default
after supplying aAgentBuilder.RawMatcher
such that one or severalAgentBuilder.Transformer
s can be supplied.static class
AgentBuilder.DescriptionStrategy.SuperTypeLoading
A description strategy that enforces the loading of any super type of a type description but delegates the actual type description to another description strategy.static class
AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous
A description strategy that enforces the loading of any super type of a type description but delegates the actual type description to another description strategy.protected static class
AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous.ThreadSwitchingClassLoadingDelegate
A class loading delegate that delegates loading of the super type to another thread.protected static class
AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous.ThreadSwitchingClassLoadingDelegate.SimpleClassLoadingAction
A class loading action that simply loads a type.protected static class
AgentBuilder.DescriptionStrategy.SuperTypeLoading.UnlockingClassLoadingDelegate
A class loading delegate that unlocks the circularity lock during class loading.static class
AgentBuilder.FallbackStrategy.ByThrowableType
A fallback strategy that discriminates by the type of theThrowable
that triggered a request.static class
AgentBuilder.InitializationStrategy.SelfInjection
An initialization strategy that adds a code block to an instrumented type's type initializer which then calls a specific class that is responsible for the explicit initialization.protected static class
AgentBuilder.InitializationStrategy.SelfInjection.Dispatcher
A dispatcher for a self-initialization strategy.protected static class
AgentBuilder.InitializationStrategy.SelfInjection.Dispatcher.InjectingInitializer
A type initializer that injects all auxiliary types of the instrumented type.static class
AgentBuilder.InjectionStrategy.UsingInstrumentation
An injection strategy that uses bootstrap injection using anInstrumentation
instance.static class
AgentBuilder.InjectionStrategy.UsingUnsafe.OfFactory
An injection strategy that uses a factory for creating an unsafe injector.static class
AgentBuilder.InstallationListener.Compound
A compound installation listener.static class
AgentBuilder.InstallationListener.StreamWriting
This installation listener prints the status of any installation to aPrintStream
.protected static class
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory
A factory that creates instances that represent lambda expressions.protected static class
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.BridgeMethodImplementation
Implements an explicit bridge method for a lambda expression.protected static class
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.BridgeMethodImplementation.Appender
An appender for implementing a bridge method for a lambda expression.protected static class
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.ConstructorImplementation.Appender
An appender to implement the executing transformer.protected static class
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.FactoryImplementation.Appender
An appender for a lambda expression factory.protected static class
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.LambdaMethodImplementation
Implements a lambda expression's functional method.protected static class
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.LambdaMethodImplementation.Appender
An appender for a lambda expression's functional method.protected static class
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.SerializationImplementation
Implements thewriteReplace
method for serializable lambda expressions.static class
AgentBuilder.Listener.Compound
A compound listener that allows to group several listeners in one instance.static class
AgentBuilder.Listener.Filtering
A listener that filters types with a given name from being logged.static class
AgentBuilder.Listener.ModuleReadEdgeCompleting
A listener that adds read-edges to any module of an instrumented class upon its transformation and opens the class's package to the module.static class
AgentBuilder.Listener.StreamWriting
A listener that writes events to aPrintStream
.static class
AgentBuilder.Listener.WithErrorsOnly
A listener that only delegates events if they are failed transformations.static class
AgentBuilder.Listener.WithTransformationsOnly
A listener that only delegates events if they are successful or failed transformations.static class
AgentBuilder.LocationStrategy.Compound
A compound location strategy that applies a list of location strategies.static class
AgentBuilder.LocationStrategy.Simple
A simple location strategy that queries a given class file locator.static class
AgentBuilder.PoolStrategy.WithTypePoolCache
A type locator that uses type pools but allows for the configuration of a custom cache provider by class loader.static class
AgentBuilder.PoolStrategy.WithTypePoolCache.Simple
An implementation of a type locatorAgentBuilder.PoolStrategy.WithTypePoolCache
(note documentation of the linked class) that is based on aConcurrentMap
.static class
AgentBuilder.RawMatcher.Conjunction
A conjunction of two raw matchers.static class
AgentBuilder.RawMatcher.Disjunction
A disjunction of two raw matchers.static class
AgentBuilder.RawMatcher.ForElementMatchers
A raw matcher implementation that checks aTypeDescription
and itsClassLoader
against two suitable matchers in order to determine if the matched type should be instrumented.static class
AgentBuilder.RawMatcher.Inversion
A raw matcher that inverts a raw matcher's result.static class
AgentBuilder.RedefinitionStrategy.BatchAllocator.ForFixedSize
A batch allocator that creates chunks with a fixed size as batch jobs.static class
AgentBuilder.RedefinitionStrategy.BatchAllocator.ForMatchedGrouping
A batch allocator that groups all batches by discriminating types using a type matcher.static class
AgentBuilder.RedefinitionStrategy.BatchAllocator.Partitioning
A partitioning batch allocator that splits types for redefinition into a fixed amount of parts.static class
AgentBuilder.RedefinitionStrategy.BatchAllocator.Slicing
A slicing batch allocator that assures that any batch is within a certain size range.static class
AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.Explicit
An explicit discovery strategy that only attempts the redefinition of specific types.protected static class
AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.Reiterating.ReiteratingIterable
An iterable that returns any loaded types and checks if any additional types were loaded during the last instrumentation.static class
AgentBuilder.RedefinitionStrategy.Dispatcher.ForJava6CapableVm
A dispatcher for a Java 6 capable VM.static class
AgentBuilder.RedefinitionStrategy.Listener.Adapter
A listener adapter that offers non-operational implementations of all listener methods.static class
AgentBuilder.RedefinitionStrategy.Listener.BatchReallocator
A batch reallocator allows to split up a failed retransformation into additional batches which are reenqueed to the current retransformation process.static class
AgentBuilder.RedefinitionStrategy.Listener.Compound
A compound listener that delegates events to several listeners.protected static class
AgentBuilder.RedefinitionStrategy.Listener.Compound.CompoundIterable
A compound iterable.static class
AgentBuilder.RedefinitionStrategy.Listener.Pausing
A listener that invokesThread.sleep(long)
prior to every batch but the first batch.static class
AgentBuilder.RedefinitionStrategy.Listener.StreamWriting
A listener that writes events to aPrintStream
.static class
AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.AtFixedRate
A resubmission scheduler that schedules jobs at a fixed rate.static class
AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.Cancelable.ForFuture
A cancelable for aFuture
.static class
AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.WithFixedDelay
A resubmission scheduler that schedules jobs with a fixed delay.static class
AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Enabled
An enabled resubmission strategy.static class
AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Installation
Represents an installation of a resubmission strategy.static class
AgentBuilder.Transformer.ForAdvice
A transformer for applying anAdvice
where this advice class might reference types of both the agent's and the user's class loader.protected static class
AgentBuilder.Transformer.ForAdvice.Entry
An entry for an advice to apply.protected static class
AgentBuilder.Transformer.ForAdvice.Entry.ForSplitAdvice
An entry for an advice class where both entry and exit advice methods are declared by the different classes.protected static class
AgentBuilder.Transformer.ForAdvice.Entry.ForUnifiedAdvice
An entry for an advice class where both the (optional) entry and exit advice methods are declared by the same class.static class
AgentBuilder.Transformer.ForBuildPlugin
A transformer that applies a buildPlugin
.static class
AgentBuilder.TransformerDecorator.Compound
A compound transformer decorator.static class
AgentBuilder.TypeStrategy.ForBuildEntryPoint
A type strategy that applies a buildEntryPoint
.class
LambdaFactory
This class serves as a dispatcher for creating lambda expression objects when Byte Buddy is configured to instrument thejava.lang.invoke.LambdaMetafactory
.static class
ResettableClassFileTransformer.WithDelegation
Implements a resettable class file transformer that allows for the delegation of a transformation. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.asm
Classes in net.bytebuddy.asm with annotations of type HashCodeAndEqualsPlugin.Enhance 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.protected static class
Advice.Appender
A byte code appender for implementingAdvice
.protected static class
Advice.ArgumentHandler.ForAdvice.Default.ForMethodEnter
An argument handler for an enter advice method.protected static class
Advice.ArgumentHandler.ForAdvice.Default.ForMethodExit
An argument handler for an exit advice method.protected static class
Advice.ArgumentHandler.ForInstrumentedMethod.Default.Copying
An argument handler for an instrumented method that copies all arguments before executing the instrumented method.protected static class
Advice.ArgumentHandler.ForInstrumentedMethod.Default.Simple
A simple argument handler for an instrumented method.static class
Advice.Delegator.ForDynamicInvocation
Invokes an advice method using a dynamic method call.static class
Advice.Dispatcher.Delegating
A dispatcher for an advice method that is being invoked from the instrumented method.protected static class
Advice.Dispatcher.Delegating.Resolved.ForMethodEnter
A resolved dispatcher for implementing method enter advice.protected static class
Advice.Dispatcher.Delegating.Resolved.ForMethodExit
A resolved dispatcher for implementing method exit advice.protected static class
Advice.Dispatcher.Delegating.Resolved.ForMethodExit.WithExceptionHandler
Implementation of exit advice that handles exceptions.static class
Advice.Dispatcher.Inlining
A dispatcher for an advice method that is being inlined into the instrumented method.protected static class
Advice.Dispatcher.Inlining.Resolved.ForMethodEnter
A resolved dispatcher for implementing method enter advice.protected static class
Advice.Dispatcher.Inlining.Resolved.ForMethodExit
A resolved dispatcher for implementing method exit advice.protected static class
Advice.Dispatcher.Inlining.Resolved.ForMethodExit.WithExceptionHandler
Implementation of exit advice that handles exceptions.static class
Advice.Dispatcher.RelocationHandler.ForType
A relocation handler that is triggered if the checked value is an instance of a given type.protected class
Advice.Dispatcher.RelocationHandler.ForType.Bound
A bound relocation handler forAdvice.Dispatcher.RelocationHandler.ForType
.protected class
Advice.Dispatcher.RelocationHandler.ForValue.Bound
A bound relocation handler forAdvice.Dispatcher.RelocationHandler.ForValue
.protected class
Advice.Dispatcher.RelocationHandler.ForValue.Inverted
An inverted version of the outer relocation handler.static class
Advice.Dispatcher.RelocationHandler.Relocation.ForLabel
A relocation that unconditionally jumps to a given label.static class
Advice.Dispatcher.Resolved.AbstractBase
An abstract base implementation of aAdvice.Dispatcher.Resolved
dispatcher.static class
Advice.Dispatcher.SuppressionHandler.Suppressing
A suppression handler that suppresses a given throwable type.static class
Advice.ExceptionHandler.Simple
A simple exception handler that returns a fixed stack manipulation.static class
Advice.OffsetMapping.Factory.Illegal<T extends java.lang.annotation.Annotation>
A factory for an annotation whose use is not permitted.static class
Advice.OffsetMapping.Factory.Simple<T extends java.lang.annotation.Annotation>
A simple factory that binds a constant offset mapping.static class
Advice.OffsetMapping.ForAllArguments
An offset mapping that maps an array containing all arguments of the instrumented method.static class
Advice.OffsetMapping.ForArgument
An offset mapping for a given parameter of the instrumented method.static class
Advice.OffsetMapping.ForArgument.Resolved
An offset mapping for a specific parameter of the instrumented method.static class
Advice.OffsetMapping.ForArgument.Resolved.Factory<T extends java.lang.annotation.Annotation>
A factory for a parameter argument of the instrumented method.static class
Advice.OffsetMapping.ForArgument.Unresolved
An offset mapping for a parameter of the instrumented method with a specific index.static class
Advice.OffsetMapping.ForEnterValue
An offset mapping that provides access to the value that is returned by the enter advice.protected static class
Advice.OffsetMapping.ForEnterValue.Factory
A factory for creating aAdvice.OffsetMapping.ForEnterValue
offset mapping.static class
Advice.OffsetMapping.ForExitValue
An offset mapping that provides access to the value that is returned by the exit advice.protected static class
Advice.OffsetMapping.ForExitValue.Factory
A factory for creating aAdvice.OffsetMapping.ForExitValue
offset mapping.static class
Advice.OffsetMapping.ForField
An offset mapping for a field.static class
Advice.OffsetMapping.ForField.Resolved
A binding for an offset mapping that represents a specific field.static class
Advice.OffsetMapping.ForField.Resolved.Factory<T extends java.lang.annotation.Annotation>
A factory that binds a field.static class
Advice.OffsetMapping.ForField.Unresolved
An offset mapping for a field that is resolved from the instrumented type by its name.static class
Advice.OffsetMapping.ForField.Unresolved.WithExplicitType
An offset mapping for a field with an explicit declaring type.static class
Advice.OffsetMapping.ForLocalValue
An offset mapping that provides access to a named local variable that is declared by the advice methods viaAdvice.Local
.protected static class
Advice.OffsetMapping.ForLocalValue.Factory
A factory for an offset mapping for a local variable that is declared by the advice methods viaAdvice.Local
.static class
Advice.OffsetMapping.ForOrigin
An offset mapping for theAdvice.Origin
annotation.static class
Advice.OffsetMapping.ForOrigin.Renderer.ForConstantValue
A renderer for a constant value.static class
Advice.OffsetMapping.ForReturnValue
An offset mapping that provides access to the value that is returned by the instrumented method.static class
Advice.OffsetMapping.ForSerializedValue
An offset mapping that loads a serialized value.static class
Advice.OffsetMapping.ForSerializedValue.Factory<T extends java.lang.annotation.Annotation>
A factory for loading a deserialized value.static class
Advice.OffsetMapping.ForStackManipulation
An offset mapping for binding a stack manipulation.static class
Advice.OffsetMapping.ForStackManipulation.Factory<T extends java.lang.annotation.Annotation>
A factory that binds a stack manipulation.static class
Advice.OffsetMapping.ForStackManipulation.OfAnnotationProperty<T extends java.lang.annotation.Annotation>
A factory for binding an annotation's property.static class
Advice.OffsetMapping.ForStackManipulation.OfDefaultValue<T extends java.lang.annotation.Annotation>
A factory for binding the annotated parameter's default value.static class
Advice.OffsetMapping.ForThisReference
An offset mapping that provides access to thethis
reference of the instrumented method.static class
Advice.OffsetMapping.ForThrowable
An offset mapping for accessing aThrowable
of the instrumented method.static class
Advice.OffsetMapping.ForUnusedValue
An offset mapping for a parameter where assignments are fully ignored and that always return the parameter type's default value.static class
Advice.OffsetMapping.Target.ForArray
A target mapping for an array of all local variables.static class
Advice.OffsetMapping.Target.ForArray.ReadWrite
A target mapping for a writable target mapping for an array of local variables.static class
Advice.OffsetMapping.Target.ForDefaultValue
A target for an offset mapping that represents a non-operational value.static class
Advice.OffsetMapping.Target.ForField
A target for an offset mapping that loads a field value.static class
Advice.OffsetMapping.Target.ForField.ReadWrite
A mapping for a writable field.static class
Advice.OffsetMapping.Target.ForStackManipulation
A target for an offset mapping that represents a read-only stack manipulation.static class
Advice.OffsetMapping.Target.ForVariable
A target for an offset mapping that represents a local variable.static class
Advice.OffsetMapping.Target.ForVariable.ReadWrite
A target for a writable mapping of a local variable.static class
Advice.PostProcessor.Compound
A compound post processor.static class
Advice.PostProcessor.Factory.Compound
A compound factory for a post processor.static class
Advice.WithCustomMapping
A builder step for creating anAdvice
that uses custom mappings of annotations to constant pool values.static class
AsmVisitorWrapper.Compound
An ordered, immutable chain ofAsmVisitorWrapper
s.static class
AsmVisitorWrapper.ForDeclaredFields
An ASM visitor wrapper that allows to wrap declared fields of the instrumented type with aAsmVisitorWrapper.ForDeclaredFields.FieldVisitorWrapper
.protected static class
AsmVisitorWrapper.ForDeclaredFields.Entry
An entry describing a field visitor wrapper paired with a matcher for fields to be wrapped.static class
AsmVisitorWrapper.ForDeclaredMethods
An ASM visitor wrapper that allows to wrap declared methods of the instrumented type with aAsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper
.protected static class
AsmVisitorWrapper.ForDeclaredMethods.Entry
An entry describing a method visitor wrapper paired with a matcher for fields to be wrapped.class
MemberAttributeExtension<T>
A visitor that adds attributes to a class member.class
MemberRemoval
A visitor wrapper that removes fields or methods that match a givenElementMatcher
.class
MemberSubstitution
Substitutes field access or method invocations within a method's body.static class
MemberSubstitution.Replacement.Binding.Resolved
A binding that was resolved for an actual substitution.static class
MemberSubstitution.Replacement.Factory.Compound
A compound factory.static class
MemberSubstitution.Replacement.ForElementMatchers
A replacement that substitutes a member based on a row of element matchers.protected static class
MemberSubstitution.Replacement.ForElementMatchers.Factory
A factory for creating a replacement that chooses members based on a row of element matchers.static class
MemberSubstitution.Replacement.ForFirstBinding
A replacement that only resolves the first matching replacement of a list of replacements.static class
MemberSubstitution.Substitution.Chain
A substitution chain allows for chaining multiple substitution steps for a byte code element being replaced.static class
MemberSubstitution.Substitution.Chain.Step.Simple
A simple substitution step within a substitution chain.static class
MemberSubstitution.Substitution.ForFieldAccess
A substitution with a field access.static class
MemberSubstitution.Substitution.ForFieldAccess.FieldResolver.ForElementMatcher
A field matcher that resolves a non-static field on the first parameter type of the substituted member usage.static class
MemberSubstitution.Substitution.ForFieldAccess.FieldResolver.Simple
A simple field resolver that returns a specific field.static class
MemberSubstitution.Substitution.ForFieldAccess.OfGivenField
A factory for a substitution that substitutes with a given field.static class
MemberSubstitution.Substitution.ForFieldAccess.OfMatchedField
A factory for a substitution that locates a field on the receiver type using a matcher.static class
MemberSubstitution.Substitution.ForMethodInvocation
A substitution with a method invocation.static class
MemberSubstitution.Substitution.ForMethodInvocation.MethodResolver.Matching
A method resolver that locates a non-static method by locating it from the receiver type.static class
MemberSubstitution.Substitution.ForMethodInvocation.MethodResolver.Simple
A simple method resolver that returns a given method.static class
MemberSubstitution.Substitution.ForMethodInvocation.OfGivenMethod
A factory for a substitution that invokes a given method.static class
MemberSubstitution.Substitution.ForMethodInvocation.OfMatchedMethod
A factory for a substitution that locates a method on the receiver type using a matcher.static class
MemberSubstitution.TypePoolResolver.ForClassFileLocator
A type pool resolver that resolves the implicit pool but additionally checks another class file locator.static class
MemberSubstitution.TypePoolResolver.ForExplicitPool
A type pool resolver that returns a specific type pool.static class
MemberSubstitution.WithoutSpecification
A member substitution that lacks a specification for how to substitute the matched members references within a method body.protected static class
MemberSubstitution.WithoutSpecification.ForMatchedByteCodeElement
Describes a member substitution that requires a specification for how to replace a byte code element.static class
MemberSubstitution.WithoutSpecification.ForMatchedField
Describes a member substitution that requires a specification for how to replace a field.static class
MemberSubstitution.WithoutSpecification.ForMatchedMethod
Describes a member substitution that requires a specification for how to replace a method or constructor.class
ModifierAdjustment
A visitor wrapper that adjusts the modifiers of the instrumented type or its members.protected static class
ModifierAdjustment.Adjustment<T>
A description of a conditional adjustment.class
TypeReferenceAdjustment
Adds an attribute value for all inner classes that are referenced by the instrumented type. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.build
Classes in net.bytebuddy.build with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
BuildLogger.Compound
A compound build logger.static class
BuildLogger.StreamWriting
A build logger that writes all statements to aPrintStream
.class
CachedReturnPlugin
A plugin that caches the return value of a method in a synthetic field.protected static class
CachedReturnPlugin.CacheFieldOffsetMapping
An offset mapping for the cached field.class
HashCodeAndEqualsPlugin
A build tool plugin that addsObject.hashCode()
andObject.equals(Object)
methods to a class if theHashCodeAndEqualsPlugin.Enhance
annotation is present and no explicit method declaration was added.protected static class
HashCodeAndEqualsPlugin.ValueMatcher
An element matcher for aHashCodeAndEqualsPlugin.ValueHandling
annotation.static class
HashCodeAndEqualsPlugin.WithNonNullableFields
A version of theHashCodeAndEqualsPlugin
that assumes that all fields are non-nullable unless they are explicitly marked.static class
Plugin.Engine.Default
A default implementation of a plugin engine.protected static class
Plugin.Engine.Dispatcher.ForParallelTransformation.EagerWork
An eager materialization that does not defer processing after preprocessing.static class
Plugin.Engine.Dispatcher.ForParallelTransformation.Factory
A factory for a dispatcher that uses a given executor service for parallel dispatching.static class
Plugin.Engine.Dispatcher.ForParallelTransformation.WithThrowawayExecutorService
A parallel dispatcher that shuts down its executor service upon completion of a plugin engine's application.static class
Plugin.Engine.Dispatcher.ForParallelTransformation.WithThrowawayExecutorService.Factory
A factory for a parallel executor service that creates a new executor service on each plugin engine application.static class
Plugin.Engine.Listener.Compound
A compound listener.static class
Plugin.Engine.Listener.ForErrorHandler
A listener decorator that forwards events to an error handler if they are applicable.static class
Plugin.Engine.Listener.StreamWriting
A listener that forwards significant events of a plugin engine application to aPrintStream
.static class
Plugin.Engine.Listener.WithErrorsOnly
A decorator for another listener to only print error events.static class
Plugin.Engine.Listener.WithTransformationsOnly
A decorator for another listener to only print transformation and error events.static class
Plugin.Engine.Source.Element.ForByteArray
An element representation for a byte array.static class
Plugin.Engine.Source.Element.ForFile
An element representation for a file.static class
Plugin.Engine.Source.Element.ForJarEntry
Represents a jar file entry as an element.static class
Plugin.Engine.Source.Filtering
A source that applies a filter upon iterating elements.static class
Plugin.Engine.Source.ForFolder
Represents the contents of a folder as class files.static class
Plugin.Engine.Source.ForJarFile
Represents a jar file as a source.static class
Plugin.Engine.Source.InMemory
A source that represents a collection of in-memory resources that are represented as byte arrays.static class
Plugin.Engine.Source.Origin.Filtering
An origin that forwards all invocations to a delegate where anElementMatcher
is applied prior to iteration.static class
Plugin.Engine.Target.ForFolder
Represents a folder as the target for a plugin engine's application.static class
Plugin.Engine.Target.ForFolder.Dispatcher.ForJava7CapableVm
A dispatcher for VMs that are capable of NIO2.static class
Plugin.Engine.Target.ForJarFile
Represents a jar file as a target.static class
Plugin.Engine.Target.InMemory
A sink that stores all elements in a memory map.static class
Plugin.Engine.TypeStrategy.ForEntryPoint
A type strategy that represents a givenEntryPoint
for a build tool.static class
Plugin.Factory.Simple
A simple factory that returns a preconstructed plugin instance..static class
Plugin.Factory.UsingReflection
A plugin factory that uses reflection for instantiating a plugin.static class
Plugin.Factory.UsingReflection.ArgumentResolver.ForIndex
An argument resolver that resolves an argument for a specific parameter index.static class
Plugin.Factory.UsingReflection.ArgumentResolver.ForIndex.WithDynamicType
An argument resolver that resolves an argument for a specific parameter index by attempting a conversion via invoking a staticvalueOf
method on the target type, if it exists.static class
Plugin.Factory.UsingReflection.ArgumentResolver.ForType<T>
An argument resolver that resolves parameters for a given type.static class
Plugin.Factory.UsingReflection.ArgumentResolver.Resolution.Resolved
Represents a resolved argument resolution.static class
Plugin.Factory.UsingReflection.Instantiator.Resolved
An instantiator that is resolved for a given constructor with arguments.static class
Plugin.Factory.UsingReflection.Instantiator.Unresolved
An instantiator that is not resolved for creating an instance.static class
Plugin.ForElementMatcher
An abstract base for aPlugin
that matches types by a givenElementMatcher
.static class
Plugin.NoOp
A non-operational plugin that does not instrument any type.class
ToStringPlugin
A build tool plugin that adds aObject.toString()
and method to a class if theToStringPlugin.Enhance
annotation is present and no explicit method declaration was added. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.description.annotation
Classes in net.bytebuddy.description.annotation with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
AnnotationDescription.Builder
A builder for pragmatically creatingAnnotationDescription
.static class
AnnotationSource.Explicit
An annotation source that declares a given list of annotations. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.description.method
Classes in net.bytebuddy.description.method with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
ParameterDescription.ForLoadedParameter.Dispatcher.ForJava8CapableVm
A dispatcher for VMs that support thejava.lang.reflect.Parameter
API for Java 8+.static class
ParameterDescription.ForLoadedParameter.ParameterAnnotationSource.ForLoadedConstructor
A source for a loaded constructor.static class
ParameterDescription.ForLoadedParameter.ParameterAnnotationSource.ForLoadedMethod
A source for a loaded method.static class
ParameterList.ForLoadedExecutable.Dispatcher.ForJava8CapableVm
A dispatcher for a legacy VM that does support thejava.lang.reflect.Parameter
type. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.description.modifier
Classes in net.bytebuddy.description.modifier with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
ModifierContributor.Resolver<T extends ModifierContributor>
A resolver for Java modifiers represented byModifierContributor
s. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.description.type
Classes in net.bytebuddy.description.type with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
RecordComponentDescription.ForLoadedRecordComponent.Dispatcher.ForJava14CapableVm
A dispatcher for a Java 14-capable JVM.protected static class
TypeDescription.Generic.AnnotationReader.Delegator.Chained
A chained delegator that bases its result on an underlying annotation reader.static class
TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm
A dispatcher for a modern JVM that supports type annotations.protected class
TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm.AnnotatedExceptionType
A delegating annotation reader for an annotated exception variable.protected class
TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm.AnnotatedFieldType
A delegating annotation reader for an annotated field variable.protected class
TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm.AnnotatedInterfaceType
A delegating annotation reader for an annotated interface type.protected class
TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm.AnnotatedParameterizedType
A delegating annotation reader for an annotated parameter variable.protected class
TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm.AnnotatedReturnType
A delegating annotation reader for an annotated return variable.protected class
TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm.AnnotatedSuperClass
A delegating annotation reader for an annotated super type.protected static class
TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm.AnnotatedTypeVariableType
A delegating annotation reader for an annotated type variable.protected static class
TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm.Resolved
A delegator for an existingjava.lang.reflect.AnnotatedElement
.static class
TypeDescription.Generic.AnnotationReader.ForTypeArgument
A chained annotation reader for reading a parameterized type's type argument.static class
TypeDescription.Generic.AnnotationReader.ForTypeVariableBoundType
A chained annotation reader for reading a type variable's type argument.protected static class
TypeDescription.Generic.AnnotationReader.ForTypeVariableBoundType.OfFormalTypeVariable
A chained annotation reader for reading a formal type variable's type argument.static class
TypeDescription.Generic.AnnotationReader.ForWildcardLowerBoundType
A chained annotation reader for reading a wildcard type's lower bound type.static class
TypeDescription.Generic.AnnotationReader.ForWildcardUpperBoundType
A chained annotation reader for reading a wildcard type's upper bound type.static class
TypeDescription.Generic.Builder
A builder for creating describing a generic type as aTypeDescription.Generic
.protected static class
TypeDescription.Generic.Builder.OfGenericArrayType
A generic type builder building a generic array type.protected static class
TypeDescription.Generic.Builder.OfNonGenericType
A generic type builder for building a non-generic type.protected static class
TypeDescription.Generic.Builder.OfParameterizedType
A generic type builder for building a parameterized type.protected static class
TypeDescription.Generic.Builder.OfTypeVariable
A generic type builder building a symbolic type variable.static class
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForGenericArray
A dispatcher for checking the assignability of a generic array type.static class
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForNonGenericType
A dispatcher for checking the assignability of a non-generic type.static class
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType
A dispatcher for checking the assignability of a parameterized type.protected static class
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType.ParameterAssigner.ContravariantBinding
A dispatcher for an contravariant parameter of a parameterized type, i.e.protected static class
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType.ParameterAssigner.CovariantBinding
A dispatcher for an covariant parameter of a parameterized type, i.e.protected static class
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType.ParameterAssigner.InvariantBinding
A dispatcher for an invariant parameter of a parameterized type, i.e.static class
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForTypeVariable
A dispatcher for checking the assignability of a type variable.static class
TypeDescription.Generic.Visitor.ForSignatureVisitor
Visits a generic type and appends the discovered type to the supplied signature visitor.static class
TypeDescription.Generic.Visitor.Reducing
A visitor that reduces a detached generic type to its erasure.static class
TypeDescription.Generic.Visitor.Substitutor.ForAttachment
A substitutor that attaches type variables to a type variable source and replaces representations ofTargetType
with a given declaring type.static class
TypeDescription.Generic.Visitor.Substitutor.ForDetachment
A visitor for detaching a type from its declaration context by detaching type variables.static class
TypeDescription.Generic.Visitor.Substitutor.ForTokenNormalization
A substitutor that normalizes a token to represent allTargetType
by a given type and that symbolizes all type variables.static class
TypeDescription.Generic.Visitor.Substitutor.ForTypeVariableBinding
A visitor for binding type variables to their values.protected class
TypeDescription.Generic.Visitor.Substitutor.ForTypeVariableBinding.TypeVariableSubstitutor
Substitutes a type variable, either with a new binding if the variable is defined by a type or with a retained type variable if the variable is defined by a method. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.dynamic
Classes in net.bytebuddy.dynamic with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
ClassFileLocator.AgentBased
A Java agent that allows the location of class files by emulating a retransformation.static class
ClassFileLocator.AgentBased.ClassLoadingDelegate.Default
A default implementation of a class loading delegate.static class
ClassFileLocator.AgentBased.ClassLoadingDelegate.Explicit
A class loading delegate that allows the location of explicitly registered classes that cannot be located by a class loader directly.static class
ClassFileLocator.AgentBased.ClassLoadingDelegate.ForDelegatingClassLoader.Dispatcher.Resolved
Represents a field that could be located.static class
ClassFileLocator.AgentBased.ClassLoadingDelegate.ForDelegatingClassLoader.Dispatcher.Unresolved
Represents a field that could not be located.static class
ClassFileLocator.AgentBased.Dispatcher.ForJava6CapableVm
A dispatcher for a Java 6 capable VM.static class
ClassFileLocator.Compound
A compoundClassFileLocator
that chains several locators.static class
ClassFileLocator.ForClassLoader
A class file locator that queries a class loader for binary representations of class files.static class
ClassFileLocator.ForFolder
A class file locator that finds files from a standardized Java folder structure with folders donating packages and class files being saved as<classname>.class
files within their package folder.static class
ClassFileLocator.ForJarFile
A class file locator that locates classes within a Java jar file.static class
ClassFileLocator.ForModule
A class file locator that locates class files by querying a Java module'sgetResourceAsStream
method.static class
ClassFileLocator.ForModuleFile
A class file locator that locates classes within a Java jmod file.static class
ClassFileLocator.ForUrl
A class file locator that reads class files from one or several URLs.protected static class
ClassFileLocator.ForUrl.ClassLoaderCreationAction
An action to create a class loader with the purpose of locating classes from an URL location.static class
ClassFileLocator.PackageDiscriminating
A class file locator that discriminates by a type's package.static class
ClassFileLocator.Resolution.Explicit
Represents a byte array as binary data.static class
ClassFileLocator.Resolution.Illegal
A canonical representation of an illegal binary representation.static class
ClassFileLocator.Simple
A simple class file locator that returns class files from a selection of given types.static class
DynamicType.Builder.AbstractBase.Adapter<U>
An adapter implementation of a dynamic type builder.protected class
DynamicType.Builder.AbstractBase.Adapter.FieldDefinitionAdapter
An adapter for defining a new field.protected class
DynamicType.Builder.AbstractBase.Adapter.FieldMatchAdapter
An adapter for matching an existing field.protected class
DynamicType.Builder.AbstractBase.Adapter.InnerTypeDefinitionForMethodAdapter
An adapter for applying an inner type definition for an outer method or constructor.protected class
DynamicType.Builder.AbstractBase.Adapter.InnerTypeDefinitionForTypeAdapter
An adapter for applying an inner type definition for an outer type.protected class
DynamicType.Builder.AbstractBase.Adapter.MethodDefinitionAdapter
An adapter for defining a new method.protected class
DynamicType.Builder.AbstractBase.Adapter.MethodDefinitionAdapter.AnnotationAdapter
An annotation adapter for a method definition.protected class
DynamicType.Builder.AbstractBase.Adapter.MethodDefinitionAdapter.ParameterAnnotationAdapter
An annotation adapter for a parameter definition.protected class
DynamicType.Builder.AbstractBase.Adapter.MethodDefinitionAdapter.SimpleParameterAnnotationAdapter
An annotation adapter for a simple parameter definition.protected class
DynamicType.Builder.AbstractBase.Adapter.MethodDefinitionAdapter.TypeVariableAnnotationAdapter
An adapter for defining a new type variable for the currently defined method.protected class
DynamicType.Builder.AbstractBase.Adapter.MethodMatchAdapter
An adapter for matching an existing method.protected class
DynamicType.Builder.AbstractBase.Adapter.MethodMatchAdapter.AnnotationAdapter
An annotation adapter for implementing annotations during a method definition.protected class
DynamicType.Builder.AbstractBase.Adapter.OptionalMethodMatchAdapter
An adapter for optionally matching methods defined by declared interfaces.protected class
DynamicType.Builder.AbstractBase.Adapter.RecordComponentDefinitionAdapter
An adapter for defining a record component.protected class
DynamicType.Builder.AbstractBase.Adapter.TypeVariableDefinitionAdapter
An adapter for defining a new type variable for the instrumented type.private static class
DynamicType.Builder.FieldDefinition.Optional.Valuable.AbstractBase.Adapter<V>
An adapter for an optional field definition that allows for defining a value.protected static class
DynamicType.Builder.MethodDefinition.AbstractBase.Adapter<V>
An adapter implementation of a method definition.static class
DynamicType.Default
A default implementation of a dynamic type.static class
DynamicType.Default.Dispatcher.ForJava7CapableVm
A dispatcher for VMs that are capable of NIO2.protected static class
DynamicType.Default.Loaded<T>
A default implementation of a loaded dynamic type.static class
DynamicType.Default.Unloaded<T>
A default implementation of an unloaded dynamic type.class
NexusAccessor
The Nexus accessor is creating a VM-global singletonNexus
such that it can be seen by all class loaders of a virtual machine.static class
NexusAccessor.Dispatcher.Available
An enabled dispatcher for registering a type initializer in aNexus
.static class
NexusAccessor.Dispatcher.Unavailable
A disabled dispatcher where aNexus
is not available.static class
NexusAccessor.InitializationAppender
An initialization appender that looks up a loaded type initializer from Byte Buddy'sNexus
.static class
Transformer.Compound<S>
A compound transformer.static class
Transformer.ForField
A transformer for a field that delegates to another transformer that transforms aFieldDescription.Token
.protected static class
Transformer.ForField.FieldModifierTransformer
A transformer for a field's modifiers.static class
Transformer.ForMethod
A transformer for a field that delegates to another transformer that transforms aMethodDescription.Token
.protected static class
Transformer.ForMethod.MethodModifierTransformer
A transformer for a method's modifiers.protected class
Transformer.ForMethod.TransformedMethod.AttachmentVisitor
A visitor that attaches type variables based on the transformed method's type variables and the instrumented type.static class
TypeResolutionStrategy.Active
A type resolution strategy that applies allLoadedTypeInitializer
as a part of class loading using reflection.protected static class
TypeResolutionStrategy.Active.Resolved
A resolved version of an active type resolution strategy. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.dynamic.loading
Classes in net.bytebuddy.dynamic.loading with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description protected class
ByteArrayClassLoader.ClassDefinitionAction
An action for defining a located class that is not yet loaded.static class
ByteArrayClassLoader.PackageLookupStrategy.ForJava9CapableVm
A package lookup strategy for Java 9 or newer.protected static class
ByteArrayClassLoader.PersistenceHandler.UrlDefinitionAction
An action to define a URL that represents a class file.protected static class
ByteArrayClassLoader.PersistenceHandler.UrlDefinitionAction.ByteArrayUrlStreamHandler
A stream handler that returns the given binary representation.static class
ByteArrayClassLoader.SynchronizationStrategy.ForJava7CapableVm
A synchronization engine for a VM that is aware of parallel-capable class loaders.static class
ByteArrayClassLoader.SynchronizationStrategy.ForJava8CapableVm
A synchronization engine for a VM that is aware of parallel-capable class loaders using method handles to respect module boundaries.static class
ClassInjector.UsingInstrumentation
A class injector using aInstrumentation
to append to either the boot classpath or the system class path.static class
ClassInjector.UsingInstrumentation.Dispatcher.ForJava6CapableVm
A dispatcher for a VM that is capable of appending to the boot and system class loader.static class
ClassInjector.UsingLookup
A class injector that uses ajava.lang.invoke.MethodHandles$Lookup
object for defining a class.static class
ClassInjector.UsingLookup.Dispatcher.ForJava9CapableVm
A dispatcher for a Java 9 capable VM that supports class definition via method handles.static class
ClassInjector.UsingReflection
A class injector that uses reflective method calls.static class
ClassInjector.UsingReflection.Dispatcher.Direct
A class injection dispatcher that is using reflection on theClassLoader
methods.protected static class
ClassInjector.UsingReflection.Dispatcher.Direct.ForJava7CapableVm
A resolved class dispatcher for a class injector on a VM running at least Java 7.static class
ClassInjector.UsingReflection.Dispatcher.Initializable.Unavailable
Represents an unsuccessfully loaded method lookup.static class
ClassInjector.UsingReflection.Dispatcher.Unavailable
Represents an unsuccessfully loaded method lookup.static class
ClassInjector.UsingReflection.Dispatcher.UsingUnsafeInjection
An indirect dispatcher that uses a redirection accessor class that was injected into the bootstrap class loader.protected static class
ClassInjector.UsingReflection.Dispatcher.UsingUnsafeOverride.ForJava7CapableVm
A resolved class dispatcher using unsafe field injection for a class injector on a VM running at least Java 7.static class
ClassInjector.UsingUnsafe
A class injector that usessun.misc.Unsafe
to inject classes.static class
ClassInjector.UsingUnsafe.Dispatcher.Enabled
An enabled dispatcher.static class
ClassInjector.UsingUnsafe.Dispatcher.Unavailable
A disabled dispatcher.static class
ClassInjector.UsingUnsafe.Factory
A factory for creating aClassInjector
that usessun.misc.Unsafe
if available but attempts a fallback to usingjdk.internal.misc.Unsafe
if thejdk.internal
module is not resolved or unavailable.protected static class
ClassLoadingStrategy.Default.InjectionDispatcher
A class loading strategy which applies a class loader injection while applying a givenProtectionDomain
on class injection.protected static class
ClassLoadingStrategy.Default.WrappingDispatcher
A class loading strategy which creates a wrapping class loader while applying a givenProtectionDomain
on class loading.static class
ClassLoadingStrategy.ForBootstrapInjection
A class loading strategy which allows class injection into the bootstrap class loader if appropriate.static class
ClassLoadingStrategy.ForUnsafeInjection
A class loading strategy that injects a class usingsun.misc.Unsafe
.static class
ClassLoadingStrategy.UsingLookup
A class loading strategy that uses ajava.lang.invoke.MethodHandles$Lookup
instance for defining types.class
ClassReloadingStrategy
The class reloading strategy allows to redefine loadedClass
es.static class
ClassReloadingStrategy.BootstrapInjection.Enabled
An enabled bootstrap class loader injection strategy.static class
MultipleParentClassLoader.Builder
A builder to collect class loader and that creates aMultipleParentClassLoader
only if multiple or noClassLoader
s are found in the process.static class
PackageDefinitionStrategy.ManifestReading
A package definer that reads a class loader's manifest file.static class
PackageDefinitionStrategy.ManifestReading.SealBaseLocator.ForTypeResourceUrl
A seal base locator that imitates the behavior of aURLClassLoader
, i.e. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.dynamic.scaffold
Classes in net.bytebuddy.dynamic.scaffold with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
FieldLocator.AbstractBase
An abstract base implementation of a field locator.static class
FieldLocator.ForClassHierarchy
A field locator that looks up fields that are declared within a class's class hierarchy.static class
FieldLocator.ForExactType
A field locator that only looks up fields that are declared by a specific type.static class
FieldLocator.ForExactType.Factory
A factory for creating aFieldLocator.ForExactType
.static class
FieldLocator.Resolution.Simple
A simple implementation for a field resolution.static class
FieldRegistry.Default
An immutable default implementation of a field registry.protected static class
FieldRegistry.Default.Compiled
A compiled default field registry.protected static class
FieldRegistry.Default.Compiled.Entry
An entry of a compiled field registry.protected static class
FieldRegistry.Default.Entry
An entry of the default field registry.static class
MethodGraph.Compiler.Default<T>
A default implementation of a method graph.protected static class
MethodGraph.Compiler.Default.Key.Store<V>
A store for collected methods that are identified by keys.static class
MethodGraph.Compiler.Default.Key.Store.Entry.Ambiguous<U>
An entry representing an ambiguous node resolution.protected static class
MethodGraph.Compiler.Default.Key.Store.Entry.Ambiguous.Node
A node implementation representing an ambiguous method resolution.static class
MethodGraph.Compiler.Default.Key.Store.Entry.Resolved<U>
An entry representing a non-ambiguous node resolution.protected static class
MethodGraph.Compiler.Default.Key.Store.Entry.Resolved.Node
A node implementation representing a non-ambiguous method.protected static class
MethodGraph.Compiler.Default.Key.Store.Graph
A graph implementation based on a key store.static class
MethodGraph.Linked.Delegation
A simple implementation of a linked method graph that exposes views by delegation to given method graphs.static class
MethodGraph.Node.Simple
A simple implementation of a resolved node of a method without bridges.static class
MethodGraph.Simple
A simple implementation of a method graph.static class
MethodRegistry.Default
A default implementation of a method registry.protected static class
MethodRegistry.Default.Compiled
A compiled version of a default method registry.protected static class
MethodRegistry.Default.Compiled.Entry
An entry of a compiled method registry.protected static class
MethodRegistry.Default.Entry
An entry of a default method registry.protected static class
MethodRegistry.Default.Prepared
A prepared version of a default method registry.protected static class
MethodRegistry.Default.Prepared.Entry
An entry of a prepared method registry.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.protected static class
MethodRegistry.Handler.ForImplementation.Compiled
A compiled handler for implementing a method.protected static class
MethodRegistry.Handler.ForVisibilityBridge.Compiled
A compiled handler for a visibility bridge handler.static class
RecordComponentRegistry.Default
An immutable default implementation of a record component registry.protected static class
RecordComponentRegistry.Default.Compiled
A compiled default record component registry.protected static class
RecordComponentRegistry.Default.Compiled.Entry
An entry of a compiled record component registry.protected static class
RecordComponentRegistry.Default.Entry
An entry of the default record component registry.static class
TypeInitializer.Drain.Default
A default implementation of a type initializer drain that creates a initializer method.static class
TypeInitializer.Simple
A simple, defined type initializer that executes a givenByteCodeAppender
.static class
TypeWriter.Default<S>
A default implementation of aTypeWriter
.protected static class
TypeWriter.Default.ClassDumpAction
An action to write a class file to the dumping location.static class
TypeWriter.Default.ClassDumpAction.Dispatcher.Enabled
An enabled dispatcher that dumps class files to a given folder.static class
TypeWriter.Default.ForCreation<U>
A type writer that creates a class file that is not based upon another, existing class.static class
TypeWriter.Default.ForInlining<U>
A type writer that inlines the created type into an existing class file.protected static class
TypeWriter.Default.ForInlining.WithFullProcessing<V>
A default type writer that reprocesses a type completely.protected class
TypeWriter.Default.UnresolvedType
An unresolved type.static class
TypeWriter.Default.ValidatingClassVisitor.Constraint.Compound
A constraint implementation that summarizes several constraints.static class
TypeWriter.Default.ValidatingClassVisitor.Constraint.ForClassFileVersion
Represents the constraint implied by a class file version.static class
TypeWriter.FieldPool.Record.ForExplicitField
A record for a rich field with attributes and a potential default value.static class
TypeWriter.FieldPool.Record.ForImplicitField
A record for a simple field without a default value where all of the field's declared annotations are appended.static class
TypeWriter.MethodPool.Record.AccessBridgeWrapper
A wrapper that appends accessor bridges for a method's implementation.static class
TypeWriter.MethodPool.Record.ForDefinedMethod.OfVisibilityBridge
A record for a visibility bridge.static class
TypeWriter.MethodPool.Record.ForDefinedMethod.WithAnnotationDefaultValue
Describes an entry that defines a method with a default annotation value.static class
TypeWriter.MethodPool.Record.ForDefinedMethod.WithBody
Describes an entry that defines a method as byte code.static class
TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody
Describes an entry that defines a method but without byte code and without an annotation value.static class
TypeWriter.MethodPool.Record.ForNonImplementedMethod
A canonical implementation of a method that is not declared but inherited by the instrumented type.static class
TypeWriter.RecordComponentPool.Record.ForExplicitRecordComponent
A record for a rich record component with attributes.static class
TypeWriter.RecordComponentPool.Record.ForImplicitRecordComponent
A record for a simple field without a default value where all of the record component's declared annotations are appended. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.dynamic.scaffold.inline
Classes in net.bytebuddy.dynamic.scaffold.inline with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description class
AbstractInliningDynamicTypeBuilder<T>
An abstract base implementation of a dynamic type builder that alters an existing type.class
DecoratingDynamicTypeBuilder<T>
A type builder that decorates a type by allowing for the application of attribute changes and ASM visitor wrappers.class
InliningImplementationMatcher
A latent method matcher that identifies methods to instrument when redefining or rebasing a type.static class
MethodNameTransformer.Prefixing
A method name transformer that adds a fixed prefix to an original method name.static class
MethodNameTransformer.Suffixing
A method name transformer that adds a fixed suffix to an original method name, separated by a$
.static class
MethodRebaseResolver.Default
A default implementation of a method rebase resolver.static class
MethodRebaseResolver.Resolution.ForRebasedConstructor
AMethodRebaseResolver.Resolution
of a rebased constructor.static class
MethodRebaseResolver.Resolution.ForRebasedMethod
AMethodRebaseResolver.Resolution
of a rebased method.static class
MethodRebaseResolver.Resolution.Preserved
AMethodRebaseResolver.Resolution
of a non-rebased method.class
RebaseDynamicTypeBuilder<T>
A type builder that rebases an instrumented type.class
RebaseImplementationTarget
An implementation target for redefining a given type while preserving the original methods within the instrumented type.static class
RebaseImplementationTarget.Factory
A factory for creating aRebaseImplementationTarget
. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.dynamic.scaffold.subclass
Classes in net.bytebuddy.dynamic.scaffold.subclass with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description protected static class
ConstructorStrategy.Default.WithMethodAttributeAppenderFactory
A wrapper for a default constructor strategy which additionally applies a method attribute appender factory.static class
ConstructorStrategy.ForDefaultConstructor
A constructor strategy that creates a default constructor that invokes a super constructor with default arguments.class
SubclassDynamicTypeBuilder<T>
A type builder that creates an instrumented type as a subclass, i.e.protected static class
SubclassDynamicTypeBuilder.InstrumentableMatcher
A matcher that locates all methods that are overridable and not ignored or that are directly defined on the instrumented type.class
SubclassImplementationTarget
An implementation target for creating a subclass of a given type. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.implementation
Classes in net.bytebuddy.implementation with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description class
DefaultMethodCall
ThisImplementation
invokes a default method for the methods it instruments.protected static class
DefaultMethodCall.Appender
The appender for implementing aDefaultMethodCall
.class
EqualsMethod
An implementation ofObject.equals(Object)
that takes a class's declared fields into consideration.protected static class
EqualsMethod.Appender
A byte code appender to implement theEqualsMethod
.protected static class
EqualsMethod.CompoundComparator
A compound comparator that compares the values of multiple fields.protected static class
EqualsMethod.ConditionalReturn
A conditional return aborts the equality computation if a given condition was reached.static class
EqualsMethod.NullValueGuard.UsingJump
A null value guard that expects a reference type and that skips the comparison if both values arenull
but returns if the invoked instance's field value isnull
but not the compared instance's value.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.class
ExceptionMethod
This implementation causes aThrowable
to be thrown when the instrumented method is invoked.static class
ExceptionMethod.ConstructionDelegate.ForDefaultConstructor
A construction delegate that calls the default constructor.static class
ExceptionMethod.ConstructionDelegate.ForStringConstructor
A construction delegate that calls a constructor that takes a single string as its argument.class
FieldAccessor
Defines a method to access a given field by following the Java bean conventions for getters and setters:static class
FieldAccessor.FieldLocation.Absolute
An absolute field description representing a previously resolved field.static class
FieldAccessor.FieldLocation.Relative
A relative field location where a field is located dynamically.protected static class
FieldAccessor.FieldLocation.Relative.Prepared
A prepared version of a field location.static class
FieldAccessor.FieldNameExtractor.ForFixedValue
A field name extractor that returns a fixed value.protected class
FieldAccessor.ForImplicitProperty.Appender
An byte code appender for an field accessor implementation.protected static class
FieldAccessor.ForSetter<T>
A field accessor for a field setter.protected class
FieldAccessor.ForSetter.Appender
An appender to implement a field setter.protected static class
FieldAccessor.ForSetter.OfConstantValue
An instrumentation that sets a constant value to a field.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 class
FixedValue.ForOriginType.Appender
An appender for writing the origin type.protected static class
FixedValue.ForPoolValue
A fixed value implementation that represents its fixed value as a value that is written to the instrumented class's constant pool.protected static class
FixedValue.ForThisValue.Appender
A byte code appender for returningthis
.protected static class
FixedValue.ForValue
A fixed value implementation that represents its fixed value as a static field of the instrumented class.private class
FixedValue.ForValue.StaticFieldByteCodeAppender
A byte code appender for returning the fixed value that was stored in a static field.class
HashCodeMethod
An implementation ofObject.hashCode()
that takes a class's declared fields into consideration.protected static class
HashCodeMethod.Appender
A byte code appender to implement a hash code method.static class
HashCodeMethod.NullValueGuard.UsingJump
A null value guard that expects a reference type and that uses a jump if a field value isnull
.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
HashCodeMethod.OffsetProvider.ForFixedValue
An offset provider that supplies a fixed value.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 isImplementation.Composable
.protected static class
Implementation.Context.Default.AccessorMethodDelegation
An implementation of aTypeWriter.MethodPool.Record
for implementing an accessor method.protected static class
Implementation.Context.Default.DelegationRecord
An abstract method pool entry that delegates the implementation of a method to itself.protected static class
Implementation.Context.Default.FieldGetterDelegation
An implementation for a field getter.protected static class
Implementation.Context.Default.FieldSetterDelegation
An implementation for a field setter.static class
Implementation.Context.ExtractableView.AbstractBase
An abstract base implementation of an extractable view of an implementation context.static class
Implementation.Simple
A simple implementation that does not register any members with the instrumented type.static class
Implementation.Target.AbstractBase
An abstract base implementation for anImplementation.Target
.class
InvocationHandlerAdapter
An adapter for adapting anInvocationHandler
.protected static class
InvocationHandlerAdapter.ForField
An implementation of anInvocationHandlerAdapter
that delegates method invocations to an adapter that is stored in an instance field.protected class
InvocationHandlerAdapter.ForField.Appender
An appender for implementing theInvocationHandlerAdapter.ForField
.protected static class
InvocationHandlerAdapter.ForInstance
An implementation of anInvocationHandlerAdapter
that delegates method invocations to an adapter that is stored in a static field.protected class
InvocationHandlerAdapter.ForInstance.Appender
An appender for implementing theInvocationHandlerAdapter.ForInstance
.class
InvokeDynamic
An implementation that applies a dynamic method invocation.protected class
InvokeDynamic.Appender
The byte code appender to be used by theInvokeDynamic
implementation.protected class
InvokeDynamic.InvocationProvider.ArgumentProvider.ConstantPoolWrapper.WrappingArgumentProvider
An argument provider that loads a primitive value from the constant pool and wraps it.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForBooleanConstant
An argument provider for aboolean
value.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForByteConstant
An argument provider for abyte
value.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForCharacterConstant
An argument provider for achar
value.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForClassConstant
An argument provider for aClass
constant.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForDoubleConstant
An argument provider for adouble
value.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForEnumerationValue
An argument provider for anEnum
constant.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForField
Provides an argument from an existing field.protected static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForField.WithExplicitType
An argument provider for a field value with an explicit type.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForFloatConstant
An argument provider for afloat
value.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForInstance
An argument provider for a value that is stored in a randomly named static field.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForIntegerConstant
An argument provider for aint
value.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForJavaConstant
An argument provider for a Java instance.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForLongConstant
An argument provider for along
value.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter
An argument provider that loads an argument of the intercepted method.protected static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter.WithExplicitType
An argument provider for a method parameter with an explicit type.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForNullValue
An argument provider for thenull
value.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForShortConstant
An argument provider for ashort
value.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForStringConstant
An argument provider for aString
value.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.ForThisInstance
An argument provider that loads the intercepted instance.static class
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved.Simple
A simple implementation of a resolved argument provider.static class
InvokeDynamic.InvocationProvider.Default
An invocation provider that requests a synthetic dynamic invocation where all arguments are explicitly provided by the user.protected static class
InvokeDynamic.InvocationProvider.Default.Target
A target for a synthetically bound method call.static class
InvokeDynamic.InvocationProvider.NameProvider.ForExplicitName
A name provider that provides an explicit name.static class
InvokeDynamic.InvocationProvider.ReturnTypeProvider.ForExplicitType
Requests an explicit return type.static class
InvokeDynamic.InvocationProvider.Target.Resolved.Simple
A simple implementation ofInvokeDynamic.InvocationProvider.Target.Resolved
.static class
LoadedTypeInitializer.Compound
A compound loaded type initializer that combines several type initializers.static class
LoadedTypeInitializer.ForStaticField
A type initializer for setting a value for a static field.class
MethodCall
ThisImplementation
allows the invocation of a specified method while providing explicit arguments to this method.protected class
MethodCall.Appender
The appender being used to implement aMethodCall
.static class
MethodCall.ArgumentLoader.ForField
Loads the value of an existing field onto the operand stack.protected static class
MethodCall.ArgumentLoader.ForField.ArgumentProvider
An argument provider for a field access.protected static class
MethodCall.ArgumentLoader.ForField.Factory
A factory for an argument loaded that loads the value of an existing field as an argument.static class
MethodCall.ArgumentLoader.ForInstance
Loads a value onto the operand stack that is stored in a static field.protected static class
MethodCall.ArgumentLoader.ForInstance.Factory
A factory that supplies the value of a static field as an argument.static class
MethodCall.ArgumentLoader.ForInstrumentedType
Loads the instrumented type onto the operand stack.static class
MethodCall.ArgumentLoader.ForMethodCall
Loads the return value of a method call onto the operand stack.protected static class
MethodCall.ArgumentLoader.ForMethodCall.ArgumentProvider
An argument provider for a method call.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
Loads a parameter of the instrumented method onto the operand stack.protected static class
MethodCall.ArgumentLoader.ForMethodParameter.Factory
A factory for an argument loader that supplies a method parameter as an argument.static class
MethodCall.ArgumentLoader.ForMethodParameterArray
Loads an array containing all arguments of a method.static class
MethodCall.ArgumentLoader.ForMethodParameterArrayElement
An argument loader that loads an element of a parameter of an array type.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 class
MethodCall.ArgumentLoader.ForStackManipulation
Loads a stack manipulation resulting in a specific type as an argument.static class
MethodCall.ArgumentLoader.ForThisReference
An argument loader that assigns thethis
reference to a parameter.static class
MethodCall.FieldSetting
AMethodCall
that sets the call's result as the value of a field.static class
MethodCall.MethodInvoker.ForContextualInvocation
Applies a contextual invocation of the provided method, i.e.static class
MethodCall.MethodInvoker.ForDefaultMethodInvocation
Invokes a method as a Java 8 default method.static class
MethodCall.MethodInvoker.ForSuperMethodInvocation
Applies a super method invocation of the provided method.static class
MethodCall.MethodInvoker.ForVirtualInvocation
Applies a virtual invocation on a given type.protected static class
MethodCall.MethodInvoker.ForVirtualInvocation.Factory
A method invoker factory for a virtual method invocation.static class
MethodCall.MethodLocator.ForElementMatcher
A method locator that identifies a unique virtual method.static class
MethodCall.MethodLocator.ForElementMatcher.Factory
A factory for a method locator that uses a matcher on the instrumented type's available methods for identifing a target method.static class
MethodCall.MethodLocator.ForExplicitMethod
Invokes a given method.static class
MethodCall.TargetHandler.ForConstructingInvocation
Invokes a method in order to construct a new instance.static class
MethodCall.TargetHandler.ForField
Creates a target handler that stores the instance to invoke a method on in an instance field.protected static class
MethodCall.TargetHandler.ForField.Factory
A factory for a field access.static class
MethodCall.TargetHandler.ForField.Location.ForExplicitField
An explicit field location.static class
MethodCall.TargetHandler.ForField.Location.ForImplicitField
An implicit field location.static class
MethodCall.TargetHandler.ForMethodCall
A target handler that executes the method and uses it's return value as the target object.protected static class
MethodCall.TargetHandler.ForMethodCall.Factory
Creates a factory for invoking a method on the return type of another method.protected static class
MethodCall.TargetHandler.ForMethodCall.Resolved
A resolved target handler for a method call.static class
MethodCall.TargetHandler.ForMethodParameter
A target handler that loads the parameter of the given index as the target object.protected static class
MethodCall.TargetHandler.ForMethodParameter.Resolved
A resolved target handler for a method parameter.static class
MethodCall.TargetHandler.ForSelfOrStaticInvocation
A target handler that invokes a method either on the instance of the instrumented type or as a static method.protected static class
MethodCall.TargetHandler.ForSelfOrStaticInvocation.Resolved
A resolved target handler for a static or self-declared invocation.static class
MethodCall.TargetHandler.ForValue
A target handler that invokes a method on an instance that is stored in a static field.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.TerminationHandler.FieldSetting
A termination handler that sets a field.protected static class
MethodCall.TerminationHandler.FieldSetting.Explicit
A factory for a field-setting termination handler that locates a given field.protected static class
MethodCall.TerminationHandler.FieldSetting.Implicit
A factory for a field-setting termination handler that uses a matcher to locate the target field on the insturmented type.class
MethodDelegation
This implementation delegates an method call to another method which can either bestatic
by providing a reference to aClass
or an instance method when another object is provided.protected static class
MethodDelegation.Appender
The appender for implementing aMethodDelegation
.static class
MethodDelegation.ImplementationDelegate.Compiled.ForConstruction
A compiled implementation delegate for a constructor delegation.static class
MethodDelegation.ImplementationDelegate.Compiled.ForField
A compiled implementation delegate that invokes methods on a field.static class
MethodDelegation.ImplementationDelegate.Compiled.ForMethodReturn
A compiled implementation delegate that invokes a method on an instance that is returned by another method.static class
MethodDelegation.ImplementationDelegate.Compiled.ForStaticCall
A compiled implementation delegate for invoking a static method.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.static class
MethodDelegation.WithCustomProperties
AMethodDelegation
with custom configuration.protected static class
SuperMethodCall.Appender
An appender for implementing aSuperMethodCall
.class
ToStringMethod
An implementation ofObject.toString()
that concatenates theString
representation of all fields that are declared by a class.protected static class
ToStringMethod.Appender
An appender to implementToStringMethod
.static class
ToStringMethod.PrefixResolver.ForFixedValue
A prefix resolver that returns a fixed value. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.implementation.attribute
Classes in net.bytebuddy.implementation.attribute with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
AnnotationAppender.Default
A default implementation for an annotation appender that writes annotations to a given byte consumer represented by an ASMAnnotationVisitor
.static class
AnnotationAppender.ForTypeAnnotations
A type visitor that visits all type annotations of a generic type and writes any discovered annotation to a suppliedAnnotationAppender
.static class
AnnotationAppender.Target.OnField
Target for an annotation that is written to a Java field.static class
AnnotationAppender.Target.OnMethod
Target for an annotation that is written to a Java method or constructor.static class
AnnotationAppender.Target.OnMethodParameter
Target for an annotation that is written to a Java method or constructor parameter.static class
AnnotationAppender.Target.OnRecordComponent
Target for an annotation that is written to a Java record component.static class
AnnotationAppender.Target.OnType
Target for an annotation that is written to a Java type.static class
FieldAttributeAppender.Compound
A field attribute appender that combines several method attribute appenders to be represented as a single field attribute appender.static class
FieldAttributeAppender.Explicit
Appends an annotation to a field.static class
FieldAttributeAppender.Factory.Compound
A field attribute appender factory that combines several field attribute appender factories to be represented as a single factory.static class
MethodAttributeAppender.Compound
A method attribute appender that combines several method attribute appenders to be represented as a single method attribute appender.static class
MethodAttributeAppender.Explicit
Appends an annotation to a method or method parameter.static class
MethodAttributeAppender.Explicit.Target.OnMethodParameter
A method attribute appender target for writing annotations onto a given method parameter.static class
MethodAttributeAppender.Factory.Compound
A method attribute appender factory that combines several method attribute appender factories to be represented as a single factory.static class
MethodAttributeAppender.ForReceiverType
A method attribute appender that writes a receiver type.static class
RecordComponentAttributeAppender.Compound
A record component attribute appender that combines several method attribute appenders to be represented as a single record component attribute appender.static class
RecordComponentAttributeAppender.Explicit
Appends an annotation to a record component.static class
RecordComponentAttributeAppender.Factory.Compound
A record component attribute appender factory that combines several record component attribute appender factories to be represented as a single factory.static class
TypeAttributeAppender.Compound
A compound type attribute appender that concatenates a number of other attribute appenders.static class
TypeAttributeAppender.Explicit
An attribute appender that appends a single annotation to a given type.static class
TypeAttributeAppender.ForInstrumentedType.Differentiating
A type attribute appender that writes all annotations of the instrumented but excludes annotations up to a given index. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.implementation.auxiliary
Classes in net.bytebuddy.implementation.auxiliary with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
AuxiliaryType.NamingStrategy.SuffixingRandom
A naming strategy for an auxiliary type which returns the instrumented type's name with a fixed extension and a random number as a suffix.class
MethodCallProxy
A method call proxy represents a class that is compiled against a particular method which can then be called whenever either itsCallable.call()
orRunnable.run()
method is called where the method call proxy implements both interfaces.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
MethodCallProxy.ConstructorCall.Appender
The appender for implementing theMethodCallProxy.ConstructorCall
.protected static class
MethodCallProxy.MethodCall
An implementation for a method of aMethodCallProxy
.protected class
MethodCallProxy.MethodCall.Appender
The appender for implementing theMethodCallProxy.MethodCall
.class
TypeProxy
A type proxy creates accessor methods for all overridable methods of a given type by subclassing the given type and delegating all method calls to accessor methods of the instrumented type it was created for.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
An implementation for a method call of aTypeProxy
.protected class
TypeProxy.MethodCall.Appender
Implementation of a byte code appender for aTypeProxy.MethodCall
.protected class
TypeProxy.MethodCall.Appender.AccessorMethodInvocation
Stack manipulation for invoking an accessor method.protected static class
TypeProxy.SilentConstruction.Appender
The appender for implementing aTypeProxy.SilentConstruction
. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.implementation.bind
Classes in net.bytebuddy.implementation.bind with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
MethodDelegationBinder.AmbiguityResolver.Compound
A chain ofMethodDelegationBinder.AmbiguityResolver
s that are applied in the given order until two bindings can be resolved.static class
MethodDelegationBinder.BindingResolver.StreamWriting
Binds a method using another resolver and prints the selected binding to aPrintStream
.protected static class
MethodDelegationBinder.MethodBinding.Builder.Build
A method binding that was created by aMethodDelegationBinder.MethodBinding.Builder
.static class
MethodDelegationBinder.MethodInvoker.Virtual
A method invocation that enforces a virtual invocation that is dispatched on a given type.static class
MethodDelegationBinder.ParameterBinding.Anonymous
An anonymous binding of a target method parameter.static class
MethodDelegationBinder.ParameterBinding.Unique<T>
A uniquely identifiable parameter binding for a target method.static class
MethodDelegationBinder.Processor
A helper class that allows to identify a best binding for a given type and source method choosing from a list of given target methods by using a givenMethodDelegationBinder
and anMethodDelegationBinder.AmbiguityResolver
. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.implementation.bind.annotation
Classes in net.bytebuddy.implementation.bind.annotation with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
Default.Binder.TypeLocator.ForType
A type locator that returns a given type.static class
DefaultCall.Binder.DefaultMethodLocator.Explicit
An explicit default method locator attempts to look up a default method in the specified interface type.protected static class
DefaultMethod.Binder.DelegationMethod
Loads the delegation method constant onto the stack.static class
DefaultMethod.Binder.MethodLocator.ForExplicitType
A method locator for an explicit target type.static class
FieldProxy.Binder
A binder for theFieldProxy
annotation.protected class
FieldProxy.Binder.AccessorProxy
A proxy type for accessing a field either by a getter or a setter.protected static class
FieldProxy.Binder.FieldGetter
Implementation for a getter method.protected class
FieldProxy.Binder.FieldGetter.Appender
A byte code appender for a getter method.static class
FieldProxy.Binder.FieldResolver.Factory.Duplex
A duplex factory for a type that both sets and gets a field value.static class
FieldProxy.Binder.FieldResolver.Factory.Simplex
A simplex factory where field getters and setters both have their own type.static class
FieldProxy.Binder.FieldResolver.ForGetter
A field resolver for a getter accessor.static class
FieldProxy.Binder.FieldResolver.ForGetterSetterPair
A field resolver for an accessor that both gets and sets a field value.static class
FieldProxy.Binder.FieldResolver.ForSetter
A field resolver for a setter accessor.protected static class
FieldProxy.Binder.FieldSetter
Implementation for a setter method.protected class
FieldProxy.Binder.FieldSetter.Appender
A byte code appender 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 class
FieldProxy.Binder.InstanceFieldConstructor.Appender
An appender for implementing anFieldProxy.Binder.InstanceFieldConstructor
.static class
Morph.Binder
A binder for theMorph
annotation.static class
Morph.Binder.DefaultMethodLocator.Explicit
An explicit default method locator attempts to look up a default method in the specified interface type.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
Morph.Binder.RedirectionProxy.InstanceFieldConstructor
Creates an instance of the proxy when instrumenting an instance method.protected static class
Morph.Binder.RedirectionProxy.InstanceFieldConstructor.Appender
The byte code appender that implements the constructor.protected static class
Morph.Binder.RedirectionProxy.MethodCall
Implements a the method call of the morphing method.protected class
Morph.Binder.RedirectionProxy.MethodCall.Appender
The byte code appender to implement the method.static class
Pipe.Binder
ATargetMethodAnnotationDrivenBinder.ParameterBinder
for binding thePipe
annotation.protected static class
Pipe.Binder.Redirection
An auxiliary type for performing the redirection of a method invocation as requested by thePipe
annotation.private static class
Pipe.Binder.Redirection.ConstructorCall.Appender
The appender for implementing thePipe.Binder.Redirection.ConstructorCall
.protected static class
Pipe.Binder.Redirection.MethodCall
The implementation to implement aPipe.Binder.Redirection
's forwarding method.private class
Pipe.Binder.Redirection.MethodCall.Appender
The appender for implementing thePipe.Binder.Redirection.MethodCall
.static class
Super.Binder.TypeLocator.ForType
A type locator that returns a given type.protected static class
SuperMethod.Binder.DelegationMethod
Loads the delegation method constant onto the stack.class
TargetMethodAnnotationDrivenBinder
ThisMethodDelegationBinder
binds method by analyzing annotations found on the target method that is subject to a method binding.protected static class
TargetMethodAnnotationDrivenBinder.DelegationProcessor
A delegation processor is a helper class for aTargetMethodAnnotationDrivenBinder
for performing its actual logic.static class
TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Bound<T extends java.lang.annotation.Annotation>
A bound handler represents an unambiguous parameter binder that was located for a given array of annotations.static class
TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Unbound
An unbound handler is a fallback for returning an illegal binding for parameters for which no parameter binder could be located.static class
TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFixedValue.OfConstant<U extends java.lang.annotation.Annotation>
A parameter binder that binds a fixed value to a parameter annotation when using aMethodDelegation
.protected static class
TargetMethodAnnotationDrivenBinder.Record
A compiled record of a target method annotation-driven binder. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.implementation.bytecode
Classes in net.bytebuddy.implementation.bytecode with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
ByteCodeAppender.Compound
A compound appender that combines a given number of other byte code appenders.static class
ByteCodeAppender.Simple
A simple byte code appender that only represents a given array ofStackManipulation
s.static class
ByteCodeAppender.Size
An immutable description of both the operand stack size and the size of the local variable array that is required to run the code generated by thisByteCodeAppender
.static class
StackManipulation.Compound
An immutable stack manipulation that aggregates a sequence of other stack manipulations.static class
StackManipulation.Size
A description of the size change that is imposed by someStackManipulation
.class
TypeCreation
A stack manipulation for creating an undefined type on which a constructor is to be called. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.implementation.bytecode.assign
Classes in net.bytebuddy.implementation.bytecode.assign with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description class
InstanceCheck
Implements aninstanceof
check.class
TypeCasting
A stack manipulation for a type down casting. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.implementation.bytecode.assign.primitive
Classes in net.bytebuddy.implementation.bytecode.assign.primitive with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description class
PrimitiveTypeAwareAssigner
This assigner is able to handle non-void
, primitive types.protected static class
PrimitiveUnboxingDelegate.ImplicitlyTypedUnboxingResponsible
An unboxing responsible for an implicitly typed value.protected static class
PrimitiveWideningDelegate.WideningStackManipulation
A stack manipulation that widens a primitive type into a more general primitive type.class
VoidAwareAssigner
This assigner is able to handle thevoid
type. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.implementation.bytecode.assign.reference
Classes in net.bytebuddy.implementation.bytecode.assign.reference with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description protected static class
GenericTypeAwareAssigner.IsAssignableToVisitor
A visitor for generic types that determines assignability of such types.protected static class
GenericTypeAwareAssigner.IsAssignableToVisitor.OfManifestType
An implementation of a assignability visitor that is applicable for any non-wildcard type.protected static class
GenericTypeAwareAssigner.IsAssignableToVisitor.OfWildcard
A visitor to determine the assignability of a wildcard type. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.implementation.bytecode.collection
Classes in net.bytebuddy.implementation.bytecode.collection with annotations of type HashCodeAndEqualsPlugin.Enhance 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.class
ArrayFactory
ACollectionFactory
that is capable of creating an array of a given type with any number of given values.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. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.implementation.bytecode.constant
Classes in net.bytebuddy.implementation.bytecode.constant with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description protected static class
ClassConstant.ForReferenceType
A class constant for a non-primitiveClass
.protected static class
DoubleConstant.ConstantPool
A stack manipulation for loading adouble
value from a class's constant pool 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.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
.protected static class
LongConstant.ConstantPool
A stack manipulation for loading along
value from a class's constant pool 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. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.implementation.bytecode.member
Classes in net.bytebuddy.implementation.bytecode.member with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description protected class
FieldAccess.AccessDispatcher
A dispatcher for implementing a non-generic read or write access on a field.protected class
FieldAccess.AccessDispatcher.FieldGetInstruction
A reading field access operation.protected class
FieldAccess.AccessDispatcher.FieldPutInstruction
A writing field access operation.protected static class
FieldAccess.OfGenericField
A dispatcher for implementing a generic read or write access on a field.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 class
MethodInvocation.Invocation
An implementation of a method invoking stack manipulation.protected static class
MethodInvocation.OfGenericMethod
A method invocation of a generically resolved method.static class
MethodVariableAccess.MethodLoading
A stack manipulation that loads all parameters of a given method onto the operand stack.static class
MethodVariableAccess.MethodLoading.TypeCastingHandler.ForBridgeTarget
A type casting handler that casts all parameters of a method to the parameter types of a compatible method with covariant parameter types.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. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.matcher
Classes in net.bytebuddy.matcher with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description class
AccessibilityMatcher<T extends ByteCodeElement>
An element matcher that validates that a given byte code element is accessible to a given type.class
AnnotationTargetMatcher<T extends AnnotationDescription>
A matcher for annotations that target a given element type.class
AnnotationTypeMatcher<T extends AnnotationDescription>
An element matcher that matches the type of an annotation description.class
ArrayTypeMatcher<T extends TypeDefinition>
Matches an enumeration type.class
BooleanMatcher<T>
An element matcher that returns a fixed result.class
CachingMatcher<T>
A matcher that remembers the results of previously matching an equal target.class
ClassLoaderHierarchyMatcher<T extends java.lang.ClassLoader>
An element matcher that matches allClassLoader
s in the matched class loaders hierarchy against a given matcher.class
ClassLoaderParentMatcher<T extends java.lang.ClassLoader>
An element matcher that matches a class loader for being a parent of the given class loader.class
CollectionElementMatcher<T>
A matcher that matches a given element of a collection.class
CollectionErasureMatcher<T extends java.lang.Iterable<? extends TypeDefinition>>
An element matcher that matches a collection of types by their erasures.class
CollectionItemMatcher<T>
A list item matcher matches any element of a collection to a given matcher and assures that at least one element matches the supplied iterable condition.class
CollectionOneToOneMatcher<T>
An element matcher that matches a given iterable collection to a list of matchers on a per-element basis.class
CollectionSizeMatcher<T extends java.lang.Iterable<?>>
An element matcher that matches a collection by its size.class
DeclaringAnnotationMatcher<T extends AnnotationSource>
An element matcher that matches the list of annotations that are provided by an annotated element.class
DeclaringFieldMatcher<T extends TypeDefinition>
An element matcher that checks if a type description declares fields of a given property.class
DeclaringMethodMatcher<T extends TypeDefinition>
An element matcher that checks if a type description declares methods of a given property.class
DeclaringTypeMatcher<T extends DeclaredByType>
An element matcher that matches the declaring type of another element, only if this element is actually declared in a type.class
DefinedShapeMatcher<T extends ByteCodeElement.TypeDependant<S,?>,S extends ByteCodeElement.TypeDependant<?,?>>
An element matcher that matches a byte code's element's token against a matcher for such a token.class
DescriptorMatcher<T extends NamedElement.WithDescriptor>
An element matcher that matches a Java descriptor.static class
ElementMatcher.Junction.Conjunction<W>
A conjunction matcher which only matches an element if both represented matchers constitute a match.static class
ElementMatcher.Junction.Disjunction<W>
A disjunction matcher which only matches an element if both represented matchers constitute a match.class
EqualityMatcher<T>
An element matcher that checks an object's equality to another object.class
ErasureMatcher<T extends TypeDefinition>
An element matcher that matches its argument'sTypeDescription.Generic
raw type against the given matcher for aTypeDescription
.class
FailSafeMatcher<T>
A fail-safe matcher catches exceptions that are thrown by a delegate matcher and returns an alternative value.class
FieldTypeMatcher<T extends FieldDescription>
An element matcher that matches a field's type.class
HasSuperClassMatcher<T extends TypeDescription>
An element matcher that matches a super class.class
HasSuperTypeMatcher<T extends TypeDescription>
An element matcher that matches a super type.class
InheritedAnnotationMatcher<T extends TypeDescription>
An element matcher that matches the list of inherited annotations of a type description.class
InstanceTypeMatcher<T>
An element matcher that matches an object's type.class
IsNamedMatcher<T extends NamedElement.WithOptionalName>
An element matcher that matches a named element only if is explicitly named.static class
LatentMatcher.Conjunction<S>
A matcher that computes the conjunction of all supplied latent matchers.static class
LatentMatcher.Disjunction<S>
A matcher that computes the disjunction of all supplied latent matchers.static class
LatentMatcher.ForFieldToken
A latent matcher where the field token is being attached to the supplied type description before matching.protected static class
LatentMatcher.ForFieldToken.ResolvedMatcher
A resolved matcher of a latent field matcher for a field token.static class
LatentMatcher.ForMethodToken
A latent matcher where the method token is being attached to the supplied type description before matching.protected static class
LatentMatcher.ForMethodToken.ResolvedMatcher
A resolved matcher of a latent method matcher for a method token.static class
LatentMatcher.ForRecordComponentToken
A latent matcher for a record component token.static class
LatentMatcher.Resolved<S>
A latent matcher representing an already resolvedElementMatcher
.class
MethodExceptionTypeMatcher<T extends MethodDescription>
An element matcher that matches the exceptions that are declared by a method.class
MethodOverrideMatcher<T extends MethodDescription>
A matcher that checks if any super type of a type declares a method with the same shape of a matched method.class
MethodParametersMatcher<T extends MethodDescription>
An element matcher that matches a method's parameters.class
MethodParameterTypeMatcher<T extends ParameterDescription>
An element matcher that matches a method's parameter's type.class
MethodParameterTypesMatcher<T extends ParameterList<?>>
An element matcher that matches a method's parameter types.class
MethodReturnTypeMatcher<T extends MethodDescription>
An element matcher that matches its argument's return type against a given type matcher.class
MethodSortMatcher<T extends MethodDescription>
Matches a method description by its general characteristics which are represented as aMethodSortMatcher.Sort
.class
ModifierMatcher<T extends ModifierReviewable>
An element matcher that matches a byte code element by its modifiers.class
NameMatcher<T extends NamedElement>
A method matcher that matches a byte code element's source code name: The source code name of types is equal to their binary name where arrays are appended a[]
by their arity and where inner classes are appended by dollar signs to their outer class's source name. Constructors and the type initializer methods are represented by the empty string as they do not represent a source code name. Fields are named as in the source code.class
NegatingMatcher<T>
An element matcher that reverses the matching result of another matcher.class
NullMatcher<T>
An element matcher that matches thenull
value.class
PrimitiveTypeMatcher<T extends TypeDefinition>
Matches a primitive type.class
RecordMatcher<T extends TypeDefinition>
Matches a record.class
SignatureTokenMatcher<T extends MethodDescription>
Matches a method description's signature token against another matcher.class
StringMatcher
An element matcher that compares two strings by a given pattern which is characterized by aStringMatcher.Mode
.class
StringSetMatcher
An element matcher which checks if a string is in a set of strings.class
SubTypeMatcher<T extends TypeDescription>
An element matcher that matches its argument for being another type's subtype.class
SuperTypeMatcher<T extends TypeDescription>
An element matcher that matches its argument for being another type's super type.class
TypeSortMatcher<T extends TypeDefinition>
An element matcher that validates that a given generic type description represents a type of a given name.class
VisibilityMatcher<T extends ByteCodeElement>
An element matcher that validates that a given byte code element is visible to a given type. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.pool
Classes in net.bytebuddy.pool with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
TypePool.AbstractBase
A base implementation of aTypePool
that is managing a cache provider and that handles the description of array and primitive types.protected static class
TypePool.AbstractBase.ArrayTypeResolution
A resolution for a type that, if resolved, represents an array type.static class
TypePool.AbstractBase.Hierarchical
Implements a hierarchical view of type pools, similarly to class loader hierarchies.static class
TypePool.ClassLoading
A type pool that attempts to load a class.static class
TypePool.Default
A default implementation of aTypePool
that models binary data in the Java byte code format into aTypeDescription
.static class
TypePool.Default.ComponentTypeLocator.ForAnnotationProperty
A component type locator that lazily analyses an annotation for resolving an annotation property's array value's component type.protected class
TypePool.Default.ComponentTypeLocator.ForAnnotationProperty.Bound
A bound representation of aTypePool.Default.ComponentTypeLocator.ForAnnotationProperty
.static class
TypePool.Default.ComponentTypeLocator.ForArrayType
A component type locator that locates an array type by a method's return value from its method descriptor.protected class
TypePool.Default.GenericTypeExtractor.ForSignature.OfMethod.ExceptionTypeRegistrant
A registrant for an exception type.protected class
TypePool.Default.GenericTypeExtractor.ForSignature.OfMethod.ParameterTypeRegistrant
A registrant for a parameter type.protected class
TypePool.Default.GenericTypeExtractor.ForSignature.OfMethod.ReturnTypeTypeRegistrant
A registrant for a return type.protected class
TypePool.Default.GenericTypeExtractor.ForSignature.OfType.InterfaceTypeRegistrant
A registrant for the interface types.protected class
TypePool.Default.GenericTypeExtractor.ForSignature.OfType.SuperClassRegistrant
A registrant for the super type.static class
TypePool.Default.GenericTypeExtractor.IncompleteToken.ForInnerClass
An incomplete generic type token representing a type with an outer type.static class
TypePool.Default.GenericTypeExtractor.IncompleteToken.ForTopLevelType
An incomplete token representing a generic type without an outer type.protected static class
TypePool.Default.LazyTypeDescription.AnnotationToken
A token for representing collected data on an annotation.static class
TypePool.Default.LazyTypeDescription.AnnotationToken.Resolution.Illegal
An illegal resolution.static class
TypePool.Default.LazyTypeDescription.AnnotationToken.Resolution.Simple
A simple resolved annotation.protected static class
TypePool.Default.LazyTypeDescription.FieldToken
A token for representing collected data on a field.static class
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForGenericArray
A generic type token that represents a generic array.static class
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForLowerBoundWildcard
A generic type token for a wildcard that is bound below.static class
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType
A generic type token that represents a parameterized type.static class
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType.Nested
A generic type token to describe a parameterized type description with a generic owner type.static class
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForRawType
A generic type token that represents a non-generic type.static class
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable
A generic type token that represents a type variable.protected static class
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.Formal
A generic type token that represent a formal type variable, i.e.static class
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForUpperBoundWildcard
A generic type token for a wildcard that is bound above.static class
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForField.Tokenized
An implementation of a tokenized resolution of the generic type of aFieldDescription
.static class
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForMethod.Tokenized
An implementation of a tokenized resolution of generic types of aMethodDescription
.static class
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForRecordComponent.Tokenized
An implementation of a tokenized resolution of the generic type of aRecordComponentDescription
.static class
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForType.Tokenized
An implementation of a tokenized resolution of generic types of aTypeDescription
.protected static class
TypePool.Default.LazyTypeDescription.MethodToken
A token for representing collected data on a method.protected static class
TypePool.Default.LazyTypeDescription.MethodToken.ParameterToken
A token representing a method's parameter.protected static class
TypePool.Default.LazyTypeDescription.RecordComponentToken
A token representing a record component.static class
TypePool.Default.LazyTypeDescription.TypeContainment.WithinMethod
Describes a type that is contained within a method or constructor.static class
TypePool.Default.LazyTypeDescription.TypeContainment.WithinType
Describes a type that is contained within another type.protected class
TypePool.Default.WithLazyResolution.LazyResolution
A lazy resolution of a type that the enclosing type pool attempts to resolve.static class
TypePool.Explicit
A type pool that supplies explicitly known type descriptions.static class
TypePool.LazyFacade
A lazy facade of a type pool that delegates any lookups to another type pool only if another value than the type's name is looked up.protected static class
TypePool.LazyFacade.LazyResolution
The lazy resolution for a lazy facade for a type pool.static class
TypePool.Resolution.Illegal
A canonical representation of a non-successful resolution of aTypePool
.static class
TypePool.Resolution.Simple
A simple resolution that represents a givenTypeDescription
. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.utility
Classes in net.bytebuddy.utility with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description static class
JavaConstant.MethodHandle.Dispatcher.AbstractBase
An abstract base implementation of a dispatcher.static class
JavaConstant.MethodHandle.Dispatcher.ForJava7CapableVm
A dispatcher that extracts the information of a method handle by using private APIs that are available in Java 7+.static class
JavaConstant.MethodHandle.Dispatcher.ForJava8CapableVm
A dispatcher for introspecting ajava.lang.invoke.MethodHandle
instance on a virtual machine that officially supports this introspection, i.e.static class
JavaConstant.MethodType.Dispatcher.ForJava7CapableVm
A dispatcher for virtual machines that are aware of thejava.lang.invoke.MethodType
type that was added in Java version 7.static class
JavaModule.Dispatcher.Enabled
A dispatcher for a VM that does support thejava.lang.Module
API.class
StreamDrainer
A utility for draining the contents of anInputStream
into abyte
array. -
Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.utility.privilege
Classes in net.bytebuddy.utility.privilege with annotations of type HashCodeAndEqualsPlugin.Enhance Modifier and Type Class Description class
GetSystemPropertyAction
An action for reading a system property as a privileged action.class
SetAccessibleAction<T extends java.lang.reflect.AccessibleObject>
An action for making anAccessibleObject
accessible.
-