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
 

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

Methods in org.jboss.aop that return Advisor
 Advisor AspectManager.getAdvisor(String name)
           
 Advisor Advised._getAdvisor()
          Return the manager.
 Advisor InstanceDomain.getAdvisor()
           
 

Methods in org.jboss.aop with parameters of type Advisor
 boolean AspectManager.isAdvisorRegistered(Advisor advisor)
          Checks to see if an Advisor represents a class that should have been undeployed.
protected  void AspectManager.applyInterfaceIntroductions(Advisor advisor, Class clazz)
           
 void InstanceDomain.setAdvisor(Advisor advisor)
           
 boolean InstanceDomain.isAdvisorRegistered(Advisor advisor)
          internal to jboss aop.
 

Constructors in org.jboss.aop with parameters of type Advisor
MethodJoinPoint(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
 Interceptor ScopedInterceptorFactory.create(Advisor advisor, Joinpoint joinpoint)
           
 Interceptor AdviceFactory.create(Advisor advisor, Joinpoint joinpoint)
           
 Object GenericAspectFactory.createPerClass(Advisor advisor)
           
 Object GenericAspectFactory.createPerInstance(Advisor advisor, InstanceAdvisor instanceAdvisor)
           
 Object GenericAspectFactory.createPerJoinpoint(Advisor advisor, Joinpoint jp)
           
 Object GenericAspectFactory.createPerJoinpoint(Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
           
protected  void GenericAspectFactory.configureInstance(Object instance, Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
           
protected  void GenericAspectFactory.injectAdvisor(Object instance, Advisor advisor, String attributeName)
           
 Interceptor InterceptorFactory.create(Advisor advisor, Joinpoint joinpoint)
           
static Interceptor PerJoinpointAdvice.createInterceptor(Advisor advisor, Joinpoint joinpoint, AspectDefinition def, String adviceName)
           
static Interceptor PerJoinpointInterceptor.createInterceptor(Advisor advisor, Joinpoint joinpoint, AspectDefinition def)
           
 Interceptor GenericInterceptorFactory.create(Advisor advisor, Joinpoint joinpoint)
           
 void AspectDefinition.addAdvisor(Advisor advisor)
           
static Interceptor PerClassAdvice.generate(Joinpoint joinpoint, Advisor advisor, String adviceName, AspectDefinition def)
           
 Interceptor[] AdviceStack.createInterceptors(Advisor advisor, Joinpoint jp)
           
 Object AspectFactoryDelegator.createPerClass(Advisor advisor)
           
 Object AspectFactoryDelegator.createPerInstance(Advisor advisor, InstanceAdvisor instanceAdvisor)
           
 Object AspectFactoryDelegator.createPerJoinpoint(Advisor advisor, Joinpoint jp)
           
 Object AspectFactoryDelegator.createPerJoinpoint(Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
           
 Object AspectFactory.createPerClass(Advisor advisor)
           
 Object AspectFactory.createPerInstance(Advisor advisor, InstanceAdvisor instanceAdvisor)
           
 Object AspectFactory.createPerJoinpoint(Advisor advisor, Joinpoint jp)
           
 Object AspectFactory.createPerJoinpoint(Advisor advisor, InstanceAdvisor instanceAdvisor, Joinpoint jp)
           
 void AdviceBinding.addAdvisor(Advisor advisor)
           
 

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

Uses of Advisor in org.jboss.aop.instrument
 

Methods in org.jboss.aop.instrument with parameters of type Advisor
protected abstract  JoinpointClassification JoinpointClassifier.classifyJoinpoint(javassist.CtMember member, Advisor advisor, JoinpointClassifier.Matcher joinpointMatcher)
          Classifies a joinpoint.
 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.
 JoinpointClassification JoinpointClassifier.classifyConstructorExecution(javassist.CtConstructor cons, Advisor advisor)
          Classifies the execution of cons.
 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.
protected  JoinpointClassification JoinpointFullClassifier.classifyJoinpoint(javassist.CtMember member, Advisor advisor, JoinpointClassifier.Matcher joinpointMatcher)
          Classifies the execution of a joinpoint.
protected  JoinpointClassification JoinpointSimpleClassifier.classifyJoinpoint(javassist.CtMember member, Advisor advisor, JoinpointClassifier.Matcher joinpointMatcher)
          Classifies the execution of 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 InterfaceIntroduction.matches(Advisor advisor, javassist.CtClass clazz)
           
 boolean InterfaceIntroduction.matches(Advisor advisor, Class clazz)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, javassist.CtClass clazz)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, javassist.CtMethod method)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, javassist.CtConstructor con)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, javassist.CtField field)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, Class clazz)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, Method method)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, Constructor con)
           
 boolean AnnotationIntroduction.matches(Advisor advisor, Field field)
           
 

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 FieldWriteInvocationWrapper.getAdvisor()
           
 Advisor MethodInvocation.getAdvisor()
           
 Advisor MethodInvocationWrapper.getAdvisor()
           
 Advisor Invocation.getAdvisor()
           
 Advisor MethodCalledByConstructorInvocationWrapper.getAdvisor()
           
 Advisor ConstructorCalledByConstructorInvocationWrapper.getAdvisor()
           
 Advisor ConstructionInvocationWrapper.getAdvisor()
           
 Advisor ConstructorCalledByMethodInvocationWrapper.getAdvisor()
           
 Advisor InvocationBase.getAdvisor()
           
 Advisor MethodCalledByMethodInvocationWrapper.getAdvisor()
           
 Advisor ConstructorInvocationWrapper.getAdvisor()
           
 Advisor FieldReadInvocationWrapper.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
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 SimpleClassMetaDataLoader.bind(Advisor advisor, ClassMetaDataBinding data, Method[] methods, Field[] fields, Constructor[] constructors)
           
 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 ClassMetaDataLoader.bind(Advisor advisor, ClassMetaDataBinding data, Method[] methods, Field[] fields, Constructor[] constructors)
          This is a full bind of metadata.
 void ClassMetaDataBinding.addAdvisor(Advisor advisor)
           
 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 SoftClassMatcher.advisor
           
protected  Advisor ConstructorMatcher.advisor
           
protected  Advisor TypeMatcher.advisor
           
protected  Advisor MethodMatcher.advisor
           
protected  Advisor FieldMatcher.advisor
           
 

Methods in org.jboss.aop.pointcut with parameters of type Advisor
 boolean DeclareDef.matches(Advisor advisor, javassist.CtClass clazz)
           
 boolean DeclareDef.matches(Advisor advisor, Class clazz)
           
 boolean DeclareDef.matchesCall(Advisor callingAdvisor, javassist.expr.MethodCall methodCall)
           
 boolean DeclareDef.matchesCall(Advisor callingAdvisor, javassist.expr.NewExpr methodCall)
           
 boolean TypedefExpression.matches(Advisor advisor, javassist.CtClass clazz)
           
 boolean TypedefExpression.matches(Advisor advisor, Class clazz)
           
 boolean Typedef.matches(Advisor advisor, javassist.CtClass clazz)
           
 boolean Typedef.matches(Advisor advisor, Class clazz)
           
 boolean PointcutExpression.softMatch(Advisor advisor)
           
 boolean PointcutExpression.matchesCall(Advisor callingAdvisor, javassist.expr.MethodCall methodCall)
           
 boolean PointcutExpression.matchesCall(Advisor callingAdvisor, javassist.expr.NewExpr methodCall)
           
 boolean PointcutExpression.matchesExecution(Advisor advisor, Method m)
           
 boolean PointcutExpression.matchesExecution(Advisor advisor, Constructor c)
           
 boolean PointcutExpression.matchesConstruction(Advisor advisor, Constructor c)
           
 boolean PointcutExpression.matchesGet(Advisor advisor, Field f)
           
 boolean PointcutExpression.matchesSet(Advisor advisor, Field f)
           
 boolean PointcutExpression.matchesExecution(Advisor advisor, javassist.CtMethod m)
           
 boolean PointcutExpression.matchesExecution(Advisor advisor, javassist.CtConstructor c)
           
 boolean PointcutExpression.matchesConstruction(Advisor advisor, javassist.CtConstructor c)
           
 boolean PointcutExpression.matchesGet(Advisor advisor, javassist.CtField f)
           
 boolean PointcutExpression.matchesSet(Advisor advisor, javassist.CtField f)
           
 boolean PointcutExpression.matchesCall(Advisor advisor, AccessibleObject within, Class calledClass, Method calledMethod)
           
 boolean PointcutExpression.matchesCall(Advisor advisor, AccessibleObject within, Class calledClass, Constructor calledCon)
           
 boolean Pointcut.softMatch(Advisor advisor)
           
 boolean Pointcut.matchesExecution(Advisor advisor, javassist.CtMethod m)
           
 boolean Pointcut.matchesExecution(Advisor advisor, javassist.CtConstructor c)
           
 boolean Pointcut.matchesConstruction(Advisor advisor, javassist.CtConstructor c)
           
 boolean Pointcut.matchesGet(Advisor advisor, javassist.CtField f)
           
 boolean Pointcut.matchesSet(Advisor advisor, javassist.CtField f)
           
 boolean Pointcut.matchesCall(Advisor callingAdvisor, javassist.expr.MethodCall methodCall)
           
 boolean Pointcut.matchesCall(Advisor callingAdvisor, javassist.expr.NewExpr methodCall)
           
 boolean Pointcut.matchesExecution(Advisor advisor, Method m)
           
 boolean Pointcut.matchesExecution(Advisor advisor, Constructor c)
           
 boolean Pointcut.matchesConstruction(Advisor advisor, Constructor c)
           
 boolean Pointcut.matchesGet(Advisor advisor, Field f)
           
 boolean Pointcut.matchesSet(Advisor advisor, Field f)
           
 boolean Pointcut.matchesCall(Advisor advisor, AccessibleObject within, Class calledClass, Method calledMethod)
           
 boolean Pointcut.matchesCall(Advisor advisor, AccessibleObject within, Class calledClass, Constructor calledCon)
           
static boolean Util.matchesClassExpr(ClassExpression classExpr, javassist.CtClass clazz, Advisor advisor)
           
static boolean Util.matchesClassExpr(ClassExpression classExpr, Class clazz, Advisor advisor)
           
static boolean Util.has(javassist.CtClass target, ASTMethod method, Advisor advisor)
           
static boolean Util.has(javassist.CtClass target, ASTMethod method, Advisor advisor, boolean checkSuper)
           
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, ASTConstructor con, Advisor advisor)
           
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(Class target, ASTField field, Advisor advisor)
           
static boolean Util.has(Class target, ASTField field, Advisor advisor, boolean checkSuper)
           
static boolean Util.has(Class target, ASTConstructor con, Advisor advisor)
           
static boolean Util.matchesTypedef(javassist.CtClass clazz, ClassExpression classExpr, Advisor advisor)
           
static boolean Util.matchesTypedef(Class clazz, ClassExpression classExpr, Advisor advisor)
           
static boolean Util.matchesParameters(Advisor advisor, ASTMethod node, javassist.CtMethod ctMethod)
           
static boolean Util.matchesParameters(Advisor advisor, ASTConstructor node, javassist.CtConstructor ctConstructor)
           
static boolean Util.matchesParameters(Advisor advisor, ASTMethod node, Method method)
           
static boolean Util.matchesParameters(Advisor advisor, ASTConstructor node, Constructor con)
           
 

Constructors in org.jboss.aop.pointcut with parameters of type Advisor
SoftClassMatcher(Advisor advisor, String classname, ASTStart start)
           
ConstructorMatcher(Advisor advisor, javassist.CtConstructor con, ASTStart start)
           
ConstructorMatcher(Advisor advisor, Constructor con, ASTStart start)
           
ConstructorCallMatcher(Advisor advisor, AccessibleObject within, Class calledClass, Constructor calledCon, ASTStart start)
           
TypeMatcher(Advisor advisor, Class clazz)
           
TypeMatcher(Advisor advisor, javassist.CtClass ctClass)
           
MethodMatcher(Advisor advisor, javassist.CtMethod method, ASTStart start)
           
MethodMatcher(Advisor advisor, Method method, ASTStart start)
           
AnnotationMatcher(Advisor advisor, Object element)
           
NewExprMatcher(Advisor advisor, javassist.expr.NewExpr call, ASTStart start)
           
DeclareTypeMatcher(Advisor advisor, Class clazz)
           
DeclareTypeMatcher(Advisor advisor, javassist.CtClass ctClass)
           
MethodCallMatcher(Advisor advisor, javassist.expr.MethodCall call, ASTStart start)
           
CallMatcher(Advisor advisor, AccessibleObject within, Class calledClass, Method calledMethod, ASTStart start)
           
ExecutionMethodMatcher(Advisor advisor, javassist.CtMethod method, ASTStart start)
           
ExecutionMethodMatcher(Advisor advisor, Method method, ASTStart start)
           
ConstructionMatcher(Advisor advisor, javassist.CtConstructor con, ASTStart start)
           
ConstructionMatcher(Advisor advisor, Constructor con, ASTStart start)
           
ExecutionConstructorMatcher(Advisor advisor, javassist.CtConstructor con, ASTStart start)
           
ExecutionConstructorMatcher(Advisor advisor, Constructor con, 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)
           
WithinMatcher(Advisor advisor, javassist.CtBehavior behavior, ASTStart start)
           
WithinMatcher(Advisor advisor, AccessibleObject 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.
 

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

Methods in org.jboss.aop.proxy.container with parameters of type Advisor
 void ProxyTemplate.setAdvisor(Advisor advisor)
           
 void AspectManaged.setAdvisor(Advisor advisor)
           
 



Copyright © 2002 JBoss Group, LLC. All Rights Reserved.