|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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
|
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 |
JoinPointInfo.getAdvisor()
|
Advisor |
InstanceAdvisorDelegate.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 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)
|
protected void |
AspectManager.attachMetaData(Advisor advisor,
Class<?> clazz)
|
void |
Domain.attachMetaData(Advisor advisor,
Class<?> clazz)
|
Interceptor |
GeneratedInstanceAdvisorMixin.InstanceInterceptorFactory.create(Advisor advisor,
Joinpoint joinpoint)
|
boolean |
Advisor.hasSameConstructorAspectLength(Advisor other)
|
boolean |
Advisor.hasSameMethodAspectLength(Advisor other)
|
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)
|
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 |
InterceptorFactory.create(Advisor advisor,
Joinpoint joinpoint)
Creates an interceptor that represents this advice and that delegates execution to this advice. |
Interceptor |
GenericInterceptorFactory.create(Advisor advisor,
Joinpoint joinpoint)
|
Interceptor |
GeneratedAdvisorInterceptor.create(Advisor advisor,
Joinpoint joinpoint)
|
Interceptor |
ScopedInterceptorFactory.create(Advisor advisor,
Joinpoint joinpoint)
|
Interceptor |
AdviceFactory.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 |
AspectFactory.createPerClass(Advisor advisor)
Creates an aspect with scope value Scope.PER_CLASS . |
Object |
AspectFactoryDelegator.createPerClass(Advisor advisor)
|
Object |
GenericAspectFactory.createPerClass(Advisor advisor)
|
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.createPerInstance(Advisor advisor,
InstanceAdvisor instanceAdvisor)
|
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,
InstanceAdvisor instanceAdvisor,
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)
|
Object |
GenericAspectFactory.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 |
Instrumentor.addMixinMethod(Advisor advisor,
javassist.CtMethod method,
javassist.CtClass clazz,
javassist.CtMethod delegate,
long hash)
|
protected javassist.CtMethod |
GeneratedAdvisorInstrumentor.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 |
InterfaceIntroduction.matches(Advisor advisor,
Class<?> clazz)
|
boolean |
AnnotationIntroduction.matches(Advisor advisor,
Class<?> clazz)
|
boolean |
AnnotationIntroduction.matches(Advisor advisor,
Constructor<?> con)
|
boolean |
InterfaceIntroduction.matches(Advisor advisor,
javassist.CtClass clazz)
|
boolean |
AnnotationIntroduction.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 |
Invocation.getAdvisor()
|
Advisor |
JoinPointBean.getAdvisor()
Gets the advisor |
Advisor |
InvocationBase.getAdvisor()
|
Advisor |
MethodInvocation.getAdvisor()
|
Advisor |
MethodInvocationWrapper.getAdvisor()
|
Advisor |
FieldReadInvocationWrapper.getAdvisor()
|
Advisor |
ConstructionInvocationWrapper.getAdvisor()
|
Advisor |
ConstructorInvocationWrapper.getAdvisor()
|
Advisor |
FieldWriteInvocationWrapper.getAdvisor()
|
Advisor |
ConstructorCalledByConstructorInvocationWrapper.getAdvisor()
|
Advisor |
MethodCalledByConstructorInvocationWrapper.getAdvisor()
|
Advisor |
ConstructorCalledByMethodInvocationWrapper.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 |
---|
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 |
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,
javassist.CtMethod[] methods,
javassist.CtField[] fields,
javassist.CtConstructor[] constructors)
|
void |
ClassMetaDataLoader.bind(Advisor advisor,
ClassMetaDataBinding data,
Method[] methods,
Field[] fields,
Constructor<?>[] constructors)
This is a full bind of metadata. |
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)
|
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 |
FieldMatcher.advisor
|
protected Advisor |
MethodMatcher.advisor
|
protected Advisor |
TypeMatcher.advisor
|
protected Advisor |
ConstructorMatcher.advisor
|
protected Advisor |
SoftClassMatcher.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 |
Typedef.matches(Advisor advisor,
Class<?> clazz)
|
boolean |
DeclareDef.matches(Advisor advisor,
Class<?> clazz)
|
boolean |
TypedefExpression.matches(Advisor advisor,
Class<?> clazz)
|
boolean |
Typedef.matches(Advisor advisor,
javassist.CtClass clazz)
|
boolean |
DeclareDef.matches(Advisor advisor,
javassist.CtClass clazz)
|
boolean |
TypedefExpression.matches(Advisor advisor,
javassist.CtClass clazz)
|
boolean |
Pointcut.matchesCall(Advisor advisor,
AccessibleObject within,
Class<?> calledClass,
Constructor<?> calledCon)
|
boolean |
PointcutExpression.matchesCall(Advisor advisor,
AccessibleObject within,
Class<?> calledClass,
Constructor<?> calledCon)
|
boolean |
Pointcut.matchesCall(Advisor advisor,
AccessibleObject within,
Class<?> calledClass,
Method calledMethod)
|
boolean |
PointcutExpression.matchesCall(Advisor advisor,
AccessibleObject within,
Class<?> calledClass,
Method calledMethod)
|
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.MethodCall methodCall)
|
boolean |
Pointcut.matchesCall(Advisor callingAdvisor,
javassist.expr.NewExpr methodCall)
|
boolean |
DeclareDef.matchesCall(Advisor callingAdvisor,
javassist.expr.NewExpr methodCall)
|
boolean |
PointcutExpression.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 |
Pointcut.matchesConstruction(Advisor advisor,
Constructor<?> c)
|
boolean |
PointcutExpression.matchesConstruction(Advisor advisor,
Constructor<?> c)
|
boolean |
Pointcut.matchesConstruction(Advisor advisor,
javassist.CtConstructor c)
|
boolean |
PointcutExpression.matchesConstruction(Advisor advisor,
javassist.CtConstructor c)
|
boolean |
Pointcut.matchesExecution(Advisor advisor,
Constructor<?> c)
|
boolean |
PointcutExpression.matchesExecution(Advisor advisor,
Constructor<?> c)
|
boolean |
Pointcut.matchesExecution(Advisor advisor,
javassist.CtConstructor c)
|
boolean |
PointcutExpression.matchesExecution(Advisor advisor,
javassist.CtConstructor c)
|
boolean |
Pointcut.matchesExecution(Advisor advisor,
javassist.CtMethod m)
|
boolean |
PointcutExpression.matchesExecution(Advisor advisor,
javassist.CtMethod m)
|
PointcutMethodMatch |
Pointcut.matchesExecution(Advisor advisor,
Method m)
|
PointcutMethodMatch |
PointcutExpression.matchesExecution(Advisor advisor,
Method m)
|
boolean |
Pointcut.matchesGet(Advisor advisor,
javassist.CtField f)
|
boolean |
PointcutExpression.matchesGet(Advisor advisor,
javassist.CtField f)
|
boolean |
Pointcut.matchesGet(Advisor advisor,
Field f)
|
boolean |
PointcutExpression.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 |
Pointcut.matchesSet(Advisor advisor,
javassist.CtField f)
|
boolean |
PointcutExpression.matchesSet(Advisor advisor,
javassist.CtField f)
|
boolean |
Pointcut.matchesSet(Advisor advisor,
Field f)
|
boolean |
PointcutExpression.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 |
Pointcut.softMatch(Advisor advisor)
|
boolean |
PointcutExpression.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 |
ContainerCache.getAdvisor()
|
Advisor |
ProxyTemplate.getAdvisor()
|
Advisor |
ProxyAdvisorDomain.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 |
ProxyTemplate.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,
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)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |