| Modifier and Type | Interface and Description |
|---|---|
interface |
IdentifiedAnnotatedType<X>
IdentifiedAnnotatedType allows multiple annotated types, based on the same underlying
type, to be defined. |
| 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> |
BeanManager.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 |
|---|---|
Iterator<AnnotatedType<?>> |
ProcessModule.getAnnotatedTypes() |
<T> Iterable<AnnotatedType<T>> |
BeanManager.getAnnotatedTypes(Class<T> type)
Obtain the
AnnotatedTypes 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. |
<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. |
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.of(AnnotatedType<X> originalType) |
static <X> UnbackedAnnotatedType<X> |
UnbackedAnnotatedType.of(AnnotatedType<X> originalType,
String id) |
| Modifier and Type | Method and Description |
|---|---|
<T> BeanDeployer |
BeanDeployer.addSyntheticClass(AnnotatedType<T> annotatedType,
Extension extension) |
protected void |
BeanDeployer.createClassBean(AnnotatedType<?> annotatedType,
Map<Class<?>,Set<AnnotatedType<?>>> otherWeldClasses) |
Extension |
BeanDeployerEnvironment.getAnnotatedTypeSource(AnnotatedType<?> annotatedType) |
void |
BeanDeployerEnvironment.removeAnnotatedType(AnnotatedType<?> annotatedType) |
void |
BeanDeployerEnvironment.vetoAnnotatedType(AnnotatedType<?> annotatedType) |
| Modifier and Type | Method and Description |
|---|---|
protected void |
BeanDeployer.createClassBean(AnnotatedType<?> annotatedType,
Map<Class<?>,Set<AnnotatedType<?>>> otherWeldClasses) |
void |
BeanDeployerEnvironment.removeAnnotatedTypes(Collection<AnnotatedType<?>> annotatedTypes) |
| Constructor and Description |
|---|
BeanDeployerEnvironment(Set<SlimAnnotatedType<?>> annotatedTypes,
Map<AnnotatedType<?>,Extension> annotatedTypeSource,
Set<Class<?>> vetoedClasses,
Map<Class<?>,Set<AbstractClassBean<?>>> classBeanMap,
Set<ProducerField<?,?>> producerFields,
Map<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<T> |
AbstractProcessInjectionTarget.getAnnotatedType() |
| Modifier and Type | Method and Description |
|---|---|
Iterator<AnnotatedType<?>> |
ProcessModuleImpl.getAnnotatedTypes() |
| Modifier and Type | Method and Description |
|---|---|
void |
BeforeBeanDiscoveryImpl.addAnnotatedType(AnnotatedType<?> type) |
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) |
| Constructor and Description |
|---|
AbstractProcessInjectionTarget(BeanManagerImpl beanManager,
AnnotatedType<T> annotatedType) |
ProcessSimpleInjectionTarget(BeanManagerImpl beanManager,
AnnotatedType<X> annotatedType,
InjectionTarget<X> injectionTarget) |
| Modifier and Type | Method and Description |
|---|---|
<T extends Enum<?>> |
EnumService.addEnumClass(AnnotatedType<T> annotatedType) |
| 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> |
AbstractInjectionTarget.getAnnotated() |
protected AnnotatedType<T> |
AbstractInjectionTarget.getType() |
| Modifier and Type | Method and Description |
|---|---|
protected Class<T> |
SubclassedComponentInstantiator.createEnhancedSubclass(AnnotatedType<T> type,
Bean<?> bean) |
protected EnhancedAnnotatedConstructor<T> |
SubclassedComponentInstantiator.initEnhancedSubclass(BeanManagerImpl manager,
AnnotatedType<T> type,
Bean<?> bean,
ConstructorInjectionPoint<T> originalConstructorInjectionPoint) |
| Constructor and Description |
|---|
SubclassedComponentInstantiator(AnnotatedType<T> type,
Bean<T> bean,
ConstructorInjectionPoint<T> originalConstructor,
BeanManagerImpl manager) |
SubclassedComponentInstantiator(AnnotatedType<T> type,
Bean<T> bean,
DefaultInstantiator<T> delegate,
BeanManagerImpl manager) |
| 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> AnnotatedType<T> |
BeanManagerImpl.createAnnotatedType(Class<T> type) |
<T> AnnotatedType<T> |
BeanManagerImpl.getAnnotatedType(Class<T> type,
String id) |
| Modifier and Type | Method and Description |
|---|---|
<T> Iterable<AnnotatedType<T>> |
BeanManagerImpl.getAnnotatedTypes(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) |
<T> InjectionTarget<T> |
BeanManagerImpl.createInjectionTarget(AnnotatedType<T> type,
Bean<T> bean) |
<X> InjectionTarget<X> |
BeanManagerImpl.fireProcessInjectionTarget(AnnotatedType<X> annotatedType) |
| Modifier and Type | Method and Description |
|---|---|
<X> InjectionTarget<X> |
WeldManager.fireProcessInjectionTarget(AnnotatedType<X> type)
Fire a ProcessInjectionTarget event for the given type.
|
| Modifier and Type | Method and Description |
|---|---|
AnnotatedType<T> |
AnnotationModel.getAnnotatedAnnotation()
Gets the annotated annotation
|
| Modifier and Type | Method and Description |
|---|---|
<T> SlimAnnotatedType<T> |
ClassTransformer.getAnnotatedType(AnnotatedType<T> type) |
<T> EnhancedAnnotatedType<T> |
ClassTransformer.getEnhancedAnnotatedType(AnnotatedType<T> annotatedType) |
| Modifier and Type | Method and Description |
|---|---|
<T> AnnotatedType<T> |
ForwardingBeanManager.createAnnotatedType(Class<T> type) |
<T> AnnotatedType<T> |
ForwardingBeanManager.getAnnotatedType(Class<T> type,
String id) |
static AnnotatedType<?> |
AnnotatedTypes.getDeclaringAnnotatedType(Annotated annotated)
Returns the declaring
AnnotatedType of a given annotated. |
| Modifier and Type | Method and Description |
|---|---|
<T> Iterable<AnnotatedType<T>> |
ForwardingBeanManager.getAnnotatedTypes(Class<T> type) |
| 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 WeldInjectionPoint<?,?> |
Decorators.findDelegateInjectionPoint(AnnotatedType<?> type,
Iterable<InjectionPoint> injectionPoints) |
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 |
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<X> |
ForwardingAnnotatedMember.getDeclaringType() |
| Modifier and Type | Method and Description |
|---|---|
static String |
Formats.formatAnnotatedType(AnnotatedType<?> type) |
Copyright © 2012 Seam Framework. All Rights Reserved.