Package org.aspectj.weaver

Class ResolvedTypeMunger

java.lang.Object

org.aspectj.weaver.ResolvedTypeMunger

Direct Known Subclasses:

AnnotationOnTypeMunger, MethodDelegateTypeMunger, MethodDelegateTypeMunger.FieldHostTypeMunger, NewConstructorTypeMunger, NewFieldTypeMunger, NewMemberClassTypeMunger, NewMethodTypeMunger, NewParentTypeMunger, PerObjectInterfaceTypeMunger, PerTypeWithinTargetTypeMunger, PrivilegedAccessMunger

public abstract class ResolvedTypeMunger
extends Object

This is an abstraction over method/field introduction. It might not have the chops to handle other inter-type declarations. This is the thing that is used on the eclipse side and serialized into a ConcreteTypeMunger.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	ResolvedTypeMunger.Kind

Field Summary

Fields

Modifier and Type	Field	Description
static ResolvedTypeMunger.Kind	AnnotationOnType
static ResolvedTypeMunger.Kind	Constructor
protected ResolvedMember	declaredSignature	The declared signature is filled in when a type munger is parameterized for application to a particular type.
static ResolvedTypeMunger.Kind	Field
static ResolvedTypeMunger.Kind	FieldHost
static ResolvedTypeMunger.Kind	InnerClass
protected ResolvedTypeMunger.Kind	kind
static ResolvedTypeMunger.Kind	Method
static ResolvedTypeMunger.Kind	MethodDelegate
static ResolvedTypeMunger.Kind	MethodDelegate2
static ResolvedTypeMunger.Kind	Parent
static ResolvedTypeMunger.Kind	PerObjectInterface
static ResolvedTypeMunger.Kind	PerTypeWithinInterface
static ResolvedTypeMunger.Kind	PrivilegedAccess
protected ResolvedMember	signature
static String	SUPER_DISPATCH_NAME
protected List<String>	typeVariableAliases

Constructor Summary

Constructors

Constructor	Description
ResolvedTypeMunger(ResolvedTypeMunger.Kind kind, ResolvedMember signature)

Method Summary

Modifier and Type	Method	Description
boolean	changesPublicSignature()
boolean	existsToSupportShadowMunging()	Some type mungers are created purely to help with the implementation of shadow mungers.
ResolvedMember	getDeclaredSignature()
UnresolvedType	getDeclaringType()
ResolvedTypeMunger.Kind	getKind()
ResolvedMember	getMatchingSyntheticMember(Member member, ResolvedType aspectType)
ResolvedMember	getSignature()
ISourceLocation	getSourceLocation()
Set<ResolvedMember>	getSuperMethodsCalled()
List<String>	getTypeVariableAliases()
boolean	hasTypeVariableAliases()
boolean	isLateMunger()	A late munger has to be done after shadow munging since which shadows are matched can affect the operation of the late munger. e.g. perobjectinterfacemunger
boolean	matches(ResolvedType matchType, ResolvedType aspectType)
boolean	needsAccessToTopmostImplementor()
ResolvedTypeMunger	parameterizedFor(ResolvedType target)	Parameterizes a resolved type munger for a particular usage of its target type (this is used when the target type is generic and the ITD shares type variables with the target) see ConcreteTypeMunger.parameterizedFor
ResolvedTypeMunger	parameterizeWith(Map<String,UnresolvedType> m, World w)
static ResolvedTypeMunger	read(VersionedDataInputStream s, ISourceContext context)
protected static List<String>	readInTypeAliases(VersionedDataInputStream s)
protected static ISourceLocation	readSourceLocation(VersionedDataInputStream s)
protected static Set<ResolvedMember>	readSuperMethodsCalled(VersionedDataInputStream s)
void	setDeclaredSignature(ResolvedMember rm)
void	setSourceLocation(ISourceLocation isl)
void	setSuperMethodsCalled(Set<ResolvedMember> c)
protected void	setTypeVariableAliases(List<String> typeVariableAliases)
boolean	sharesTypeVariablesWithGenericType()	return true if type variables are specified with the target type for this ITD. e.g. this would return true: "int I<A,B>.m() { return 42; }"
String	toString()
abstract void	write(CompressingDataOutputStream s)
protected void	writeOutTypeAliases(DataOutputStream s)
protected void	writeSourceLocation(CompressingDataOutputStream s)
protected void	writeSuperMethodsCalled(CompressingDataOutputStream s)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Details

kind

protected ResolvedTypeMunger.Kind kind

signature

protected ResolvedMember signature

declaredSignature

protected ResolvedMember declaredSignature

The declared signature is filled in when a type munger is parameterized for application to a particular type. It represents the signature originally declared in the source file.

typeVariableAliases

protected List<String> typeVariableAliases

Field

public static final ResolvedTypeMunger.Kind Field

Method

public static final ResolvedTypeMunger.Kind Method

Constructor

public static final ResolvedTypeMunger.Kind Constructor

PerObjectInterface

public static final ResolvedTypeMunger.Kind PerObjectInterface

PrivilegedAccess

public static final ResolvedTypeMunger.Kind PrivilegedAccess

Parent

public static final ResolvedTypeMunger.Kind Parent

PerTypeWithinInterface

public static final ResolvedTypeMunger.Kind PerTypeWithinInterface

AnnotationOnType

public static final ResolvedTypeMunger.Kind AnnotationOnType

MethodDelegate

public static final ResolvedTypeMunger.Kind MethodDelegate

FieldHost

public static final ResolvedTypeMunger.Kind FieldHost

MethodDelegate2

public static final ResolvedTypeMunger.Kind MethodDelegate2

InnerClass

public static final ResolvedTypeMunger.Kind InnerClass

SUPER_DISPATCH_NAME

public static final String SUPER_DISPATCH_NAME

See Also:

Constant Field Values

Constructor Details

ResolvedTypeMunger

public ResolvedTypeMunger(ResolvedTypeMunger.Kind kind,
 ResolvedMember signature)

Method Details

setSourceLocation

public void setSourceLocation(ISourceLocation isl)

getSourceLocation

public ISourceLocation getSourceLocation()

matches

public boolean matches(ResolvedType matchType,
 ResolvedType aspectType)

toString

public String toString()

Overrides:

toString in class Object

read

public static ResolvedTypeMunger read(VersionedDataInputStream s,
 ISourceContext context)
                               throws IOException

Throws:

IOException

readSuperMethodsCalled

protected static Set<ResolvedMember> readSuperMethodsCalled(VersionedDataInputStream s)
                                                     throws IOException

Throws:

IOException

writeSuperMethodsCalled

protected final void writeSuperMethodsCalled(CompressingDataOutputStream s)
                                      throws IOException

Throws:

IOException

readSourceLocation

protected static ISourceLocation readSourceLocation(VersionedDataInputStream s)
                                             throws IOException

Throws:

IOException

writeSourceLocation

protected final void writeSourceLocation(CompressingDataOutputStream s)
                                  throws IOException

Throws:

IOException

write

public abstract void write(CompressingDataOutputStream s)
                    throws IOException

Throws:

IOException

getKind

public ResolvedTypeMunger.Kind getKind()

setSuperMethodsCalled

public void setSuperMethodsCalled(Set<ResolvedMember> c)

getSuperMethodsCalled

public Set<ResolvedMember> getSuperMethodsCalled()

getSignature

public ResolvedMember getSignature()

getMatchingSyntheticMember

public ResolvedMember getMatchingSyntheticMember(Member member,
 ResolvedType aspectType)

changesPublicSignature

public boolean changesPublicSignature()

needsAccessToTopmostImplementor

public boolean needsAccessToTopmostImplementor()

readInTypeAliases

protected static List<String> readInTypeAliases(VersionedDataInputStream s)
                                         throws IOException

Throws:

IOException

writeOutTypeAliases

protected final void writeOutTypeAliases(DataOutputStream s)
                                  throws IOException

Throws:

IOException

getTypeVariableAliases

public List<String> getTypeVariableAliases()

setTypeVariableAliases

protected void setTypeVariableAliases(List<String> typeVariableAliases)

hasTypeVariableAliases

public boolean hasTypeVariableAliases()

sharesTypeVariablesWithGenericType

public boolean sharesTypeVariablesWithGenericType()

return true if type variables are specified with the target type for this ITD. e.g. this would return true: "int I<A,B>.m() { return 42; }"

parameterizedFor

public ResolvedTypeMunger parameterizedFor(ResolvedType target)

Parameterizes a resolved type munger for a particular usage of its target type (this is used when the target type is generic and the ITD shares type variables with the target) see ConcreteTypeMunger.parameterizedFor

setDeclaredSignature

public void setDeclaredSignature(ResolvedMember rm)

getDeclaredSignature

public ResolvedMember getDeclaredSignature()

isLateMunger

public boolean isLateMunger()

A late munger has to be done after shadow munging since which shadows are matched can affect the operation of the late munger. e.g. perobjectinterfacemunger

existsToSupportShadowMunging

public boolean existsToSupportShadowMunging()

Some type mungers are created purely to help with the implementation of shadow mungers. For example to support the cflow() pointcut we create a new cflow field in the aspect, and that is added via a BcelCflowCounterFieldAdder. During compilation we need to compare sets of type mungers, and if some only come into existence after the 'shadowy' type things have been processed, we need to ignore them during the comparison. Returning true from this method indicates the type munger exists to support 'shadowy' stuff - and so can be ignored in some comparison.

parameterizeWith

public ResolvedTypeMunger parameterizeWith(Map<String,UnresolvedType> m,
 World w)

getDeclaringType

public UnresolvedType getDeclaringType()