BeanManagerImpl (Weld OSGi Bundle 1.1.27.Final API)

java.lang.Object
- org.jboss.weld.manager.BeanManagerImpl

All Implemented Interfaces:

java.io.Serializable, BeanManager, WeldManager
```
public class BeanManagerImpl
extends java.lang.Object
implements WeldManager, java.io.Serializable
```
Implementation of the Bean Manager.
Essentially a singleton for registering Beans, Contexts, Observers, Interceptors etc. as well as providing resolution

Author:

Pete Muir, Marius Bogoevici, Ales Justin, Marko Luksa

See Also:
Serialized Form

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addAccessibleBeanManager(BeanManagerImpl accessibleBeanManager)`
`void`	`addBean(Bean<?> bean)`
`void`	`addContext(Context context)`
`void`	`addDecorator(Decorator<?> bean)`
`void`	`addInterceptor(Interceptor<?> bean)`
`void`	`addObserver(ObserverMethod<?> observer)` Does the actual observer registration
`void`	`cleanup()`
`BeanManagerImpl`	`createActivity()` Create a new child activity.
`<T> AnnotatedType<T>`	`createAnnotatedType(java.lang.Class<T> type)` Obtain an `AnnotatedType` that may be used to read the annotations of the given class or interface.
`<T> WeldCreationalContext<T>`	`createCreationalContext(Contextual<T> contextual)` Obtain an instance of a `CreationalContext` for the given contextual type, or for a non-contextual object.
`<T> InjectionTarget<T>`	`createInjectionTarget(AnnotatedType<T> type)` Obtains an `InjectionTarget` for the given `AnnotatedType`.
`<T> InjectionTarget<T>`	`createInjectionTarget(EjbDescriptor<T> descriptor)` The injection target for the given EJB, or null if Weld was not given this descriptor in the deployment.
`boolean`	`equals(java.lang.Object obj)`
`java.util.Set<InterceptorBindingType>`	`extractAndFlattenInterceptorBindings(java.lang.Iterable<java.lang.annotation.Annotation> annotations)`
`java.util.Set<InterceptorBindingType>`	`extractInterceptorBindings(java.lang.Iterable<java.lang.annotation.Annotation> annotations)`
`java.util.Set<QualifierInstance>`	`extractInterceptorBindingsForQualifierInstance(java.lang.Iterable<QualifierInstance> annotations)`
`void`	`fireEvent(java.lang.Object event, java.lang.annotation.Annotation... qualifiers)` Fires an event object with given event object for given bindings
`<X> InjectionTarget<X>`	`fireProcessInjectionTarget(AnnotatedType<X> annotatedType)` Fire a ProcessInjectionTarget event for the given type.
`java.util.Set<InterceptorBindingType>`	`flattenInterceptorBindings(java.util.Set<InterceptorBindingType> interceptorBindingTypes)` Extracts the complete set of interception bindings from a given set of interceptorBindingTypes.
`java.lang.Iterable<Bean<?>>`	`getAccessibleBeans()`
`java.lang.Iterable<Decorator<?>>`	`getAccessibleDecorators()`
`java.lang.Iterable<Interceptor<?>>`	`getAccessibleInterceptors()`
`java.util.HashSet<BeanManagerImpl>`	`getAccessibleManagers()`
`java.lang.Iterable<java.lang.String>`	`getAccessibleNamespaces()`
`ObserverNotifier`	`getAccessibleObserverNotifier()` Get the observer notifier for accessible observer methods.
`<T> SessionBean<T>`	`getBean(EjbDescriptor<T> descriptor)` Get the Bean object for the given EJB, or null if Weld was not given this descriptor in the deployment.
`<T> Bean<T>`	`getBean(Resolvable resolvable)`
`TypeSafeBeanResolver<Bean<?>>`	`getBeanResolver()` Get the web bean resolver.
`java.util.List<Bean<?>>`	`getBeans()` The beans registered with the Web Bean manager which are resolvable.
`java.util.Set<Bean<?>>`	`getBeans(InjectionPoint injectionPoint)`
`java.util.Set<Bean<?>>`	`getBeans(java.lang.String name)` Return the set of beans which have the given EL name and are available for injection in the module or library containing the class into which the `BeanManager` was injected or the Java EE component from whose JNDI environment namespace the `BeanManager` was obtained, according to the rules of EL name resolution.
`java.util.Set<Bean<?>>`	`getBeans(java.lang.reflect.Type beanType, java.lang.annotation.Annotation... qualifiers)` Return the set of beans which have the given required type and qualifiers and are available for injection in the module or library containing the class into which the `BeanManager` was injected or the Java EE component from whose JNDI environment namespace the `BeanManager` was obtained, according to the rules of typesafe resolution.
`java.util.Set<Bean<?>>`	`getBeans(java.lang.reflect.Type beanType, java.util.Set<java.lang.annotation.Annotation> qualifiers)`
`java.util.concurrent.atomic.AtomicInteger`	`getChildIds()`
`ClientProxyProvider`	`getClientProxyProvider()`
`BeansClosure`	`getClosure()`
`Context`	`getContext(java.lang.Class<? extends java.lang.annotation.Annotation> scopeType)` Gets an active context of the given scope.
`protected java.util.Map<java.lang.Class<? extends java.lang.annotation.Annotation>,java.util.List<Context>>`	`getContexts()`
`BeanManagerImpl`	`getCurrent()`
`TypeSafeResolver<Resolvable,Decorator<?>>`	`getDecoratorResolver()` Get the decorator resolver.
`java.util.List<Decorator<?>>`	`getDecorators()`
`java.lang.Iterable<Bean<?>>`	`getDirectlyAccessibleBeans()`
`java.lang.Iterable<java.lang.String>`	`getDirectlyAccessibleNamespaces()`
`<T> EjbDescriptor<T>`	`getEjbDescriptor(java.lang.String beanName)` Get the EjbDescriptor for the given ejb name
`ELResolver`	`getELResolver()` Returns a `javax.el.ELResolver` that resolves beans by EL name.
`Enabled`	`getEnabled()` Enabled Alternatives, Interceptors and Decorators
`java.util.Map<EjbDescriptor<?>,SessionBean<?>>`	`getEnterpriseBeans()` Gets the class-mapped beans.
`java.lang.String`	`getId()` The ID of the manager, identical to the ID provided by the BDA
`java.lang.Object`	`getInjectableReference(InjectionPoint injectionPoint, CreationalContext<?> creationalContext)` Obtains an injectable reference for a certain injection point.
`java.util.Set<java.lang.annotation.Annotation>`	`getInterceptorBindingDefinition(java.lang.Class<? extends java.lang.annotation.Annotation> bindingType)` Obtains the set of meta-annotations for a certain interceptor binding type.
`MetadataCachingReader`	`getInterceptorMetadataReader()`
`java.util.Map<java.lang.Class<?>,InterceptionModel<ClassMetadata<?>,?>>`	`getInterceptorModelRegistry()`
`java.util.List<Interceptor<?>>`	`getInterceptors()`
`MetaAnnotationStore`	`getMetaAnnotationStore()`
`<X> Bean<? extends X>`	`getMostSpecializingBean(Bean<X> bean)`
`protected java.util.List<java.lang.String>`	`getNamespaces()`
`java.util.List<ObserverMethod<?>>`	`getObservers()`
`Bean<?>`	`getPassivationCapableBean(java.lang.String id)` Returns the `PassivationCapable` bean with the given identifier.
`java.lang.Object`	`getReference(Bean<?> bean, CreationalContext<?> creationalContext, boolean noProxy)`
`java.lang.Object`	`getReference(Bean<?> bean, java.lang.reflect.Type beanType, CreationalContext<?> creationalContext)` Obtains a contextual reference for a certain bean and a certain bean type of the bean.
`java.lang.Object`	`getReference(InjectionPoint injectionPoint, Bean<?> resolvedBean, CreationalContext<?> creationalContext)` Get a reference, registering the injection point used.
`Namespace`	`getRootNamespace()`
`ServiceRegistry`	`getServices()` Get the services registered for this manager
`java.util.Map<Contextual<?>,Contextual<?>>`	`getSpecializedBeans()` Deprecated.
`java.util.Set<java.lang.annotation.Annotation>`	`getStereotypeDefinition(java.lang.Class<? extends java.lang.annotation.Annotation> stereotype)` Obtains meta-annotations for a certain stereotype.
`int`	`hashCode()`
`Instance<java.lang.Object>`	`instance()`
`boolean`	`isBeanEnabled(Bean<?> bean)`
`boolean`	`isInterceptorBinding(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)` Test the given annotation type to determine if it is an interceptor binding type.
`boolean`	`isNormalScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)` Test the given annotation type to determine if it is a normal scope type.
`boolean`	`isPassivatingScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)` Test the given annotation type to determine if it is a passivating scope type.
`boolean`	`isQualifier(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)` Test the given annotation type to determine if it is a qualifier type.
`boolean`	`isScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)` Test the given annotation type to determine if it is a scope type.
`boolean`	`isStereotype(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)` Test the given annotation type to determine if it is a stereotype.
`static BeanManagerImpl`	`newChildActivityManager(BeanManagerImpl parentManager)` Create a new child manager
`static BeanManagerImpl`	`newManager(BeanManagerImpl rootManager, java.lang.String id, ServiceRegistry services, Enabled enabled)`
`static BeanManagerImpl`	`newRootManager(java.lang.String id, ServiceRegistry serviceRegistry, Enabled enabled)` Create a new, root, manager
`protected java.lang.Object`	`readResolve()`
`protected void`	`registerBeanNamespace(Bean<?> bean)`
`<X> Bean<? extends X>`	`resolve(java.util.Set<Bean<? extends X>> beans)` Apply the ambiguous dependency resolution rules to a set of beans.
`java.util.List<Decorator<?>>`	`resolveDecorators(java.util.Set<java.lang.reflect.Type> types, java.lang.annotation.Annotation... qualifiers)` Return an ordered list of decorators for a set of bean types and a set of qualifiers and which are enabled in the module or library containing the class into which the `BeanManager` was injected or the Java EE component from whose JNDI environment namespace the `BeanManager` was obtained.
`java.util.List<Decorator<?>>`	`resolveDecorators(java.util.Set<java.lang.reflect.Type> types, java.util.Set<java.lang.annotation.Annotation> qualifiers)`
`java.util.List<Interceptor<?>>`	`resolveInterceptors(InterceptionType type, java.lang.annotation.Annotation... interceptorBindings)` Resolves a list of interceptors based on interception type and interceptor bindings
`java.util.List<Interceptor<?>>`	`resolveInterceptors(InterceptionType type, java.util.Set<InterceptorBindingType> flattenedInterceptorBindings)`
`<T> java.util.Set<ObserverMethod<? super T>>`	`resolveObserverMethods(T event, java.lang.annotation.Annotation... bindings)` Return the set of observers for an event.
`BeanManagerImpl`	`setCurrent(java.lang.Class<? extends java.lang.annotation.Annotation> scopeType)` Associate an activity with the current context for a normal scope
`java.lang.String`	`toString()` Gets a string representation
`void`	`validate(InjectionPoint ij)` Validate a certain injection point.
`ExpressionFactory`	`wrapExpressionFactory(ExpressionFactory expressionFactory)` Returns a wrapper `javax.el.ExpressionFactory` that delegates `javax.el.MethodExpression` and `javax.el.ValueExpression` creation to the given `javax.el.ExpressionFactory`.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Method Detail
  - newRootManager
```
public static BeanManagerImpl newRootManager(java.lang.String id,
                             ServiceRegistry serviceRegistry,
                             Enabled enabled)
```
    Create a new, root, manager
    
    Parameters:
    serviceRegistry -
    
    Returns:
  - newManager
```
public static BeanManagerImpl newManager(BeanManagerImpl rootManager,
                         java.lang.String id,
                         ServiceRegistry services,
                         Enabled enabled)
```
  - newChildActivityManager
```
public static BeanManagerImpl newChildActivityManager(BeanManagerImpl parentManager)
```
    Create a new child manager
    
    Parameters:
    parentManager - the parent manager
    
    Returns:
    new child manager
  - getClosure
```
public BeansClosure getClosure()
```
  - addAccessibleBeanManager
```
public void addAccessibleBeanManager(BeanManagerImpl accessibleBeanManager)
```
  - getAccessibleManagers
```
public java.util.HashSet<BeanManagerImpl> getAccessibleManagers()
```
  - addBean
```
public void addBean(Bean<?> bean)
```
  - addDecorator
```
public void addDecorator(Decorator<?> bean)
```
  - resolveObserverMethods
```
public <T> java.util.Set<ObserverMethod<? super T>> resolveObserverMethods(T event,
                                                                  java.lang.annotation.Annotation... bindings)
```
    Description copied from interface: BeanManager
    
    Return the set of observers for an event.
    
    Specified by:
    
    resolveObserverMethods in interface BeanManager
    
    Type Parameters:
    T - the type of the event
    Parameters:
    event - the event object
    bindings - the event qualifiers
  - addInterceptor
```
public void addInterceptor(Interceptor<?> bean)
```
  - getEnabled
```
public Enabled getEnabled()
```
    Enabled Alternatives, Interceptors and Decorators
    
    Returns:
  - isBeanEnabled
```
public boolean isBeanEnabled(Bean<?> bean)
```
  - getBeans
```
public java.util.Set<Bean<?>> getBeans(java.lang.reflect.Type beanType,
                              java.lang.annotation.Annotation... qualifiers)
```
    Description copied from interface: BeanManager
    
    Return the set of beans which have the given required type and qualifiers and are available for injection in the module or library containing the class into which the BeanManager was injected or the Java EE component from whose JNDI environment namespace the BeanManager was obtained, according to the rules of typesafe resolution. If no qualifiers are given, the default qualifier is assumed.
    
    Specified by:
    
    getBeans in interface BeanManager
    
    Parameters:
    beanType - the required bean type
    qualifiers - the required qualifiers
    
    Returns:
    the resulting set of beans
  - getBeans
```
public java.util.Set<Bean<?>> getBeans(java.lang.reflect.Type beanType,
                              java.util.Set<java.lang.annotation.Annotation> qualifiers)
```
  - getBeans
```
public java.util.Set<Bean<?>> getBeans(InjectionPoint injectionPoint)
```
  - registerBeanNamespace
```
protected void registerBeanNamespace(Bean<?> bean)
```
  - getEnterpriseBeans
```
public java.util.Map<EjbDescriptor<?>,SessionBean<?>> getEnterpriseBeans()
```
    Gets the class-mapped beans. For internal use.
    
    Returns:
    The bean map
  - getBeans
```
public java.util.List<Bean<?>> getBeans()
```
    The beans registered with the Web Bean manager which are resolvable. Does not include interceptor and decorator beans
    
    Returns:
    The list of known beans
  - getDecorators
```
public java.util.List<Decorator<?>> getDecorators()
```
  - getInterceptors
```
public java.util.List<Interceptor<?>> getInterceptors()
```
  - getAccessibleBeans
```
public java.lang.Iterable<Bean<?>> getAccessibleBeans()
```
  - getDirectlyAccessibleBeans
```
public java.lang.Iterable<Bean<?>> getDirectlyAccessibleBeans()
```
  - getAccessibleInterceptors
```
public java.lang.Iterable<Interceptor<?>> getAccessibleInterceptors()
```
  - getAccessibleDecorators
```
public java.lang.Iterable<Decorator<?>> getAccessibleDecorators()
```
  - addContext
```
public void addContext(Context context)
```
  - addObserver
```
public void addObserver(ObserverMethod<?> observer)
```
    Does the actual observer registration
    
    Parameters:
    observer - =
  - fireEvent
```
public void fireEvent(java.lang.Object event,
             java.lang.annotation.Annotation... qualifiers)
```
    Fires an event object with given event object for given bindings
    
    Specified by:
    
    fireEvent in interface BeanManager
    
    Parameters:
    event - The event object to pass along
    qualifiers - The binding types to match
    See Also:
    BeanManager.fireEvent(java.lang.Object, java.lang.annotation.Annotation[])
  - getContext
```
public Context getContext(java.lang.Class<? extends java.lang.annotation.Annotation> scopeType)
```
    Gets an active context of the given scope. Throws an exception if there are no active contexts found or if there are too many matches
    
    Specified by:
    
    getContext in interface BeanManager
    
    Parameters:
    scopeType - The scope to match
    
    Returns:
    A single active context of the given scope
    See Also:
    BeanManager.getContext(java.lang.Class)
  - getReference
```
public java.lang.Object getReference(Bean<?> bean,
                            CreationalContext<?> creationalContext,
                            boolean noProxy)
```
  - getReference
```
public java.lang.Object getReference(Bean<?> bean,
                            java.lang.reflect.Type beanType,
                            CreationalContext<?> creationalContext)
```
    Description copied from interface: BeanManager
    
    Obtains a contextual reference for a certain bean and a certain bean type of the bean.
    
    Specified by:
    
    getReference in interface BeanManager
    
    Parameters:
    bean - the Bean object representing the bean
    beanType - a bean type that must be implemented by any client proxy that is returned
    creationalContext - a CreationalContext that may be used to destroy any object with scope {javax.enterprise.context.Dependent} that is created
    
    Returns:
    a contextual reference representing the bean
  - getReference
```
public java.lang.Object getReference(InjectionPoint injectionPoint,
                            Bean<?> resolvedBean,
                            CreationalContext<?> creationalContext)
```
    Get a reference, registering the injection point used.
    
    Parameters:
    injectionPoint - the injection point to register
    resolvedBean - the bean to get a reference to
    creationalContext - the creationalContext
    
    Returns:
  - getInjectableReference
```
public java.lang.Object getInjectableReference(InjectionPoint injectionPoint,
                                      CreationalContext<?> creationalContext)
```
    Description copied from interface: BeanManager
    
    Obtains an injectable reference for a certain injection point.
    
    Specified by:
    
    getInjectableReference in interface BeanManager
    
    Parameters:
    injectionPoint - the target injection point
    creationalContext - a CreationalContext that may be used to destroy any object with scope {javax.enterprise.context.Dependent} that is created
    
    Returns:
    the injectable reference
  - getBean
```
public <T> Bean<T> getBean(Resolvable resolvable)
```
  - getBeans
```
public java.util.Set<Bean<?>> getBeans(java.lang.String name)
```
    Description copied from interface: BeanManager
    
    Return the set of beans which have the given EL name and are available for injection in the module or library containing the class into which the BeanManager was injected or the Java EE component from whose JNDI environment namespace the BeanManager was obtained, according to the rules of EL name resolution.
    
    Specified by:
    
    getBeans in interface BeanManager
    
    Parameters:
    name - the EL name
    
    Returns:
    the resulting set of beans
  - resolveDecorators
```
public java.util.List<Decorator<?>> resolveDecorators(java.util.Set<java.lang.reflect.Type> types,
                                             java.lang.annotation.Annotation... qualifiers)
```
    Description copied from interface: BeanManager
    
    Return an ordered list of decorators for a set of bean types and a set of qualifiers and which are enabled in the module or library containing the class into which the BeanManager was injected or the Java EE component from whose JNDI environment namespace the BeanManager was obtained.
    
    Specified by:
    
    resolveDecorators in interface BeanManager
    
    Parameters:
    types - the set of bean types of the decorated bean
    qualifiers - the qualifiers declared by the decorated bean
    
    Returns:
    the resulting set of decorators
  - resolveDecorators
```
public java.util.List<Decorator<?>> resolveDecorators(java.util.Set<java.lang.reflect.Type> types,
                                             java.util.Set<java.lang.annotation.Annotation> qualifiers)
```
  - resolveInterceptors
```
public java.util.List<Interceptor<?>> resolveInterceptors(InterceptionType type,
                                                 java.lang.annotation.Annotation... interceptorBindings)
```
    Resolves a list of interceptors based on interception type and interceptor bindings
    
    Specified by:
    
    resolveInterceptors in interface BeanManager
    
    Parameters:
    type - The interception type to resolve
    interceptorBindings - The binding types to match
    
    Returns:
    A list of matching interceptors
    See Also:
    BeanManager.resolveInterceptors(javax.enterprise.inject.spi.InterceptionType, java.lang.annotation.Annotation...)
  - resolveInterceptors
```
public java.util.List<Interceptor<?>> resolveInterceptors(InterceptionType type,
                                                 java.util.Set<InterceptorBindingType> flattenedInterceptorBindings)
```
  - getBeanResolver
```
public TypeSafeBeanResolver<Bean<?>> getBeanResolver()
```
    Get the web bean resolver. For internal use
    
    Returns:
    The resolver
  - getDecoratorResolver
```
public TypeSafeResolver<Resolvable,Decorator<?>> getDecoratorResolver()
```
    Get the decorator resolver. For internal use
    
    Returns:
    The resolver
  - getAccessibleObserverNotifier
```
public ObserverNotifier getAccessibleObserverNotifier()
```
    Get the observer notifier for accessible observer methods. For internal use
    
    Returns:
    The ObserverNotifier
  - toString
```
public java.lang.String toString()
```
    Gets a string representation
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    A string representation
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - createActivity
```
public BeanManagerImpl createActivity()
```
    Description copied from interface: WeldManager
    
    Create a new child activity. A child activity inherits all beans, interceptors, decorators, observers, and contexts defined by its direct and indirect parent activities. This method should not be called by the application.
    
    Specified by:
    
    createActivity in interface WeldManager
    
    Returns:
    the child activity
  - setCurrent
```
public BeanManagerImpl setCurrent(java.lang.Class<? extends java.lang.annotation.Annotation> scopeType)
```
    Description copied from interface: WeldManager
    
    Associate an activity with the current context for a normal scope
    
    Specified by:
    
    setCurrent in interface WeldManager
    
    Parameters:
    scopeType - the scope to associate the activity with
    
    Returns:
    the activity
  - getCurrent
```
public BeanManagerImpl getCurrent()
```
    Specified by:
    
    getCurrent in interface WeldManager
    
    Returns:
    the WeldManager that corresponds to the current activity
  - getServices
```
public ServiceRegistry getServices()
```
    Description copied from interface: WeldManager
    
    Get the services registered for this manager
    
    Specified by:
    
    getServices in interface WeldManager
    
    Returns:
  - getSpecializedBeans
```
@Deprecated
public java.util.Map<Contextual<?>,Contextual<?>> getSpecializedBeans()
```
    Deprecated.
  - readResolve
```
protected java.lang.Object readResolve()
```
  - getClientProxyProvider
```
public ClientProxyProvider getClientProxyProvider()
```
  - getContexts
```
protected java.util.Map<java.lang.Class<? extends java.lang.annotation.Annotation>,java.util.List<Context>> getContexts()
```
  - getNamespaces
```
protected java.util.List<java.lang.String> getNamespaces()
```
    Returns:
    the namespaces
  - getAccessibleNamespaces
```
public java.lang.Iterable<java.lang.String> getAccessibleNamespaces()
```
  - getDirectlyAccessibleNamespaces
```
public java.lang.Iterable<java.lang.String> getDirectlyAccessibleNamespaces()
```
  - getId
```
public java.lang.String getId()
```
    Description copied from interface: WeldManager
    
    The ID of the manager, identical to the ID provided by the BDA
    
    Specified by:
    
    getId in interface WeldManager
    
    Returns:
  - getChildIds
```
public java.util.concurrent.atomic.AtomicInteger getChildIds()
```
  - getObservers
```
public java.util.List<ObserverMethod<?>> getObservers()
```
  - getRootNamespace
```
public Namespace getRootNamespace()
```
  - createInjectionTarget
```
public <T> InjectionTarget<T> createInjectionTarget(AnnotatedType<T> type)
```
    Description copied from interface: BeanManager
    
    Obtains an InjectionTarget for the given AnnotatedType. The container ignores the annotations and types declared by the elements of the actual Java class and uses the metadata provided via the Annotated interface instead.
    
    Specified by:
    
    createInjectionTarget in interface BeanManager
    
    Type Parameters:
    T - the type
    Parameters:
    type - the AnnotatedType
  - createInjectionTarget
```
public <T> InjectionTarget<T> createInjectionTarget(EjbDescriptor<T> descriptor)
```
    Description copied from interface: WeldManager
    
    The injection target for the given EJB, or null if Weld was not given this descriptor in the deployment. This should only be used to create an inject contextual EJBs by the EJB container. #fireProcessInjectionTarget() must be used to obtain an InjectionTarget for non-contextual EJB injection.
    
    Specified by:
    
    createInjectionTarget in interface WeldManager
    
    Returns:
  - getMostSpecializingBean
```
public <X> Bean<? extends X> getMostSpecializingBean(Bean<X> bean)
```
  - validate
```
public void validate(InjectionPoint ij)
```
    Description copied from interface: BeanManager
    
    Validate a certain injection point.
    
    Specified by:
    
    validate in interface BeanManager
    
    Parameters:
    ij - the injection point to validate
  - getInterceptorBindingDefinition
```
public java.util.Set<java.lang.annotation.Annotation> getInterceptorBindingDefinition(java.lang.Class<? extends java.lang.annotation.Annotation> bindingType)
```
    Description copied from interface: BeanManager
    
    Obtains the set of meta-annotations for a certain interceptor binding type.
    
    Specified by:
    
    getInterceptorBindingDefinition in interface BeanManager
    
    Parameters:
    bindingType - the interceptor binding type
    
    Returns:
    the set of meta-annotations
  - getPassivationCapableBean
```
public Bean<?> getPassivationCapableBean(java.lang.String id)
```
    Description copied from interface: BeanManager
    
    Returns the PassivationCapable bean with the given identifier.
    
    Specified by:
    
    getPassivationCapableBean in interface BeanManager
    
    Parameters:
    id - the identifier
    
    Returns:
    a Bean that implements PassivationCapable and has the given identifier, or a null value if there is no such bean
  - getStereotypeDefinition
```
public java.util.Set<java.lang.annotation.Annotation> getStereotypeDefinition(java.lang.Class<? extends java.lang.annotation.Annotation> stereotype)
```
    Description copied from interface: BeanManager
    
    Obtains meta-annotations for a certain stereotype.
    
    Specified by:
    
    getStereotypeDefinition in interface BeanManager
    
    Parameters:
    stereotype - the stereotype
    
    Returns:
    the set of meta-annotations
  - isQualifier
```
public boolean isQualifier(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
```
    Description copied from interface: BeanManager
    
    Test the given annotation type to determine if it is a qualifier type.
    
    Specified by:
    
    isQualifier in interface BeanManager
    
    Parameters:
    annotationType - the annotation type
    
    Returns:
    true if the annotation type is a qualifier type
  - isInterceptorBinding
```
public boolean isInterceptorBinding(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
```
    Description copied from interface: BeanManager
    
    Test the given annotation type to determine if it is an interceptor binding type.
    
    Specified by:
    
    isInterceptorBinding in interface BeanManager
    
    Parameters:
    annotationType - the annotation to test
    
    Returns:
    true if the annotation type is a interceptor binding type
  - isNormalScope
```
public boolean isNormalScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
```
    Description copied from interface: BeanManager
    
    Test the given annotation type to determine if it is a normal scope type.
    
    Specified by:
    
    isNormalScope in interface BeanManager
    
    Parameters:
    annotationType - the annotation type
    
    Returns:
    true if the annotation type is a normal scope type
  - isPassivatingScope
```
public boolean isPassivatingScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
```
    Description copied from interface: BeanManager
    
    Test the given annotation type to determine if it is a passivating scope type.
    
    Specified by:
    
    isPassivatingScope in interface BeanManager
    
    Parameters:
    annotationType - the annotation type
    
    Returns:
    true if the annotation type is a passivating scope type
  - isScope
```
public boolean isScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
```
    Description copied from interface: BeanManager
    
    Test the given annotation type to determine if it is a scope type.
    
    Specified by:
    
    isScope in interface BeanManager
    
    Parameters:
    annotationType - the annotation type
    
    Returns:
    true if the annotation type is a scope type
  - isStereotype
```
public boolean isStereotype(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
```
    Description copied from interface: BeanManager
    
    Test the given annotation type to determine if it is a stereotype.
    
    Specified by:
    
    isStereotype in interface BeanManager
    
    Parameters:
    annotationType - the annotation type
    
    Returns:
    true if the annotation type is a stereotype
  - getMetaAnnotationStore
```
public MetaAnnotationStore getMetaAnnotationStore()
```
  - getELResolver
```
public ELResolver getELResolver()
```
    Description copied from interface: BeanManager
    
    Returns a javax.el.ELResolver that resolves beans by EL name.
    
    Specified by:
    
    getELResolver in interface BeanManager
  - wrapExpressionFactory
```
public ExpressionFactory wrapExpressionFactory(ExpressionFactory expressionFactory)
```
    Description copied from interface: BeanManager
    
    Returns a wrapper javax.el.ExpressionFactory that delegates javax.el.MethodExpression and javax.el.ValueExpression creation to the given javax.el.ExpressionFactory. When a Unified EL expression is evaluated using a javax.el.MethodExpression or javax.el.ValueExpression returned by the wrapper javax.el.ExpressionFactory, the container handles destruction of objects with scope Dependent.
    
    Specified by:
    
    wrapExpressionFactory in interface BeanManager
    
    Parameters:
    expressionFactory - the javax.el.ExpressionFactory to wrap
    
    Returns:
    the wrapped javax.el.ExpressionFactory
  - createCreationalContext
```
public <T> WeldCreationalContext<T> createCreationalContext(Contextual<T> contextual)
```
    Description copied from interface: BeanManager
    
    Obtain an instance of a CreationalContext for the given contextual type, or for a non-contextual object.
    
    Specified by:
    
    createCreationalContext in interface BeanManager
    
    Parameters:
    contextual - the Contextual, or a null value in the case of a non-contextual object
    
    Returns:
    the new CreationalContext
  - createAnnotatedType
```
public <T> AnnotatedType<T> createAnnotatedType(java.lang.Class<T> type)
```
    Description copied from interface: BeanManager
    
    Obtain an AnnotatedType that may be used to read the annotations of the given class or interface.
    
    Specified by:
    
    createAnnotatedType in interface BeanManager
    
    Type Parameters:
    T - the class or interface
    Parameters:
    type - the Class object
    
    Returns:
    the AnnotatedType
  - resolve
```
public <X> Bean<? extends X> resolve(java.util.Set<Bean<? extends X>> beans)
```
    Description copied from interface: BeanManager
    
    Apply the ambiguous dependency resolution rules to a set of beans.
    
    Specified by:
    
    resolve in interface BeanManager
    
    Type Parameters:
    X - a common type of the beans
    Parameters:
    beans - a set of beans of the given type
  - getEjbDescriptor
```
public <T> EjbDescriptor<T> getEjbDescriptor(java.lang.String beanName)
```
    Description copied from interface: WeldManager
    
    Get the EjbDescriptor for the given ejb name
    
    Specified by:
    
    getEjbDescriptor in interface WeldManager
    
    Returns:
  - getBean
```
public <T> SessionBean<T> getBean(EjbDescriptor<T> descriptor)
```
    Description copied from interface: WeldManager
    
    Get the Bean object for the given EJB, or null if Weld was not given this descriptor in the deployment.
    
    Specified by:
    
    getBean in interface WeldManager
    
    Returns:
  - cleanup
```
public void cleanup()
```
  - getInterceptorModelRegistry
```
public java.util.Map<java.lang.Class<?>,InterceptionModel<ClassMetadata<?>,?>> getInterceptorModelRegistry()
```
  - getInterceptorMetadataReader
```
public MetadataCachingReader getInterceptorMetadataReader()
```
  - fireProcessInjectionTarget
```
public <X> InjectionTarget<X> fireProcessInjectionTarget(AnnotatedType<X> annotatedType)
```
    Description copied from interface: WeldManager
    
    Fire a ProcessInjectionTarget event for the given type. A helper method to allow integration code to easily fire the ProcessInjectionTarget for Java EE component classes supporting injection The container must use the returned InjectionTarget to inject the Java EE component.
    
    Specified by:
    
    fireProcessInjectionTarget in interface WeldManager
    
    Returns:
  - extractAndFlattenInterceptorBindings
```
public java.util.Set<InterceptorBindingType> extractAndFlattenInterceptorBindings(java.lang.Iterable<java.lang.annotation.Annotation> annotations)
```
  - extractInterceptorBindings
```
public java.util.Set<InterceptorBindingType> extractInterceptorBindings(java.lang.Iterable<java.lang.annotation.Annotation> annotations)
```
  - extractInterceptorBindingsForQualifierInstance
```
public java.util.Set<QualifierInstance> extractInterceptorBindingsForQualifierInstance(java.lang.Iterable<QualifierInstance> annotations)
```
  - flattenInterceptorBindings
```
public java.util.Set<InterceptorBindingType> flattenInterceptorBindings(java.util.Set<InterceptorBindingType> interceptorBindingTypes)
```
    Extracts the complete set of interception bindings from a given set of interceptorBindingTypes.
    
    Parameters:
    interceptorBindingTypes -
    
    Returns:
  - instance
```
public Instance<java.lang.Object> instance()
```
    Specified by:
    
    instance in interface WeldManager

Class BeanManagerImpl

Method Summary

Methods inherited from class java.lang.Object

Method Detail

newRootManager

newManager

newChildActivityManager

getClosure

addAccessibleBeanManager

getAccessibleManagers

addBean

addDecorator

resolveObserverMethods

addInterceptor

getEnabled

isBeanEnabled

getBeans

getBeans

getBeans

registerBeanNamespace

getEnterpriseBeans

getBeans

getDecorators

getInterceptors

getAccessibleBeans

getDirectlyAccessibleBeans

getAccessibleInterceptors

getAccessibleDecorators

addContext

addObserver

fireEvent

getContext

getReference

getReference

getReference

getInjectableReference

getBean

getBeans

resolveDecorators

resolveDecorators

resolveInterceptors

resolveInterceptors

getBeanResolver

getDecoratorResolver

getAccessibleObserverNotifier

toString

equals

hashCode

createActivity

setCurrent

getCurrent

getServices

getSpecializedBeans

readResolve

getClientProxyProvider

getContexts

getNamespaces

getAccessibleNamespaces

getDirectlyAccessibleNamespaces

getId

getChildIds

getObservers

getRootNamespace

createInjectionTarget

createInjectionTarget

getMostSpecializingBean

validate

getInterceptorBindingDefinition

getPassivationCapableBean

getStereotypeDefinition

isQualifier

isInterceptorBinding

isNormalScope

isPassivatingScope

isScope

isStereotype

getMetaAnnotationStore

getELResolver

wrapExpressionFactory

createCreationalContext