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

All Implemented Interfaces:

Serializable, BeanManager, org.jboss.weld.manager.api.WeldManager
```
public class BeanManagerImpl
extends Object
implements org.jboss.weld.manager.api.WeldManager, 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, Jozef Hartinger

See Also:

Serialized Form

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`void`	`addAccessibleBeanManager(BeanManagerImpl accessibleBeanManager)`
`void`	`addBean(Bean<?> bean)`
`void`	`addBeans(Collection<? extends Bean<?>> beans)`	Optimization which modifies CopyOnWrite structures only once instead of once for every bean.
`void`	`addContext(Context context)`
`void`	`addDecorator(Decorator<?> bean)`
`void`	`addInterceptor(Interceptor<?> bean)`
`void`	`addObserver(ObserverMethod<?> observer)`	Does the actual observer registration
`void`	`addValidationFailureCallback(BiConsumer<Exception,org.jboss.weld.bootstrap.api.Environment> callback)`
`boolean`	`areInterceptorBindingsEquivalent(Annotation interceptorBinding1, Annotation interceptorBinding2)`	Determine if two interceptor bindings are considered equivalent for the purposes of typesafe resolution, taking into account any members annotated with `Nonbinding`.
`boolean`	`areQualifiersEquivalent(Annotation qualifier1, Annotation qualifier2)`	Determine if two qualifiers are considered equivalent for the purposes of typesafe resolution, taking into account any members annotated with `Nonbinding`.
`void`	`cleanup()`
`void`	`cleanupAfterBoot()`	For internal use only.
`<T> AnnotatedType<T>`	`createAnnotatedType(Class<T> type)`	Obtain an `AnnotatedType` that may be used to read the annotations of the given class or interface.
`<T> AnnotatedType<T>`	`createAnnotatedType(Class<T> type, String id)`
`<T> Bean<T>`	`createBean(BeanAttributes<T> attributes, Class<T> beanClass, InjectionTargetFactory<T> injectionTargetFactory)`	Obtains a `Bean` for the given `BeanAttributes`, bean class and `InjectionTarget`.
`<T,X> Bean<T>`	`createBean(BeanAttributes<T> attributes, Class<X> beanClass, ProducerFactory<X> producerFactory)`	Obtains a `Bean` for the given `BeanAttributes`, bean class and `Producer`.
`BeanAttributes<?>`	`createBeanAttributes(AnnotatedMember<?> member)`	Obtains a `BeanAttributes` for the given `AnnotatedType`.
`<T> BeanAttributes<T>`	`createBeanAttributes(AnnotatedType<T> type)`	Obtains a `BeanAttributes` for the given `AnnotatedType`.
`<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> EnhancedAnnotatedType<T>`	`createEnhancedAnnotatedType(Class<T> type)`
`FieldInjectionPointAttributes<?,?>`	`createInjectionPoint(AnnotatedField<?> field)`	Obtains a container provided implementation of `InjectionPoint` for the given `AnnotatedField`.
`ParameterInjectionPointAttributes<?,?>`	`createInjectionPoint(AnnotatedParameter<?> parameter)`	Obtains a container provided implementation of `InjectionPoint` for the given `AnnotatedParameter`.
`<T> InjectionTarget<T>`	`createInjectionTarget(AnnotatedType<T> type)`	Obtains an `InjectionTarget` for the given `AnnotatedType`.
`<T> InjectionTarget<T>`	`createInjectionTarget(org.jboss.weld.ejb.spi.EjbDescriptor<T> descriptor)`
`<T> org.jboss.weld.manager.api.WeldInjectionTargetBuilder<T>`	`createInjectionTargetBuilder(AnnotatedType<T> type)`
`WeldInstance<Object>`	`createInstance()`	Obtains an `Instance` object to access to beans instances.
`<T> InterceptionFactory<T>`	`createInterceptionFactory(CreationalContext<T> ctx, Class<T> clazz)`	Create an `InterceptionFactory` for the given `CreationalContext` and type.
`<T> void`	`disposeAnnotatedType(Class<T> type, String id)`
`boolean`	`equals(Object obj)`
`WeldEvent<Object>`	`event()`
`Set<QualifierInstance>`	`extractInterceptorBindingsForQualifierInstance(Iterable<QualifierInstance> annotations)`
`void`	`fireEvent(Object event, Annotation... qualifiers)`	Fires an event object with given event object for given bindings
`<X> InjectionTarget<X>`	`fireProcessInjectionTarget(AnnotatedType<X> annotatedType)`
`<X> InjectionTarget<X>`	`fireProcessInjectionTarget(AnnotatedType<X> annotatedType, InjectionTarget<X> injectionTarget)`
`void`	`fireRequestContextBeforeDestroyed(Object payload)`
`void`	`fireRequestContextDestroyed(Object payload)`
`void`	`fireRequestContextInitialized(Object payload)`
`Set<Bean<?>>`	`getAccessibleBeans()`	Unlike `getDynamicAccessibleBeans()` this method returns a mutable set which is not updated automatically.
`ObserverNotifier`	`getAccessibleLenientObserverNotifier()`	Get the lenient observer notifier for accessible observer methods.
`HashSet<BeanManagerImpl>`	`getAccessibleManagers()`
`List<String>`	`getAccessibleNamespaces()`	Unlike `getDynamicAccessibleNamespaces()` this method returns a mutable set which is not updated automatically.
`<T> SessionBean<T>`	`getBean(org.jboss.weld.ejb.spi.EjbDescriptor<T> descriptor)`
`<T> Bean<T>`	`getBean(Resolvable resolvable)`
`TypeSafeBeanResolver`	`getBeanResolver()`	Get the web bean resolver.
`List<Bean<?>>`	`getBeans()`	The beans registered with the Web Bean manager which are resolvable.
`Set<Bean<?>>`	`getBeans(Type beanType, 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 Jakarta EE component from whose JNDI environment namespace the `BeanManager` was obtained, according to the rules of typesafe resolution.
`Set<Bean<?>>`	`getBeans(Type beanType, Set<Annotation> qualifiers)`
`Set<Bean<?>>`	`getBeans(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 Jakarta EE component from whose JNDI environment namespace the `BeanManager` was obtained, according to the rules of EL name resolution.
`Set<Bean<?>>`	`getBeans(InjectionPoint injectionPoint)`
`ClientProxyProvider`	`getClientProxyProvider()`
`ContainerLifecycleEvents`	`getContainerLifecycleEvents()`
`Context`	`getContext(Class<? extends Annotation> scopeType)`	Gets an active context of the given scope.
`String`	`getContextId()`
`protected Map<Class<? extends Annotation>,List<Context>>`	`getContexts()`
`TypeSafeDecoratorResolver`	`getDecoratorResolver()`	Get the decorator resolver.
`List<Decorator<?>>`	`getDecorators()`
`Iterable<Bean<?>>`	`getDynamicAccessibleBeans()`
`Iterable<Decorator<?>>`	`getDynamicAccessibleDecorators()`
`Iterable<Interceptor<?>>`	`getDynamicAccessibleInterceptors()`
`Iterable<String>`	`getDynamicAccessibleNamespaces()`
`<T> org.jboss.weld.ejb.spi.EjbDescriptor<T>`	`getEjbDescriptor(String beanName)`
`javax.el.ELResolver`	`getELResolver()`	Returns a `ELResolver` that resolves beans by EL name.
`ModuleEnablement`	`getEnabled()`	Enabled Alternatives, Interceptors and Decorators
`Map<org.jboss.weld.ejb.spi.EjbDescriptor<?>,SessionBean<?>>`	`getEnterpriseBeans()`	Gets the class-mapped beans.
`Event<Object>`	`getEvent()`	Returns an instance of Event with specified type `java.lang.Object` and specified qualifier `@Default` It allows typesafe synchronous or asynchronous event firing without injection of `Event` built-in bean requirement.
`<T extends Extension> T`	`getExtension(Class<T> extensionClass)`	Obtains the container's instance of an Extension class declared in `META-INF/services`.
`ObserverNotifier`	`getGlobalLenientObserverNotifier()`	Get the lenient global observer notifier.
`ObserverNotifier`	`getGlobalStrictObserverNotifier()`	Get the Strict global observer notifier.
`String`	`getId()`
`Object`	`getInjectableReference(InjectionPoint injectionPoint, CreationalContext<?> creationalContext)`	Obtains an injectable reference for a certain injection point.
`Object`	`getInjectableReference(InjectionPoint injectionPoint, Bean<?> resolvedBean, CreationalContext<?> creationalContext)`	Get a reference, registering the injection point used.
`<T> org.jboss.weld.manager.api.WeldInjectionTargetFactory<T>`	`getInjectionTargetFactory(AnnotatedType<T> type)`	Creates an `InjectionTargetFactory` for a given type.
`<T> WeldInstance<Object>`	`getInstance(CreationalContext<?> ctx)`
`Set<Annotation>`	`getInterceptorBindingDefinition(Class<? extends Annotation> bindingType)`	Obtains the set of meta-annotations for a certain interceptor binding type .
`int`	`getInterceptorBindingHashCode(Annotation interceptorBinding)`	Determine the hash code of an interceptor binding, using the JDK algorithm for determining an annotation hash code, ignoring any members annotated with `Nonbinding`.
`InterceptorMetadataReader`	`getInterceptorMetadataReader()`
`ConcurrentMap<SlimAnnotatedType<?>,InterceptionModel>`	`getInterceptorModelRegistry()`
`TypeSafeInterceptorResolver`	`getInterceptorResolver()`
`List<Interceptor<?>>`	`getInterceptors()`
`<T> InjectionTargetFactoryImpl<T>`	`getLocalInjectionTargetFactory(AnnotatedType<T> type)`	Creates an `InjectionTargetFactory` for a given type.
`NameBasedResolver`	`getNameBasedResolver()`
`protected List<String>`	`getNamespaces()`
`List<ObserverMethod<?>>`	`getObservers()`
`Bean<?>`	`getPassivationCapableBean(String id)`	Returns the `PassivationCapable` bean with the given identifier.
`Bean<?>`	`getPassivationCapableBean(org.jboss.weld.serialization.spi.BeanIdentifier identifier)`
`<X> FieldProducerFactory<X>`	`getProducerFactory(AnnotatedField<? super X> field, Bean<X> declaringBean)`	An implementation of `ProducerFactory` that provides container created `Producer` instances for the given field.
`<X> MethodProducerFactory<X>`	`getProducerFactory(AnnotatedMethod<? super X> method, Bean<X> declaringBean)`	An implementation of `ProducerFactory` that provides container created `Producer` instances for the given method.
`int`	`getQualifierHashCode(Annotation qualifier)`	Determine the hash code of a qualifier, using the JDK algorithm for determining an annotation hash code, ignoring any members annotated with `Nonbinding`.
`Object`	`getReference(Bean<?> bean, Type requestedType, CreationalContext<?> creationalContext)`	Obtains a contextual reference for a certain bean and a certain bean type of the bean.
`Object`	`getReference(Bean<?> bean, Type requestedType, CreationalContext<?> creationalContext, boolean noProxy)`
`Object`	`getReference(InjectionPoint injectionPoint, Bean<?> resolvedBean, CreationalContext<?> creationalContext)`	Deprecated. Use `getInjectableReference(InjectionPoint, Bean, CreationalContext)` instead
`Collection<Class<? extends Annotation>>`	`getScopes()`
`org.jboss.weld.bootstrap.api.ServiceRegistry`	`getServices()`
`Set<Annotation>`	`getStereotypeDefinition(Class<? extends Annotation> stereotype)`	Obtains meta-annotations for a certain stereotype.
`Context`	`getUnwrappedContext(Class<? extends Annotation> scopeType)`
`int`	`hashCode()`
`Instance<Object>`	`instance()`
`<X> BeanAttributes<?>`	`internalCreateBeanAttributes(AnnotatedMember<X> member)`
`boolean`	`isBeanEnabled(Bean<?> bean)`
`boolean`	`isContextActive(Class<? extends Annotation> scopeType)`
`boolean`	`isInterceptorBinding(Class<? extends Annotation> annotationType)`	Test the given annotation type to determine if it is an interceptor binding type .
`boolean`	`isNormalScope(Class<? extends Annotation> annotationType)`	Test the given annotation type to determine if it is a normal scope type.
`boolean`	`isPassivatingScope(Class<? extends Annotation> annotationType)`	Test the given annotation type to determine if it is a passivating scope type.
`boolean`	`isQualifier(Class<? extends Annotation> annotationType)`	Test the given annotation type to determine if it is a qualifier type.
`boolean`	`isScope(Class<? extends Annotation> annotationType)`	Test the given annotation type to determine if it is a scope type.
`boolean`	`isStereotype(Class<? extends Annotation> annotationType)`	Test the given annotation type to determine if it is a stereotype.
`static BeanManagerImpl`	`newManager(BeanManagerImpl rootManager, String id, org.jboss.weld.bootstrap.api.ServiceRegistry services)`
`static BeanManagerImpl`	`newRootManager(String contextId, String id, org.jboss.weld.bootstrap.api.ServiceRegistry serviceRegistry)`	Create a new, root, manager
`protected Object`	`readResolve()`
`protected void`	`registerBeanNamespace(Bean<?> bean)`
`<X> Bean<? extends X>`	`resolve(Set<Bean<? extends X>> beans)`	Apply the ambiguous dependency resolution rules to a set of beans.
`List<Decorator<?>>`	`resolveDecorators(Set<Type> types, 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 Jakarta EE component from whose JNDI environment namespace the `BeanManager` was obtained.
`List<Decorator<?>>`	`resolveDecorators(Set<Type> types, Set<Annotation> qualifiers)`
`List<Interceptor<?>>`	`resolveInterceptors(InterceptionType type, Annotation... interceptorBindings)`	Resolves a list of interceptors based on interception type and interceptor bindings.
`List<Interceptor<?>>`	`resolveInterceptors(InterceptionType type, Collection<Annotation> interceptorBindings)`	Resolves a list of interceptors based on interception type and interceptor bindings.
`<T> Set<ObserverMethod<? super T>>`	`resolveObserverMethods(T event, Annotation... bindings)`	Return an ordered set of observer methods for an event.
`void`	`setEnabled(ModuleEnablement enabled)`
`String`	`toString()`	Gets a string representation
`BeanManagerImpl`	`unwrap()`
`void`	`validate(InjectionPoint ij)`	Validate a certain injection point.
`void`	`validationFailed(Exception failure, org.jboss.weld.bootstrap.api.Environment environment)`
`javax.el.ExpressionFactory`	`wrapExpressionFactory(javax.el.ExpressionFactory expressionFactory)`	Returns a wrapper `ExpressionFactory` that delegates `MethodExpression` and `ValueExpression` creation to the given `ExpressionFactory`.

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

Methods inherited from interface org.jboss.weld.manager.api.WeldManager
getActiveContexts, getActiveWeldAlterableContexts

- Method Detail
  - newRootManager
```
public static BeanManagerImpl newRootManager(String contextId,
                                             String id,
                                             org.jboss.weld.bootstrap.api.ServiceRegistry serviceRegistry)
```
    Create a new, root, manager
    
    Parameters:
    
    serviceRegistry -
    
    Returns:
  - newManager
```
public static BeanManagerImpl newManager(BeanManagerImpl rootManager,
                                         String id,
                                         org.jboss.weld.bootstrap.api.ServiceRegistry services)
```
  - getContextId
```
public String getContextId()
```
  - addAccessibleBeanManager
```
public void addAccessibleBeanManager(BeanManagerImpl accessibleBeanManager)
```
  - getAccessibleManagers
```
public HashSet<BeanManagerImpl> getAccessibleManagers()
```
  - addBean
```
public void addBean(Bean<?> bean)
```
  - addBeans
```
public void addBeans(Collection<? extends Bean<?>> beans)
```
    Optimization which modifies CopyOnWrite structures only once instead of once for every bean.
    
    Parameters:
    
    beans -
  - addDecorator
```
public void addDecorator(Decorator<?> bean)
```
  - resolveObserverMethods
```
public <T> Set<ObserverMethod<? super T>> resolveObserverMethods(T event,
                                                                 Annotation... bindings)
```
    Description copied from interface: BeanManager
    
    Return an ordered set of observer methods for an event.
    Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only return observers discovered by the container before the AfterBeanDiscovery event is fired.
    
    Specified by:
    
    resolveObserverMethods in interface BeanManager
    
    Type Parameters:
    
    T - the type of the event
    
    Parameters:
    
    event - the event object
    
    bindings - the event qualifiers
    
    Returns:
    
    the resulting set of observer methods
  - addInterceptor
```
public void addInterceptor(Interceptor<?> bean)
```
  - getEnabled
```
public ModuleEnablement getEnabled()
```
    Enabled Alternatives, Interceptors and Decorators
    
    Returns:
  - setEnabled
```
public void setEnabled(ModuleEnablement enabled)
```
  - isBeanEnabled
```
public boolean isBeanEnabled(Bean<?> bean)
```
  - getBeans
```
public Set<Bean<?>> getBeans(Type beanType,
                             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 Jakarta 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.
    Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only return beans discovered by the container before the AfterBeanDiscovery event is fired.
    
    Specified by:
    
    getBeans in interface BeanManager
    
    Parameters:
    
    beanType - the required bean type
    
    qualifiers - the required qualifiers
    
    Returns:
    
    the resulting set of beans
  - getBeans
```
public Set<Bean<?>> getBeans(Type beanType,
                             Set<Annotation> qualifiers)
```
  - getBeans
```
public Set<Bean<?>> getBeans(InjectionPoint injectionPoint)
```
  - registerBeanNamespace
```
protected void registerBeanNamespace(Bean<?> bean)
```
  - getEnterpriseBeans
```
public Map<org.jboss.weld.ejb.spi.EjbDescriptor<?>,SessionBean<?>> getEnterpriseBeans()
```
    Gets the class-mapped beans. For internal use.
    
    Returns:
    
    The bean map
  - getBeans
```
public 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 List<Decorator<?>> getDecorators()
```
  - getInterceptors
```
public List<Interceptor<?>> getInterceptors()
```
  - getDynamicAccessibleBeans
```
public Iterable<Bean<?>> getDynamicAccessibleBeans()
```
  - getAccessibleBeans
```
public Set<Bean<?>> getAccessibleBeans()
```
    Unlike getDynamicAccessibleBeans() this method returns a mutable set which is not updated automatically.
    
    Returns:
    
    all accessible beans
  - getDynamicAccessibleInterceptors
```
public Iterable<Interceptor<?>> getDynamicAccessibleInterceptors()
```
  - getDynamicAccessibleDecorators
```
public Iterable<Decorator<?>> getDynamicAccessibleDecorators()
```
  - addContext
```
public void addContext(Context context)
```
  - addObserver
```
public void addObserver(ObserverMethod<?> observer)
```
    Does the actual observer registration
    
    Parameters:
    
    observer - =
  - fireEvent
```
public void fireEvent(Object event,
                      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(Class<? extends 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
    
    Throws:
    
    IllegalStateException - if there are multiple active scopes for a given context
    
    See Also:
    
    BeanManager.getContext(java.lang.Class)
  - getUnwrappedContext
```
public Context getUnwrappedContext(Class<? extends Annotation> scopeType)
```
  - isContextActive
```
public boolean isContextActive(Class<? extends Annotation> scopeType)
```
    Specified by:
    
    isContextActive in interface org.jboss.weld.manager.api.WeldManager
  - getReference
```
public Object getReference(Bean<?> bean,
                           Type requestedType,
                           CreationalContext<?> creationalContext,
                           boolean noProxy)
```
  - getReference
```
public Object getReference(Bean<?> bean,
                           Type requestedType,
                           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
    
    requestedType - 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 Dependent that is created
    
    Returns:
    
    a contextual reference representing the bean
  - getReference
```
@Deprecated
public Object getReference(InjectionPoint injectionPoint,
                           Bean<?> resolvedBean,
                           CreationalContext<?> creationalContext)
```
    Deprecated.
    Use getInjectableReference(InjectionPoint, Bean, CreationalContext) instead
    
    The name of this method was misleading, use getInjectableReference(InjectionPoint, Bean, CreationalContext) instead.
    
    Parameters:
    
    injectionPoint -
    
    resolvedBean -
    
    creationalContext -
    
    Returns:
    
    the injectable reference
  - getInjectableReference
```
public Object getInjectableReference(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:
    
    the injectable reference
  - getInjectableReference
```
public 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 Dependent that is created
    
    Returns:
    
    the injectable reference
  - getBean
```
public <T> Bean<T> getBean(Resolvable resolvable)
```
  - getBeans
```
public Set<Bean<?>> getBeans(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 Jakarta EE component from whose JNDI environment namespace the BeanManager was obtained, according to the rules of EL name resolution.
    Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only return beans discovered by the container before the AfterBeanDiscovery event is fired.
    
    Specified by:
    
    getBeans in interface BeanManager
    
    Parameters:
    
    name - the EL name
    
    Returns:
    
    the resulting set of beans
  - resolveDecorators
```
public List<Decorator<?>> resolveDecorators(Set<Type> types,
                                            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 Jakarta EE component from whose JNDI environment namespace the BeanManager was obtained.
    Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only return decorators discovered by the container before the AfterBeanDiscovery event is fired.
    
    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 List<Decorator<?>> resolveDecorators(Set<Type> types,
                                            Set<Annotation> qualifiers)
```
  - resolveInterceptors
```
public List<Interceptor<?>> resolveInterceptors(InterceptionType type,
                                                Annotation... interceptorBindings)
```
    Resolves a list of interceptors based on interception type and interceptor bindings. Transitive interceptor bindings of the interceptor bindings passed as a parameter are considered in the resolution process.
    
    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 List<Interceptor<?>> resolveInterceptors(InterceptionType type,
                                                Collection<Annotation> interceptorBindings)
```
    Resolves a list of interceptors based on interception type and interceptor bindings. Transitive interceptor bindings of the interceptor bindings passed as a parameter are NOT considered in the resolution process. Therefore, the caller is responsible for filtering of transitive interceptor bindings in order to comply with interceptor binding inheritance and overriding (See JSR-346 9.5.2). This is a Weld-specific method.
    
    Parameters:
    
    type - The interception type to resolve
    
    interceptorBindings - The binding types to match
    
    Returns:
    
    A list of matching interceptors
  - getBeanResolver
```
public TypeSafeBeanResolver getBeanResolver()
```
    Get the web bean resolver. For internal use
    
    Returns:
    
    The resolver
  - getDecoratorResolver
```
public TypeSafeDecoratorResolver getDecoratorResolver()
```
    Get the decorator resolver. For internal use
    
    Returns:
    
    The resolver
  - getInterceptorResolver
```
public TypeSafeInterceptorResolver getInterceptorResolver()
```
  - getNameBasedResolver
```
public NameBasedResolver getNameBasedResolver()
```
  - getAccessibleLenientObserverNotifier
```
public ObserverNotifier getAccessibleLenientObserverNotifier()
```
    Get the lenient observer notifier for accessible observer methods. Should never be exposed to an application.
    
    Returns:
    
    The ObserverNotifier
  - getGlobalLenientObserverNotifier
```
public ObserverNotifier getGlobalLenientObserverNotifier()
```
    Get the lenient global observer notifier. Should never be exposed to an application.
    
    Returns:
    
    The ObserverNotifier
  - getGlobalStrictObserverNotifier
```
public ObserverNotifier getGlobalStrictObserverNotifier()
```
    Get the Strict global observer notifier. This one should be used for firing application / extension events.
    
    Returns:
    
    The ObserverNotifier
  - toString
```
public String toString()
```
    Gets a string representation
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    A string representation
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - getServices
```
public org.jboss.weld.bootstrap.api.ServiceRegistry getServices()
```
    Specified by:
    
    getServices in interface org.jboss.weld.manager.api.WeldManager
  - readResolve
```
protected Object readResolve()
                      throws ObjectStreamException
```
    Throws:
    
    ObjectStreamException
  - getClientProxyProvider
```
public ClientProxyProvider getClientProxyProvider()
```
  - getContexts
```
protected Map<Class<? extends Annotation>,List<Context>> getContexts()
```
  - getNamespaces
```
protected List<String> getNamespaces()
```
    Returns:
    
    the namespaces
  - getDynamicAccessibleNamespaces
```
public Iterable<String> getDynamicAccessibleNamespaces()
```
  - getAccessibleNamespaces
```
public List<String> getAccessibleNamespaces()
```
    Unlike getDynamicAccessibleNamespaces() this method returns a mutable set which is not updated automatically.
    
    Returns:
    
    the accessible namespaces
  - getId
```
public String getId()
```
    Specified by:
    
    getId in interface org.jboss.weld.manager.api.WeldManager
  - getObservers
```
public List<ObserverMethod<?>> getObservers()
```
  - 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.
    
    This method is deprecated from CDI 1.1 and BeanManager.getInjectionTargetFactory(AnnotatedType) should be used instead.
    
    Specified by:
    
    createInjectionTarget in interface BeanManager
    
    Type Parameters:
    
    T - the type
    
    Parameters:
    
    type - the AnnotatedType
    
    Returns:
    
    a container provided implementation of InjectionTarget
  - createInjectionTarget
```
public <T> InjectionTarget<T> createInjectionTarget(org.jboss.weld.ejb.spi.EjbDescriptor<T> descriptor)
```
    Specified by:
    
    createInjectionTarget in interface org.jboss.weld.manager.api.WeldManager
  - validate
```
public void validate(InjectionPoint ij)
```
    Description copied from interface: BeanManager
    
    Validate a certain injection point.
    Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only validate injection points discovered by the container before the AfterBeanDiscovery event is fired.
    
    Specified by:
    
    validate in interface BeanManager
    
    Parameters:
    
    ij - the injection point to validate
  - getInterceptorBindingDefinition
```
public Set<Annotation> getInterceptorBindingDefinition(Class<? extends 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(String id)
```
    Description copied from interface: BeanManager
    
    Returns the PassivationCapable bean with the given identifier.
    Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only return beans discovered by the container before the AfterBeanDiscovery event is fired.
    
    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
  - getPassivationCapableBean
```
public Bean<?> getPassivationCapableBean(org.jboss.weld.serialization.spi.BeanIdentifier identifier)
```
    Specified by:
    
    getPassivationCapableBean in interface org.jboss.weld.manager.api.WeldManager
  - getStereotypeDefinition
```
public Set<Annotation> getStereotypeDefinition(Class<? extends 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(Class<? extends 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(Class<? extends 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(Class<? extends 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(Class<? extends 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(Class<? extends 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(Class<? extends 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
  - getELResolver
```
public javax.el.ELResolver getELResolver()
```
    Description copied from interface: BeanManager
    
    Returns a ELResolver that resolves beans by EL name.
    
    Specified by:
    
    getELResolver in interface BeanManager
    
    Returns:
    
    the ELResolver
  - wrapExpressionFactory
```
public javax.el.ExpressionFactory wrapExpressionFactory(javax.el.ExpressionFactory expressionFactory)
```
    Description copied from interface: BeanManager
    
    Returns a wrapper ExpressionFactory that delegates MethodExpression and ValueExpression creation to the given ExpressionFactory. When a Unified EL expression is evaluated using a MethodExpression or ValueExpression returned by the wrapper ExpressionFactory, the container handles destruction of objects with scope Dependent.
    
    Specified by:
    
    wrapExpressionFactory in interface BeanManager
    
    Parameters:
    
    expressionFactory - the ExpressionFactory to wrap
    
    Returns:
    
    the wrapped 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
    
    Specified by:
    
    createCreationalContext in interface org.jboss.weld.manager.api.WeldManager
    
    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(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
  - createEnhancedAnnotatedType
```
public <T> EnhancedAnnotatedType<T> createEnhancedAnnotatedType(Class<T> type)
```
  - createAnnotatedType
```
public <T> AnnotatedType<T> createAnnotatedType(Class<T> type,
                                                String id)
```
    Specified by:
    
    createAnnotatedType in interface org.jboss.weld.manager.api.WeldManager
  - disposeAnnotatedType
```
public <T> void disposeAnnotatedType(Class<T> type,
                                     String id)
```
    Specified by:
    
    disposeAnnotatedType in interface org.jboss.weld.manager.api.WeldManager
  - resolve
```
public <X> Bean<? extends X> resolve(Set<Bean<? extends X>> beans)
```
    Description copied from interface: BeanManager
    
    Apply the ambiguous dependency resolution rules to a set of beans.
    Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only return beans discovered by the container before the AfterBeanDiscovery event is fired.
    
    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
    
    Returns:
    
    the resolved bean, or null if null or an empty set is passed
  - getEjbDescriptor
```
public <T> org.jboss.weld.ejb.spi.EjbDescriptor<T> getEjbDescriptor(String beanName)
```
    Specified by:
    
    getEjbDescriptor in interface org.jboss.weld.manager.api.WeldManager
  - getBean
```
public <T> SessionBean<T> getBean(org.jboss.weld.ejb.spi.EjbDescriptor<T> descriptor)
```
    Specified by:
    
    getBean in interface org.jboss.weld.manager.api.WeldManager
  - cleanup
```
public void cleanup()
```
  - cleanupAfterBoot
```
public void cleanupAfterBoot()
```
    For internal use only. This happens after bootstrap services cleanup but before RIBean.cleanupAfterBoot().
    
    See Also:
    
    Bootstrap.endInitialization()
  - getInterceptorModelRegistry
```
public ConcurrentMap<SlimAnnotatedType<?>,InterceptionModel> getInterceptorModelRegistry()
```
  - getInterceptorMetadataReader
```
public InterceptorMetadataReader getInterceptorMetadataReader()
```
  - fireProcessInjectionTarget
```
public <X> InjectionTarget<X> fireProcessInjectionTarget(AnnotatedType<X> annotatedType)
```
    Specified by:
    
    fireProcessInjectionTarget in interface org.jboss.weld.manager.api.WeldManager
  - fireProcessInjectionTarget
```
public <X> InjectionTarget<X> fireProcessInjectionTarget(AnnotatedType<X> annotatedType,
                                                         InjectionTarget<X> injectionTarget)
```
    Specified by:
    
    fireProcessInjectionTarget in interface org.jboss.weld.manager.api.WeldManager
  - extractInterceptorBindingsForQualifierInstance
```
public Set<QualifierInstance> extractInterceptorBindingsForQualifierInstance(Iterable<QualifierInstance> annotations)
```
  - instance
```
public Instance<Object> instance()
```
    Specified by:
    
    instance in interface org.jboss.weld.manager.api.WeldManager
  - event
```
public WeldEvent<Object> event()
```
  - getInstance
```
public <T> WeldInstance<Object> getInstance(CreationalContext<?> ctx)
```
  - createBeanAttributes
```
public <T> BeanAttributes<T> createBeanAttributes(AnnotatedType<T> type)
```
    Description copied from interface: BeanManager
    
    Obtains a BeanAttributes 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:
    
    createBeanAttributes in interface BeanManager
    
    Type Parameters:
    
    T - the type
    
    Parameters:
    
    type - the AnnotatedType
    
    Returns:
    
    a container provided implementation of InjectionTarget
  - createBeanAttributes
```
public BeanAttributes<?> createBeanAttributes(AnnotatedMember<?> member)
```
    Description copied from interface: BeanManager
    
    Obtains a BeanAttributes 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:
    
    createBeanAttributes in interface BeanManager
    
    Parameters:
    
    member - the AnnotatedType
    
    Returns:
    
    a container provided implementation of InjectionTarget
  - internalCreateBeanAttributes
```
public <X> BeanAttributes<?> internalCreateBeanAttributes(AnnotatedMember<X> member)
```
  - createBean
```
public <T> Bean<T> createBean(BeanAttributes<T> attributes,
                              Class<T> beanClass,
                              InjectionTargetFactory<T> injectionTargetFactory)
```
    Description copied from interface: BeanManager
    
    Obtains a Bean for the given BeanAttributes, bean class and InjectionTarget.
    
    The InjectionTarget creates and destroys instances of the bean, performs dependency injection and lifecycle callbacks, and determines the return value of Bean.getInjectionPoints(). The InjectionTarget is obtained from the InjectionTargetFactory. BeanManager.getInjectionTargetFactory(AnnotatedType) allows use of a container created InjectionTarget.
    
    Specified by:
    
    createBean in interface BeanManager
    
    Type Parameters:
    
    T - the type
    
    Parameters:
    
    attributes - a BeanAttributes which determines the bean types, qualifiers, scope, name and stereotypes of the returned Bean, and the return values of BeanAttributes.isAlternative() and Bean.isNullable()
    
    beanClass - a class, which determines the return value of Bean.getBeanClass()
    
    injectionTargetFactory - an InjectionTargetFactory, used to obtain an InjectionTarget
    
    Returns:
    
    a container provided implementation of Bean
  - createBean
```
public <T,X> Bean<T> createBean(BeanAttributes<T> attributes,
                                      Class<X> beanClass,
                                      ProducerFactory<X> producerFactory)
```
    Description copied from interface: BeanManager
    
    Obtains a Bean for the given BeanAttributes, bean class and Producer.
    
    The Producer creates and destroys instances of the decorator, and determines the return value of Bean.getInjectionPoints(). The Producer is obtained from the ProducerFactory. BeanManager.getProducerFactory(AnnotatedMethod, Bean) or BeanManager.getProducerFactory(AnnotatedField, Bean) allows use of a container created Producer.
    
    Specified by:
    
    createBean in interface BeanManager
    
    Type Parameters:
    
    T - the type
    
    X - the type of the declaring bean
    
    Parameters:
    
    attributes - a BeanAttributes which determines the bean types, qualifiers, scope, name and stereotypes of the returned Bean, and the return values of BeanAttributes.isAlternative() and Bean.isNullable()
    
    beanClass - a class, which determines the return value of Bean.getClass()
    
    producerFactory - a ProducerFactory, used to obtain a Producer
    
    Returns:
    
    a container provided implementation of Bean
  - createInjectionPoint
```
public FieldInjectionPointAttributes<?,?> createInjectionPoint(AnnotatedField<?> field)
```
    Description copied from interface: BeanManager
    
    Obtains a container provided implementation of InjectionPoint for the given AnnotatedField.
    
    Specified by:
    
    createInjectionPoint in interface BeanManager
    
    Parameters:
    
    field - the AnnotatedField defining the injection point
    
    Returns:
    
    the container provided InjectionPoint
  - createInjectionPoint
```
public ParameterInjectionPointAttributes<?,?> createInjectionPoint(AnnotatedParameter<?> parameter)
```
    Description copied from interface: BeanManager
    
    Obtains a container provided implementation of InjectionPoint for the given AnnotatedParameter.
    
    Specified by:
    
    createInjectionPoint in interface BeanManager
    
    Parameters:
    
    parameter - the AnnotatedParameter defining the injection point
    
    Returns:
    
    the container provided InjectionPoint
  - getExtension
```
public <T extends Extension> T getExtension(Class<T> extensionClass)
```
    Description copied from interface: BeanManager
    
    Obtains the container's instance of an Extension class declared in META-INF/services.
    
    Specified by:
    
    getExtension in interface BeanManager
    
    Type Parameters:
    
    T - the type of the extension
    
    Parameters:
    
    extensionClass - the type of the extension class
    
    Returns:
    
    the extension instance
  - createInterceptionFactory
```
public <T> InterceptionFactory<T> createInterceptionFactory(CreationalContext<T> ctx,
                                                            Class<T> clazz)
```
    Description copied from interface: BeanManager
    
    Create an InterceptionFactory for the given CreationalContext and type.
    
    Specified by:
    
    createInterceptionFactory in interface BeanManager
    
    Type Parameters:
    
    T - type of the instance this factory will work on
    
    Parameters:
    
    ctx - CreationalContext for the InterceptionFactory to create
    
    clazz - class of the instance this factory will work on
    
    Returns:
    
    a new InterceptionFactory to add services on on instances of T
  - getEvent
```
public Event<Object> getEvent()
```
    Description copied from interface: BeanManager
    
    Returns an instance of Event with specified type java.lang.Object and specified qualifier @Default It allows typesafe synchronous or asynchronous event firing without injection of Event built-in bean requirement.
    
    Specified by:
    
    getEvent in interface BeanManager
    
    Returns:
    
    a new Event object whose event type is Object and qualifier @Default
  - getContainerLifecycleEvents
```
public ContainerLifecycleEvents getContainerLifecycleEvents()
```
  - areQualifiersEquivalent
```
public boolean areQualifiersEquivalent(Annotation qualifier1,
                                       Annotation qualifier2)
```
    Description copied from interface: BeanManager
    
    Determine if two qualifiers are considered equivalent for the purposes of typesafe resolution, taking into account any members annotated with Nonbinding.
    
    Specified by:
    
    areQualifiersEquivalent in interface BeanManager
    
    Parameters:
    
    qualifier1 - a qualifier to check
    
    qualifier2 - a qualifier to check
    
    Returns:
    
    true if the two qualifiers are equivalent, otherwise false
  - areInterceptorBindingsEquivalent
```
public boolean areInterceptorBindingsEquivalent(Annotation interceptorBinding1,
                                                Annotation interceptorBinding2)
```
    Description copied from interface: BeanManager
    
    Determine if two interceptor bindings are considered equivalent for the purposes of typesafe resolution, taking into account any members annotated with Nonbinding.
    
    Specified by:
    
    areInterceptorBindingsEquivalent in interface BeanManager
    
    Parameters:
    
    interceptorBinding1 - an interceptor binding to check
    
    interceptorBinding2 - an interceptor binding to check
    
    Returns:
    
    true if the two interceptor bindings are equivalent, otherwise false
  - getQualifierHashCode
```
public int getQualifierHashCode(Annotation qualifier)
```
    Description copied from interface: BeanManager
    
    Determine the hash code of a qualifier, using the JDK algorithm for determining an annotation hash code, ignoring any members annotated with Nonbinding.
    
    Specified by:
    
    getQualifierHashCode in interface BeanManager
    
    Parameters:
    
    qualifier - the qualifier to consider
    
    Returns:
    
    the hashCode for the qualifier
  - getInterceptorBindingHashCode
```
public int getInterceptorBindingHashCode(Annotation interceptorBinding)
```
    Description copied from interface: BeanManager
    
    Determine the hash code of an interceptor binding, using the JDK algorithm for determining an annotation hash code, ignoring any members annotated with Nonbinding.
    
    Specified by:
    
    getInterceptorBindingHashCode in interface BeanManager
    
    Parameters:
    
    interceptorBinding - the interceptor binding to consider
    
    Returns:
    
    the hashCode for the interceptor binding
  - getLocalInjectionTargetFactory
```
public <T> InjectionTargetFactoryImpl<T> getLocalInjectionTargetFactory(AnnotatedType<T> type)
```
    Creates an InjectionTargetFactory for a given type. The factory will be using this BeanManager.
  - getInjectionTargetFactory
```
public <T> org.jboss.weld.manager.api.WeldInjectionTargetFactory<T> getInjectionTargetFactory(AnnotatedType<T> type)
```
    Creates an InjectionTargetFactory for a given type. The BeanManager for the InjectionTarget will be inferred using CDI11Deployment.getBeanDeploymentArchive(Class).
    
    Specified by:
    
    getInjectionTargetFactory in interface BeanManager
    
    Specified by:
    
    getInjectionTargetFactory in interface org.jboss.weld.manager.api.WeldManager
    
    Parameters:
    
    type - the annotated type to create the injection target factory for
    
    Returns:
    
    an InjectionTargetFactory
  - getProducerFactory
```
public <X> FieldProducerFactory<X> getProducerFactory(AnnotatedField<? super X> field,
                                                      Bean<X> declaringBean)
```
    Description copied from interface: BeanManager
    
    An implementation of ProducerFactory that provides container created Producer instances for the given field.
    
    This factory can be wrapped to add behavior to container created producers.
    
    Specified by:
    
    getProducerFactory in interface BeanManager
    
    Parameters:
    
    field - the field to create the producer factory for
    
    declaringBean - the bean declaring the producer. May be null if the producer is static or the declaring object is non-contextual
    
    Returns:
    
    the producer factory for the field
  - getProducerFactory
```
public <X> MethodProducerFactory<X> getProducerFactory(AnnotatedMethod<? super X> method,
                                                       Bean<X> declaringBean)
```
    Description copied from interface: BeanManager
    
    An implementation of ProducerFactory that provides container created Producer instances for the given method.
    
    This factory can be wrapped to add behavior to container created producers.
    
    Specified by:
    
    getProducerFactory in interface BeanManager
    
    Parameters:
    
    method - the method to create the producer factory for
    
    declaringBean - the bean declaring the producer. May be null if the producer is static or the declaring object is non-contextual
    
    Returns:
    
    the producer factory for the method
  - createInjectionTargetBuilder
```
public <T> org.jboss.weld.manager.api.WeldInjectionTargetBuilder<T> createInjectionTargetBuilder(AnnotatedType<T> type)
```
    Specified by:
    
    createInjectionTargetBuilder in interface org.jboss.weld.manager.api.WeldManager
  - createInstance
```
public WeldInstance<Object> createInstance()
```
    Description copied from interface: BeanManager
    
    Obtains an Instance object to access to beans instances. The returned Instance object can only access instances of beans that are available for injection in the module or library containing the class into which the BeanManager was injected or the Jakarta EE component from whose JNDI environment namespace the BeanManager was obtained, according to the rules of typesafe resolution. Note that when called during invocation of an AfterBeanDiscovery event observer, the Instance returned by this method will only give access to instances of beans discovered by the container before the AfterBeanDiscovery event is fired. Instances of dependent scoped beans obtained with this Instance must be explicitly destroyed by calling Instance.destroy(Object) If no qualifier is passed to Instance.select(java.lang.annotation.Annotation...) method, the @Default qualifier is assumed.
    
    Specified by:
    
    createInstance in interface BeanManager
    
    Returns:
    
    an Instance object to request beans instances
  - unwrap
```
public BeanManagerImpl unwrap()
```
    Specified by:
    
    unwrap in interface org.jboss.weld.manager.api.WeldManager
  - fireRequestContextInitialized
```
public void fireRequestContextInitialized(Object payload)
```
  - fireRequestContextBeforeDestroyed
```
public void fireRequestContextBeforeDestroyed(Object payload)
```
  - fireRequestContextDestroyed
```
public void fireRequestContextDestroyed(Object payload)
```
  - addValidationFailureCallback
```
public void addValidationFailureCallback(BiConsumer<Exception,org.jboss.weld.bootstrap.api.Environment> callback)
```
  - validationFailed
```
public void validationFailed(Exception failure,
                             org.jboss.weld.bootstrap.api.Environment environment)
```
  - getScopes
```
public Collection<Class<? extends Annotation>> getScopes()
```
    Specified by:
    
    getScopes in interface org.jboss.weld.manager.api.WeldManager

Class BeanManagerImpl

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.jboss.weld.manager.api.WeldManager

Method Detail

newRootManager

newManager

getContextId

addAccessibleBeanManager

getAccessibleManagers

addBean

addBeans

addDecorator

resolveObserverMethods

addInterceptor

getEnabled

setEnabled

isBeanEnabled

getBeans

getBeans

getBeans

registerBeanNamespace

getEnterpriseBeans

getBeans

getDecorators

getInterceptors

getDynamicAccessibleBeans

getAccessibleBeans

getDynamicAccessibleInterceptors

getDynamicAccessibleDecorators

addContext

addObserver

fireEvent

getContext

getUnwrappedContext

isContextActive

getReference

getReference

getReference

getInjectableReference

getInjectableReference

getBean

getBeans

resolveDecorators

resolveDecorators

resolveInterceptors

resolveInterceptors

getBeanResolver

getDecoratorResolver

getInterceptorResolver

getNameBasedResolver

getAccessibleLenientObserverNotifier

getGlobalLenientObserverNotifier

getGlobalStrictObserverNotifier

toString

equals

hashCode

getServices

readResolve

getClientProxyProvider

getContexts

getNamespaces

getDynamicAccessibleNamespaces

getAccessibleNamespaces

getId

getObservers

createInjectionTarget

createInjectionTarget

validate

getInterceptorBindingDefinition

getPassivationCapableBean

getPassivationCapableBean

getStereotypeDefinition

isQualifier

isInterceptorBinding

isNormalScope

isPassivatingScope

isScope

isStereotype

getELResolver