Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.jboss.aop
Class AspectManager

    java.lang.Object
      org.jboss.aop.AspectManager

All Implemented Interfaces:
  org.jboss.util.loading.Translator

Direct Known Subclasses:
  Domain

public class AspectManager
extends Object
implements org.jboss.util.loading.Translator

This singleton class manages all pointcuts and metadata. Coders can access it via the AspectManager.instance() method.

It is also the middle man between the ClassLoader and the actual class instrumentation as well.

App Developers that want to create and apply, interceptors, pointcuts, or metadata at runtime can also use this object to do that.

Version:
  $Revision: 1.152 $
Author:
  Bill Burke

Field Summary
`protected WeakHashMap` | `advisors`
`protected LinkedHashMap` | `annotationIntroductions`
`protected LinkedHashMap` | `annotationOverrides`
`protected EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap` | `aspectDefinitions`
`protected LinkedHashMap` | `bindings`
`protected boolean` | `call`
`protected EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap` | `cflowStacks`
`static ClassLoaderValidation` | `classLoaderValidator`
`protected LinkedHashMap` | `classMetaData`
`protected Hashtable` | `classMetaDataLoaders`
`protected javassist.ClassPool` | `classpool`
`static ClassPoolFactory` | `classPoolFactory`
`protected boolean` | `construction`
`protected HashMap` | `containers`
`protected EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap` | `convertableReference`
`static boolean` | `debugClasses`
`protected HashMap` | `declares`
`protected EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap` | `dynamicCFlows`
`protected DynamicAOPStrategy` | `dynamicStrategy`
`protected ArrayList` | `exclude` class name prefixes to explicitly exclude unless contained in include.
`protected boolean` | `execution`
`protected boolean` | `get`
`protected EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap` | `hasConstructorInterception`
`protected EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap` | `hasFieldInterception`
`protected ArrayList` | `ignore` A set of wildcard enabled classnames that will be ignored no matter if they have been included.
`protected ClassExpression[]` | `ignoreExpressions` ClassExpressions built from ignore.
`protected ArrayList` | `include` class name prefixes to explicitly include, this overrides whatever was set in exclude.
`protected HashMap` | `interceptorFactories`
`protected HashMap` | `interceptorStacks`
`protected LinkedHashMap` | `interfaceIntroductions`
`protected static AspectManager` | `manager`
`static AspectNotificationHandler` | `notificationHandler` This is a callback object that receives events about new pointcuts, interceptors and metadata.
`static boolean` | `optimize`
`protected EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap` | `perVMAspects`
`protected LinkedHashMap` | `pointcutInfos`
`protected LinkedHashMap` | `pointcuts`
`protected LinkedHashMap` | `precedenceDefs`
`static boolean` | `prune`
`protected WeakHashMap` | `registeredCLs`
`protected WeakHashMap` | `scopedClassLoaderDomains` A map of domains by classloader, maintaned by the top level AspectManager
`static AOPScopedClassLoaderHelper` | `scopedCLHelper`
`protected boolean` | `set`
`protected EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap` | `skipConstructorInterception`
`protected EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap` | `skipConvertableReference`
`protected EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap` | `skipFieldInterception`
`protected PrecedenceDefEntry[]` | `sortedPrecedenceDefEntries`
`protected WeakHashMap` | `subDomainsPerClass` A map of domains by class, maintaned by the top level AspectManager
`protected int` | `subscribedDomainQueueRef`
`protected WeakHashMap` | `subscribedSubDomains` Each domain may have sub domains interested in changes happening in this manager/domain
`protected WeakHashMap` | `subscribedSubDomainsQueue` A queue for adding new subscribed subdomains to
`static boolean` | `suppressReferenceErrors` Suppress when a class cannot be found that a class references This may happen if code in a class references something and the class is not in the classpath.
`static boolean` | `suppressTransformationErrors`
`protected boolean` | `transformationStarted`
`protected LinkedHashMap` | `typedefs`
`protected HashMap` | `ucl2classes`
`static boolean` | `verbose` logging switch.
`protected boolean` | `within`
`protected boolean` | `withincode`

Constructor Summary
`AspectManager()`

Method Summary
`void` | `addAdviceStack(AdviceStack stack)` Add a referencable InterceptorStack( <stack> )
`protected void` | `addAdvisorToClassMetaDataBinding(ClassMetaDataBinding meta, Class clazz, Advisor advisor, Class advisedClass)`
`void` | `addAnnotationIntroduction(AnnotationIntroduction pointcut)` Register an annotation introduction
`void` | `addAnnotationOverride(AnnotationIntroduction pointcut)` Register an annotation introduction
`void` | `addAspectDefinition(AspectDefinition def)`
`void` | `addBinding(AdviceBinding binding)` Add an interceptor pointcut with a given name
`void` | `addCFlowStack(CFlowStack stack)`
`void` | `addClassMetaData(ClassMetaDataBinding meta)`
`void` | `addClassMetaDataLoader(String group, ClassMetaDataLoader loader)` Every <class-metadata> tag corresponds to a ClassMetaDataLoader.
`void` | `addConstructionInterceptionMarker(String classname)`
`void` | `addContainer(DomainDefinition def)`
`void` | `addDeclare(DeclareDef declare)`
`void` | `addDynamicCFlow(String name, DynamicCFlowDefinition cflow)`
`void` | `addFieldInterceptionMarker(String classname)`
`void` | `addInterceptorFactory(String name, InterceptorFactory factory)` Add an interceptor factory that can be referenced by name.
`void` | `addInterfaceIntroduction(InterfaceIntroduction pointcut)` Register an introduction pointcut
`void` | `addPointcut(Pointcut pointcut)` Add an interceptor pointcut with a given name
`void` | `addPrecedence(PrecedenceDef precedenceDef)`
`void` | `addSubDomainPerClass(Class clazz, Domain domain)`
`void` | `addTypedef(Typedef def)`
`protected void` | `applyInterfaceIntroductions(Advisor advisor, Class clazz)`
`protected void` | `applyInterfaceIntroductions(ClassAdvisor advisor, javassist.CtClass clazz)`
`protected void` | `attachMetaData(ClassAdvisor advisor, Class clazz)`
`protected boolean` | `attachMetaData(ClassAdvisor advisor, javassist.CtClass clazz, boolean addAdvisor)`
`void` | `clearUnregisteredClassLoaders()` This method will check to see if a register classloader has been undeployed (as in JBoss)
`boolean` | `convertReference(String classname)`
`boolean` | `excludeClass(String classname)`
`Advisor` | `findAdvisor(Class clazz)`
`ClassMetaDataLoader` | `findClassMetaDataLoader(String group)` Every <class-metadata> tag corresponds to a ClassMetaDataLoader.
`javassist.ClassPool` | `findClassPool(ClassLoader cl)`
`protected void` | `forceResortPrecedenceDefs()`
`AdviceStack` | `getAdviceStack(String name)` Find an interceptor stack referenced by name ( <stack> )
`ClassAdvisor` | `getAdvisor(Class clazz)` This method is called by the aspectized class when it is loaded This causes all initialization of interceptors for ClassAdvisor
`Advisor` | `getAdvisor(String name)`
`ClassAdvisor` | `getAdvisorIfAdvised(Class clazz)`
`Map` | `getAdvisors()`
`List` | `getAnnotationIntroductions()`
`List` | `getAnnotationOverrides()`
`Advisor` | `getAnyAdvisorIfAdvised(Class clazz)` Take into account that an advisor may be a container
`AspectDefinition` | `getAspectDefinition(String name)`
`Map` | `getAspectDefinitions()`
`LinkedHashMap` | `getBindings()`
`CFlowStack` | `getCFlowStack(String name)`
`Map` | `getCflowStacks()`
`Map` | `getClassMetaData()`
`Map` | `getClassMetaDataLoaders()`
`DomainDefinition` | `getContainer(String name)`
`Iterator` | `getDeclares()`
`DynamicAOPStrategy` | `getDynamicAOPStrategy()` Returns the dynamic aop strategy to be used.
`DynamicCFlow` | `getDynamicCFlow(String name)`
`Map` | `getDynamicCFlows()`
`ArrayList` | `getExclude()`
`ArrayList` | `getIgnore()`
`ClassExpression[]` | `getIgnoreExpressions()`
`ArrayList` | `getInclude()`
`Map` | `getInterceptorFactories()`
`InterceptorFactory` | `getInterceptorFactory(String name)` Find the interceptor factory that can be referenced by name.
`Map` | `getInterceptorStacks()`
`InterfaceIntroduction` | `getInterfaceIntroduction(String name)` Retrieve an introduction pointcut of a certain name
`Map` | `getInterfaceIntroductions()`
`Object` | `getPerVMAspect(AspectDefinition def)`
`Object` | `getPerVMAspect(String def)`
`Map` | `getPerVMAspects()`
`Pointcut` | `getPointcut(String name)` Find a pointcut of with a given name
`LinkedHashMap` | `getPointcutInfos()`
`LinkedHashMap` | `getPointcuts()`
`LinkedHashMap` | `getPrecedenceDefs()`
`protected javassist.ClassPool` | `getRegisteredClassPool(ClassLoader cl)`
`Map` | `getRegisteredCLs()`
`protected Map` | `getScopedClassLoaderDomains()`
`PrecedenceDefEntry[]` | `getSortedPrecedenceDefEntries()`
`protected Map` | `getSubDomainsPerClass()`
`ClassAdvisor` | `getTempClassAdvisor(javassist.CtClass clazz)`
`Advisor` | `getTempClassAdvisorIfNotExist(Class clazz)`
`static AspectManager` | `getTopLevelAspectManager()`
`Typedef` | `getTypedef(String name)`
`Map` | `getTypedefs()`
`protected Map` | `getUcl2Classes()`
`boolean` | `ignoreClass(String classname)`
`boolean` | `includeClass(String classname)`
`void` | `initialiseClassAdvisor(Class clazz, ClassAdvisor advisor)`
`static AspectManager` | `instance()`
`static AspectManager` | `instance(ClassLoader loadingClassLoader)`
`boolean` | `isAdvisorRegistered(Advisor advisor)` Checks to see if an Advisor represents a class that should have been undeployed.
`boolean` | `isCall()`
`boolean` | `isConstruction()`
`boolean` | `isExecution()`
`boolean` | `isGet()`
`boolean` | `isNonAdvisableClassName(String classname)`
`boolean` | `isSet()`
`boolean` | `isWithin()`
`boolean` | `isWithincode()`
`protected void` | `registerClass(Class clazz)`
`javassist.ClassPool` | `registerClassLoader(ClassLoader ucl)`
`void` | `removeAnnotationIntroduction(AnnotationIntroduction pointcut)` remove an annotation pointcut
`void` | `removeAnnotationOverride(AnnotationIntroduction pointcut)` remove an annotation pointcut
`void` | `removeAspectDefinition(String name)`
`void` | `removeBinding(String name)` Remove an interceptor pointcut with a given name
`void` | `removeBindings(ArrayList binds)`
`void` | `removeCFlowStack(String name)`
`void` | `removeClassMetaData(String name)`
`void` | `removeClassMetaDataLoader(String group)` Remove a loader for a given group
`void` | `removeContainer(String name)`
`void` | `removeDeclare(String name)`
`void` | `removeDynamicCFlow(String name)`
`void` | `removeInterceptorFactory(String name)` Remove an interceptor factory that can be referenced by name.
`void` | `removeInterceptorStack(String name)` Remove a referencable InterceptorStack( <stack> )
`void` | `removeInterfaceIntroduction(String name)` remove an introduction pointcut of a certain name
`void` | `removePointcut(String name)` Remove an interceptor pointcut with a given name
`void` | `removePrecedence(String name)`
`void` | `removeTypedef(String name)`
`void` | `setBindings(LinkedHashMap bindings)`
`void` | `setDynamicAOPStrategy(DynamicAOPStrategy strategy)` Sets the dynamic aop strategy to be used.
`void` | `setExclude(ArrayList exclude)`
`void` | `setIgnore(ArrayList ignore)`
`void` | `setInclude(ArrayList include)`
`boolean` | `shouldSkipConstruction(String classname)`
`boolean` | `shouldSkipFieldAccess(String classname)`
`void` | `skipConstruction(String classname)`
`void` | `skipFieldAccess(String classname)`
`void` | `skipReference(String classname)`
`void` | `subscribeSubDomain(Domain domain)` Add subscriber to queue
`byte[]` | `transform(ClassLoader loader, String className, Class classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer)` This is the hook for ClassLoaders that want to instrument their classes with AOP This would be called during a findClass or loadClass call.
`byte[]` | `translate(String className, ClassLoader loader)` This is to be backward compatible with JBoss 3.2.3 Translator interface
`byte[]` | `translate(String className, ClassLoader loader, byte[] classfileBuffer)` This is to be backward compatible with JBoss 3.2.3 Translator interface
`void` | `unregisterClassLoader(ClassLoader cl)`
`void` | `unsubscribeSubDomain(Domain domain)`
`void` | `updateAdvisorsForAddedAnnotationOverride(AnnotationIntroduction introduction)`
`void` | `updateAdvisorsForAddedBinding(AdviceBinding binding)`
`protected void` | `updateAdvisorsForAddedClassMetaData(ClassMetaDataBinding meta)`
`protected void` | `updatePointcutStats(Pointcut pointcut)` THis method is used for performance reasons.
`protected void` | `updateStats(PointcutStats stats)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### registeredCLs

    protected final WeakHashMap registeredCLs

### ucl2classes

    protected final HashMap ucl2classes

### advisors

    protected final WeakHashMap advisors

### scopedClassLoaderDomains

    protected final WeakHashMap scopedClassLoaderDomains

  A map of domains by classloader, maintaned by the top level AspectManager

### subDomainsPerClass

    protected final WeakHashMap subDomainsPerClass

  A map of domains by class, maintaned by the top level AspectManager

### subscribedSubDomains

    protected final WeakHashMap subscribedSubDomains

  Each domain may have sub domains interested in changes happening in this manager/domain

### subscribedSubDomainsQueue

    protected final WeakHashMap subscribedSubDomainsQueue

  A queue for adding new subscribed subdomains to

### subscribedDomainQueueRef

    protected int subscribedDomainQueueRef

### classpool

    protected javassist.ClassPool classpool

### interfaceIntroductions

    protected final LinkedHashMap interfaceIntroductions

### annotationIntroductions

    protected final LinkedHashMap annotationIntroductions

### annotationOverrides

    protected final LinkedHashMap annotationOverrides

### bindings

    protected final LinkedHashMap bindings

### typedefs

    protected final LinkedHashMap typedefs

### interceptorFactories

    protected final HashMap interceptorFactories

### classMetaDataLoaders

    protected final Hashtable classMetaDataLoaders

### interceptorStacks

    protected final HashMap interceptorStacks

### declares

    protected final HashMap declares

### cflowStacks

    protected final EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap cflowStacks

### dynamicCFlows

    protected final EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap dynamicCFlows

### aspectDefinitions

    protected final EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap aspectDefinitions

### perVMAspects

    protected final EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap perVMAspects

### exclude

    protected final ArrayList exclude

  class name prefixes to explicitly exclude unless contained in include. Maintained by top-level AspectManager

### include

    protected final ArrayList include

  class name prefixes to explicitly include, this overrides whatever was set in exclude. Maintained by top-level AspectManager

### ignore

    protected final ArrayList ignore

  A set of wildcard enabled classnames that will be ignored no matter if they have been included. Maintained by top-level AspectManager

### ignoreExpressions

    protected ClassExpression[] ignoreExpressions

  ClassExpressions built from ignore. Maintained by top-level AspectManager

### pointcuts

    protected final LinkedHashMap pointcuts

### pointcutInfos

    protected final LinkedHashMap pointcutInfos

### execution

    protected boolean execution

### construction

    protected boolean construction

### call

    protected boolean call

### within

    protected boolean within

### get

    protected boolean get

### set

    protected boolean set

### withincode

    protected boolean withincode

### classMetaData

    protected final LinkedHashMap classMetaData

### containers

    protected final HashMap containers

### precedenceDefs

    protected final LinkedHashMap precedenceDefs

### sortedPrecedenceDefEntries

    protected PrecedenceDefEntry[] sortedPrecedenceDefEntries

### convertableReference

    protected final EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap convertableReference

### hasFieldInterception

    protected final EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap hasFieldInterception

### hasConstructorInterception

    protected final EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap hasConstructorInterception

### skipConvertableReference

    protected final EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap skipConvertableReference

### skipFieldInterception

    protected final EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap skipFieldInterception

### skipConstructorInterception

    protected final EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap skipConstructorInterception

### dynamicStrategy

    protected DynamicAOPStrategy dynamicStrategy

### transformationStarted

    protected boolean transformationStarted

### scopedCLHelper

    public static AOPScopedClassLoaderHelper scopedCLHelper

### manager

    protected static AspectManager manager

### optimize

    public static boolean optimize

### prune

    public static boolean prune

### debugClasses

    public static boolean debugClasses

### classLoaderValidator

    public static ClassLoaderValidation classLoaderValidator

### verbose

    public static boolean verbose

  logging switch. We don't use log4j to avoid another heavy library

### classPoolFactory

    public static ClassPoolFactory classPoolFactory

### notificationHandler

    public static AspectNotificationHandler notificationHandler

  This is a callback object that receives events about new pointcuts, interceptors and metadata. The Aspect Management console hooks into this listener

### suppressTransformationErrors

    public static boolean suppressTransformationErrors

### suppressReferenceErrors

    public static boolean suppressReferenceErrors

  Suppress when a class cannot be found that a class references This may happen if code in a class references something and the class is not in the classpath.

Constructor Detail

### AspectManager

    public AspectManager()

Method Detail

### addConstructionInterceptionMarker

    public void addConstructionInterceptionMarker(String classname)

### addFieldInterceptionMarker

    public void addFieldInterceptionMarker(String classname)

### skipReference

    public void skipReference(String classname)

### shouldSkipConstruction

    public boolean shouldSkipConstruction(String classname)

### shouldSkipFieldAccess

    public boolean shouldSkipFieldAccess(String classname)

### skipConstruction

    public void skipConstruction(String classname)

### skipFieldAccess

    public void skipFieldAccess(String classname)

### convertReference

    public boolean convertReference(String classname)

### getTopLevelAspectManager

    public static AspectManager getTopLevelAspectManager()

### instance

    public static AspectManager instance()

### instance

    public static AspectManager instance(ClassLoader loadingClassLoader)

### getPointcuts

    public LinkedHashMap getPointcuts()

### getPointcutInfos

    public LinkedHashMap getPointcutInfos()

### getCFlowStack

    public CFlowStack getCFlowStack(String name)

### addCFlowStack

    public void addCFlowStack(CFlowStack stack)

### removeCFlowStack

    public void removeCFlowStack(String name)

### getDynamicCFlow

    public DynamicCFlow getDynamicCFlow(String name)

### addDynamicCFlow

    public void addDynamicCFlow(String name,
                                DynamicCFlowDefinition cflow)

### removeDynamicCFlow

    public void removeDynamicCFlow(String name)

### findClassMetaDataLoader

    public ClassMetaDataLoader findClassMetaDataLoader(String group)

  Every <class-metadata> tag corresponds to a ClassMetaDataLoader. The ClassMetaDataLoader knows how to take arbitrary XML and apply it to SimpleMetaData.

  Given a group, return the loader for that group

### addClassMetaDataLoader

    public void addClassMetaDataLoader(String group,
                                       ClassMetaDataLoader loader)

  Every <class-metadata> tag corresponds to a ClassMetaDataLoader. The ClassMetaDataLoader knows how to take arbitrary XML and apply it to SimpleMetaData.

  Add a loader for a given group

### removeClassMetaDataLoader

    public void removeClassMetaDataLoader(String group)

  Remove a loader for a given group

### getAdvisors

    public Map getAdvisors()

### getAdvisor

    public Advisor getAdvisor(String name)

### getBindings

    public LinkedHashMap getBindings()

### getSubDomainsPerClass

    protected Map getSubDomainsPerClass()

### findAdvisor

    public Advisor findAdvisor(Class clazz)

### getAdvisorIfAdvised

    public ClassAdvisor getAdvisorIfAdvised(Class clazz)

### getAnyAdvisorIfAdvised

    public Advisor getAnyAdvisorIfAdvised(Class clazz)

  Take into account that an advisor may be a container

### getAdvisor

    public ClassAdvisor getAdvisor(Class clazz)

  This method is called by the aspectized class when it is loaded This causes all initialization of interceptors for ClassAdvisor

  Parameters:
    `clazz` -
  Returns:

### initialiseClassAdvisor

    public void initialiseClassAdvisor(Class clazz,
                                       ClassAdvisor advisor)

### getRegisteredCLs

    public Map getRegisteredCLs()

### clearUnregisteredClassLoaders

    public void clearUnregisteredClassLoaders()

  This method will check to see if a register classloader has been undeployed (as in JBoss)

### isAdvisorRegistered

    public boolean isAdvisorRegistered(Advisor advisor)

  Checks to see if an Advisor represents a class that should have been undeployed.

  Parameters:
    `advisor` -
  Returns:

### findClassPool

    public javassist.ClassPool findClassPool(ClassLoader cl)

### getRegisteredClassPool

    protected javassist.ClassPool getRegisteredClassPool(ClassLoader cl)

### registerClassLoader

    public javassist.ClassPool registerClassLoader(ClassLoader ucl)

### getUcl2Classes

    protected Map getUcl2Classes()

### registerClass

    protected void registerClass(Class clazz)

### getScopedClassLoaderDomains

    protected Map getScopedClassLoaderDomains()

### unregisterClassLoader

    public void unregisterClassLoader(ClassLoader cl)

  Specified by:
    `unregisterClassLoader` in interface `org.jboss.util.loading.Translator`

### getExclude

    public ArrayList getExclude()

### setExclude

    public void setExclude(ArrayList exclude)

### getInclude

    public ArrayList getInclude()

### setInclude

    public void setInclude(ArrayList include)

### getIgnore

    public ArrayList getIgnore()

### getIgnoreExpressions

    public ClassExpression[] getIgnoreExpressions()

### setIgnore

    public void setIgnore(ArrayList ignore)

### ignoreClass

    public boolean ignoreClass(String classname)

### includeClass

    public boolean includeClass(String classname)

### excludeClass

    public boolean excludeClass(String classname)

### isNonAdvisableClassName

    public boolean isNonAdvisableClassName(String classname)

### transform

    public byte[] transform(ClassLoader loader,
                            String className,
                            Class classBeingRedefined,
                            ProtectionDomain protectionDomain,
                            byte[] classfileBuffer)
                     throws Exception

  This is the hook for ClassLoaders that want to instrument their classes with AOP

  This would be called during a findClass or loadClass call. The return value is used by defineClass to create the class from bytecode

  Specified by:
    `transform` in interface `org.jboss.util.loading.Translator`
  Throws:
    `Exception`

### translate

    public byte[] translate(String className,
                            ClassLoader loader)
                     throws Exception

  This is to be backward compatible with JBoss 3.2.3 Translator interface

  Parameters:
    `className` -
    `loader` -
  Returns:
  Throws:
    `Exception`

### translate

    public byte[] translate(String className,
                            ClassLoader loader,
                            byte[] classfileBuffer)
                     throws Exception

  This is to be backward compatible with JBoss 3.2.3 Translator interface

  Parameters:
    `className` -
    `loader` -
  Returns:
  Throws:
    `Exception`

### addInterceptorFactory

    public void addInterceptorFactory(String name,
                                      InterceptorFactory factory)

  Add an interceptor factory that can be referenced by name.

### removeInterceptorFactory

    public void removeInterceptorFactory(String name)

  Remove an interceptor factory that can be referenced by name.

### getInterceptorFactories

    public Map getInterceptorFactories()

### getInterceptorFactory

    public InterceptorFactory getInterceptorFactory(String name)

  Find the interceptor factory that can be referenced by name.

### addPrecedence

    public void addPrecedence(PrecedenceDef precedenceDef)

### removePrecedence

    public void removePrecedence(String name)

### forceResortPrecedenceDefs

    protected void forceResortPrecedenceDefs()

### getPrecedenceDefs

    public LinkedHashMap getPrecedenceDefs()

### getSortedPrecedenceDefEntries

    public PrecedenceDefEntry[] getSortedPrecedenceDefEntries()

### addAdviceStack

    public void addAdviceStack(AdviceStack stack)

  Add a referencable InterceptorStack( <stack> )

### removeInterceptorStack

    public void removeInterceptorStack(String name)

  Remove a referencable InterceptorStack( <stack> )

### getAdviceStack

    public AdviceStack getAdviceStack(String name)

  Find an interceptor stack referenced by name ( <stack> )

### attachMetaData

    protected boolean attachMetaData(ClassAdvisor advisor,
                                     javassist.CtClass clazz,
                                     boolean addAdvisor)
                              throws Exception

  Throws:
    `Exception`

### attachMetaData

    protected void attachMetaData(ClassAdvisor advisor,
                                  Class clazz)

### getTempClassAdvisor

    public ClassAdvisor getTempClassAdvisor(javassist.CtClass clazz)
                                     throws Exception

  Throws:
    `Exception`

### getTempClassAdvisorIfNotExist

    public Advisor getTempClassAdvisorIfNotExist(Class clazz)

### getContainer

    public DomainDefinition getContainer(String name)

### addContainer

    public void addContainer(DomainDefinition def)

### removeContainer

    public void removeContainer(String name)

### getPointcut

    public Pointcut getPointcut(String name)

  Find a pointcut of with a given name

### removePointcut

    public void removePointcut(String name)

  Remove an interceptor pointcut with a given name

### addPointcut

    public void addPointcut(Pointcut pointcut)

  Add an interceptor pointcut with a given name

### updatePointcutStats

    protected void updatePointcutStats(Pointcut pointcut)

  THis method is used for performance reasons.

  Parameters:
    `pointcut` -

### updateStats

    protected void updateStats(PointcutStats stats)

### isExecution

    public boolean isExecution()

### isConstruction

    public boolean isConstruction()

### isCall

    public boolean isCall()

### isWithin

    public boolean isWithin()

### isWithincode

    public boolean isWithincode()

### isGet

    public boolean isGet()

### isSet

    public boolean isSet()

### removeBinding

    public void removeBinding(String name)

  Remove an interceptor pointcut with a given name

### removeBindings

    public void removeBindings(ArrayList binds)

### addBinding

    public void addBinding(AdviceBinding binding)

  Add an interceptor pointcut with a given name

### updateAdvisorsForAddedBinding

    public void updateAdvisorsForAddedBinding(AdviceBinding binding)

### removeClassMetaData

    public void removeClassMetaData(String name)

### addClassMetaData

    public void addClassMetaData(ClassMetaDataBinding meta)

### updateAdvisorsForAddedClassMetaData

    protected void updateAdvisorsForAddedClassMetaData(ClassMetaDataBinding meta)

### addAdvisorToClassMetaDataBinding

    protected void addAdvisorToClassMetaDataBinding(ClassMetaDataBinding meta,
                                                    Class clazz,
                                                    Advisor advisor,
                                                    Class advisedClass)

### getInterfaceIntroduction

    public InterfaceIntroduction getInterfaceIntroduction(String name)

  Retrieve an introduction pointcut of a certain name

### addInterfaceIntroduction

    public void addInterfaceIntroduction(InterfaceIntroduction pointcut)

  Register an introduction pointcut

### removeInterfaceIntroduction

    public void removeInterfaceIntroduction(String name)

  remove an introduction pointcut of a certain name

### addAnnotationIntroduction

    public void addAnnotationIntroduction(AnnotationIntroduction pointcut)

  Register an annotation introduction

### removeAnnotationIntroduction

    public void removeAnnotationIntroduction(AnnotationIntroduction pointcut)

  remove an annotation pointcut

### getAnnotationIntroductions

    public List getAnnotationIntroductions()

### addDeclare

    public void addDeclare(DeclareDef declare)

### removeDeclare

    public void removeDeclare(String name)

### getDeclares

    public Iterator getDeclares()

### applyInterfaceIntroductions

    protected void applyInterfaceIntroductions(Advisor advisor,
                                               Class clazz)

### applyInterfaceIntroductions

    protected void applyInterfaceIntroductions(ClassAdvisor advisor,
                                               javassist.CtClass clazz)
                                        throws Exception

  Throws:
    `Exception`

### addAnnotationOverride

    public void addAnnotationOverride(AnnotationIntroduction pointcut)

  Register an annotation introduction

### updateAdvisorsForAddedAnnotationOverride

    public void updateAdvisorsForAddedAnnotationOverride(AnnotationIntroduction introduction)

### removeAnnotationOverride

    public void removeAnnotationOverride(AnnotationIntroduction pointcut)

  remove an annotation pointcut

### getAnnotationOverrides

    public List getAnnotationOverrides()

### getPerVMAspect

    public Object getPerVMAspect(AspectDefinition def)

### getPerVMAspect

    public Object getPerVMAspect(String def)

### addAspectDefinition

    public void addAspectDefinition(AspectDefinition def)

### removeAspectDefinition

    public void removeAspectDefinition(String name)

### getAspectDefinitions

    public Map getAspectDefinitions()

### getAspectDefinition

    public AspectDefinition getAspectDefinition(String name)

### addTypedef

    public void addTypedef(Typedef def)
                    throws Exception

  Throws:
    `Exception`

### removeTypedef

    public void removeTypedef(String name)

### getTypedef

    public Typedef getTypedef(String name)

### getInterfaceIntroductions

    public Map getInterfaceIntroductions()

### getTypedefs

    public Map getTypedefs()

### getInterceptorStacks

    public Map getInterceptorStacks()

### getClassMetaDataLoaders

    public Map getClassMetaDataLoaders()

### getCflowStacks

    public Map getCflowStacks()

### getDynamicCFlows

    public Map getDynamicCFlows()

### getPerVMAspects

    public Map getPerVMAspects()

### getClassMetaData

    public Map getClassMetaData()

### getDynamicAOPStrategy

    public DynamicAOPStrategy getDynamicAOPStrategy()

  Returns the dynamic aop strategy to be used.

### setDynamicAOPStrategy

    public void setDynamicAOPStrategy(DynamicAOPStrategy strategy)

  Sets the dynamic aop strategy to be used. Should be called only before any class is transformed.

  Parameters:
    `strategy` - the new dynamic aop strategy.

### setBindings

    public void setBindings(LinkedHashMap bindings)

### addSubDomainPerClass

    public void addSubDomainPerClass(Class clazz,
                                     Domain domain)

### subscribeSubDomain

    public void subscribeSubDomain(Domain domain)

  Add subscriber to queue

  See Also:
    `AspectManager#copySubDomainsFromQueue(boolean)`

### unsubscribeSubDomain

    public void unsubscribeSubDomain(Domain domain)

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2004 JBoss Inc. All Rights Reserved.