Uses of Class
org.jboss.aop.Advisor

Packages that use Advisor
org.jboss.aop   
org.jboss.aop.advice   
org.jboss.aop.array   
org.jboss.aop.instrument   
org.jboss.aop.introduction   
org.jboss.aop.joinpoint   
org.jboss.aop.metadata   
org.jboss.aop.microcontainer.lifecycle   
org.jboss.aop.pointcut   
org.jboss.aop.proxy.container   
org.jboss.aop.standalone   
org.jboss.aop.util   
org.jboss.aspects.concurrent   
org.jboss.aspects.logging   
 

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 InstanceDomain.advisor
           
protected  Advisor ReflectiveAspectBinder.advisor
           
 

Fields in org.jboss.aop with type parameters of type Advisor
protected  WeakHashMap<Class<?>,WeakReference<Advisor>> AspectManager.advisors
          Advisors registered with this manager/domain
protected  WeakReference<Advisor> InstanceAdvisorDelegate.classAdvisor
           
protected  WeakReference<Advisor> ClassInstanceAdvisor.classAdvisorRef
           
 

Methods in org.jboss.aop that return Advisor
 Advisor Advised._getAdvisor()
          Returns the manager, also known as advisor, of the weaved class.
 Advisor AspectManager.findAdvisor(Class<?> clazz)
           
 Advisor InstanceAdvisorDelegate.getAdvisor()
           
 Advisor InstanceDomain.getAdvisor()
           
 Advisor JoinPointInfo.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 that return types with arguments of type Advisor
 Map<Class<?>,WeakReference<Advisor>> AspectManager.getAdvisors()
           
 

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)
           
 void Domain.attachMetaData(Advisor advisor, Class<?> clazz)
           
protected  void AspectManager.attachMetaData(Advisor advisor, Class<?> clazz)
           
 Interceptor GeneratedInstanceAdvisorMixin.InstanceInterceptorFactory.create(Advisor advisor, Joinpoint joinpoint)
           
 boolean Advisor.hasSameConstructorAspectLength(Advisor other)
           
 boolean Advisor.hasSameMethodAspectLength(Advisor other)
           
 boolean InstanceDomain.isAdvisorRegistered(Advisor advisor)
          internal to jboss aop.
 boolean AspectManager.isAdvisorRegistered(Advisor advisor)
          Checks to see if an Advisor represents a class that should have been undeployed.
 void InstanceDomain.setAdvisor(Advisor advisor)
           
 void JoinPointInfo.setAdvisor(Advisor advisor)
           
 

Method parameters in org.jboss.aop with type arguments of type Advisor
protected  void AspectManager.updateAdvisorsForAddedBinding(AdviceBinding binding, Set<Advisor> handledAdvisors)
           
 

Constructors in org.jboss.aop with parameters of type Advisor
CallerConstructorInfo(Advisor advisor, Class<?> calledClass, Constructor<?> called, long calledConHash, Method wrappingMethod, Interceptor[] in, Class<?> clazz)
           
CallerMethodInfo(Advisor advisor, Class<?> calledClass, Method m, long calledMethodHash, Interceptor[] in, Class<?> clazz)
           
ClassInstanceAdvisor(Advisor advizor)
           
ConByConInfo(Advisor advisor, Class<?> calledClass, Class<?> callingClass, int callingIndex, Constructor<?> called, long calledConHash, Method wrappingMethod, Interceptor[] in)
           
ConByMethodInfo(Advisor advisor, Class<?> calledClass, Method callingMethod, 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(Advisor advisor, boolean read)
           
FieldInfo(Class<?> clazz, int index, String fieldName, long wrapperHash, Advisor advisor, boolean read)
           
InstanceAdvisorDelegate(Advisor classAdvisor, InstanceAdvisor instanceAdvisor)
           
JoinPointInfo(Advisor advisor, Class<?> clazz)
           
MethodByConInfo(Advisor advisor, Class<?> calledClass, Class<?> callingClass, int callingIndex, Method m, long calledMethodHash, Interceptor[] in)
           
MethodByMethodInfo(Advisor advisor, Class<?> calledClass, Method m, Method callingMethod, long callingMethodHash, long calledMethodHash, Interceptor[] in)
           
MethodInfo(Class<?> clazz, long hash, long unadvisedHash, Advisor advisor)
           
MethodInterceptors(Advisor advisor)
           
ReflectiveAspectBinder(Class<?> clazz, Advisor advisor)
           
 

Uses of Advisor in org.jboss.aop.advice
 

Fields in org.jboss.aop.advice with type parameters of type Advisor
protected  Map<Advisor,Boolean> AdviceBinding.advisors
          Contains all the client advisors, mapped to a boolean value.
 Map<Advisor,Boolean> AspectDefinition.advisors
          Deprecated. should not call this directly
 

Methods in org.jboss.aop.advice that return types with arguments of type Advisor
 ArrayList<Advisor> AdviceBinding.getAdvisors()
          Returns the list of the client advisors.
 

Methods in org.jboss.aop.advice with parameters of type Advisor
 void AdviceBinding.addAdvisor(Advisor advisor)
          Adds an advisor as a client of this binding.
protected  void GenericAspectFactory.configureInstance(Object instance, Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
           
 Interceptor GenericInterceptorFactory.create(Advisor advisor, Joinpoint joinpoint)
           
 Interceptor InterceptorFactory.create(Advisor advisor, Joinpoint joinpoint)
          Creates an interceptor that represents this advice and that delegates execution to this advice.
 Interceptor GeneratedAdvisorInterceptor.create(Advisor advisor, Joinpoint joinpoint)
           
 Interceptor AdviceFactory.create(Advisor advisor, Joinpoint joinpoint)
           
 Interceptor ScopedInterceptorFactory.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 AspectFactory.createPerClass(Advisor advisor)
          Creates an aspect with scope value Scope.PER_CLASS.
 Object AspectFactoryDelegator.createPerClass(Advisor advisor)
           
 Object GenericAspectFactory.createPerInstance(Advisor advisor, InstanceAdvisor instanceAdvisor)
           
 Object AspectFactory.createPerInstance(Advisor advisor, InstanceAdvisor instanceAdvisor)
          Creates an aspect with scope value Scope.PER_INSTANCE.
 Object AspectFactoryDelegator.createPerInstance(Advisor advisor, InstanceAdvisor instanceAdvisor)
           
 Object GenericAspectFactory.createPerJoinpoint(Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
           
 Object AspectFactory.createPerJoinpoint(Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
          Creates an aspect with scope value or Scope.PER_JOINPOINT.
 Object AspectFactoryDelegator.createPerJoinpoint(Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
           
 Object GenericAspectFactory.createPerJoinpoint(Advisor advisor, Joinpoint jp)
           
 Object AspectFactory.createPerJoinpoint(Advisor advisor, Joinpoint jp)
          Creates an aspect with scope value Scope.PER_CLASS_JOINPOINT or Scope.PER_JOINPOINT.
 Object AspectFactoryDelegator.createPerJoinpoint(Advisor advisor, Joinpoint jp)
           
static Interceptor PerClassAdvice.generate(Joinpoint joinpoint, Advisor advisor, String adviceName, AspectDefinition def)
           
 Object GeneratedAdvisorInterceptor.getAspect(Advisor advisor, Joinpoint joinpoint)
          Used to obtain aspects from the generated code at runtime for joinpoints/aspects requiring an instance advisor
 Object GeneratedAdvisorInterceptor.getAspect(Advisor advisor, Joinpoint joinpoint, boolean forCodeGeneration)
          Also used as a convenience method to create aspect instances for the JoinPointGenerator in order to figure out what the class of the aspect should be when making the call from the generated joinpoint class.
 Object GeneratedAdvisorInterceptor.getPerInstanceAspect(Advisor advisor, Joinpoint joinpoint, InstanceAdvisor ia)
          Used to obtain aspects from the generated code at runtime for joinpoints/aspects requiring an instance advisor
protected  void GenericAspectFactory.injectAdvisor(Object instance, Advisor advisor, String attributeName)
           
 void AspectDefinition.registerAdvisor(Advisor advisor)
          Registers advisor as being a client of this definition.
 void AspectDefinition.unregisterAdvisor(Advisor advisor)
          Unregisters advisor as being a client of this definition.
 

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.array
 

Methods in org.jboss.aop.array that return Advisor
 Advisor ArrayElementInvocation.getAdvisor()
           
 

Methods in org.jboss.aop.array with parameters of type Advisor
 boolean ArrayReplacement.matches(Advisor advisor, Class<?> clazz)
           
 boolean ArrayReplacement.matches(Advisor advisor, javassist.CtClass clazz)
           
 void ArrayElementInvocation.setAdvisor(Advisor advisor)
           
 

Uses of Advisor in org.jboss.aop.instrument
 

Methods in org.jboss.aop.instrument with parameters of type Advisor
protected  javassist.CtMethod GeneratedAdvisorInstrumentor.addMixinMethod(Advisor advisor, javassist.CtMethod method, javassist.CtClass clazz, javassist.CtMethod delegate, long hash)
           
protected  javassist.CtMethod Instrumentor.addMixinMethod(Advisor advisor, javassist.CtMethod method, javassist.CtClass clazz, javassist.CtMethod delegate, long hash)
           
 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, JoinpointClassifier.BindingCollectionAccessor bindingCollectionAccessor)
          Classifies a joinpoint.
protected  JoinpointClassification JoinpointSimpleClassifier.classifyJoinpoint(javassist.CtMember member, Advisor advisor, JoinpointClassifier.Matcher joinpointMatcher, JoinpointClassifier.BindingCollectionAccessor bindingCollectionAccessor)
          Classifies the execution of a joinpoint.
protected  JoinpointClassification JoinpointFullClassifier.classifyJoinpoint(javassist.CtMember member, Advisor advisor, JoinpointClassifier.Matcher joinpointMatcher, JoinpointClassifier.BindingCollectionAccessor bindingCollectionAccessor)
          Classifies the execution of a joinpoint.
 JoinpointClassification JoinpointClassifier.classifyMethodExecution(javassist.CtMethod method, Advisor advisor)
          Classifies the execution of method.
 Collection<PointcutInfo> JoinpointClassifier.BindingCollectionAccessor.getPointcutInfos(Advisor advisor)
           
 Collection<Pointcut> JoinpointClassifier.BindingCollectionAccessor.getPointcuts(Advisor advisor)
           
 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
 

Fields in org.jboss.aop.introduction with type parameters of type Advisor
protected  ArrayList<WeakReference<Advisor>> InterfaceIntroduction.advisors
           
 

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 MethodInvocationWrapper.getAdvisor()
           
 Advisor FieldReadInvocationWrapper.getAdvisor()
           
 Advisor FieldWriteInvocationWrapper.getAdvisor()
           
 Advisor InvocationBase.getAdvisor()
           
 Advisor MethodCalledByConstructorInvocationWrapper.getAdvisor()
           
 Advisor JoinPointBean.getAdvisor()
          Gets the advisor
 Advisor ConstructionInvocationWrapper.getAdvisor()
           
 Advisor Invocation.getAdvisor()
           
 Advisor ConstructorInvocationWrapper.getAdvisor()
           
 Advisor MethodCalledByMethodInvocationWrapper.getAdvisor()
           
 Advisor MethodInvocation.getAdvisor()
           
 Advisor ConstructorCalledByMethodInvocationWrapper.getAdvisor()
           
 Advisor ConstructorCalledByConstructorInvocationWrapper.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
 

Fields in org.jboss.aop.metadata with type parameters of type Advisor
protected  ArrayList<WeakReference<Advisor>> ClassMetaDataBinding.advisors
           
 

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.microcontainer.lifecycle
 

Methods in org.jboss.aop.microcontainer.lifecycle with parameters of type Advisor
 boolean LifecycleCallbackBinding.matches(Advisor advisor, Class<?> clazz)
           
 

Uses of Advisor in org.jboss.aop.pointcut
 

Fields in org.jboss.aop.pointcut declared as Advisor
protected  Advisor SoftClassMatcher.advisor
           
protected  Advisor TypeMatcher.advisor
           
protected  Advisor MethodMatcher.advisor
           
protected  Advisor FieldMatcher.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 TypedefExpression.matches(Advisor advisor, Class<?> clazz)
           
 boolean DeclareDef.matches(Advisor advisor, Class<?> clazz)
           
 boolean Typedef.matches(Advisor advisor, Class<?> clazz)
           
 boolean TypedefExpression.matches(Advisor advisor, javassist.CtClass clazz)
           
 boolean DeclareDef.matches(Advisor advisor, javassist.CtClass clazz)
           
 boolean Typedef.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)
           
 PointcutMethodMatch PointcutExpression.matchesExecution(Advisor advisor, Method m)
           
 PointcutMethodMatch Pointcut.matchesExecution(Advisor advisor, Method m)
           
 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)
           
 boolean MatcherStrategy.subtypeOf(Class<?> clazz, ClassExpression instanceOf, Advisor advisor)
           
static boolean Util.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)
           
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)
           
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
 class MarshalledProxyAdvisor
          The advisor used by a container proxy that is unmarshalled in a remote jvm
 

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

Fields in org.jboss.aop.proxy.container with type parameters of type Advisor
protected  WeakReference<Advisor> ProxyAdvisorDomain.advisor
           
 

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

Methods in org.jboss.aop.proxy.container with parameters of type Advisor
static InstanceProxyContainer InstanceProxyContainer.createInstanceProxyContainer(Advisor classAdvisor, InterfaceIntroduction introduction, org.jboss.metadata.spi.MetaData metaData)
           
static Class<?> ContainerProxyFactory.getProxyClass(boolean objectAsSuper, ClassLoader loader, ContainerProxyCacheKey key, Advisor advisor)
           
static Class<?> ContainerProxyFactory.getProxyClass(boolean objectAsSuper, ClassLoader loader, ContainerProxyCacheKey key, Advisor advisor, MarshalledContainerProxy outOfVmProxy)
           
static Class<?> ContainerProxyFactory.getProxyClass(boolean objectAsSuper, ContainerProxyCacheKey key, Advisor advisor)
           
static Class<?> ContainerProxyFactory.getProxyClass(boolean objectAsSuper, ContainerProxyCacheKey key, Advisor advisor, MarshalledContainerProxy outOfVmProxy)
           
 void ProxyAdvisorDomain.removeAdvisor(Advisor advisor)
           
 void AspectManaged.setAdvisor(Advisor advisor)
           
 void ProxyAdvisorDomain.setAdvisor(Advisor advisor)
           
 void ProxyTemplate.setAdvisor(Advisor advisor)
           
 

Constructors in org.jboss.aop.proxy.container with parameters of type Advisor
InstanceProxyContainer(String name, ProxyAdvisorDomain instanceDomain, Advisor classAdvisor, org.jboss.metadata.spi.MetaData metaData)
           
MarshalledContainerProxy(AspectManaged proxyInstance, ContainerProxyCacheKey key, Object[] mixins, Object delegate, Advisor currentAdvisor, SimpleMetaData metadata)
           
 

Uses of Advisor in org.jboss.aop.standalone
 

Fields in org.jboss.aop.standalone with type parameters of type Advisor
 HashMap<String,Advisor> Package.advisors
           
 

Uses of Advisor in org.jboss.aop.util
 

Methods in org.jboss.aop.util with parameters of type Advisor
static boolean JoinPointComparator.hasSameMethodAspectLength(long[] myKeys, long[] otherKeys, Advisor myAdvisor, Advisor otherAdvisor)
           
 

Uses of Advisor in org.jboss.aspects.concurrent
 

Methods in org.jboss.aspects.concurrent with parameters of type Advisor
 Object MutexAspectFactory.createPerClass(Advisor advisor)
           
 Object MutexAspectFactory.createPerInstance(Advisor advisor, InstanceAdvisor instanceAdvisor)
           
 Object MutexAspectFactory.createPerJoinpoint(Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
           
 Object MutexAspectFactory.createPerJoinpoint(Advisor advisor, Joinpoint jp)
           
 

Uses of Advisor in org.jboss.aspects.logging
 

Methods in org.jboss.aspects.logging with parameters of type Advisor
 Object InvocationLogInterceptorFactory.createPerClass(Advisor advisor)
           
 Object CallLoggingInterceptorFactory.createPerClass(Advisor advisor)
           
 Object InvocationLogInterceptorFactory.createPerInstance(Advisor advisor, InstanceAdvisor instanceAdvisor)
           
 Object CallLoggingInterceptorFactory.createPerInstance(Advisor advisor, InstanceAdvisor instanceAdvisor)
           
 Object InvocationLogInterceptorFactory.createPerJoinpoint(Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
           
 Object CallLoggingInterceptorFactory.createPerJoinpoint(Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
           
 Object InvocationLogInterceptorFactory.createPerJoinpoint(Advisor advisor, Joinpoint jp)
           
 Object CallLoggingInterceptorFactory.createPerJoinpoint(Advisor advisor, Joinpoint jp)
           
 



Copyright © 2009 JBoss, a division of Red Hat, Inc.. All Rights Reserved.