|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use AnnotatedMethod | |
---|---|
com.caucho.config.event | |
com.caucho.config.extension | |
com.caucho.config.gen | |
com.caucho.config.inject | |
com.caucho.config.j2ee | |
com.caucho.config.reflect | |
com.caucho.config.timer | |
com.caucho.ejb.cfg | |
com.caucho.ejb.gen | |
com.caucho.ejb.session | |
com.caucho.ejb.xa | |
javax.enterprise.inject.spi | Java Dependency Injection programmatic APIs. |
Uses of AnnotatedMethod in com.caucho.config.event |
---|
Methods in com.caucho.config.event that return AnnotatedMethod | |
---|---|
AnnotatedMethod<X> |
ObserverMethodImpl.getAnnotatedMethod()
Returns the annotated method |
Methods in com.caucho.config.event with parameters of type AnnotatedMethod | ||
---|---|---|
|
EventManager.addObserver(Bean<X> bean,
AnnotatedMethod<Z> beanMethod)
|
|
static
|
EventManager.findObserverAnnotation(AnnotatedMethod<Z> method)
|
Constructors in com.caucho.config.event with parameters of type AnnotatedMethod | |
---|---|
ObserverMethodAfterCompletionImpl(InjectManager beanManager,
Bean<X> bean,
AnnotatedMethod<X> method,
java.lang.reflect.Type type,
java.util.Set<java.lang.annotation.Annotation> qualifiers)
|
|
ObserverMethodAfterFailureImpl(InjectManager beanManager,
Bean<X> bean,
AnnotatedMethod<X> method,
java.lang.reflect.Type type,
java.util.Set<java.lang.annotation.Annotation> qualifiers)
|
|
ObserverMethodAfterSuccessImpl(InjectManager beanManager,
Bean<X> bean,
AnnotatedMethod<X> method,
java.lang.reflect.Type type,
java.util.Set<java.lang.annotation.Annotation> qualifiers)
|
|
ObserverMethodBeforeCompletionImpl(InjectManager beanManager,
Bean<X> bean,
AnnotatedMethod<X> method,
java.lang.reflect.Type type,
java.util.Set<java.lang.annotation.Annotation> qualifiers)
|
|
ObserverMethodImpl(InjectManager beanManager,
Bean<X> bean,
AnnotatedMethod<X> method,
java.lang.reflect.Type type,
java.util.Set<java.lang.annotation.Annotation> qualifiers)
|
Uses of AnnotatedMethod in com.caucho.config.extension |
---|
Methods in com.caucho.config.extension that return AnnotatedMethod | |
---|---|
AnnotatedMethod<X> |
ProcessObserverImpl.getAnnotatedMethod()
|
AnnotatedMethod<X> |
ProcessProducerMethodImpl.getAnnotatedProducerMethod()
|
Methods in com.caucho.config.extension with parameters of type AnnotatedMethod | ||
---|---|---|
|
ExtensionManager.processObserver(ObserverMethod<T> observer,
AnnotatedMethod<X> method)
Processes the observer. |
|
|
ExtensionManager.processProducer(AnnotatedMethod<X> producesMethod,
Producer<T> producer)
Processes the discovered method producer |
Uses of AnnotatedMethod in com.caucho.config.gen |
---|
Fields in com.caucho.config.gen declared as AnnotatedMethod | |
---|---|
protected AnnotatedMethod<? super X> |
MethodTailGenerator._method
|
Methods in com.caucho.config.gen that return AnnotatedMethod | |
---|---|
AnnotatedMethod<? super X> |
InterceptorFactory.getAroundInvokeMethod()
|
AnnotatedMethod<? super X> |
AbstractAspectGenerator.getMethod()
|
AnnotatedMethod<? super X> |
AspectGenerator.getMethod()
Returns the underlying method. |
AnnotatedMethod<? super X> |
MethodTailGenerator.getMethod()
|
AnnotatedMethod<? super X> |
NullGenerator.getMethod()
|
Methods in com.caucho.config.gen with parameters of type AnnotatedMethod | ||
---|---|---|
AspectGenerator<X> |
AspectBeanFactory.create(AnnotatedMethod<? super X> method)
Creates an aspect generator. |
|
AspectGenerator<X> |
CandiAspectBeanFactory.create(AnnotatedMethod<? super X> method)
Creates a new aspect for a method. |
|
AspectGenerator<X> |
LifecycleAspectBeanFactory.create(AnnotatedMethod<? super X> method)
|
|
AspectGenerator<X> |
AbstractAspectFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
Returns an aspect for the method if one exists. |
|
AspectGenerator<X> |
AspectFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
Returns an aspect for the method if one exists. |
|
AspectGenerator<X> |
AsynchronousFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
Creates an aspect for interception if the method should be intercepted. |
|
AspectGenerator<X> |
CacheFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
Creates an aspect for interception if the method should be intercepted. |
|
AspectGenerator<X> |
CandiMethodHeadFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
|
|
AspectGenerator<X> |
InterceptorFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
Creates an aspect for interception if the method should be intercepted. |
|
AspectGenerator<X> |
LifecycleMethodHeadFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
|
|
AspectGenerator<X> |
LifecycleMethodTailFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
|
|
AspectGenerator<X> |
LockFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
Creates an aspect for interception if the method should be intercepted. |
|
AspectGenerator<X> |
MethodHeadFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
Returns an aspect for the method if one exists. |
|
AspectGenerator<X> |
MethodTailFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
Returns an aspect for the method if one exists. |
|
AspectGenerator<X> |
SecurityFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
Creates an aspect for interception if the method should be intercepted. |
|
AspectGenerator<X> |
XaFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
Creates an aspect for interception if the method should be intercepted. |
|
static void |
AspectGeneratorUtil.generateHeader(JavaWriter out,
boolean isOverride,
java.lang.String accessModifier,
java.lang.String methodName,
AnnotatedMethod<?> method,
java.util.Set<VarType<?>> typeVariables,
java.lang.Class<?>[] exnList)
Generates the method's signature before the call:
|
|
protected
|
AbstractAspectGenerator.getAnnotation(java.lang.Class<Z> annotationType,
AnnotatedMethod<?> apiMethod,
AnnotatedMethod<?> implMethod)
|
|
protected
|
AbstractAspectGenerator.getAnnotation(java.lang.Class<Z> annotationType,
AnnotatedMethod<?> apiMethod,
AnnotatedMethod<?> implMethod)
|
|
protected
|
AbstractAspectGenerator.getAnnotation(java.lang.Class<Z> annotationType,
AnnotatedMethod<?> apiMethod,
AnnotatedType<?> apiClass,
AnnotatedMethod<?> implementationMethod,
AnnotatedType<?> implementationClass)
|
|
protected
|
AbstractAspectGenerator.getAnnotation(java.lang.Class<Z> annotationType,
AnnotatedMethod<?> apiMethod,
AnnotatedType<?> apiClass,
AnnotatedMethod<?> implementationMethod,
AnnotatedType<?> implementationClass)
|
Constructors in com.caucho.config.gen with parameters of type AnnotatedMethod | |
---|---|
AbstractAspectGenerator(AspectFactory<X> factory,
AnnotatedMethod<? super X> method,
AspectGenerator<X> next)
|
|
AsyncHeadGenerator(AsynchronousFactory<X> factory,
AnnotatedMethod<? super X> method,
AspectGenerator<X> next)
|
|
AsynchronousGenerator(AsynchronousFactory<X> factory,
AnnotatedMethod<? super X> method,
AspectGenerator<X> head)
|
|
CacheGenerator(CacheFactory<X> factory,
AnnotatedMethod<? super X> method,
AspectGenerator<X> next,
CacheResult cacheResult,
CachePut cachePut,
CacheRemoveEntry cacheRemove,
CacheRemoveAll cacheRemoveAll)
|
|
CandiMethodHeadGenerator(MethodHeadFactory<X> factory,
AnnotatedMethod<? super X> method,
AspectGenerator<X> next)
|
|
InterceptorGenerator(InterceptorFactory<X> factory,
AnnotatedMethod<? super X> method,
AspectGenerator<X> next,
InterceptionType type,
java.util.HashSet<java.lang.Class<?>> methodInterceptors,
java.util.HashMap<java.lang.Class<?>,java.lang.annotation.Annotation> methodInterceptorMap,
java.util.HashSet<java.lang.Class<?>> decoratorSet,
boolean isExcludeClassInterceptors)
|
|
LifecycleMethodHeadGenerator(LifecycleMethodHeadFactory<X> factory,
AnnotatedMethod<? super X> method,
AspectGenerator<X> next)
|
|
LifecycleMethodTailGenerator(LifecycleMethodTailFactory<X> factory,
AnnotatedMethod<? super X> method)
|
|
LockGenerator(LockFactory<X> factory,
AnnotatedMethod<? super X> method,
AspectGenerator<X> next,
LockType lockType,
long lockTimeout,
java.util.concurrent.TimeUnit lockTimeoutUnit)
|
|
MethodHeadGenerator(MethodHeadFactory<X> factory,
AnnotatedMethod<? super X> method,
AspectGenerator<X> next)
|
|
MethodTailGenerator(MethodTailFactory<X> factory,
AnnotatedMethod<? super X> method)
|
|
SecurityGenerator(SecurityFactory<X> factory,
AnnotatedMethod<? super X> method,
AspectGenerator<X> next,
java.lang.String[] roleNames,
java.lang.String runAs)
|
|
XaGenerator(XaFactory<X> factory,
AnnotatedMethod<? super X> method,
AspectGenerator<X> next,
TransactionAttributeType xa,
boolean isBeanManaged)
|
Uses of AnnotatedMethod in com.caucho.config.inject |
---|
Methods in com.caucho.config.inject that return AnnotatedMethod | |
---|---|
static AnnotatedMethod<?> |
AnnotatedOverrideMap.getMethod(java.lang.reflect.Method method)
|
AnnotatedMethod<? super X> |
ProducesMethodBean.getProducesMethod()
|
Methods in com.caucho.config.inject with parameters of type AnnotatedMethod | ||
---|---|---|
|
InjectManager.addObserver(ObserverMethod<T> observer,
AnnotatedMethod<X> method)
|
|
protected
|
ManagedProducesBuilder.addProducesMethod(Bean<X> bean,
AnnotatedType<X> beanType,
AnnotatedMethod<? super X> producesMethod,
AnnotatedMethod<? super X> disposesMethod)
|
|
protected
|
ManagedProducesBuilder.addProducesMethod(Bean<X> bean,
AnnotatedType<X> beanType,
AnnotatedMethod<? super X> producesMethod,
AnnotatedMethod<? super X> disposesMethod)
|
|
protected
|
ProducesBuilder.addProducesMethod(Bean<X> bean,
AnnotatedType<X> beanType,
AnnotatedMethod<? super X> producesMethod,
AnnotatedMethod<? super X> disposesMethod)
|
|
protected
|
ProducesBuilder.addProducesMethod(Bean<X> bean,
AnnotatedType<X> beanType,
AnnotatedMethod<? super X> producesMethod,
AnnotatedMethod<? super X> disposesMethod)
|
|
static
|
ProducesMethodBean.create(InjectManager manager,
Bean<X> producer,
AnnotatedMethod<? super X> producesMethod,
Arg<? super X>[] producesArgs,
AnnotatedMethod<? super X> disposesMethod,
Arg<? super X>[] disposesArgs)
|
|
static
|
ProducesMethodBean.create(InjectManager manager,
Bean<X> producer,
AnnotatedMethod<? super X> producesMethod,
Arg<? super X>[] producesArgs,
AnnotatedMethod<? super X> disposesMethod,
Arg<? super X>[] disposesArgs)
|
|
static ProducesFieldBean |
ProducesFieldBean.create(InjectManager manager,
Bean producer,
AnnotatedField beanField,
AnnotatedMethod disposesMethod,
Arg[] disposesArgs)
|
|
protected
|
ProducesBuilder.introspectArguments(Bean<X> bean,
AnnotatedMethod<T> method)
|
|
protected
|
ProducesBuilder.introspectDisposesArgs(AnnotatedMethod<?> method,
java.util.List<AnnotatedParameter<X>> params)
|
|
ConfigProgram |
InjectionPointHandler.introspectMethod(AnnotatedMethod<?> method)
|
|
protected boolean |
ProducesBuilder.isDisposes(AnnotatedMethod<?> method)
|
|
static void |
AnnotatedOverrideMap.putMethod(java.lang.reflect.Method method,
AnnotatedMethod<?> annMethod)
|
Constructors in com.caucho.config.inject with parameters of type AnnotatedMethod | |
---|---|
ProducesFieldBean(InjectManager manager,
Bean<X> producerBean,
AnnotatedField<X> beanField,
AnnotatedMethod<X> disposesMethod,
Arg[] disposesArgs)
|
Uses of AnnotatedMethod in com.caucho.config.j2ee |
---|
Methods in com.caucho.config.j2ee that return AnnotatedMethod | |
---|---|
AnnotatedMethod<?> |
PostConstructProgram.getAnnotatedMethod()
|
Methods in com.caucho.config.j2ee with parameters of type AnnotatedMethod | |
---|---|
ConfigProgram |
DataSourceDefinitionHandler.introspectMethod(AnnotatedMethod<?> method)
|
ConfigProgram |
EjbHandler.introspectMethod(AnnotatedMethod<?> method)
|
ConfigProgram |
PersistenceContextHandler.introspectMethod(AnnotatedMethod<?> method)
|
ConfigProgram |
PersistenceUnitHandler.introspectMethod(AnnotatedMethod<?> method)
|
ConfigProgram |
ResourceHandler.introspectMethod(AnnotatedMethod<?> method)
|
Constructors in com.caucho.config.j2ee with parameters of type AnnotatedMethod | |
---|---|
PostConstructProgram(AnnotatedMethod<?> annMethod,
java.lang.reflect.Method init)
|
Uses of AnnotatedMethod in com.caucho.config.reflect |
---|
Classes in com.caucho.config.reflect that implement AnnotatedMethod | |
---|---|
class |
AnnotatedMethodImpl<T>
Abstract introspected view of a Bean |
Methods in com.caucho.config.reflect that return AnnotatedMethod | ||
---|---|---|
AnnotatedMethod<? super X> |
AnnotatedTypeImpl.createMethod(java.lang.reflect.Method method)
Returns the matching method, creating one if necessary. |
|
AnnotatedMethod<? super T> |
ReflectionAnnotatedType.createMethod(java.lang.reflect.Method method)
Returns the matching method, creating one if necessary. |
|
static
|
AnnotatedTypeUtil.findMethod(AnnotatedType<X> type,
AnnotatedMethod<?> method)
Finds any method matching the method name and parameter types. |
|
static
|
AnnotatedTypeUtil.findMethod(AnnotatedType<X> type,
java.lang.reflect.Method javaMethod)
Finds any method matching the method name and parameter types. |
|
static
|
AnnotatedTypeUtil.findMethod(AnnotatedType<X> type,
java.lang.String methodName,
java.lang.Class<?>[] param)
Finds any method matching the method name and parameter types. |
|
static
|
AnnotatedTypeUtil.findMethod(java.util.Collection<AnnotatedMethod<? super X>> methodList,
AnnotatedMethod<?> method)
Finds any method matching the method name and parameter types. |
|
static
|
AnnotatedTypeUtil.findMethod(java.util.Set<AnnotatedMethod<? super X>> methods,
java.lang.reflect.Method method)
Finds any method matching the method name and parameter types. |
|
static
|
AnnotatedTypeUtil.findMethod(java.util.Set<AnnotatedMethod<? super X>> methods,
java.lang.String methodName,
java.lang.Class<?>[] param)
Finds any method matching the method name and parameter types. |
Methods in com.caucho.config.reflect that return types with arguments of type AnnotatedMethod | |
---|---|
java.util.Set<AnnotatedMethod<? super X>> |
AnnotatedTypeImpl.getMethods()
Returns the abstract introspected methods |
java.util.Set<AnnotatedMethod<? super T>> |
ReflectionAnnotatedType.getMethods()
Returns the abstract introspected methods |
java.util.Set<AnnotatedMethod<? super X>> |
ReflectionSimpleAnnotatedType.getMethods()
Returns the abstract introspected methods |
java.util.Set<AnnotatedMethod<? super X>> |
AnnotatedTypeImpl.getMethodsForUpdate()
Returns the abstract introspected methods |
Methods in com.caucho.config.reflect with parameters of type AnnotatedMethod | ||
---|---|---|
static
|
AnnotatedTypeUtil.findMethod(AnnotatedType<X> type,
AnnotatedMethod<?> method)
Finds any method matching the method name and parameter types. |
|
static
|
AnnotatedTypeUtil.findMethod(java.util.Collection<AnnotatedMethod<? super X>> methodList,
AnnotatedMethod<?> method)
Finds any method matching the method name and parameter types. |
|
static boolean |
AnnotatedTypeUtil.hasException(AnnotatedMethod<?> method,
java.lang.Class<?> exn)
Tests if a method throws a checked exception. |
|
static boolean |
AnnotatedTypeUtil.isMatch(AnnotatedMethod<?> methodA,
AnnotatedMethod<?> methodB)
Tests if two annotated methods are equivalent. |
|
static boolean |
AnnotatedTypeUtil.isMatch(AnnotatedMethod<?> methodA,
AnnotatedMethod<?> methodB)
Tests if two annotated methods are equivalent. |
|
static boolean |
AnnotatedTypeUtil.isMatch(AnnotatedMethod<?> method,
java.lang.String name,
java.lang.Class<?>[] param)
Tests if an annotated method matches a name and parameter types. |
Method parameters in com.caucho.config.reflect with type arguments of type AnnotatedMethod | ||
---|---|---|
static
|
AnnotatedTypeUtil.findMethod(java.util.Collection<AnnotatedMethod<? super X>> methodList,
AnnotatedMethod<?> method)
Finds any method matching the method name and parameter types. |
|
static
|
AnnotatedTypeUtil.findMethod(java.util.Set<AnnotatedMethod<? super X>> methods,
java.lang.reflect.Method method)
Finds any method matching the method name and parameter types. |
|
static
|
AnnotatedTypeUtil.findMethod(java.util.Set<AnnotatedMethod<? super X>> methods,
java.lang.String methodName,
java.lang.Class<?>[] param)
Finds any method matching the method name and parameter types. |
Uses of AnnotatedMethod in com.caucho.config.timer |
---|
Methods in com.caucho.config.timer with parameters of type AnnotatedMethod | |
---|---|
protected java.lang.reflect.Method |
ScheduleIntrospector.getScheduledMethod(AnnotatedMethod<?> method)
Returns the method to call when the schedule event occurs. |
Uses of AnnotatedMethod in com.caucho.ejb.cfg |
---|
Methods in com.caucho.ejb.cfg that return AnnotatedMethod | ||
---|---|---|
protected
|
EjbBean.findFirstCreateMethod(AnnotatedType<T> cl)
|
|
static
|
EjbBean.findMethod(MethodSignature sig,
AnnotatedType<Y> cl,
java.lang.String intf)
Finds the method in the class. |
|
static
|
EjbBean.getMethod(AnnotatedType<X> cl,
AnnotatedMethod<? extends T> sourceMethod)
Finds the method in the class. |
|
static
|
EjbBean.getMethod(AnnotatedType<X> cl,
java.lang.String name,
java.lang.Class<?>[] param)
Finds the method in the class. |
|
protected AnnotatedMethod<? super X> |
EjbBean.getMethod(java.lang.String methodName,
java.lang.Class<?>[] paramTypes)
Finds the method in the class. |
Methods in com.caucho.ejb.cfg with parameters of type AnnotatedMethod | ||
---|---|---|
boolean |
EjbBean.classHasMethod(AnnotatedType<?> cl,
AnnotatedMethod<?> method)
Tests is a method is declared in a class. |
|
void |
AfterBeginMethod.configure(AnnotatedMethod<?> method)
Configures the bean with the override values |
|
void |
BeforeCompletionMethod.configure(AnnotatedMethod<?> method)
Configures the bean with the override values |
|
void |
ConcurrentMethod.configure(AnnotatedMethod<?> method)
Configures the bean with the override values |
|
void |
EjbMethodPattern.configure(AnnotatedMethod<?> apiMethod)
Configures the bean with the override values |
|
void |
PostConstructType.configure(AnnotatedMethod<?> method)
|
|
void |
RemoveMethod.configure(AnnotatedMethod<?> method)
Configures the bean with the override values |
|
static java.lang.String |
EjbBean.getFullMethodName(AnnotatedMethod<?> method)
Returns a full method name with arguments. |
|
static
|
EjbBean.getMethod(AnnotatedType<X> cl,
AnnotatedMethod<? extends T> sourceMethod)
Finds the method in the class. |
|
EjbMethodPattern<X> |
EjbBean.getMethodPattern(AnnotatedMethod<?> method,
java.lang.String intf)
Gets the best method. |
|
boolean |
AroundInvokeConfig.isMatch(AnnotatedMethod<?> method)
|
|
boolean |
AsyncConfig.isMatch(AnnotatedMethod<?> method)
|
|
boolean |
BeanMethod.isMatch(AnnotatedMethod<?> otherMethod)
|
|
boolean |
ConcurrentMethod.isMatch(AnnotatedMethod<?> method)
|
|
boolean |
EjbBean.isMatch(AnnotatedMethod<?> method)
|
|
boolean |
EjbMethod.isMatch(AnnotatedMethod<?> otherMethod)
|
|
boolean |
EjbMethodPattern.isMatch(AnnotatedMethod<?> method)
|
|
boolean |
InterceptorBinding.isMatch(AnnotatedMethod<?> method)
|
|
boolean |
MethodParams.isMatch(AnnotatedMethod<?> otherMethod)
|
|
boolean |
PostConstructType.isMatch(AnnotatedMethod<?> method)
|
|
boolean |
RemoveMethod.isMatch(AnnotatedMethod<?> method)
|
|
boolean |
MethodSignature.isMatch(AnnotatedMethod<?> annMethod,
java.lang.String intf)
|
|
InterceptorsLiteral |
InterceptorBinding.mergeAnnotation(AnnotatedMethod<?> m)
|
|
void |
EjbBean.validateException(AnnotatedMethod<?> method,
java.lang.Class<?> e)
|
|
void |
EjbBean.validateExceptions(AnnotatedMethod<?> caller,
AnnotatedMethod<? super X> callee)
|
|
void |
EjbBean.validateExceptions(AnnotatedMethod<?> caller,
AnnotatedMethod<? super X> callee)
|
|
void |
EjbBean.validateExceptions(AnnotatedMethod<?> method,
java.lang.Class<?>[] exn)
Check that the method throws the expected exceptions. |
Uses of AnnotatedMethod in com.caucho.ejb.gen |
---|
Methods in com.caucho.ejb.gen that return AnnotatedMethod | |
---|---|
AnnotatedMethod<? super X> |
NonBusinessMethodGenerator.getMethod()
|
Methods in com.caucho.ejb.gen that return types with arguments of type AnnotatedMethod | |
---|---|
protected java.util.ArrayList<AnnotatedMethod<? super X>> |
SessionGenerator.getAnnotatedMethods()
Returns the merged annotated methods |
Methods in com.caucho.ejb.gen with parameters of type AnnotatedMethod | |
---|---|
void |
MessageGenerator.addBusinessMethod(AnnotatedMethod<? super X> method)
|
protected void |
SessionGenerator.addBusinessMethod(AnnotatedMethod<? super X> method)
|
protected void |
MessageGenerator.addLifecycleMethod(AnnotatedMethod<? super X> method)
|
protected void |
SessionGenerator.addNonBusinessMethod(AnnotatedMethod<? super X> method)
|
protected void |
SessionGenerator.addPostConstructMethod(AnnotatedMethod<? super X> method)
|
protected void |
SessionGenerator.addPreDestroyMethod(AnnotatedMethod<? super X> method)
|
protected void |
SessionGenerator.addScheduledMethod(AnnotatedMethod<? super X> method)
|
AspectGenerator<X> |
NonBusinessAspectBeanFactory.create(AnnotatedMethod<? super X> method)
|
AspectGenerator<X> |
MessageMethodHeadFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
|
AspectGenerator<X> |
MessageMethodTailFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
|
AspectGenerator<X> |
SingletonMethodHeadFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
|
AspectGenerator<X> |
StatefulMethodHeadFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
|
AspectGenerator<X> |
StatelessMethodHeadFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
|
AspectGenerator<X> |
StatelessMethodTailFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
|
AspectGenerator<X> |
StatelessScheduledMethodHeadFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
|
AspectGenerator<X> |
StatelessScheduledMethodTailFactory.create(AnnotatedMethod<? super X> method,
boolean isEnhanced)
|
Uses of AnnotatedMethod in com.caucho.ejb.session |
---|
Methods in com.caucho.ejb.session that return types with arguments of type AnnotatedMethod | |
---|---|
java.util.Set<AnnotatedMethod<? super X>> |
ExtAnnotatedType.getMethods()
|
Uses of AnnotatedMethod in com.caucho.ejb.xa |
---|
Methods in com.caucho.ejb.xa with parameters of type AnnotatedMethod | |
---|---|
static ConfigProgram |
XaInterceptor.create(AnnotatedMethod<?> method)
|
Constructors in com.caucho.ejb.xa with parameters of type AnnotatedMethod | |
---|---|
XaInterceptor(AnnotatedMethod<?> method)
|
Uses of AnnotatedMethod in javax.enterprise.inject.spi |
---|
Methods in javax.enterprise.inject.spi that return AnnotatedMethod | |
---|---|
AnnotatedMethod<X> |
ProcessObserverMethod.getAnnotatedMethod()
|
AnnotatedMethod<T> |
ProcessProducerMethod.getAnnotatedProducerMethod()
|
Methods in javax.enterprise.inject.spi that return types with arguments of type AnnotatedMethod | |
---|---|
java.util.Set<AnnotatedMethod<? super X>> |
AnnotatedType.getMethods()
Returns the abstract introspected methods |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |