Modifier and Type | Method and Description |
---|---|
<T> AnnotatedType<T> |
BeanManager.createAnnotatedType(Class<T> type)
Obtain an
AnnotatedType that may be used to read the annotations of the given class or interface. |
AnnotatedType<X> |
ProcessManagedBean.getAnnotatedBeanClass()
Returns the
AnnotatedType representing the bean class. |
AnnotatedType<X> |
ProcessInjectionTarget.getAnnotatedType()
Returns the
AnnotatedType representing the managed bean class, session bean class or
other Java EE component class supporting injection. |
AnnotatedType<X> |
ProcessAnnotatedType.getAnnotatedType()
Returns the
AnnotatedType object that will be used by the container to read the
declared annotations. |
<T> AnnotatedType<T> |
AfterBeanDiscovery.getAnnotatedType(Class<T> type,
String id)
Obtain the
AnnotatedType that may be used to read the annotations of the given class or interface as defined
during container initialization. |
AnnotatedType<X> |
AnnotatedMember.getDeclaringType()
Get the type which defines this member.
|
Modifier and Type | Method and Description |
---|---|
<T> Iterable<AnnotatedType<T>> |
AfterBeanDiscovery.getAnnotatedTypes(Class<T> type)
Obtain the
AnnotatedType s that may be used to read the annotations of the given class or interface as defined
during container initialization. |
Modifier and Type | Method and Description |
---|---|
void |
BeforeBeanDiscovery.addAnnotatedType(AnnotatedType<?> type)
Adds a given
AnnotatedType to the set of types which will be scanned during bean
discovery. |
void |
BeforeBeanDiscovery.addAnnotatedType(AnnotatedType<?> type,
String id)
Adds a given
AnnotatedType to the set of types which will be scanned during bean
discovery. |
void |
AfterTypeDiscovery.addAnnotatedType(AnnotatedType<?> type,
String id)
Adds a given
AnnotatedType to the set of types which will be scanned during bean
discovery. |
void |
BeforeBeanDiscovery.addInterceptorBinding(AnnotatedType<? extends Annotation> bindingType)
Declares an annotation type as an interceptor binding type.
|
void |
BeforeBeanDiscovery.addQualifier(AnnotatedType<? extends Annotation> qualifier)
Declares an annotation type as a Qualifier qualifier type.
|
<T> BeanAttributes<T> |
BeanManager.createBeanAttributes(AnnotatedType<T> type)
Obtains a
BeanAttributes for the given AnnotatedType . |
<T> InjectionTarget<T> |
BeanManager.createInjectionTarget(AnnotatedType<T> type)
Obtains an
InjectionTarget for the given AnnotatedType . |
<T> InjectionTargetFactory<T> |
BeanManager.getInjectionTargetFactory(AnnotatedType<T> annotatedType)
An implementation of
InjectionTargetFactory that provides container created InjectionTarget instances. |
void |
ProcessAnnotatedType.setAnnotatedType(AnnotatedType<X> type)
Replaces the
AnnotatedType . |
Modifier and Type | Method and Description |
---|---|
static void |
AnnotatedTypeValidator.validateAnnotatedType(AnnotatedType<?> type) |
Modifier and Type | Interface and Description |
---|---|
interface |
EnhancedAnnotatedType<T>
Represents a Class
|
interface |
EnhancedAnnotation<T extends Annotation>
Represents a meta annotation
|
Modifier and Type | Class and Description |
---|---|
class |
EnhancedAnnotatedTypeImpl<T>
Represents an annotated class
This class is immutable, and therefore threadsafe
|
class |
EnhancedAnnotationImpl<T extends Annotation>
Represents an annotated annotation
This class is immutable and therefore threadsafe
|
Modifier and Type | Interface and Description |
---|---|
interface |
SlimAnnotatedType<T>
Marker interface for lightweight implementations of
AnnotatedType . |
Modifier and Type | Class and Description |
---|---|
class |
BackedAnnotatedType<X> |
Modifier and Type | Class and Description |
---|---|
class |
UnbackedAnnotatedType<X>
Wrapper for extension-provided
AnnotatedType . |
Modifier and Type | Method and Description |
---|---|
static <X> UnbackedAnnotatedType<X> |
UnbackedAnnotatedType.additionalAnnotatedType(AnnotatedType<X> source,
String bdaId,
String suffix) |
static <X> UnbackedAnnotatedType<X> |
UnbackedAnnotatedType.modifiedAnnotatedType(SlimAnnotatedType<X> originalType,
AnnotatedType<X> source) |
Modifier and Type | Method and Description |
---|---|
<T> BeanDeployer |
BeanDeployer.addSyntheticClass(AnnotatedType<T> source,
Extension extension,
String suffix) |
Extension |
BeanDeployerEnvironment.getAnnotatedTypeSource(AnnotatedType<?> annotatedType) |
void |
BeanDeployerEnvironment.removeAnnotatedType(AnnotatedType<?> annotatedType) |
void |
BeanDeployerEnvironment.vetoAnnotatedType(AnnotatedType<?> annotatedType) |
Modifier and Type | Method and Description |
---|---|
void |
BeanDeployerEnvironment.removeAnnotatedTypes(Collection<AnnotatedType<?>> annotatedTypes) |
Constructor and Description |
---|
BeanDeployerEnvironment(Set<SlimAnnotatedType<?>> annotatedTypes,
Map<AnnotatedType<?>,Extension> annotatedTypeSource,
Set<Class<?>> vetoedClasses,
LoadingCache<Class<?>,Set<AbstractClassBean<?>>> classBeanMap,
Set<ProducerField<?,?>> producerFields,
LoadingCache<BeanDeployerEnvironment.WeldMethodKey,Set<ProducerMethod<?,?>>> producerMethodBeanMap,
Set<RIBean<?>> beans,
Set<ObserverInitializationContext<?,?>> observers,
Set<DisposalMethod<?,?>> allDisposalBeans,
Set<DisposalMethod<?,?>> resolvedDisposalBeans,
Set<DecoratorImpl<?>> decorators,
Set<InterceptorImpl<?>> interceptors,
EjbDescriptors ejbDescriptors,
Set<EnhancedAnnotatedType<?>> newManagedBeanClasses,
Map<InternalEjbDescriptor<?>,EnhancedAnnotatedType<?>> newSessionBeanDescriptorsFromInjectionPoint,
BeanManagerImpl manager) |
Modifier and Type | Field and Description |
---|---|
protected AnnotatedType<T> |
AbstractProcessInjectionTarget.annotatedType |
Modifier and Type | Method and Description |
---|---|
AnnotatedType<Object> |
ProcessSessionBeanImpl.getAnnotatedBeanClass() |
AnnotatedType<X> |
ProcessManagedBeanImpl.getAnnotatedBeanClass() |
AnnotatedType<X> |
ProcessSessionBeanImpl.getAnnotatedSessionBeanClass() |
AnnotatedType<X> |
ProcessAnnotatedTypeImpl.getAnnotatedType() |
AnnotatedType<T> |
AbstractProcessInjectionTarget.getAnnotatedType() |
<T> AnnotatedType<T> |
AfterBeanDiscoveryImpl.getAnnotatedType(Class<T> type,
String id) |
Modifier and Type | Method and Description |
---|---|
<T> Iterable<AnnotatedType<T>> |
AfterBeanDiscoveryImpl.getAnnotatedTypes(Class<T> type) |
Modifier and Type | Method and Description |
---|---|
void |
BeforeBeanDiscoveryImpl.addAnnotatedType(AnnotatedType<?> source) |
void |
BeforeBeanDiscoveryImpl.addAnnotatedType(AnnotatedType<?> type,
String id) |
void |
AfterTypeDiscoveryImpl.addAnnotatedType(AnnotatedType<?> type,
String id) |
void |
BeforeBeanDiscoveryImpl.addInterceptorBinding(AnnotatedType<? extends Annotation> bindingType) |
void |
BeforeBeanDiscoveryImpl.addQualifier(AnnotatedType<? extends Annotation> qualifier) |
protected void |
AbstractAnnotatedTypeRegisteringEvent.addSyntheticAnnotatedType(AnnotatedType<?> type,
String id) |
protected static <X> InjectionTarget<X> |
AbstractProcessInjectionTarget.fire(BeanManagerImpl beanManager,
AnnotatedType<X> annotatedType,
InjectionTarget<X> injectionTarget) |
<X> InjectionTarget<X> |
ContainerLifecycleEvents.fireProcessInjectionTarget(BeanManagerImpl beanManager,
AnnotatedType<X> annotatedType,
InjectionTarget<X> injectionTarget) |
void |
ProcessAnnotatedTypeImpl.setAnnotatedType(AnnotatedType<X> type) |
protected void |
AfterTypeDiscoveryImpl.storeSyntheticAnnotatedType(BeanDeployment deployment,
AnnotatedType<?> type,
String id) |
protected void |
AbstractAnnotatedTypeRegisteringEvent.storeSyntheticAnnotatedType(BeanDeployment deployment,
AnnotatedType<?> type,
String id) |
Constructor and Description |
---|
AbstractProcessInjectionTarget(BeanManagerImpl beanManager,
AnnotatedType<T> annotatedType) |
ProcessSimpleInjectionTarget(BeanManagerImpl beanManager,
AnnotatedType<X> annotatedType,
InjectionTarget<X> injectionTarget) |
Modifier and Type | Method and Description |
---|---|
AnnotatedType<T> |
InjectionContextImpl.getAnnotatedType() |
Constructor and Description |
---|
InjectionContextImpl(BeanManagerImpl beanManager,
InjectionTarget<T> injectionTarget,
AnnotatedType<T> annotatedType,
T target) |
Modifier and Type | Method and Description |
---|---|
AnnotatedType<T> |
BasicInjectionTarget.getAnnotated() |
protected AnnotatedType<T> |
BasicInjectionTarget.getType() |
Modifier and Type | Method and Description |
---|---|
protected Class<T> |
SubclassedComponentInstantiator.createEnhancedSubclass(AnnotatedType<T> type,
Bean<?> bean) |
Modifier and Type | Method and Description |
---|---|
AnnotatedType<T> |
InjectionContext.getAnnotatedType()
Get the
AnnotatedType for the instance being injected |
Modifier and Type | Method and Description |
---|---|
<T> void |
InjectionServices.registerInjectionTarget(InjectionTarget<T> injectionTarget,
AnnotatedType<T> annotatedType)
This method is invoked during Weld bootstrap and allows an integrator to process an
InjectionTarget that may be
injected at runtime. |
Modifier and Type | Method and Description |
---|---|
<T> AnnotatedType<T> |
BeanManagerImpl.createAnnotatedType(Class<T> type) |
Modifier and Type | Method and Description |
---|---|
<T> BeanAttributes<T> |
BeanManagerImpl.createBeanAttributes(AnnotatedType<T> type) |
<T> InjectionTarget<T> |
BeanManagerImpl.createInjectionTarget(AnnotatedType<T> type) |
<X> InjectionTarget<X> |
BeanManagerImpl.fireProcessInjectionTarget(AnnotatedType<X> annotatedType) |
<X> InjectionTarget<X> |
BeanManagerImpl.fireProcessInjectionTarget(AnnotatedType<X> annotatedType,
InjectionTarget<X> injectionTarget) |
<T> InjectionTargetFactoryImpl<T> |
BeanManagerImpl.getInjectionTargetFactory(AnnotatedType<T> type)
Creates an
InjectionTargetFactory for a given type. |
<T> InjectionTargetFactoryImpl<T> |
BeanManagerImpl.getLocalInjectionTargetFactory(AnnotatedType<T> type)
Creates an
InjectionTargetFactory for a given type. |
Constructor and Description |
---|
InjectionTargetFactoryImpl(AnnotatedType<T> type,
BeanManagerImpl manager) |
Modifier and Type | Method and Description |
---|---|
<X> InjectionTarget<X> |
WeldManager.fireProcessInjectionTarget(AnnotatedType<X> type)
Fire a ProcessInjectionTarget event for the given type.
|
<X> InjectionTarget<X> |
WeldManager.fireProcessInjectionTarget(AnnotatedType<X> annotatedType,
InjectionTarget<X> injectionTarget)
Fire a ProcessInjectionTarget event for the given type.
|
<T> WeldInjectionTargetFactory<T> |
WeldManager.getInjectionTargetFactory(AnnotatedType<T> type) |
Modifier and Type | Method and Description |
---|---|
AnnotatedType<T> |
AnnotationModel.getAnnotatedAnnotation()
Gets the annotated annotation
|
Modifier and Type | Method and Description |
---|---|
void |
ClassTransformer.addSyntheticAnnotation(AnnotatedType<? extends Annotation> annotation,
String bdaId) |
<T> EnhancedAnnotatedType<T> |
ClassTransformer.getEnhancedAnnotatedType(AnnotatedType<T> annotatedType,
String bdaId) |
<T> UnbackedAnnotatedType<T> |
ClassTransformer.getUnbackedAnnotatedType(AnnotatedType<T> source,
String bdaId,
String suffix) |
<T> UnbackedAnnotatedType<T> |
ClassTransformer.getUnbackedAnnotatedType(SlimAnnotatedType<T> originalType,
AnnotatedType<T> source) |
Modifier and Type | Method and Description |
---|---|
<T> AnnotatedType<T> |
ForwardingBeanManager.createAnnotatedType(Class<T> type) |
static AnnotatedType<?> |
AnnotatedTypes.getDeclaringAnnotatedType(Annotated annotated)
Returns the declaring
AnnotatedType of a given annotated. |
Modifier and Type | Method and Description |
---|---|
static boolean |
AnnotatedTypes.compareAnnotatedTypes(AnnotatedType<?> t1,
AnnotatedType<?> t2)
Compares two annotated types and returns true if they are the same
|
static boolean |
AnnotatedTypes.compareAnnotatedTypes(AnnotatedType<?> t1,
AnnotatedType<?> t2)
Compares two annotated types and returns true if they are the same
|
<T> BeanAttributes<T> |
ForwardingBeanManager.createBeanAttributes(AnnotatedType<T> type) |
<T> InjectionTarget<T> |
ForwardingBeanManager.createInjectionTarget(AnnotatedType<T> type) |
static <X> String |
AnnotatedTypes.createTypeId(AnnotatedType<X> annotatedType)
Generates a unique signature for an annotated type.
|
static WeldInjectionPointAttributes<?,?> |
Decorators.findDelegateInjectionPoint(AnnotatedType<?> type,
Iterable<InjectionPoint> injectionPoints) |
<T> InjectionTargetFactory<T> |
ForwardingBeanManager.getInjectionTargetFactory(AnnotatedType<T> annotatedType) |
static List<AnnotatedMethod<?>> |
Beans.getInterceptableMethods(AnnotatedType<?> type) |
static boolean |
Beans.hasSimpleCdiConstructor(AnnotatedType<?> type) |
static <T> boolean |
Beans.isInterceptor(AnnotatedType<T> annotatedItem) |
static boolean |
Beans.isTypeManagedBeanOrDecoratorOrInterceptor(AnnotatedType<?> annotatedType)
Indicates if the type is a simple Web Bean
|
static boolean |
Beans.isVetoed(AnnotatedType<?> type) |
static Map<Class<? extends Annotation>,Annotation> |
Interceptors.mergeBeanInterceptorBindings(BeanManagerImpl beanManager,
AnnotatedType<?> clazz,
Collection<Class<? extends Annotation>> stereotypes)
Merge class-level interceptor bindings with interceptor bindings inherited from interceptor bindings and stereotypes.
|
Modifier and Type | Class and Description |
---|---|
class |
AnnotatedTypeWrapper<T> |
class |
ForwardingAnnotatedType<X>
Forwarding implementation of AnnotatedType
|
class |
ForwardingWeldAnnotation<T extends Annotation> |
class |
ForwardingWeldClass<T> |
Modifier and Type | Method and Description |
---|---|
abstract AnnotatedType<X> |
ForwardingAnnotatedType.delegate() |
AnnotatedType<T> |
AnnotatedTypeWrapper.delegate() |
AnnotatedType<X> |
ForwardingAnnotatedMember.getDeclaringType() |
Constructor and Description |
---|
AnnotatedTypeWrapper(AnnotatedType<T> delegate,
Annotation... additionalAnnotations) |
Modifier and Type | Method and Description |
---|---|
static String |
Formats.formatAnnotatedType(AnnotatedType<?> type) |
Copyright © 2013 Seam Framework. All Rights Reserved.