All Classes and Interfaces
Class
Description
Signal that a process was aborted before completion.
Basic "common"
CacheBacking implementationUseful "common" functionality for caching to files
Uses an
index file to keep track of the cached entriesThe default index entry in the index file
Implements common functions to be used across ISignaturePatterns.
Runtime representation of an advice declaration inside an aspect
The different kinds of advice in AspectJ
The five kinds of advice in AspectJ.
Used to annotated code-style advice to name it
Name is used by reflection api if present, may in future be used in adviceexecution() pcd.
After finally advice
After returning advice
After throwing advice
Java 1.5 preMain agent to hook in the class pre processor
Can be used with -javaagent:aspectjweaver.jar
Adapter between the generic class pre processor interface and the AspectJ weaver Load time weaving consistency relies on
Bcel.setRepository
These attributes are written to and read from .class files (see the JVM spec).
Synthetic members should have NO advice put on them or on their contents.
internal representation of declare annotation statement, used by reflect api
The AjcMemberMaker is responsible for creating the representations of methods/fields/etc that are placed in both aspects and
affected target types.
The runtime representation of a type (Aspect, Class, Interface, Annotation, Enum, or Array) in an AspectJ
program.
This is the anchor for the AspectJ runtime type system.
Represents the AND of two other signature patterns.
left && right
Represents any element that may have annotations
Represents access to an annotation on an element, relating to some kinded pointcut.
Simple representation of an annotation that the weaver can work with.
This attribute is attached to a method and indicates the default
value for an annotation element.
Represents adding an annotation to a type
(at)Annotation((at)Foo) or (at)Annotation(foo)
A TypeSafeEnum similar to the Java5 ElementType Enum
This type represents a type pattern of '*' but with an annotation specified, e.g.
args(arguments)
Around advice
Represents a resolved array type
Denotes array type, such as int[][]
Determines if a version of asm is around that will enable us to add stack map attributes to classes that we produce.
The Abstract Structure Model (ASM) represents the containment hierarchy and crosscutting structure map for AspectJ programs.
A ModelInfo object captures basic information about the structure model.
Provides utility methods for generating details for IProgramElements used when creating the model both from source (via
AsmElementFormatter.visit(..)) and when filling in the model for binary aspects (via AsmRelationshipProvider bug 145963)
Aspect declaration
Used to represent a variable reference to an aspect instance.
Handles generic aspectOf method when those are not available in the aspects but added later on
thru load time weaving.
For users working on a level of Java prior to Java5, Aspects14 handles generic aspectOf methods when they
are not available in the aspects but added later on through load time weaving.
Uses a background thread to do the actual I/O and for caching "persistence"
so that the caching works faster on repeated activations of the application.
Represents an asynchronous command that can be sent to the
AsynchronousFileCacheBacking instance to be executed
on it asynchronouslyBase class for
AsynchronousFileCacheBacking.AbstractCommands that refer to a cache keyAnnotation defined aspect reader.
LazyResolvedPointcutDefinition lazyly resolve the pointcut so that we have time to register all pointcut referenced before
pointcut resolution happens
Abstract super class for Attribute objects.
Denotes basic type such as int.
Looks for all access to method or field that are not public within the body of the around advices and replace the invocations to
a wrapper call so that the around advice can further be inlined.
Wraps a Bcel Annotation object and uses it to answer AnnotationAJ method calls.
XXX Erik and I need to discuss this hierarchy.
This type munger will modify a given class (see the munge() method) to include a field representing a CflowCounter object.
An implementation of the constant pool reader that speaks Bcel.
XXX Erik and I need to discuss this hierarchy.
A utility class that assists in unpacking constituent parts of generic signature attributes and returning their equivalents in
UnresolvedType world.
Adds aspectOf(), hasAspect() etc to the annotation defined aspects
Wraps a reference to a classloader inside a WeakReference.
Bcel implementation of the weaving support required in a BcelWorld which will actually modify bytecode.
Exception to use inside the bcweaver.
Before advice
Represents an attempt to bind the field of an annotation within a pointcut.
Marker interface for BindingTypePattern and BindingAnnotationTypePattern
BindingScope that knows the enclosingType, which is needed for pointcut reference resolution
Represents the BootstrapMethods attribute in Java 7 classes.
A BoundedReferenceType is the result of a generics wildcard expression ? extends String, ? super Foo etc..
BranchHandle is returned by specialized InstructionList.append() whenever a BranchInstruction is appended.
Utility class that implements a sequence of bytes which can be read
via the `readByte()' method.
Interface for the backing to the cache; usually a file,
but could be an in-memory backing for testing.
Represents a class which has been cached
A typed reference to a cached class entry.
Facility for overriding the default CacheKeyResolver
and CacheBacking; an implementing factory must be set
on the
WeavedClassCache before the
WeavingAdaptor is
configured.Interface to allow alternate hashing schemes for weaved and
generated classes.
Maintains some basic statistics on the class cache.
Taken from org.aspectj.org.eclipse.jdt.core.compiler.CharOperation
Representation of a shadow munger for a declare error or warning declaration.
Thrown when the BCEL attempts to read a class file and determines
that the file is malformed or otherwise cannot be interpreted as a
class file.
Template class for building up a java class.
Thrown on internal errors.
Implementors should provide access to a ClassLoader instance.
The repository maintains information about which classes have been loaded.
Wrapper class that parses a given Java .class file.
Responsible for loading (class) files from the CLASSPATH.
Contains information about file/ZIP entry of the Java class.
Generic class pre processor interface that allows to separate the AspectJ 5 load time weaving from Java 5 JVMTI interfaces for
further use on Java 1.3 / 1.4
Java 1.5 adapter for class pre processor
Interface to make use of the Visitor pattern programming style.
This class represents a chunk of Java byte code contained in a method.
This class represents an entry in the exception table of the Code
attribute and is used only there.
This class represents an exception handler, i.e., specifies the region where
a handler is active and an instruction where the actual handling is done.
Provide code generation hints to the compiler (e.g.
This class is responsible for tracking progress through the various phases of compilation and weaving.
A variation of a DataOutputStream that is linked to a constant pool writer.
Generates bytecode for concrete-aspect.
Abstract superclass for classes to represent the different constant types in the constant pool of a class file.
This class is derived from the abstract Constant class and
represents a reference to a (external) class.
Abstract super class for Fieldref and Methodref constants.
This class is derived from the abstract Constant class and
represents a reference to a Double object.
This class is derived from the abstract Constant class and
represents a reference to the name and signature of a field or method.
This class represents a constant pool reference to a field.
This class is derived from the abstract Constant class and
represents a reference to a float object.
This class is derived from the abstract Constant class and
represents a reference to an int object.
This class represents a constant pool reference to an interface method.
This class is derived from the abstract Constant class and
represents a reference to the name and signature of a field or method.
This class is derived from the abstract Constant class and
represents a reference to a long object.
This class is derived from the abstract Constant class and
represents a reference to the name and signature of a field or method.
This class represents a constant pool reference to a method.
This class is derived from the abstract Constant class and
represents a reference to the name and signature of a field or method.
Represents a module.
This class is derived from the abstract Constant class and
represents a reference to the name and signature of a field or method.
This interface denotes those constants that have a "natural" value, such as ConstantLong, ConstantString, etc..
Represents a module.
This class represents the constant pool, i.e., a table of constants, of a parsed classfile.
Used during attribute reading to decode constant pool references.
Used during attribute writing to encode common strings/etc as constant pool references.
Constants for the project, mostly defined in the JVM specification.
Some useful weaver constants.
Carries information about major, minor and preview-minor version byte values found in Java class files for a
specific Java version.
This class is derived from the abstract Constant class and
represents a reference to a String object.
This class is derived from the abstract Constant class and
represents a reference to a Utf8 encoded string.
This class is derived from Attribute and represents a constant value, i.e., a default value for initializing a class
field.
Pointcut expression interface for pointcut
expressions returned by a
PointcutDesignatorHandler.
When an entry is added to the CompilationAndWeavingContext stack,
a ContextToken is returned.
Wrap an IMessageHandler to count messages handled.
This holds on to all members that have an invasive effect outside of there own compilation unit.
This holds on to all CrosscuttingMembers for a world.
This interface is introduced to support tools like PointcutDoctor.
The AspectJ runtime representation of a declare annotation member in an aspect.
Represents a declare annotation statement, one of atField, atMethod, atConstructor or atType.
Captures type of declare annotation (method/type/field/constructor)
AspectJ runtime representation of a declare error or declare warning member
in an aspect.
DeclareMixin annotation - see design and usage in https://bugs.eclipse.org/bugs/show_bug.cgi?id=266552
Declare parents mixin annotation
A declare parents member defined inside an aspect
Constructed based on an @DeclareMixin being found in an aspect.
Aspect precedence declaration
AspectJ runtime representation of a declare precedence statement as
declared in an aspect.
AspectJ runtime representation of a declare soft member within an aspect.
For a declare error/warning that specified a type pattern rather than a pointcut.
Default factory for creating the backing and resolving classes.
Naive default class and classloader hashing implementation useful
for some multi-classloader environments.
Simplistic ClassLoaderReference that merely delegates to a classloader.
Naive File-Backed Class Cache with no expiry or application
centric invalidation.
Default implementation of MatchingContext, backed
by a Map.
Use in non-OSGi environment
When a Java15ReflectionBasedDelegate gets the pointcuts for a given class it tries to resolve them before returning.
A POJO that contains raw strings from the XML (sort of XMLBean for our simple LTW DTD)
This class is derived from Attribute and denotes that this is a deprecated method.
This attribute exists for local or
anonymous classes and ...
Represents an attempt to bind the field of an annotation within a pointcut.
Matches an annotation of a given type
Exception constants.
exceptionRanges are set initially to be low priority.
This class represents the table of exceptions that are thrown by a method.
Special kind of privileged access munger which exposes a type to be public.
For implementing declare @type interacting with declare @parents during compilation - we need to be able to add an annotation to
'binary type binding' (this is how types are seen during incremental compilation).
Represents a type that pointcuts may match.
This class represents the field info structure, i.e., the representation for a variable in the class.
Template class for building up a field.
Super class for FieldGen and MethodGen objects, since they have some methods in common!
Super class for the GET/PUTxxx family of instructions.
Abstract super class for fields and methods.
Super class for InvokeInstruction and FieldInstruction, since they have some methods in common!
A pipe when run reads from an input stream to an output stream, optionally sleeping between reads.
Uses a "flat" files model to store the cached instrumented classes
and aspects - i.e., each class/aspect is stored as a separate (binary)
file.
A marker class for bindings for which we want to ignore unbound issue and consider them as implicit binding - f.e.
This class implements boolean that include a "maybe"
This class implements a boolean that includes a "maybe"
Handler for generated classes; such as Shadowed closures, etc.
Interface implemented by weaving class loaders to allow classes generated by
the weaving process to be defined.
A delegate that can sit in the ReferenceType instance created for an aspect generated from aop.xml.
Encapsulate generic signature parsing
structure holding a parsed class signature
structure capturing a FormalTypeParameter from the Signature grammar
This interface exists to support two different strategies for answering
generic signature related questions on Java 5 and pre-Java 5.
Parses the generic signature attribute as defined in the JVM spec.
Uses "typesafe enum" pattern.
This is a kind of KindedPointcut.
pr354470.
An IClassWeaver is initialized with a class (a type, really, but let's ignore that for now) and a world, and has one method that
actually weaves the contents of the world into the class implementation.
Command wrapper with collecting parameter for messages.
Clients can pass a single cross-reference handler to the weaver on construction of a BcelWorld.
Adapter used to uniquely identify program element handles.
Compiler listeners get notified of structure model update events.
IINC - Increment local variable by constant
Interface that can be implemented by MessageHandlers that need to
perform some additional processing when a build is starting and
when it has finished.
Wrap message with any associated throwable or source location.
Handle messages, logging and/or aborting as appropriate.
Hold and query a collection of messages.
When dumping the model out (for debugging/testing), various parts of it can be passed through this filter.
Signature for static and instance initializers.
This class represents a inner class attribute, i.e., the class indices of the inner and outer classes, the name and the
attributes of the inner class.
This class is derived from Attribute and denotes that this class is an Inner class of another.
Abstract super class for all Java byte codes.
Abstract super class for branching instructions like GOTO, IFEQ, etc..
Instruction that needs one byte
A small subclass of the local variable accessing instruction class InstructionLV - this subclass does
not allow the index to be altered.
This interface contains shareable instruction objects.
Class for instructions that use an index into the constant pool such as LDC, INVOKEVIRTUAL, etc.
Instances of this class may be used, e.g., to generate typed versions of instructions.
Instances of this class give users a handle to the instructions contained in an InstructionList.
This class is a container for a list of Instruction objects.
Abstract super class for instructions dealing with local variables.
Select - Abstract super class for LOOKUPSWITCH and TABLESWITCH instructions.
Instruction that needs one short
Denote that a class targets InstructionHandles within an InstructionList.
Interface implementing the Visitor pattern programming style.
Runtime representation of an inter-type constructor member declared within an
aspect.
Represents an inter-type method, field, or constructor declared in an aspect.
Represents an inter-type field declaration declared in an aspect.
Represents an inter-type method declaration member within an aspect.
INVOKEDYNAMIC
Super class for the INVOKExxx family of instructions.
INVOKEINTERFACE - Invoke interface method
Represents program elements in the AspectJ containment hierarchy.
Uses "typesafe enum" pattern.
Uses "typesafe enum" pattern.
Uses "typesafe enum" pattern.
Used to give progress information typically to IDEs
A relationship has a name (e.g.
Maps from a program element handles to a list of relationships between that element and other program elements.
Represent source location as a starting line/column and ending line in a source file.
Abstraction of a structure model
A filter represents a mapping function from Iterator to Iterator
A getter represents a mapping function from Object to Iterator
History: 246125
Implementors provide a 'verify()' method that is invoked at the end of type
binding completion.
This class adds support to AspectJ for an OSGi environment
Encapsulates operations that a world will need to support if it is actually going to modify bytecode rather than just match
against it.
Under JDK 1.4 or lower, we can't give generic signature info...
Uses Java 1.5 reflection APIs to determine generic signatures
Provides Java 5 behaviour in reflection based delegates (overriding 1.4 behaviour from superclass where
appropriate)
Represents a Java class, i.e., the data structures, constant pool, fields, methods and commands contained in a Java .class file.
Handles the translation of java.lang.reflect.Type objects into AspectJ UnresolvedTypes.
Creates JDT-like handles, for example
method with string argument:
<tjp{Demo.java[Demo~main~\[QString;
method with generic argument: <pkg{MyClass.java[MyClass~myMethod~QList\<QString;>;
aspect: <pkg*A1.aj}A1
advice with Integer arg: <pkg*A8.aj}A8&afterReturning&QInteger;
method call: <pkg*A10.aj[C~m1?method-call(void pkg.C.m2())
Provides reflective access to both the state available at a join point and
static information about it.
This helper object contains only the static information about a join point.
Iterates over the signatures of a join point, calculating new signatures lazily to minimize processing and to avoid unneccessary
"can't find type" errors.
Handle an external process asynchrously.
check if input contains any packages to elide.
Lazy lazy lazy.
A LazyMethodGen should be treated as a MethodGen.
This class represents a (PC offset, line number) pair, i.e., a line number in the source that corresponds to a relative address
in the byte code.
This class represents a line number within a method, i.e., give an instruction
a line number corresponding to the source code line.
This class represents a table of line numbers for debugging purposes.
we don't actually target instructions, but instructions target us.
This class represents a local variable within a method.
This class represents a local variable within a method.
This class represents collection of local variables in a method.
LOOKUPSWITCH - Switch with unordered set of values
When extending AspectJ's pointcut parsing and
matching with custom PointcutDesignatorHandlers,
it may be necessary to match based on context information
at a join point not exposed simply by java.lang.reflect
member information or argument values.
Test that uses MatchingContext to match (or not)
Abstract representation of a member (field/constructor/method) within a type.
Common utility methods for members.
Implement messages.
This handler accumulates messages.
Convenience API's for constructing, printing, and sending messages.
parameterize rendering behavior for messages
An IMessageHandler implementation that writes all to a PrintWriter.
This class represents the method info structure, i.e., the representation for a method in the class.
Type munger for annotation style ITD declare parents.
Template class for building up a method.
When we try to resolve a type in the world that we require to be present, and then fail to find it, we return an instance of this
class.
Super class for all objects that have modifiers like private, final, ...
This class is derived from Attribute and represents the module
information captured in a class file.
Indicates the main class of a module.
Indicates all the packages of a module that are exported or opened by the module attribute.
MULTIANEWARRAY - Create new mutidimensional array of references
Common super type for Pointcuts that can bind formal parameters.
https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.7.28
https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.7.29
Code that created version one style ITD type mungers will be using direct field access from the dispatchers
Weaver representation of an intertype declared member class.
Thrown by the
aspectOf special method on aspect types
when there is no aspect of that type currently bound.Denote class to have an accept method();
The repository maintains information about which classes have been loaded.
Thrown when AjType.getDeclaredAdvice is called with an advice name and no matching
advice declaration can be found.
Thrown when AjType.getDeclaredPointcut is called with a pointcut name, and no
matching pointcut declaration can be found.
Represents the NOT of a signature pattern
!TypePattern
Denotes reference such as java.lang.String.
A class that hanldes LTW options.
Represents the OR of two other signature patterns.
left || right
This class implements a partial order
It includes routines for doing a topo-sort
All classes that want to be part of a partial order must implement PartialOrder.PartialComparable.
A Pointcut or TypePattern visitor
AspectJ runtime representation of the per-clause associated with an aspect.
The different per-clauses (aspect instantiation models)
supported by AspectJ
A visitor that turns a pointcut into a type pattern equivalent for a perthis or pertarget matching: - pertarget(target(Foo)) →
Foo+ (this one is a special case..) - pertarget(execution(* Foo.do()) → Foo - perthis(call(* Foo.do()) → * - perthis(!call(*
Foo.do()) → * (see how the ! has been absorbed here..)
Pointcut declaration
AspectJ runtime representation of a pointcut member inside a class or aspect.
The lifecycle of Pointcuts is modeled by Pointcut.State.
Representation of a pointcut based per-clause associated with an aspect
(perthis/target/cflow/cflowbelow)
The PointcutDesignator interface allows extension of the
AspectJ pointcut language so that third-party tools integrating
with AspectJ can add easily their own custom
domain-specific designators and have them interoperate seamlessly
with the standard AspectJ designators.
Implementation of Pointcut that is backed by a user-extension pointcut designator handler.
Represents an anonymous pointcut expression as used in pointcuts, advice declarations,
declares, and per-clauses
Represents an AspectJ pointcut expression and provides convenience methods to determine
whether or not the pointcut matches join points specified in terms of the
java.lang.reflect interfaces.
Map from weaver.tools interface to internal Pointcut implementation...
A PointcutParser can be used to build PointcutExpressions for a user-defined subset of AspectJ's pointcut language
An enumeration of the different kinds of pointcut primitives
supported by AspectJ.
Performs term rewriting for pointcut expressions.
Walks a pointcut and determines if the synchronization related designators have been used: lock() or unlock()
A privileged access munger is for handling privileged access to a member.
ProceedingJoinPoint exposes the proceed(..) method in order to support around advice in @AJ aspects
Super class for object and array types.
A reference type represents some 'real' type, not a primitive, not an array -
but a real type, for example java.util.List.
Abstraction over a type - a reference type is Object or a descendant of Object, other types (int/etc) are considered primitive
types.
Subtype of ResolvedMemberImpl used in reflection world.
An implementation of FastMatchInfo that can also expose a MatchingContext.
A variable at a reflection shadow, used by the residual tests.
A ReflectionWorld is used solely for purposes of type resolution based on the runtime classpath (java.lang.reflect).
The repository maintains informations about class interdependencies, e.g., whether a class is a sub-class of another.
Abstract definition of a class repository.
Can be specified on an aspect to ensure that particular types must be accessible before
the aspect will be 'activated'.
Carries an array of unresolved types - will resolve them on demand.
Represent a resolved member.
This is an abstraction over method/field introduction.
RET - Return from subroutine
Returnaddress, the type JSR or JSR_W instructions push upon the stack.
Captures important runtime versions.
A scope that also considers type variables when looking up a type.
A type-safe enum representing the kind of shadows
The result of asking a PointcutExpression to match at a shadow (method execution,
handler, constructor call, and so on).
For every shadow munger, nothing can be done with it until it is concretized.
This class is derived from Attribute and represents a reference to a invalid input: '<'href="https://wwwipd.ira.uka.de/~pizza/gj/">GJ
attribute.
Represents the signature at a join point.
AspectJ runtime representation of a signature pattern as used in various
aspect members (for example, declare @method, declare @field).
Basic implementation of signature pattern
This class has been created to avoid deadlocks when instrumenting SAXParser.
Copyright (c) 2012 Contributors.
Wrapper for checked exceptions matched by a 'declare soft'.
This class is derived from Attribute and represents a reference to the source file of this class.
Immutable source location.
For defining code, the class defined and location in a source file.
This class represents a stack map attribute used for preverification of Java classes for the
Java 2 Micro Edition (J2ME).
Uses asm to add the stack map attribute to methods in a class.
This class represents a stack map entry recording the types of
local variables and the the of stack items at a given byte code offset.
This class represents the type of a local variable or item on stack
used in the StackMap entries.
This type represents the weavers abstraction of an annotation - it is not tied to any underlying BCI toolkit.
Represents an AspectJ pointcut expression and provides convenience methods to determine whether or not the pointcut matches join
points specified in terms of the java.lang.reflect interfaces.
Map from weaver.tools interface to internal Pointcut implementation...
A PointcutParser can be used to build PointcutExpressions for a user-defined subset of AspectJ's pointcut language
Annotate members to avoid AspectJ error messages.
SWITCH - Branch depending on int value, generates either LOOKUPSWITCH or
TABLESWITCH instruction, depending on whether the match values (int[]) can be
sorted with no gaps between the numbers.
This class is derived from Attribute and declares this class as `synthetic', i.e., it needs special handling.
This repository is used in situations where a Class is created outside the realm of a ClassLoader.
TABLESWITCH - Switch within given range of values, i.e., low..high
A tag is an instruction-targeter that does not remember its target.
Thrown by InstructionList.remove() when one or multiple disposed instruction
are still being referenced by a InstructionTargeter object.
Some methods need a temporary type munger (because ConcreteTypeMunger is abstract - dont ask...).
Corresponds to target or this pcd.
Abstract super class for all possible java types, namely basic types such as int, object types like String and array types, e.g.
Used for @this() @target() @args() - represents accessing an annotated 'thing'.
A TypeCategoryTypePattern matches on the category of a type, one of class/interface/aspect/inner/anonymous/enum/annotation, and
these are specified in the pointcut via isClass() isInterface() isAspect() isInner() isAnonymous() isEnum() isAnnotation().
A type delegate resolver is able to create type delegates for a named reference type.
AspectJ runtime representation of a type pattern as used in member
declarations such as declare parents.
On creation, type pattern only contains WildTypePattern nodes, not BindingType or ExactType.
AspectJ runtime representation of a type pattern based per-clause associated
with an aspect (pertypewithin).
Default impl of a type pattern.
A compiled AspectJ type pattern that can be used to
match against types at runtime.
Represents a type variable with possible bounds.
Tag interface - methods and types can be declaring elements for type variables.
Implemented by Types that represent references to type variables
ReferenceType pointing to a type variable.
This class represents a reference to an unknown (i.e., application-specific) attribute of a class.
A UnresolvedType represents a type to the weaver.
Load classes as File from File[] dirs or URL[] jars.
Utility functions that do not really belong to any class in particular.
release-specific version information
Lightweight subclass of DataInputStream that knows what version of the weaver was used to construct the data in it.
Check if there are illegal 'void[]' , 'void[][]' etc.
Wraps a reference to a classloader inside a WeakReference.
Manages a cache of weaved and generated classes similar to Eclipse Equinox,
except designed to operate across multiple restarts of the JVM and with one
cache per classloader; allowing URLClassLoaders with the same set of URI
paths to share the same cache (with the default configuration).
WeaverStateInfo represents how a type was processed.
This adaptor allows the AspectJ compiler to be embedded in an existing system to facilitate load-time weaving.
An interface for weaving class loaders to provide callbacks for a
WeavingAdaptor.
Represents a wildcarded bound for a generic type, this can be unbounded '?' or bounded via extends '? extends Foo' or super '?
super Foo'.
The PatternParser always creates WildTypePatterns for type patterns in pointcut expressions (apart from *, which is sometimes
directly turned into TypePattern.ANY).
A World is a collection of known types and crosscutting members.
Uses a ZIP file to store the instrumented classes/aspects - each one as a
separate
ZipEntry.