Uses of Class
org.jboss.aop.Advisor

Packages that use Advisor
org.jboss.aop   
org.jboss.aop.advice   
org.jboss.aop.instrument   
org.jboss.aop.introduction   
org.jboss.aop.joinpoint   
org.jboss.aop.metadata   
org.jboss.aop.pointcut   
org.jboss.aop.proxy.container   
 

Uses of Advisor in org.jboss.aop
 

Subclasses of Advisor in org.jboss.aop
 class ClassAdvisor
          Advises a class and provides access to the class's aspect chain.
 class ClassContainer
          Comment
 class GeneratedClassAdvisor
          Comment
 

Fields in org.jboss.aop declared as Advisor
protected  Advisor ReflectiveAspectBinder.advisor
           
protected  Advisor InstanceDomain.advisor
           
 

Methods in org.jboss.aop that return Advisor
 Advisor Advised._getAdvisor()
          Return the manager.
 Advisor AspectManager.findAdvisor(Class clazz)
           
 Advisor InstanceAdvisorDelegate.getAdvisor()
           
 Advisor JoinPointInfo.getAdvisor()
           
 Advisor InstanceDomain.getAdvisor()
           
 Advisor AspectManager.getAdvisor(String name)
           
 Advisor AspectManager.getAnyAdvisorIfAdvised(Class clazz)
          Take into account that an advisor may be a container
 Advisor AspectManager.getTempClassAdvisorIfNotExist(Class clazz)
           
 

Methods in org.jboss.aop with parameters of type Advisor
protected  void AspectManager.addAdvisorToClassMetaDataBinding(ClassMetaDataBinding meta, Class clazz, Advisor advisor, Class advisedClass)
           
protected  void AspectManager.applyInterfaceIntroductions(Advisor advisor, Class clazz)
           
 Interceptor GeneratedInstanceAdvisorMixin.InstanceInterceptorFactory.create(Advisor advisor, Joinpoint joinpoint)
           
 boolean AspectManager.isAdvisorRegistered(Advisor advisor)
          Checks to see if an Advisor represents a class that should have been undeployed.
 boolean InstanceDomain.isAdvisorRegistered(Advisor advisor)
          internal to jboss aop.
 void JoinPointInfo.setAdvisor(Advisor advisor)
           
 void InstanceDomain.setAdvisor(Advisor advisor)
           
 

Constructors in org.jboss.aop with parameters of type Advisor
CallerConstructorInfo(Advisor advisor, Class calledClass, Constructor called, long calledConHash, Method wrappingMethod, Interceptor[] in)
           
CallerMethodInfo(Advisor advisor, Class calledClass, Method m, long calledMethodHash, Interceptor[] in)
           
ConByConInfo(Advisor advisor, Class calledClass, int callingIndex, Constructor called, long calledConHash, Method wrappingMethod, Interceptor[] in)
           
ConByMethodInfo(Advisor advisor, Class calledClass, long callingMethodHash, Constructor c, long calledConHash, Method wrappingMethod, Interceptor[] in)
          Create a new ConByMethodJoinPont.
ConstructionInfo(Class clazz, int index, long constructorHash, Advisor advisor)
           
ConstructorInfo(Class clazz, int index, long wrapperHash, long constructorHash, Advisor advisor)
           
FieldInfo(Class clazz, int index, String fieldName, long wrapperHash, Advisor advisor, boolean read)
           
InstanceAdvisorDelegate(Advisor classAdvisor, InstanceAdvisor instanceAdvisor)
           
JoinPointInfo(Advisor advisor)
           
MethodByConInfo(Advisor advisor, Class calledClass, int callingIndex, Method m, long calledMethodHash, Interceptor[] in)
           
MethodByMethodInfo(Advisor advisor, Class calledClass, Method m, long callingMethodHash, long calledMethodHash, Interceptor[] in)
           
MethodInfo(Class clazz, long hash, long unadvisedHash, Advisor advisor)
           
ReflectiveAspectBinder(Class clazz, Advisor advisor)
           
 

Uses of Advisor in org.jboss.aop.advice
 

Methods in org.jboss.aop.advice with parameters of type Advisor
 void AdviceBinding.addAdvisor(Advisor advisor)
           
protected  void GenericAspectFactory.configureInstance(Object instance, Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
           
 Interceptor GenericInterceptorFactory.create(Advisor advisor, Joinpoint joinpoint)
           
 Interceptor ScopedInterceptorFactory.create(Advisor advisor, Joinpoint joinpoint)
           
 Interceptor AdviceFactory.create(Advisor advisor, Joinpoint joinpoint)
           
 Interceptor InterceptorFactory.create(Advisor advisor, Joinpoint joinpoint)
           
 Interceptor InterceptorFactoryWrapper.create(Advisor advisor, Joinpoint joinpoint)
           
static Interceptor PerJoinpointInterceptor.createInterceptor(Advisor advisor, Joinpoint joinpoint, AspectDefinition def)
           
static Interceptor PerJoinpointAdvice.createInterceptor(Advisor advisor, Joinpoint joinpoint, AspectDefinition def, String adviceName)
           
 Interceptor[] AdviceStack.createInterceptors(Advisor advisor, Joinpoint jp)
           
 Object GenericAspectFactory.createPerClass(Advisor advisor)
           
 Object AspectFactoryDelegator.createPerClass(Advisor advisor)
           
 Object AspectFactory.createPerClass(Advisor advisor)
           
 Object GenericAspectFactory.createPerInstance(Advisor advisor, InstanceAdvisor instanceAdvisor)
           
 Object AspectFactoryDelegator.createPerInstance(Advisor advisor, InstanceAdvisor instanceAdvisor)
           
 Object AspectFactory.createPerInstance(Advisor advisor, InstanceAdvisor instanceAdvisor)
           
 Object GenericAspectFactory.createPerJoinpoint(Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
           
 Object AspectFactoryDelegator.createPerJoinpoint(Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
           
 Object AspectFactory.createPerJoinpoint(Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
           
 Object GenericAspectFactory.createPerJoinpoint(Advisor advisor, Joinpoint jp)
           
 Object AspectFactoryDelegator.createPerJoinpoint(Advisor advisor, Joinpoint jp)
           
 Object AspectFactory.createPerJoinpoint(Advisor advisor, Joinpoint jp)
           
static Interceptor PerClassAdvice.generate(Joinpoint joinpoint, Advisor advisor, String adviceName, AspectDefinition def)
           
 Object InterceptorFactoryWrapper.getAspect(Advisor advisor, Joinpoint joinpoint)
          Create a new aspect instance to figure out what class it is Also used as a convenience method to create aspect instances for the JoinPointGenerator PER_INSTANCE or PER_JOINPOINT (for non-static fields) aspects cannot be created "properly" until at runtime, since that requires access to the instance advisor
 Object InterceptorFactoryWrapper.getPerInstanceAspect(Advisor advisor, Joinpoint joinpoint, InstanceAdvisor ia)
           
protected  void GenericAspectFactory.injectAdvisor(Object instance, Advisor advisor, String attributeName)
           
 void AspectDefinition.registerAdvisor(Advisor advisor)
           
 void AspectDefinition.unregisterAdvisor(Advisor advisor)
           
 

Constructors in org.jboss.aop.advice with parameters of type Advisor
PerInstanceAdvice(String adviceName, AspectDefinition a, Advisor advisor)
           
PerInstanceInterceptor(AspectDefinition a, Advisor advisor)
           
PerJoinpointAdvice(String adviceName, AspectDefinition a, Advisor advisor, Joinpoint joinpoint)
           
PerJoinpointInterceptor(AspectDefinition a, Advisor advisor, Joinpoint joinpoint)
           
 

Uses of Advisor in org.jboss.aop.instrument
 

Methods in org.jboss.aop.instrument with parameters of type Advisor
 JoinpointClassification JoinpointClassifier.classifyConstructorExecution(javassist.CtConstructor cons, Advisor advisor)
          Classifies the execution of cons.
 JoinpointClassification JoinpointClassifier.classifyFieldGet(javassist.CtField field, Advisor advisor)
          Classifies the reading of field value.
 JoinpointClassification JoinpointClassifier.classifyFieldSet(javassist.CtField field, Advisor advisor)
          Classifies the writing of field value.
protected abstract  JoinpointClassification JoinpointClassifier.classifyJoinpoint(javassist.CtMember member, Advisor advisor, JoinpointClassifier.Matcher joinpointMatcher)
          Classifies a joinpoint.
protected  JoinpointClassification JoinpointSimpleClassifier.classifyJoinpoint(javassist.CtMember member, Advisor advisor, JoinpointClassifier.Matcher joinpointMatcher)
          Classifies the execution of a joinpoint.
protected  JoinpointClassification JoinpointFullClassifier.classifyJoinpoint(javassist.CtMember member, Advisor advisor, JoinpointClassifier.Matcher joinpointMatcher)
          Classifies the execution of a joinpoint.
 JoinpointClassification JoinpointClassifier.classifyMethodExecution(javassist.CtMethod method, Advisor advisor)
          Classifies the execution of method.
 boolean JoinpointClassifier.Matcher.matches(Pointcut pointcut, Advisor advisor, javassist.CtMember member)
          Checks if pointcut matches a joinpoint.
 

Uses of Advisor in org.jboss.aop.introduction
 

Methods in org.jboss.aop.introduction with parameters of type Advisor
 void InterfaceIntroduction.addAdvisor(Advisor advisor)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, Class clazz)
           
 boolean InterfaceIntroduction.matches(Advisor advisor, Class clazz)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, Constructor con)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, javassist.CtClass clazz)
           
 boolean InterfaceIntroduction.matches(Advisor advisor, javassist.CtClass clazz)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, javassist.CtConstructor con)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, javassist.CtField field)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, javassist.CtMethod method)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, Field field)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, Method method)
           
 

Uses of Advisor in org.jboss.aop.joinpoint
 

Fields in org.jboss.aop.joinpoint declared as Advisor
protected  Advisor InvocationBase.advisor
           
 

Methods in org.jboss.aop.joinpoint that return Advisor
 Advisor ConstructionInvocationWrapper.getAdvisor()
           
 Advisor MethodInvocation.getAdvisor()
           
 Advisor FieldReadInvocationWrapper.getAdvisor()
           
 Advisor Invocation.getAdvisor()
           
 Advisor ConstructorCalledByMethodInvocationWrapper.getAdvisor()
           
 Advisor InvocationBase.getAdvisor()
           
 Advisor ConstructorInvocationWrapper.getAdvisor()
           
 Advisor MethodInvocationWrapper.getAdvisor()
           
 Advisor ConstructorCalledByConstructorInvocationWrapper.getAdvisor()
           
 Advisor FieldWriteInvocationWrapper.getAdvisor()
           
 Advisor MethodCalledByConstructorInvocationWrapper.getAdvisor()
           
 Advisor MethodCalledByMethodInvocationWrapper.getAdvisor()
           
 

Methods in org.jboss.aop.joinpoint with parameters of type Advisor
 void InvocationBase.setAdvisor(Advisor advisor)
           
 

Constructors in org.jboss.aop.joinpoint with parameters of type Advisor
CallerInvocation(Advisor advisor, Object callingObject, Interceptor[] interceptors)
           
ConstructorCalledByConstructorInvocation(Advisor advisor, Constructor calling, Constructor constructor, Method wrappingMethod, Object callingObject, Object[] args, Interceptor[] interceptors)
           
ConstructorCalledByMethodInvocation(Advisor advisor, Class callingClass, Method callingMethod, Constructor constructor, Method wrappingMethod, Object callingObject, Object[] args, Interceptor[] interceptors)
           
MethodCalledByConstructorInvocation(Advisor advisor, Constructor calling, Method method, Object callingObject, Object target, Object[] args, Interceptor[] interceptors)
           
MethodCalledByMethodInvocation(Advisor advisor, Class callingClass, Method callingMethod, Method method, Object callingObject, Object targetObject, Object[] args, Interceptor[] interceptors)
           
MethodInvocation(Interceptor[] interceptors, long methodHash, Method advisedMethod, Method unadvisedMethod, Advisor advisor)
           
 

Uses of Advisor in org.jboss.aop.metadata
 

Methods in org.jboss.aop.metadata with parameters of type Advisor
 void ClassMetaDataBinding.addAdvisor(Advisor advisor)
           
 void SimpleClassMetaDataLoader.bind(Advisor advisor, ClassMetaDataBinding data, javassist.CtMethod[] methods, javassist.CtField[] fields, javassist.CtConstructor[] constructors)
           
 void ClassMetaDataLoader.bind(Advisor advisor, ClassMetaDataBinding data, javassist.CtMethod[] methods, javassist.CtField[] fields, javassist.CtConstructor[] constructors)
          This is a prebind of metadata so that loader/compiler can work with metadata as strings
 void SimpleClassMetaDataLoader.bind(Advisor advisor, ClassMetaDataBinding data, Method[] methods, Field[] fields, Constructor[] constructors)
           
 void ClassMetaDataLoader.bind(Advisor advisor, ClassMetaDataBinding data, Method[] methods, Field[] fields, Constructor[] constructors)
          This is a full bind of metadata.
protected  void SimpleClassMetaDataLoader.bindMethodMetaData(Advisor advisor, SimpleClassMetaDataBinding data, MethodMetaData methodMetaData, Method[] advisedMethods)
           
 boolean ClassMetaDataBinding.matches(Advisor advisor, Class clazz)
           
 boolean ClassMetaDataBinding.matches(Advisor advisor, javassist.CtClass clazz)
           
 

Uses of Advisor in org.jboss.aop.pointcut
 

Fields in org.jboss.aop.pointcut declared as Advisor
protected  Advisor MethodMatcher.advisor
           
protected  Advisor SoftClassMatcher.advisor
           
protected  Advisor FieldMatcher.advisor
           
protected  Advisor TypeMatcher.advisor
           
protected  Advisor ConstructorMatcher.advisor
           
 

Methods in org.jboss.aop.pointcut with parameters of type Advisor
protected abstract  boolean MatcherStrategy.checkIntroductions(Class clazz, ClassExpression instanceOf, Advisor advisor)
           
protected  boolean AdvisorMatcherStrategy.checkIntroductions(Class clazz, ClassExpression instanceOf, Advisor advisor)
           
protected  boolean ProxyMatcherStrategy.checkIntroductions(Class clazz, ClassExpression instanceOf, Advisor advisor)
           
abstract  Class MatcherStrategy.getDeclaringClass(Advisor advisor, Method m)
           
 Class AdvisorMatcherStrategy.getDeclaringClass(Advisor advisor, Method m)
           
 Class ProxyMatcherStrategy.getDeclaringClass(Advisor advisor, Method m)
          Interface Introduced methods on the proxy will have the wrong declaring class for the matcher, use the advisor class if it is an interface
static MatcherStrategy MatcherStrategy.getMatcher(Advisor advisor)
           
static boolean Util.has(Class target, ASTConstructor con, Advisor advisor)
           
static boolean Util.has(Class target, ASTField field, Advisor advisor)
           
static boolean Util.has(Class target, ASTField field, Advisor advisor, boolean checkSuper)
           
static boolean Util.has(Class target, ASTMethod method, Advisor advisor)
           
static boolean Util.has(Class target, ASTMethod method, Advisor advisor, boolean checkSuper)
           
static boolean Util.has(javassist.CtClass target, ASTConstructor con, Advisor advisor)
           
static boolean Util.has(javassist.CtClass target, ASTField field, Advisor advisor)
           
static boolean Util.has(javassist.CtClass target, ASTField field, Advisor advisor, boolean checkSuper)
           
static boolean Util.has(javassist.CtClass target, ASTMethod method, Advisor advisor)
           
static boolean Util.has(javassist.CtClass target, ASTMethod method, Advisor advisor, boolean checkSuper)
           
 boolean DeclareDef.matches(Advisor advisor, Class clazz)
           
 boolean Typedef.matches(Advisor advisor, Class clazz)
           
 boolean TypedefExpression.matches(Advisor advisor, Class clazz)
           
 boolean DeclareDef.matches(Advisor advisor, javassist.CtClass clazz)
           
 boolean Typedef.matches(Advisor advisor, javassist.CtClass clazz)
           
 boolean TypedefExpression.matches(Advisor advisor, javassist.CtClass clazz)
           
 boolean PointcutExpression.matchesCall(Advisor advisor, AccessibleObject within, Class calledClass, Constructor calledCon)
           
 boolean Pointcut.matchesCall(Advisor advisor, AccessibleObject within, Class calledClass, Constructor calledCon)
           
 boolean PointcutExpression.matchesCall(Advisor advisor, AccessibleObject within, Class calledClass, Method calledMethod)
           
 boolean Pointcut.matchesCall(Advisor advisor, AccessibleObject within, Class calledClass, Method calledMethod)
           
 boolean PointcutExpression.matchesCall(Advisor callingAdvisor, javassist.expr.MethodCall methodCall)
           
 boolean Pointcut.matchesCall(Advisor callingAdvisor, javassist.expr.MethodCall methodCall)
           
 boolean DeclareDef.matchesCall(Advisor callingAdvisor, javassist.expr.MethodCall methodCall)
           
 boolean PointcutExpression.matchesCall(Advisor callingAdvisor, javassist.expr.NewExpr methodCall)
           
 boolean Pointcut.matchesCall(Advisor callingAdvisor, javassist.expr.NewExpr methodCall)
           
 boolean DeclareDef.matchesCall(Advisor callingAdvisor, javassist.expr.NewExpr methodCall)
           
static boolean Util.matchesClassExpr(ClassExpression classExpr, Class clazz, Advisor advisor)
           
static boolean Util.matchesClassExpr(ClassExpression classExpr, javassist.CtClass clazz, Advisor advisor)
           
 boolean PointcutExpression.matchesConstruction(Advisor advisor, Constructor c)
           
 boolean Pointcut.matchesConstruction(Advisor advisor, Constructor c)
           
 boolean PointcutExpression.matchesConstruction(Advisor advisor, javassist.CtConstructor c)
           
 boolean Pointcut.matchesConstruction(Advisor advisor, javassist.CtConstructor c)
           
 boolean PointcutExpression.matchesExecution(Advisor advisor, Constructor c)
           
 boolean Pointcut.matchesExecution(Advisor advisor, Constructor c)
           
 boolean PointcutExpression.matchesExecution(Advisor advisor, javassist.CtConstructor c)
           
 boolean Pointcut.matchesExecution(Advisor advisor, javassist.CtConstructor c)
           
 boolean PointcutExpression.matchesExecution(Advisor advisor, javassist.CtMethod m)
           
 boolean Pointcut.matchesExecution(Advisor advisor, javassist.CtMethod m)
           
 boolean PointcutExpression.matchesExecution(Advisor advisor, Method m)
           
 boolean Pointcut.matchesExecution(Advisor advisor, Method m)
           
 boolean PointcutExpression.matchesExecution(Advisor advisor, Method m, boolean matchOnAdvisor)
           
 boolean Pointcut.matchesExecution(Advisor advisor, Method m, boolean matchOnAdvisor)
           
 boolean PointcutExpression.matchesGet(Advisor advisor, javassist.CtField f)
           
 boolean Pointcut.matchesGet(Advisor advisor, javassist.CtField f)
           
 boolean PointcutExpression.matchesGet(Advisor advisor, Field f)
           
 boolean Pointcut.matchesGet(Advisor advisor, Field f)
           
static boolean Util.matchesParameters(Advisor advisor, ASTConstructor node, Constructor con)
           
static boolean Util.matchesParameters(Advisor advisor, ASTConstructor node, javassist.CtConstructor ctConstructor)
           
static boolean Util.matchesParameters(Advisor advisor, ASTMethod node, javassist.CtMethod ctMethod)
           
static boolean Util.matchesParameters(Advisor advisor, ASTMethod node, Method method)
           
 boolean PointcutExpression.matchesSet(Advisor advisor, javassist.CtField f)
           
 boolean Pointcut.matchesSet(Advisor advisor, javassist.CtField f)
           
 boolean PointcutExpression.matchesSet(Advisor advisor, Field f)
           
 boolean Pointcut.matchesSet(Advisor advisor, Field f)
           
static boolean Util.matchesTypedef(Class clazz, ClassExpression classExpr, Advisor advisor)
           
static boolean Util.matchesTypedef(javassist.CtClass clazz, ClassExpression classExpr, Advisor advisor)
           
static boolean Util.methodExistsInSuperClassOrInterface(Method method, ClassExpression target, boolean exactSuper, Advisor advisor)
           
 boolean PointcutExpression.softMatch(Advisor advisor)
           
 boolean Pointcut.softMatch(Advisor advisor)
           
static boolean Util.subtypeOf(Class clazz, ClassExpression instanceOf, Advisor advisor)
           
 boolean MatcherStrategy.subtypeOf(Class clazz, ClassExpression instanceOf, Advisor advisor)
           
static boolean Util.subtypeOf(javassist.CtClass clazz, ClassExpression instanceOf, Advisor advisor)
           
 

Constructors in org.jboss.aop.pointcut with parameters of type Advisor
AnnotationMatcher(Advisor advisor, Object element)
           
CallMatcher(Advisor advisor, AccessibleObject within, Class calledClass, Method calledMethod, ASTStart start)
           
ConstructionMatcher(Advisor advisor, Constructor con, ASTStart start)
           
ConstructionMatcher(Advisor advisor, javassist.CtConstructor con, ASTStart start)
           
ConstructorCallMatcher(Advisor advisor, AccessibleObject within, Class calledClass, Constructor calledCon, ASTStart start)
           
ConstructorMatcher(Advisor advisor, Constructor con, ASTStart start)
           
ConstructorMatcher(Advisor advisor, javassist.CtConstructor con, ASTStart start)
           
DeclareTypeMatcher(Advisor advisor, Class clazz)
           
DeclareTypeMatcher(Advisor advisor, javassist.CtClass ctClass)
           
ExecutionConstructorMatcher(Advisor advisor, Constructor con, ASTStart start)
           
ExecutionConstructorMatcher(Advisor advisor, javassist.CtConstructor con, ASTStart start)
           
ExecutionMethodMatcher(Advisor advisor, javassist.CtMethod method, ASTStart start)
           
ExecutionMethodMatcher(Advisor advisor, Method method, ASTStart start, boolean matchOnAdvisor)
           
FieldGetMatcher(Advisor advisor, javassist.CtField field, ASTStart start)
           
FieldGetMatcher(Advisor advisor, Field field, ASTStart start)
           
FieldMatcher(Advisor advisor, javassist.CtField field, ASTStart start)
           
FieldMatcher(Advisor advisor, Field field, ASTStart start)
           
FieldSetMatcher(Advisor advisor, javassist.CtField field, ASTStart start)
           
FieldSetMatcher(Advisor advisor, Field field, ASTStart start)
           
MethodCallMatcher(Advisor advisor, javassist.expr.MethodCall call, ASTStart start)
           
MethodMatcher(Advisor advisor, javassist.CtMethod method, ASTStart start)
           
MethodMatcher(Advisor advisor, Method method, ASTStart start)
           
MethodMatcher(Advisor advisor, Method method, ASTStart start, boolean matchOnAdvisor)
           
NewExprMatcher(Advisor advisor, javassist.expr.NewExpr call, ASTStart start)
           
SoftClassMatcher(Advisor advisor, String classname, ASTStart start)
           
TypeMatcher(Advisor advisor, Class clazz)
           
TypeMatcher(Advisor advisor, javassist.CtClass ctClass)
           
WithinMatcher(Advisor advisor, AccessibleObject behavior, ASTStart start)
           
WithinMatcher(Advisor advisor, javassist.CtBehavior behavior, ASTStart start)
           
 

Uses of Advisor in org.jboss.aop.proxy.container
 

Subclasses of Advisor in org.jboss.aop.proxy.container
 class ClassProxyContainer
          Extension of ClassContainer needed because of Mixins we want to be able to match pointcut expressions on the base class of the delegate we also want to be able to match pointcuts of instanceof{} of the Mixin interfaces.
 class InstanceProxyContainer
          The InstanceAdvisor returned by ClassProxyContainer
 

Fields in org.jboss.aop.proxy.container declared as Advisor
protected  Advisor ProxyTemplate.currentAdvisor
           
 

Methods in org.jboss.aop.proxy.container that return Advisor
 Advisor ProxyTemplate.getAdvisor()
           
 Advisor AspectManaged.getAdvisor()
           
 Advisor ProxyAdvisorDomain.getAdvisor()
           
 Advisor ContainerCache.getAdvisor()
           
 Advisor ContainerCache.getClassAdvisor()
           
 Advisor InstanceProxyContainer.getClassAdvisor()
           
 

Methods in org.jboss.aop.proxy.container with parameters of type Advisor
static InstanceProxyContainer InstanceProxyContainer.createInstanceProxyContainer(Advisor classAdvisor, InterfaceIntroduction introduction)
           
static javassist.CtClass ContainerProxyFactory.createProxyCtClass(boolean objectAsSuper, ArrayList mixins, Class clazz, Advisor advisor)
           
static Class ContainerProxyFactory.getProxyClass(boolean objectAsSuper, ContainerProxyCacheKey key, Advisor advisor)
           
 void ProxyAdvisorDomain.removeAdvisor(Advisor advisor)
           
 void ProxyTemplate.setAdvisor(Advisor advisor)
           
 void AspectManaged.setAdvisor(Advisor advisor)
           
 void ProxyAdvisorDomain.setAdvisor(Advisor advisor)
           
 

Constructors in org.jboss.aop.proxy.container with parameters of type Advisor
InstanceProxyContainer(String name, ProxyAdvisorDomain instanceDomain, Advisor classAdvisor)
           
 



Copyright © 2004 JBoss Inc. All Rights Reserved.