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 by byte 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 a DynamicType by enhancing a given type.
net.bytebuddy.dynamic.scaffold.subclass	All classes and types in this package are related to creating a DynamicType by creating a subclass of a given type.
net.bytebuddy.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 given InstrumentedType.
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 a MethodDescription.
net.bytebuddy.implementation.bytecode.assign	An Assigner is responsible for transforming a given TypeDescription into another one.
net.bytebuddy.implementation.bytecode.assign.primitive	Assigner implementations of this package are capable of handling primitive types or the void type.
net.bytebuddy.implementation.bytecode.collection	This package is dedicated to creating StackManipulations that create collections or arrays from a given number of values.
net.bytebuddy.implementation.bytecode.constant	StackManipulations in this package are responsible for creating compile-time constants and pushing them onto the operand stack.
net.bytebuddy.implementation.bytecode.member	StackManipulations 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 creating TypeDescriptions 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 containing PrivilegedActions 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 and 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 the values 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 the values method of any enumeration 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 and 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 an AgentBuilder.
static class	AgentBuilder.Default.BootstrapInjectionStrategy.Enabled An enabled bootstrap injection strategy.
static class	AgentBuilder.Default.ExecutingTransformer.Factory.ForJava9CapableVm A factory for a class file transformer on a JVM that supports the java.lang.Module API to override the newly added method of the ClassFileTransformer 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.
static class	AgentBuilder.Default.Transformation.Compound A compound transformation that applied several transformation in the given order and applies the first active transformation.
static class	AgentBuilder.Default.Transformation.Resolution.Unresolved A canonical implementation of a non-resolved resolution.
static class	AgentBuilder.Default.Transformation.Simple A simple, active transformation.
protected static class	AgentBuilder.Default.Transformation.Simple.Resolution A resolution that performs a type transformation.
protected static class	AgentBuilder.Default.Transformation.Simple.Resolution.BootstrapClassLoaderCapableInjectorFactory An injector factory that resolves to a bootstrap class loader injection if this is necessary and enabled.
protected class	AgentBuilder.Default.Transforming A helper class that describes a AgentBuilder.Default after supplying a AgentBuilder.RawMatcher such that one or several AgentBuilder.Transformers 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 the Throwable 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.InstallationListener.Compound A compound installation listener.
static class	AgentBuilder.InstallationListener.StreamWriting This installation listener prints the status of any installation to a PrintStream.
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 the writeReplace 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.
static class	AgentBuilder.Listener.StreamWriting A listener that writes events to a PrintStream.
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 locator AgentBuilder.PoolStrategy.WithTypePoolCache (note documentation of the linked class) that is based on a ConcurrentMap.
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 a TypeDescription and its ClassLoader 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.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 invokes Thread.sleep(long) prior to every batch but the first batch.
static class	AgentBuilder.RedefinitionStrategy.Listener.StreamWriting A listener that writes events to a PrintStream.
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 a Future.
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.Compound A compound transformer that allows to group several AgentBuilder.Transformers as a single transformer.
static class	AgentBuilder.Transformer.ForAdvice A transformer for applying an Advice 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 build Plugin.
static class	AgentBuilder.TypeStrategy.ForBuildEntryPoint A type strategy that applies a build EntryPoint.
class	LambdaFactory This class serves as a dispatcher for creating lambda expression objects when Byte Buddy is configured to instrument the java.lang.invoke.LambdaMetafactory.

Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.asm

Classes in net.bytebuddy.asm with annotations of type HashCodeAndEqualsPlugin.Enhance

Modifier and Type	Class and 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 implementing Advice.
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.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 for Advice.Dispatcher.RelocationHandler.ForType.
protected class	Advice.Dispatcher.RelocationHandler.ForValue.Bound A bound relocation handler for Advice.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 a Advice.OffsetMapping.ForArgument.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 Annotation> A factory for an annotation whose use is not permitted.
static class	Advice.OffsetMapping.Factory.Simple<T extends 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 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 a Advice.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 a Advice.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 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 via Advice.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 via Advice.Local.
static class	Advice.OffsetMapping.ForOrigin An offset mapping for the Advice.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 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 Annotation> A factory that binds a stack manipulation.
static class	Advice.OffsetMapping.ForStackManipulation.OfAnnotationProperty<T extends Annotation> A factory for binding an annotation's property.
static class	Advice.OffsetMapping.ForStackManipulation.OfDefaultValue<T extends Annotation> A factory for binding the annotated parameter's default value.
static class	Advice.OffsetMapping.ForThisReference An offset mapping that provides access to the this reference of the instrumented method.
static class	Advice.OffsetMapping.ForThrowable An offset mapping for accessing a Throwable 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.WithCustomMapping A builder step for creating an Advice that uses custom mappings of annotations to constant pool values.
static class	AsmVisitorWrapper.Compound An ordered, immutable chain of AsmVisitorWrappers.
static class	AsmVisitorWrapper.ForDeclaredFields An ASM visitor wrapper that allows to wrap declared fields of the instrumented type with a AsmVisitorWrapper.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 a AsmVisitorWrapper.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	MemberRemoval A visitor wrapper that removes fields or methods that match a given ElementMatcher.
class	MemberSubstitution Substitutes field access or method invocations within a method's body.
static class	MemberSubstitution.Substitution.Compound A compound substitution.
static class	MemberSubstitution.Substitution.ForElementMatchers A substitution that uses element matchers for determining if a byte code element should be substituted.
static class	MemberSubstitution.Substitution.Resolver.FieldAccessing A resolver that replaces an interaction with a byte code element with a field access.
static class	MemberSubstitution.Substitution.Resolver.MethodInvoking A resolver that invokes a method.
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.

Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.build

Classes in net.bytebuddy.build with annotations of type HashCodeAndEqualsPlugin.Enhance

Modifier and Type	Class and Description
class	HashCodeAndEqualsPlugin A build tool plugin that adds Object.hashCode() and Object.equals(Object) methods to a class if the HashCodeAndEqualsPlugin.Enhance annotation is present and no explicit method declaration was added.
protected static class	HashCodeAndEqualsPlugin.ValueMatcher An element matcher for a HashCodeAndEqualsPlugin.ValueHandling annotation.
static class	HashCodeAndEqualsPlugin.WithNonNullableFields A version of the HashCodeAndEqualsPlugin that assumes that all fields are non-nullable unless they are explicitly marked.
class	ToStringPlugin A build tool plugin that adds a Object.toString() and method to a class if the ToStringPlugin.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 and Description
static class	AnnotationDescription.Builder A builder for pragmatically creating AnnotationDescription.
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 and Description
static class	ParameterDescription.ForLoadedParameter.Dispatcher.ForJava8CapableVm A dispatcher for VMs that support the java.lang.reflect.Parameter API for Java 8+.
static class	ParameterList.ForLoadedExecutable.Dispatcher.ForJava8CapableVm A dispatcher for a legacy VM that does support the java.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 and Description
static class	ModifierContributor.Resolver<T extends ModifierContributor> A resolver for Java modifiers represented by ModifierContributors.

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 and Description
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 existing java.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 a TypeDescription.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 of TargetType 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 all TargetType 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 and 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.Compound A compound ClassFileLocator 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's getResourceAsStream method.
static class	ClassFileLocator.ForModuleFile A class file locator that locates classes within a Java jmod file.
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.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.TypeVariableDefinitionAdapter An adapter for defining a new type variable for the instrumented type.
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.
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 singleton Nexus 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 a Nexus.
static class	NexusAccessor.Dispatcher.Unavailable A disabled dispatcher where a Nexus is not available.
static class	NexusAccessor.InitializationAppender An initialization appender that looks up a loaded type initializer from Byte Buddy's Nexus.
static class	Transformer.Compound<S> A compound transformer.
static class	Transformer.ForField A transformer for a field that delegates to another transformer that transforms a FieldDescription.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 a MethodDescription.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 all LoadedTypeInitializer 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 and 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 a Instrumentation to append to either the boot classpath or the system class path.
static class	ClassInjector.UsingLookup A class injector that uses a java.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 the ClassLoader 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.Indirect An indirect dispatcher that uses a redirection accessor class that was injected into the bootstrap class loader.
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.UsingUnsafe A class injector that uses sun.misc.Unsafe to inject classes.
static class	ClassInjector.UsingUnsafe.Dispatcher.Disabled A disabled dispatcher.
static class	ClassInjector.UsingUnsafe.Dispatcher.Enabled An enabled dispatcher.
protected static class	ClassLoadingStrategy.Default.InjectionDispatcher A class loading strategy which applies a class loader injection while applying a given ProtectionDomain on class injection.
protected static class	ClassLoadingStrategy.Default.WrappingDispatcher A class loading strategy which creates a wrapping class loader while applying a given ProtectionDomain 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 using sun.misc.Unsafe.
static class	ClassLoadingStrategy.UsingLookup A class loading strategy that uses a java.lang.invoke.MethodHandles$Lookup instance for defining types.
class	ClassReloadingStrategy The class reloading strategy allows to redefine loaded Classes.
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 a MultipleParentClassLoader only if multiple or no ClassLoaders 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 a URLClassLoader, 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 and 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 a FieldLocator.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	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 given ByteCodeAppender.
static class	TypeWriter.Default<S> A default implementation of a TypeWriter.
protected static class	TypeWriter.Default.ClassDumpAction An action to write a class file to the dumping location.
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 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.

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 and Description
class	AbstractInliningDynamicTypeBuilder<T> An abstract base implementation of a dynamic type builder that alters an existing type.
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 A MethodRebaseResolver.Resolution of a rebased constructor.
static class	MethodRebaseResolver.Resolution.ForRebasedMethod A MethodRebaseResolver.Resolution of a rebased method.
static class	MethodRebaseResolver.Resolution.Preserved A MethodRebaseResolver.Resolution of a non-rebased method.
class	RebaseDynamicTypeBuilder<T> A type builder that rebases an instrumented type.
protected static class	RebaseDynamicTypeBuilder.RebaseableMatcher A matcher that filters any method that should not be rebased, i.e.
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 a RebaseImplementationTarget.

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 and 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 and Description
class	DefaultMethodCall This Implementation invokes a default method for the methods it instruments.
protected static class	DefaultMethodCall.Appender The appender for implementing a DefaultMethodCall.
class	EqualsMethod An implementation of Object.equals(Object) that takes a class's declared fields into consideration.
protected static class	EqualsMethod.Appender A byte code appender to implement the EqualsMethod.
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 are null but returns if the invoked instance's field value is null 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 a Throwable 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.ForParameterSetter A field accessor that sets a parameters value of a given index.
protected class	FieldAccessor.ForParameterSetter.Appender An appender for a field accessor that sets a parameter of a given index.
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 returning this.
protected static class	FixedValue.ForValue A fixed value implementation that represents its fixed value as a static field of the instrumented class.
class	HashCodeMethod An implementation of Object.hashCode() that takes a class's declared fields into consideration.
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 is null.
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.
protected static class	Implementation.Context.Default.AccessorMethodDelegation An implementation of a TypeWriter.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 an Implementation.Target.
class	InvocationHandlerAdapter An adapter for adapting an InvocationHandler.
protected static class	InvocationHandlerAdapter.ForField An implementation of an InvocationHandlerAdapter that delegates method invocations to an adapter that is stored in an instance field.
protected class	InvocationHandlerAdapter.ForField.Appender An appender for implementing the InvocationHandlerAdapter.ForField.
protected static class	InvocationHandlerAdapter.ForInstance An implementation of an InvocationHandlerAdapter that delegates method invocations to an adapter that is stored in a static field.
protected class	InvocationHandlerAdapter.ForInstance.Appender An appender for implementing the InvocationHandlerAdapter.ForInstance.
class	InvokeDynamic An implementation that applies a dynamic method invocation.
protected class	InvokeDynamic.Appender The byte code appender to be used by the InvokeDynamic 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 a boolean value.
static class	InvokeDynamic.InvocationProvider.ArgumentProvider.ForByteConstant An argument provider for a byte value.
static class	InvokeDynamic.InvocationProvider.ArgumentProvider.ForCharacterConstant An argument provider for a char value.
static class	InvokeDynamic.InvocationProvider.ArgumentProvider.ForClassConstant An argument provider for a Class constant.
static class	InvokeDynamic.InvocationProvider.ArgumentProvider.ForDoubleConstant An argument provider for a double value.
static class	InvokeDynamic.InvocationProvider.ArgumentProvider.ForEnumerationValue An argument provider for an Enum 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 a float 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 a int value.
static class	InvokeDynamic.InvocationProvider.ArgumentProvider.ForJavaConstant An argument provider for a Java instance.
static class	InvokeDynamic.InvocationProvider.ArgumentProvider.ForLongConstant An argument provider for a long 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 the null value.
static class	InvokeDynamic.InvocationProvider.ArgumentProvider.ForShortConstant An argument provider for a short value.
static class	InvokeDynamic.InvocationProvider.ArgumentProvider.ForStringConstant An argument provider for a String 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.ForMethodDescription A target that requests to dynamically invoke a method to substitute for a given method.
static class	InvokeDynamic.InvocationProvider.Target.Resolved.Simple A simple implementation of InvokeDynamic.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 This Implementation allows the invocation of a specified method while providing explicit arguments to this method.
protected class	MethodCall.Appender The appender being used to implement a MethodCall.
static class	MethodCall.ArgumentLoader.ForField Loads the value of an existing field onto the operand stack.
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.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.
protected 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 the this reference to a parameter.
static class	MethodCall.MethodInvoker.ForVirtualInvocation Applies a virtual invocation on a given type.
static class	MethodCall.MethodLocator.ForElementMatcher A method locator that identifies a unique virtual method.
static class	MethodCall.MethodLocator.ForExplicitMethod Invokes a given method.
static class	MethodCall.TargetHandler.ForField Creates a target handler that stores the instance to invoke a method on in an instance field.
static class	MethodCall.TargetHandler.ForMethodParameter A target handler that loads the parameter of the given index as the target object.
static class	MethodCall.TargetHandler.ForValue A target handler that invokes a method on an instance that is stored in a static field.
class	MethodDelegation This implementation delegates an method call to another method which can either be static by providing a reference to a Class or an instance method when another object is provided.
protected static class	MethodDelegation.Appender The appender for implementing a MethodDelegation.
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.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.ForStaticMethod An implementation delegate for a static method delegation.
static class	MethodDelegation.WithCustomProperties A MethodDelegation with custom configuration.
protected static class	SuperMethodCall.Appender An appender for implementing a SuperMethodCall.
class	ToStringMethod An implementation of Object.toString() that concatenates the String representation of all fields that are declared by a class.
protected static class	ToStringMethod.Appender An appender to implement ToStringMethod.
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 and Description
static class	AnnotationAppender.Default A default implementation for an annotation appender that writes annotations to a given byte consumer represented by an ASM AnnotationVisitor.
static class	AnnotationAppender.ForTypeAnnotations A type visitor that visits all type annotations of a generic type and writes any discovered annotation to a supplied AnnotationAppender.
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.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	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 and 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 its Callable.call() or Runnable.run() method is called where the method call proxy implements both interfaces.
static class	MethodCallProxy.AssignableSignatureCall A stack manipulation that creates a MethodCallProxy for a given method an pushes such an object onto the call stack.
protected static class	MethodCallProxy.ConstructorCall.Appender The appender for implementing the MethodCallProxy.ConstructorCall.
protected static class	MethodCallProxy.MethodCall An implementation for a method of a MethodCallProxy.
protected class	MethodCallProxy.MethodCall.Appender The appender for implementing the MethodCallProxy.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's ReflectionFactory.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 a TypeProxy.
protected class	TypeProxy.MethodCall.Appender Implementation of a byte code appender for a TypeProxy.MethodCall.
protected class	TypeProxy.MethodCall.Appender.AccessorMethodInvocation Stack manipulation for invoking an accessor method.
protected static class	TypeProxy.SilentConstruction.Appender The appender for implementing a TypeProxy.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 and Description
static class	MethodDelegationBinder.AmbiguityResolver.Compound A chain of MethodDelegationBinder.AmbiguityResolvers 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 a PrintStream.
protected static class	MethodDelegationBinder.MethodBinding.Builder.Build A method binding that was created by a MethodDelegationBinder.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 given MethodDelegationBinder and an MethodDelegationBinder.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 and 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 the FieldProxy 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 an FieldProxy.Binder.InstanceFieldConstructor.
static class	Morph.Binder A binder for the Morph 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 A TargetMethodAnnotationDrivenBinder.ParameterBinder for binding the Pipe annotation.
protected static class	Pipe.Binder.Redirection An auxiliary type for performing the redirection of a method invocation as requested by the Pipe annotation.
protected static class	Pipe.Binder.Redirection.MethodCall The implementation to implement a Pipe.Binder.Redirection's forwarding method.
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 This MethodDelegationBinder 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 a TargetMethodAnnotationDrivenBinder for performing its actual logic.
static class	TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Bound<T extends 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 Annotation> A parameter binder that binds a fixed value to a parameter annotation when using a MethodDelegation.
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 and 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 of StackManipulations.
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 this ByteCodeAppender.
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 some StackManipulation.
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 and Description
class	InstanceCheck Implements an instanceof 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 and 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 the void 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 and Description
protected class	ArrayAccess.Loader A stack manipulation for loading an array's value.
protected class	ArrayAccess.Putter A stack manipulation for storing an array's value.
class	ArrayFactory A CollectionFactory 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 and Description
protected static class	ClassConstant.ForReferenceType A class constant for a non-primitive Class.
protected static class	DoubleConstant.ConstantPool A stack manipulation for loading a double value from a class's constant pool onto the operand stack.
protected static class	FloatConstant.ConstantPool A stack manipulation for loading a float value from a class's constant pool onto the operand stack.
protected static class	IntegerConstant.ConstantPool A stack manipulation that loads a JVM-integer value from a constant pool value onto the operand stack.
protected static class	IntegerConstant.SingleBytePush A stack manipulation that loads a JVM-integer value by a BIPUSH operation which is legal for single byte integer values.
protected static class	IntegerConstant.TwoBytePush A stack manipulation that loads a JVM-integer value by a SIPUSH operation which is legal for up to two byte integer values.
class	JavaConstantValue A constant representing a JavaConstant.
protected static class	LongConstant.ConstantPool A stack manipulation for loading a long value from a class's constant pool onto the operand stack.
protected static class	MethodConstant.CachedConstructor Represents a cached constructor for a MethodConstant.
class	SerializedConstant A constant that represents a value in its serialized form.
class	TextConstant Represents a String value that is stored in a type's constant pool.

Uses of 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 and 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 and Description
class	AccessibilityMatcher<T extends ByteCodeElement> An element matcher that validates that a given byte code element is accessible to a given type.
class	AnnotationTypeMatcher<T extends AnnotationDescription> An element matcher that matches the type of an annotation description.
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 ClassLoader> An element matcher that matches all ClassLoaders in the matched class loaders hierarchy against a given matcher.
class	ClassLoaderParentMatcher<T extends 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 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 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 ByteCodeElement> 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's TypeDescription.Generic raw type against the given matcher for a TypeDescription.
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	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.Resolved<S> A latent matcher representing an already resolved ElementMatcher.
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 a MethodSortMatcher.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 dots 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 the null value.
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 a StringMatcher.Mode.
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 and Description
static class	TypePool.AbstractBase A base implementation of a TypePool 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 a TypePool that models binary data in the Java byte code format into a TypeDescription.
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 a TypePool.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 a FieldDescription.
static class	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForMethod.Tokenized An implementation of a tokenized resolution of generic types of a MethodDescription.
static class	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForType.Tokenized An implementation of a tokenized resolution of generic types of a TypeDescription.
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.
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 a TypePool.
static class	TypePool.Resolution.Simple A simple resolution that represents a given TypeDescription.

Uses of HashCodeAndEqualsPlugin.Enhance in net.bytebuddy.utility

Classes in net.bytebuddy.utility with annotations of type HashCodeAndEqualsPlugin.Enhance

Modifier and Type	Class and 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 a java.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 the java.lang.invoke.MethodType type that was added in Java version 7.
static class	JavaModule.Dispatcher.Enabled A dispatcher for a VM that does support the java.lang.Module API.
class	StreamDrainer A utility for draining the contents of an InputStream into a byte 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 and Description
class	GetSystemPropertyAction An action for reading a system property as a privileged action.
class	SetAccessibleAction<T extends AccessibleObject> An action for making an AccessibleObject accessible.