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	JoinPointInfo.getAdvisor()
Advisor	InstanceDomain.getAdvisor()
Advisor	InstanceAdvisorDelegate.getAdvisor()
Advisor	AspectManager.getAdvisor(String name)
Advisor	AspectManager.findAdvisor(Class clazz)
Advisor	AspectManager.getAnyAdvisorIfAdvised(Class clazz) Take into account that an advisor may be a container
Advisor	AspectManager.getTempClassAdvisorIfNotExist(Class clazz)
Advisor	Advised._getAdvisor() Return the manager.

Methods in org.jboss.aop with parameters of type Advisor

void	JoinPointInfo.setAdvisor(Advisor advisor)
void	InstanceDomain.setAdvisor(Advisor advisor)
boolean	InstanceDomain.isAdvisorRegistered(Advisor advisor) internal to jboss aop.
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.
protected void	AspectManager.addAdvisorToClassMetaDataBinding(ClassMetaDataBinding meta, Class clazz, Advisor advisor, Class advisedClass)
protected void	AspectManager.applyInterfaceIntroductions(Advisor advisor, Class clazz)

Constructors in org.jboss.aop with parameters of type Advisor

ReflectiveAspectBinder(Class clazz, Advisor advisor)

MethodInfo(Class clazz, long hash, long unadvisedHash, Advisor advisor)

MethodByMethodInfo(Advisor advisor, Class calledClass, Method m, long callingMethodHash, long calledMethodHash, Interceptor[] in)

MethodByConInfo(Advisor advisor, Class calledClass, int callingIndex, Method m, long calledMethodHash, Interceptor[] in)

JoinPointInfo(Advisor advisor)

InstanceAdvisorDelegate(Advisor classAdvisor, InstanceAdvisor instanceAdvisor)

FieldInfo(Class clazz, int index, String fieldName, long wrapperHash, Advisor advisor, boolean read)

ConstructorInfo(Class clazz, int index, long wrapperHash, long constructorHash, Advisor advisor)

ConstructionInfo(Class clazz, int index, long constructorHash, Advisor advisor)

ConByMethodInfo(Advisor advisor, Class calledClass, long callingMethodHash, Constructor c, long calledConHash, Method wrappingMethod, Interceptor[] in)
Create a new ConByMethodJoinPont.

ConByConInfo(Advisor advisor, Class calledClass, int callingIndex, Constructor called, long calledConHash, Method wrappingMethod, Interceptor[] in)

CallerMethodInfo(Advisor advisor, Class calledClass, Method m, long calledMethodHash, Interceptor[] in)

CallerConstructorInfo(Advisor advisor, Class calledClass, Constructor called, long calledConHash, Method wrappingMethod, Interceptor[] in)

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)
static Interceptor	PerJoinpointInterceptor.createInterceptor(Advisor advisor, Joinpoint joinpoint, AspectDefinition def)
static Interceptor	PerJoinpointAdvice.createInterceptor(Advisor advisor, Joinpoint joinpoint, AspectDefinition def, String adviceName)
static Interceptor	PerClassAdvice.generate(Joinpoint joinpoint, Advisor advisor, String adviceName, AspectDefinition def)
Interceptor	InterceptorFactoryWrapper.create(Advisor advisor, Joinpoint joinpoint)
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)
Interceptor	InterceptorFactory.create(Advisor advisor, Joinpoint joinpoint)
Interceptor	GenericInterceptorFactory.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)
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)
Interceptor[]	AdviceStack.createInterceptors(Advisor advisor, Joinpoint jp)
Interceptor	AdviceFactory.create(Advisor advisor, Joinpoint joinpoint)
void	AdviceBinding.addAdvisor(Advisor advisor)

Constructors in org.jboss.aop.advice with parameters of type Advisor

PerJoinpointInterceptor(AspectDefinition a, Advisor advisor, Joinpoint joinpoint)

PerJoinpointAdvice(String adviceName, AspectDefinition a, Advisor advisor, Joinpoint joinpoint)

PerInstanceInterceptor(AspectDefinition a, Advisor advisor)

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

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

MethodCalledByMethodInvocation(Advisor advisor, Class callingClass, Method callingMethod, Method method, Object callingObject, Object targetObject, Object[] args, Interceptor[] interceptors)

MethodCalledByConstructorInvocation(Advisor advisor, Constructor calling, Method method, Object target, Object[] args, Interceptor[] interceptors)

ConstructorCalledByMethodInvocation(Advisor advisor, Class callingClass, Method callingMethod, Constructor constructor, Method wrappingMethod, Object callingObject, Object[] args, Interceptor[] interceptors)

ConstructorCalledByConstructorInvocation(Advisor advisor, Constructor calling, Constructor constructor, Method wrappingMethod, Object[] args, Interceptor[] interceptors)

CallerInvocation(Advisor advisor, Interceptor[] interceptors)

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)
protected void	SimpleClassMetaDataLoader.bindMethodMetaData(Advisor advisor, SimpleClassMetaDataBinding data, MethodMetaData methodMetaData, Method[] advisedMethods)
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	TypeMatcher.advisor
protected Advisor	SoftClassMatcher.advisor
protected Advisor	MethodMatcher.advisor
protected Advisor	FieldMatcher.advisor
protected Advisor	ConstructorMatcher.advisor

Methods in org.jboss.aop.pointcut with parameters of type Advisor

static boolean	Util.matchesClassExpr(ClassExpression classExpr, javassist.CtClass clazz, Advisor advisor)
static boolean	Util.matchesClassExpr(ClassExpression classExpr, Class clazz, Advisor advisor)
static boolean	Util.subtypeOf(Class clazz, ClassExpression instanceOf, 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)
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)
protected boolean	ProxyMatcherStrategy.checkIntroductions(Class clazz, ClassExpression instanceOf, Advisor advisor)
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
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, Method m, boolean matchOnAdvisor)
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, Method m, boolean matchOnAdvisor)
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 MatcherStrategy	MatcherStrategy.getMatcher(Advisor advisor)
boolean	MatcherStrategy.subtypeOf(Class clazz, ClassExpression instanceOf, Advisor advisor)
protected abstract boolean	MatcherStrategy.checkIntroductions(Class clazz, ClassExpression instanceOf, Advisor advisor)
abstract Class	MatcherStrategy.getDeclaringClass(Advisor advisor, Method m)
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)
protected boolean	AdvisorMatcherStrategy.checkIntroductions(Class clazz, ClassExpression instanceOf, Advisor advisor)
Class	AdvisorMatcherStrategy.getDeclaringClass(Advisor advisor, Method m)

Constructors in org.jboss.aop.pointcut with parameters of type Advisor

WithinMatcher(Advisor advisor, javassist.CtBehavior behavior, ASTStart start)

WithinMatcher(Advisor advisor, AccessibleObject behavior, ASTStart start)

TypeMatcher(Advisor advisor, Class clazz)

TypeMatcher(Advisor advisor, javassist.CtClass ctClass)

SoftClassMatcher(Advisor advisor, String classname, ASTStart start)

NewExprMatcher(Advisor advisor, javassist.expr.NewExpr call, ASTStart start)

MethodMatcher(Advisor advisor, javassist.CtMethod method, ASTStart start)

MethodMatcher(Advisor advisor, Method method, ASTStart start, boolean matchOnAdvisor)

MethodMatcher(Advisor advisor, Method method, ASTStart start)

MethodCallMatcher(Advisor advisor, javassist.expr.MethodCall call, ASTStart start)

FieldSetMatcher(Advisor advisor, javassist.CtField field, ASTStart start)

FieldSetMatcher(Advisor advisor, Field field, ASTStart start)

FieldMatcher(Advisor advisor, javassist.CtField field, ASTStart start)

FieldMatcher(Advisor advisor, Field field, ASTStart start)

FieldGetMatcher(Advisor advisor, javassist.CtField field, ASTStart start)

FieldGetMatcher(Advisor advisor, Field field, ASTStart start)

ExecutionMethodMatcher(Advisor advisor, javassist.CtMethod method, ASTStart start)

ExecutionMethodMatcher(Advisor advisor, Method method, ASTStart start, boolean matchOnAdvisor)

ExecutionConstructorMatcher(Advisor advisor, javassist.CtConstructor con, ASTStart start)

ExecutionConstructorMatcher(Advisor advisor, Constructor con, ASTStart start)

DeclareTypeMatcher(Advisor advisor, Class clazz)

DeclareTypeMatcher(Advisor advisor, javassist.CtClass ctClass)

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)

ConstructionMatcher(Advisor advisor, javassist.CtConstructor con, ASTStart start)

ConstructionMatcher(Advisor advisor, Constructor con, ASTStart start)

CallMatcher(Advisor advisor, AccessibleObject within, Class calledClass, Method calledMethod, ASTStart start)

AnnotationMatcher(Advisor advisor, Object element)

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	ProxyAdvisorDomain.getAdvisor()
Advisor	InstanceProxyContainer.getClassAdvisor()
Advisor	ContainerCache.getAdvisor()
Advisor	ContainerCache.getClassAdvisor()
Advisor	AspectManaged.getAdvisor()

Methods in org.jboss.aop.proxy.container with parameters of type Advisor

void	ProxyTemplate.setAdvisor(Advisor advisor)
void	ProxyAdvisorDomain.setAdvisor(Advisor advisor)
void	ProxyAdvisorDomain.removeAdvisor(Advisor advisor)
static InstanceProxyContainer	InstanceProxyContainer.createInstanceProxyContainer(Advisor classAdvisor, InterfaceIntroduction introduction, org.jboss.repository.spi.MetaDataContext metaDataContext)
static Class	ContainerProxyFactory.getProxyClass(boolean objectAsSuper, ContainerProxyCacheKey key, Advisor advisor)
static javassist.CtClass	ContainerProxyFactory.createProxyCtClass(boolean objectAsSuper, ArrayList mixins, Class clazz, Advisor advisor)
void	AspectManaged.setAdvisor(Advisor advisor)

Constructors in org.jboss.aop.proxy.container with parameters of type Advisor

InstanceProxyContainer(String name, ProxyAdvisorDomain instanceDomain, Advisor classAdvisor, org.jboss.repository.spi.MetaDataContext metaDataContext)