All Classes

Class	Description
Accessor	Defines an accessor method in a mixin, the method can be a getter (must return the field type and take no arguments) or a setter (must take an argument of the field type and return void).
AccessorGenerator	Base class for accessor generators
AccessorGeneratorField	Accessor generator for field accessors
AccessorGeneratorFieldGetter	Generator for instance field getters
AccessorGeneratorFieldSetter	Generator for field setters
AccessorGeneratorMethodProxy	Generator for proxy methods
AccessorGeneratorObjectFactory	Generator for factory methods (constructor invokers)
AccessorInfo	Information about an accessor
AccessorInfo.AccessorName	Accessor Name struct
AccessorInfo.AccessorType	Accessor types
ActivityStack	Tracker for processors which want to express their activity stack on crash in a user-readable way.
AfterInvoke	This injection point searches for INVOKEVIRTUAL, INVOKESTATIC and INVOKESPECIAL opcodes matching its arguments and returns a list of insns after the matching instructions, with special handling for methods invocations which return a value and immediately assign it to a local variable.
AfterStoreLocal	This injection point is a companion for the ModifyVariable injector which searches for STORE operations which match the local variables described by the injector's defined discriminators.
AnnotatedMethodInfo	Data bundle for an annotated method in a mixin
Annotations	Utility class for working with ASM annotations
Args	Argument bundle class used in ModifyArgs callbacks.
ArgsClassGenerator	Class generator which creates subclasses of Args to be used by the ModifyArgs injector.
ArgumentCountException	Exception thrown when varargs array passed into Args.setAll(java.lang.Object...) is of a different length than the args
ArgumentIndexOutOfBoundsException	Exception thrown when attempting to set an argument (via) Args which is out of bounds
ASM	Utility methods for determining ASM version and other version-specific shenanigans
At	Annotation for specifying the type of InjectionPoint to use to perform an Inject process.
At.Shift	Shift is used to shift resulting opcodes
BeforeConstant	Special injection point which can be defined by an Constant annotation or using the at code CONSTANT.
BeforeFieldAccess	This injection point searches for GETFIELD and PUTFIELD (and static equivalent) opcodes matching its arguments and returns a list of insns immediately prior to matching instructions.
BeforeFinalReturn	This injection point searches for the last RETURN opcode in the target method and returns it.
BeforeInvoke	This injection point searches for INVOKEVIRTUAL, INVOKESTATIC and INVOKESPECIAL opcodes matching its arguments and returns a list of insns immediately prior to matching instructions.
BeforeInvoke.SearchType	Member search type, the PERMISSIVE search is only used when refmap remapping is enabled.
BeforeLoadLocal	This injection point is a companion for the ModifyVariable injector which searches for LOAD operations which match the local variables described by the injector's defined discriminators.
BeforeNew	This injection point searches for NEW opcodes matching its arguments and returns a list of insns immediately prior to matching instructions.
BeforeReturn	This injection point searches for RETURN opcodes in the target method and returns a list of insns immediately prior to matching instructions.
BeforeStringInvoke	Like BeforeInvoke, this injection point searches for INVOKEVIRTUAL, INVOKESTATIC and INVOKESPECIAL opcodes matching its arguments and returns a list of insns immediately prior to matching instructions.
Bytecode	Utility methods for working with bytecode via ASM
Bytecode.DelegateInitialiser	Information bundle returned from Bytecode.findDelegateInit(org.objectweb.asm.tree.MethodNode, java.lang.String, java.lang.String)
Bytecode.Visibility	Ordinal member visibility level.
CallbackInfo	CallbackInfo instances are passed to callbacks in order to provide information and handling opportunities to the callback to interact with the callback itself.
CallbackInfoReturnable<R>	For callbacks with a non-void return type, a CallbackInfoReturnable is passed to the callback instead to allow the callback to interact with the method return value.
CallbackInjectionInfo	Information about a callback to inject, usually specified by Inject
CallbackInjector	This class is responsible for generating the bytecode for injected callbacks
Cancellable	Interface for things which can be cancelled
CancellationException	Exception thrown when a consumer attemtps to call cancel() on a callback not marked as cancellable.
ClassAlreadyLoadedException	Exception raised when a class was loaded before mixins were able to be applied.
ClassInfo	Information about a class, used as a way of keeping track of class hierarchy information needed to support more complex mixin behaviour such as detached superclass and mixin inheritance.
ClassInfo.FrameData	Information about frames in a method
ClassInfo.SearchType	Search type for the findInHierarchy methods, replaces a boolean flag which made calling code difficult to read
ClassInfo.Traversal	To all intents and purposes, the "real" class hierarchy and the mixin class hierarchy exist in parallel, this means that for some hierarchy validation operations we need to walk across to the other hierarchy in order to allow meaningful validation to occur.
ClassInfo.TypeLookup	When using ClassInfo.forType(org.objectweb.asm.Type, org.spongepowered.asm.mixin.transformer.ClassInfo.TypeLookup), determines whether an array type should be returned as declared (eg.
ClassMetadataNotFoundException	Since it's inconvenient to throw the (checked) ClassNotFoundException this exception can be selectively thrown when ClassInfo.forName(java.lang.String) returns null (indicating class couldn't be loaded or was not found) in situations where we actually care about it failing and want to throw something.
ClassSignature	Represents an object-oriented view of a generic class signature.
Coerce	Usage with callback injectors (@Inject)
CommandLineOptions	Options passed in to Mixin via the command line
CompareUtil	Comparison helpers.
Config	Handle for marshalling mixin configs outside of the transformer package
Constant	Annotation for specifying the injection point for an ModifyConstant injector.
Constant.Condition	Available options for the Constant.expandZeroConditions() setting.
Constants	Miscellaneous shared constants
Constants.ManifestAttributes	Shared Jar Manifest Attributes
ConstraintParser	Parser for constraints
ConstraintParser.Constraint	A constraint.
ConstraintViolationException	Exception thrown when a constraint violation is encountered
ContainerHandleURI	Container handle which directly replaces the use of classpath location URIs from previous mixin versions
ContainerHandleVirtual	A virtual container, used to marshal other containers around
Counter	Mutable integer for use in collections
Debug	Anotation used to decorate items you might wish to examine after mixin application.
Dynamic	Decorator annotation for mixin elements whose targets are not available in the original class and are either fabricated or transformed at runtime.
ElementNode<TNode>	Holder for FieldNode and MethodNode for consumers which can handle both types (since they have a lot in common), with common accessors for overlapping properties.
ExtensionCheckClass	Mixin transformer module which runs CheckClassAdapter on the post-mixin bytecode
ExtensionCheckClass.ValidationFailedException	Exception thrown when checkclass fails
ExtensionCheckInterfaces	Checks whether interfaces declared on mixin target classes are actually fully implemented and generates reports to the console and to files on disk
ExtensionClassExporter	Debug exporter
Extensions	Mixin transformer extensions and common modules such as class generators
Final	This annotation has two uses: On an Shadow field, it can be used to raise an error-level log message if any write occurrences appear in the mixin bytecode.
GlobalProperties	Access to underlying global property service provided by the current environment
GlobalProperties.Keys	Global property keys
Group	This annotation can be used on any injector callback to define a value for total required injections across multiple callbacks.
IClassBytecodeProvider	Interface for object which can provide class bytecode
IClassGenerator	Base interface for class generators
IClassProvider	Interface for marshal object which can retrieve classes from the environment
IClassReferenceMapper
IClassTracker	Class trackers are responsible for interacting with the class loading process to for the purposes of tracking class load activity and class load restrictions.
IConsumer<TItem>	No Java 8 here but I need this interface
IContainerHandle	Interface for container handles.
IDecompiler	Interface to allow the actual decompiler to be loaded on-demand
IEnvironmentTokenProvider	Provides a token value into the attached environment
IExtension	Mixin Transformer extension interface for pre- and post-processors
IExtensionRegistry	Interface for the mixin Extensions registry
IGlobalPropertyService	Global property service
IHotSwap	Interface to allow the hot-swap agent to be loaded on-demand
IInjectionPointContext	Context for an injection point, used to access the mixin as well as the owner method and annotation for the injection point
ILegacyClassTransformer	Adapter interface for legacy class transformers.
IllegalClassLoadError	Error thrown when a class defined in a mixin package is classloaded
IMapping<TMapping>	Base class for member mapping entries
IMapping.Type	Type of mapping
IMessageSink	Interface for generic message consumers
IMixinAuditTrail	Audit trail is responsible for logging activities during mixin application to target classes for use as debugging information later on.
IMixinConfig	Interface for loaded mixin configurations
IMixinConfigPlugin	A companion plugin for a mixin configuration object.
IMixinConnector	A connector class is a bootstrap agent for a mixin consumer.
IMixinContext	Context for performing reference mapping
IMixinErrorHandler	Interface for objects which want to perform custom behaviour when fatal mixin errors occur.
IMixinErrorHandler.ErrorAction	Action to take when handling an error.
IMixinInfo	Interface for MixinInfo, used in extensibility API
IMixinPlatformAgent	Base interface for platform agents.
IMixinPlatformAgent.AcceptResult	Result type returned from IMixinPlatformAgent.accept(org.spongepowered.asm.launch.platform.MixinPlatformManager, org.spongepowered.asm.launch.platform.container.IContainerHandle)
IMixinPlatformServiceAgent	Service agents provide additional platform-specific extensions leveraged by mixin services.
IMixinService	Mixin Service interface.
IMixinServiceBootstrap	Bootstrap interface for Mixin services.
IMixinTransformer	Transformation engine
Implements	Pseudo-implements decorator for Mixins with conflicting methods in a superclass to soft-implement an interface
Inject	Specifies that this mixin method should inject a callback (or callbacks) to itself in the target method(s) identified by Inject.method().
InjectionError	Error to throw for critical injection problems
InjectionInfo	Contructs information about an injection from an Inject annotation and allows the injection to be processed.
InjectionInfo.AnnotationType	Decoration for subclasses which indicates the injector annotation that the subclass handles
InjectionInfo.HandlerPrefix	Decoration for subclasses which specifies the prefix to use when conforming annotated handler methods
InjectionNodes	Used to keep track of instruction nodes in a Target method which are targetted by various types of injector.
InjectionNodes.InjectionNode	A node targetted by one or more injectors.
InjectionPoint	Base class for injection point discovery classes.
InjectionPoint.AtCode	Injection point code for At annotations to use
InjectionPoint.RestrictTargetLevel	Target restriction level for different injection point types when used by restricted injectors (eg.
InjectionPoint.Selector	Selector type for slice delmiters, ignored for normal injection points.
InjectionPointData	Data read from an At annotation and passed into an InjectionPoint ctor
InjectionValidationException	Thrown when an injector group fails an injection check
Injector	Base class for bytecode injectors
Injector.InjectorData	Redirection data bundle base.
Injector.TargetNode	A nominated target node
InjectorGroupInfo	Information store for injector groups
InjectorGroupInfo.Map	Storage for injector groups
InjectorTarget	Couples method slices to a Target for injection purposes.
InsnFinder	Utility class for finding instructions using static analysis
Interface	This annotation is used to define information for a soft-implemented interface.
Interface.Remap	Describes the remapping strategy applied to methods matching this interface.
InterfaceInfo	Information about an interface being runtime-patched onto a mixin target class, see Implements
Intrinsic	This annotation allows fine-tuning of the overwrite policy for a soft-implemented interface member method.
InvalidAccessorException	Thrown when an accessor fails a state check
InvalidConstraintException	Exception thrown when a constraint declaration is invalid
InvalidImplicitDiscriminatorException	Thrown when an implicit discriminator (no args) fails to identify a unique candidate.
InvalidInjectionException	Thrown when an injector fails a state check, for example if an injector handler signature is invalid, an invalid opcode is targetted, etc.
InvalidInjectionPointException	Thrown when an injection point cannot be parsed due to invalid data
InvalidInterfaceMixinException	Exception thrown for bad states when parsing/loading interface mixins
InvalidMemberDescriptorException	Thrown when a MemberInfo fails basic syntax validation
InvalidMixinException	Thrown by the mixin validator when a mixin fails a pre-flight check
InvalidSelectorException	Exception to be thrown from ITargetSelector.validate() when a target selector fails verification
InvalidSliceException	Thrown when an injector slice fails a state check, for example if a slice selector fails or a slice is negative in size
InvokeInjector	Base class for injectors which inject at method invokes
Invoker	Defines an invoker method (also known as a proxy method in a mixin, the method.
IPropertyKey	Marker interface for property keys
IReferenceMapper	Interface for reference mapper objects
IRemapper	Interface for remap chain participants
ISliceContext	Context for a slice declaration
ISyntheticClassInfo	Interface for information bundle about a synthetic class provided by Mixin.
ISyntheticClassRegistry	Registry for synthetic classes, used internally to track which classes need to be generated at runtime by the mixin pipeline.
ITargetClassContext	Interface for target classes passed into transformer modules via IExtension
ITargetSelector	Target Selectors are used to identify target members in a class, with the criteria for selection being specified in a single string, effectively defining the query parameters.
ITargetSelectorByName	A target selector which selects elements directly by name.
ITargetSelectorConstructor	A target selector which can identify constructor types
ITargetSelectorRemappable	A target selector which can be remapped at compile time via an obfuscation service
ITokenProvider	Agent which can supply token values to a ConstraintParser.Constraint.
ITransformer	Base interface for transformer types
ITransformerProvider	Interface for interacting with transforming classloaders.
ITreeClassTransformer	Adapter interface for tree class transformers.
JavaVersion	Small helper to resolve the current java version
JumpInsnPoint	This injection point searches for JUMP opcodes (if, try/catch, continue, break, conditional assignment, etc.) with either a particular opcode or at a particular ordinal in the method body (eg.
LocalCapture	Specifies the behaviour for capturing local variables at an injection point.
Locals	Utility methods for working with local variables using ASM
LocalVariableDiscriminator	Encapsulates logic for identifying a local variable in a target method using 3 criteria: ordinal, index and name.
LocalVariableDiscriminator.Context	Discriminator context information, wraps all relevant information about a target location for use when performing discrimination
LVTGeneratorError	Exception thrown when something goes horribly wrong whilst summoning the antichrist generating the LVT for a target method.
MainAttributes	"Main" attribute cache for a URI container, mainly to avoid constantly opening jar files just to read odd values out of the manifest.
MappingField	Stores information about a field mapping during AP runs
MappingFieldSrg	An SRG field mapping
MappingMethod	Stores information about a method mapping during AP runs
MatchResult	Result of a target selector match operation which describes the type of match.
MemberInfo	Target selector, also used as a general-purpose information bundle about a member (method or field) parsed from a String token in another annotation, this is used where target members need to be specified as Strings in order to parse the String representation to something useful.
MemberRef	Reference to a field or method that also includes invocation instructions.
MemberRef.Field	A static reference to a field backed by field get/put instruction
MemberRef.Handle	A reference to a field or method backed by a method handle
MemberRef.Method	A static reference to a method backed by an invoke instruction
MessageRouter	Logging router for objects which may need to log messages during standard runtime or during Annotation Processor sessions.
MethodHead	This injection point simply returns the first instruction in the target method body, allowing the injection to be placed at the "head" of the target method.
MethodMapper	Maintains method remaps for a target class
MethodNodeEx	MethodNode with some extra convenience functionality
MethodSlice	Stores information about a defined method slice for a particular injector.
MethodSlices	Represents a collection of MethodSlices, mapped by ID.
MethodVisitorEx	MethodVisitor with some extra convenience functionality
Mixin	Decorator for mixin classes
MixinApplicatorException	Exception thrown for errors during mixin application
MixinApplyError	Error to throw for required mixins when mixing of the mixin fails
MixinBootstrap	Bootstraps the mixin subsystem.
MixinClassGenerator	Handles delegation of class generation tasks to the extensions
MixinClassWriter	ClassWriter which resolves common superclasses using Mixin's metadata instead of calling Class.forName
MixinConnectorManager	Manager for Mixin containers bootstrapping via IMixinConnector
MixinContainer	A collection of IMixinPlatformAgent platform agents) for a particular container
MixinEnvironment	The mixin environment manages global state information for the mixin subsystem.
MixinEnvironment.CompatibilityLevel	Operational compatibility level for the mixin subsystem
MixinEnvironment.CompatibilityLevel.LanguageFeature	Bitmask values for language features supported
MixinEnvironment.Option	Mixin options
MixinEnvironment.Phase	Environment phase, deliberately not implemented as an enum
MixinEnvironment.Side	Represents a "side", client or dedicated server
MixinError	An internal error in mixin, not an invalid mixin or user state, but something wrong in Mixin's state which isn't the user's fault
MixinException	Base class for all mixin processor exceptions
MixinInitialisationError	Error raised when mixin subsystem initialisation fails
MixinInner	Decoration annotation used by the mixin inner class generator to mark inner classes which have been generated from an existing inner class in a mixin
MixinMerged	For internal use only! Contains small parts.
MixinPlatformAgentAbstract	Platform agent base class
MixinPlatformAgentDefault	Default platform agent, handles the mixin manifest keys such as MixinConfigs and MixinTokenProviders.
MixinPlatformManager	Handler for platform-specific behaviour required in different mixin environments.
MixinPrepareError	Error to throw for required configs when initialising of the config fails
MixinPreProcessorException	Exception indicating a problem during pre-processing
MixinProcessor	Heart of the Mixin pipeline
MixinProxy	Decoration annotation used by postprocessor to mark methods which have had their contents replaced with a proxy.
MixinReloadException	An exception that occurs when a mixin reloads and does something it is normally allowed to do but isn't due to reloading restrictions.
MixinRenamed	Internal use only.
Mixins	Entry point for registering global mixin resources.
MixinService	Provides access to the service layer which connects the mixin transformer to a particular host environment.
MixinServiceAbstract	Mixin Service base class
MixinTargetAlreadyLoadedException	Exception thrown when a specified mixin target was already classloaded.
MixinTargetContext	This object keeps track of data for applying a mixin to a specific target class during a mixin application.
MixinTransformerError	Error to throw for things which really shouldn't happen
MixinVerifier	Verifier which handles class info lookups via ClassInfo
ModifyArg	Specifies that this mixin method should inject an argument modifier to itself in the target method(s) identified by ModifyArg.method().
ModifyArgInjectionInfo	Information about a ModifyArg injector
ModifyArgInjector	A bytecode injector which allows a single argument of a chosen method call to be altered.
ModifyArgs	Specifies that this mixin method should inject an multi-argument modifier callback to itself in the target method(s) identified by ModifyArgs.method().
ModifyArgsInjectionInfo	Information about a ModifyArgs injector
ModifyArgsInjector	A bytecode injector which allows a single argument of a chosen method call to be altered.
ModifyConstant	Specifies that this mixin method should inject a constant modifier callback to itself in the target method(s) identified by ModifyConstant.method() at the specified LDC (or specialised const opcode) instruction in order to adjust the constant value returned.
ModifyConstantInjectionInfo	Information about a constant modifier injector
ModifyConstantInjector	A bytecode injector which allows a specific constant value to be identified and replaced with a callback
ModifyVariable	Specifies that this mixin method should inject a variable modifier callback to itself in the target method(s) identified by ModifyVariable.method().
ModifyVariableInjectionInfo	Information about a ModifyVariable injector
ModifyVariableInjector	A bytecode injector which allows a single local variable in the target method to be captured and altered.
Mutable	Use in conjunction with Final or Accessor to indicate that whilst a target field is final in the target class, mutation within the mixin is intentional.
ObfuscationUtil	Utility methods for obfuscation tasks
ObfuscationUtil.IClassRemapper	Interface for remapper proxies
Overwrite	Annotation used to indicate a mixin class member which must overwrite a method in the target class.
PrettyPrinter	Prints information in a pretty box
PrettyPrinter.Alignment	Table column alignment
PrettyPrinter.IPrettyPrintable	Interface for object which supports printing to pretty printer
Profiler	Performance profiler for Mixin.
Pseudo	A Mixin marked as Pseudo is allowed to target classes which are not available at compile time and may not be available at runtime.
Redirect	Specifies that this mixin method should redirect the specified method call, field access or object construction (via the new keyword) to the method decorated with this annotation.
RedirectInjectionInfo	Information about a redirector injector
RedirectInjector	A bytecode injector which allows a method call, field access or new object creation to be redirected to the annotated handler method.
ReEntranceLock	Re-entrance semaphore used to share re-entrance data with the metadata service
ReEntrantTransformerError	Error thrown when transformer re-entrance is detected
ReferenceMapper	Stores runtime information allowing field, method and type references which cannot be hard remapped by the reobfuscation process to be remapped in a "soft" manner at runtime.
RemapperChain	Mixin environment remapper chain.
RemappingReferenceMapper	This adapter is designed to apply the same remapping used elsewhere in the development chain (RemapperChain) to reference maps.
ServiceInitialisationException	Exception thrown when a service fails during initialisation, expected if the service is missing a dependency or is attempting to boot in an incompatible environment
ServiceNotAvailableError	Error to throw when no service is available in the current environment
ServiceVersionError	Error to throw when loaded service is out of date or mismatched
Shadow	Used to indicate a Mixin class member which is acting as a placeholder for a method or field in the target class
SignaturePrinter	Generates callback signature for callback pretty-print
Slice	A Slice identifies a section of a method to search for injection points.
SoftOverride	Decorator for methods which override a method in a supermixin which the containing mixin does not directly extend
SourceMap	Structure which contains information about a SourceDebugExtension SMAP
SourceMap.File	Defines a source code file within a source map stratum
SpecialMethodInfo	Information about a special mixin method such as an injector or accessor
Surrogate	Annotation used to decorate surrogate injector methods.
SyntheticBridgeException	Exception thrown when comparing two synthetic bridge methods fails, thrown with the corresponding problem and functionality to support debugging when verbosity is enabled.
SyntheticBridgeException.Problem	Problem types for synthetic bridge comparisons
SyntheticClassInfo	Information bundle about a synthetic class provided by Mixin
Target	Information about the current injection target, mainly just convenience rather than passing a bunch of values around.
TargetNotSupportedException	Exception thrown when target selector is not valid for the supplied target context during ITargetSelector.attach(org.spongepowered.asm.mixin.refmap.IMixinContext)
TargetSelector	Utility class for parsing selectors
TargetSelector.Result<TNode>	Query result struct
TreeTransformer	Base class for transformers which work with ASM tree model
Unique	This annotation, when applied to a member method or field in a mixin, indicates that the member should never overwrite a matching member in the target class.
VersionNumber	Represents a software version number in major.minor.revision.build format as a sequence of four shorts packed into a long.