All Classes and Interfaces
Class
Description
Base class for Request Context activation via interceptor.
Base class for AssignabilityRules implementations.
An abstract bean representation common for all beans
Common functionality for qualifiers and interceptor bindings.
Base class for contexts using a thread local to store a bound bean context
Common superclass for
Bean, Interceptor and Decorator builtin beans.Abstract implementation of CDI which forwards all Instance methods to a delegate.
An abstract bean representation common for class-based beans
General
ResourceLoader implementation that delegates resource loading to AbstractClassLoaderResourceLoader.classLoader().Abstract container.
Base for the Context implementations.
The base of the conversation context, which can use a variety of storage
forms
Built-in bean that can be decorated by a
DecoratorCommon functionality for an instantiator capable of applying decorators to a given instance.
Represents functionality common for all annotated items, mainly different
mappings of the annotations and meta-annotations
Represents an abstract annotated member (field, method or constructor)
Common implementation of
ExecutorServicesCommon implementation for binding-type-based helpers
The built-in bean for facade objects.
Common implementation for all immutable map implementations.
Provides support for Weld injection into servlets, servlet filters etc.
Abstract Jetty container.
Common functionality for
Producers backing producer fields and producer methods.The implicit producer bean
A decorated built-in bean for which, unlike
AbstractFacadeBean, decorators only need to be resolved once.Common supertype for
Beans which are created based on extension-provided Producer implementation.AbstractTypeSafeBeanResolver<T extends jakarta.enterprise.inject.spi.Bean<?>,C extends Collection<T>>
Base class for contexts using a thread local to store a bound bean context
This interceptor binding can be used to activate the request context within a business method invocation.
Annotation literal for
ActivateRequestContextUses Weld API binding - @org.jboss.weld.context.activator.ActivateRequestContext.
Provides message localization service for the
.
Configurator for
AnnotatedConstructor.Configurator for
AnnotatedField.Configurator for
AnnotatedMethod.Configurator for
AnnotatedParameter.Configurator for
AnnotatedType.An identifier for a an
AnnotatedType The identifier is composed of four parts:
The identifier of the BeanDeploymentArchive which the type resides in.Class that can take an AnnotatedType and return a unique string
representation of that type
Validates that methods of an
Annotated implementation return sane values.Abstract representation of an annotation model
Utility methods for working with annotations.
A base class for utility classes that represent annotations, classes etc
"Not found" class
"Not found" annotation
"Not found" enumeration value.
The built in application context, associated with
ApplicationScoped.
A bound bean store backed by attributes.
BackedAnnotatedMember.BackedAnnotatedMemberSerializationProxy<X,A extends jakarta.enterprise.inject.spi.AnnotatedMember<? super X>>
Basic
InjectionTarget implementation.Creates
BeanAttributes based on a given annotated.Represents an EE module that holds bean archives.
Repository for
BeanDeploymentModules.Serializable holder that keeps reference to a bean and is capable of reloading the reference on deserialization.
An optional per deployment service.
An abstract naming scheme which makes use of
BeanIdentifierIndex if possible.Each proxy maintains a single bean instance on which methods
are invoked.
Log messages for Beans.
Warning this class consists of generated code.
Implementation of the Bean Manager.
Log messages for bean manager and related support classes.
Warning this class consists of generated code.
Simple facade over
CDI11Deployment that allows BeanManager for a given class to be looked up at runtime.Client view of
BeanManagerImpl.Emulates the behavior of the naming resource binding that is typically done
using configuration files in Tomcat and Jetty.
Allows a bean to obtain information about itself.
Helper class for bean inspection
A
Map like store of contextual instances, used to back the Weld built
in contexts.Retained for backward compatibility with Arquillian and WildFly which incorrectly rely on Weld internals!
Retained for backward compatibility with Arquillian and WildFly which incorrectly rely on Weld internals!
Simple yet efficient parser for beans.xml.
This validator is thread safe and suitable for sharing between threads.
Implementation of the Section 5.2.4 of the CDI specification.
Utility methods for working with qualifiers and interceptor bindings.
Log messages for bootstrap
Warning this class consists of generated code.
Qualifier used with all for all of the bound (map backed) contexts Weld offers.
A bean store may be bound to some external data store, for example a Http
Session.
Allows a thread-based context to be bound to some external instance storage (such as an HttpSession).
A conversation context which can be bound to a pair of Maps encapsulated by
BoundRequest.Annotation literal for
Bound
A conversation is used to span multiple requests, however is shorter than a session.
A request context which can be bound to any Map.
A session context which can be bound to any Map.
A localized message version of the
.
An object that generates bytecode to resolve a
Method at runtime.utility class for common bytecode operations
InterceptorFactory that obtains an interceptor instance using
BeanManagerImpl.Uses CDI API binding - @jakarta.enterprise.context.control.ActivateRequestContext.
Marker for
Bean implementations that are defined by a Java class.A (@link ResourceLoader} implementation that uses a specific @{link ClassLoader}
Proxy factory that generates client proxies, it uses optimizations that
are not valid for other proxy types.
A proxy pool for holding scope adaptors (client proxies)
A method handler that wraps the invocation of interceptors and decorators.
Common superclass for beans that are identified using id.
Wrapper for
ForkJoinPool.commonPool().A simple abstraction for computing cache.
A builder for
ComputingCache instances.BeanDeployer that processes some of the deployment tasks in parallel.
A BeanStore that uses a HashMap as backing storage
Processes validation of beans, decorators and interceptors in parallel.
This enum lists all the supported configuration keys.
Log messages for configuration.
Warning this class consists of generated code.
Serializable holder for
Constructor.High-level representation of an injected constructor.
Delegating
Instantiator that takes care of AroundConstruct interceptor invocation.Utility class for working with constructors in the low level javassist API
A Weld application container
Abstract the web container setup notion.
Wrap listener arguments.
Marker for lifecycle events dispatched by the Weld container.
Marker interface for container lifecycle event observer methods.
Allows observer methods for container lifecycle events to be resolved upfront while the deployment is waiting for classloader
or reflection API.
Application container instance state
ContextBean<T extends jakarta.enterprise.context.spi.Context>
An instance locator that uses a context to lookup the instance if
it exists; otherwise, a new instance will be created from the
bean.
General event payload for
Initialized / Destroyed events.ContextHolder<T extends jakarta.enterprise.context.spi.Context>
Log messages for Contexts
Message Ids: 000200 - 000299
Warning this class consists of generated code.
A localized message version of the .
Convenience facade for using
ContextualInstanceStrategy.Represents a contextual instance of a given type.
This component allows optimized strategies for obtaining contextual instances of a given bean to be plugged in.
Implementation of
ContextualStore
A forwarding JSF ViewHandler implementation that produces URLs containing the
conversation id query string parameter.
The built in conversation context is associated with
ConversationScoped.The default conversation id generator
Log messages for conversations.
Warning this class consists of generated code.
A naming scheme which can have it's cid swapped out.
Utility class that captures standard covariant Java assignability rules.
A version of that supports message localization.
This comparator sorts classes alphabetically based on
Class.getName() with notable difference that all
classes starting with java.* or javax.* come after all other classes.A wrapper for a decorated instance.
ThreadFactory that creates daemon threads so that Weld does not hang e.g. in a SE environment.Marker interface for a
Bean that can have decorators.Allows a decorator to obtain information about the bean it decorates.
Annotation literal for
Decorated.InjectionTarget implementation used for decorators.Allows a decorator to obtain information about itself.
Marker interface to identify Decorator proxies
This special proxy factory is mostly used for abstract decorators.
Method handler for decorated beans
Helper class for inspections.
A
BytecodeMethodResolver that looks up the method using the reflection API.Injector implementation that injects
Inject-annotated fields and calls CDI initializer methods.Creates a new Java object by calling its class constructor.
If the component is not intercepted this implementation takes care of invoking its lifecycle callback methods.
Default
ProxyInstantiator implementation that uses proxy class' no-arg constructor to create a new instance.A simple resource loader.
Thrown if the definition of a bean is incorrect
Implementation of the Section 8.3.1 of the CDI specification.
The built in dependent context, associated with
Dependent.The dependent context
Thrown if an deployment exception occurs.
A Deployment visitor which can find the transitive closure of Bean Deployment Archives
Unlike javadoc this description may be inspected at runtime.
InjectionPoint that represents an injected Event or Instance object.Qualifier used with all for all of the EJB contexts Weld offers.
Annotation literal for
Ejb
A request context which can be bound to the
InvocationContext.This service provides EJB support.
Log messages for EL resolution.
Warning this class consists of generated code.
AnnotatedItem provides uniform access to the annotations on an annotated item defined either in Java or XML
Represents a Class Constructor
Represents an annotated constructor
AnnotatedField provides a uniform access to the annotations on an annotated
field
Represents an annotated field
AnnotatedMember provides enhanced access to an annotated member
AnnotatedType provides a uniform access to the annotations on an annotated
class defined either in Java or XML
Represents an annotated method
AnnotatedParameter provides a uniform access to a method parameter defined
either in Java or XML
Represents a parameter
Represents a Class
Represents an annotated class
Represents a meta annotation
Represents an annotated annotation
This listener also implements
ServletContainerInitializer so that it's able to boot Weld before any application code
is called, and thus injections
will succeed for all listeners, servlets, filters etc.An immutable Enumeration -> List adaptor
Implementation of the Event interface
Log messages for events
Message ids: 000400 - 000499
Warning this class consists of generated code.
Marker interface for observer methods which are able to decide whether an access to
EventMetadata is required or not.Built-in bean for event metadata.
Simple
EventMetadata implementation.Builds a special
TypeResolver capable of resolving type variables by using a combination of two type hierarchies.This class implements Section 10.3.1 of the CDI specification.
Abstraction over common EL operations.
ExtensionBean<E extends jakarta.enterprise.inject.spi.Extension>
An implementation of
ObserverMethod used for events delivered to extensions.Creates
BeanAttributes based on BeanAttributes provided by an extension.Helper class for preparing JSF URLs which include the conversation id.
An optimized internal facility for dispatching events.
ProcessAnnotatedType observer method resolver.
Serializable holder for
Field.A predicate which selects classes to process based on a filter.
Implementation of
ExtendedExecutorServices that uses a fixed thread pool.Utility class to produce friendly names e.g. for debugging
Base class to allow implementation of the decorator pattern
Forwarding implementation of
AnnotatedCallable.Forwarding implementation of
AnnotatedConstructor.Forwarding implementation of
AnnotatedField.Forwarding implementation of
AnnotatedMember.Forwarding implementation of
AnnotatedMethod.Forwarding implementation of AnnotatedType
A delegating bean
Delegating
BeanAttributes.Forwarding implementation of
BeanManager.Forwarding implementation of
ContextCopied from Weld core.
Forwarding implementation of ExecutorService
An implementation of
WeldInjectionPointAttributes that forwards calls to an extension-provided InjectionPoint
implementation.Delegating implementation of
Interceptor.Forwarding implementation of
InvocationContext.An implementation of
WeldInjectionPointAttributes that forwards calls to an extension-provided InjectionPoint
implementation.Forwarding implementation of
Instance.This service gathers globally enabled interceptors, decorators and alternatives and builds a list of each.
Hosts a
ObserverNotifier that uses the global TypeSafeObserverResolver which has access to every enabled
observer method in the deployment.ProxiedMethodFilter implementation for Groovy.A BeanStore that uses a HashMap as backing storage
Utility class that discovers transitive type closure of a given type.
ReflectionCache implementation that works around possible deadlocks in HotSpot:Qualifier used with all for all of the Servlet backed contexts Weld offers.
An Http Session backed conversation context.
Annotation literal for
Http
A request context which can be bound to the
ServletRequest.
A session context which can be bound to the
HttpServletRequest.Marker interface for anything that needs to be identified by an explicit
Identifier.Marker interface for an identifier.
An
IllegalArgumentException with support for
localized messages in Weld.An with support for
localized messages in Weld.
An
IllegalStateException with support for
localized messages in Weld.Implementation of
BeanAttributes used by Weld.Immutable
Set implementation.Weld's immutable
List implementations.Weld's immutable map implementation.
Weld's immutable set implementation.
Builder for building immutable sets.
An implementation of
WeldInjectionPointAttributes that infers the attributes by reading
EnhancedAnnotatedField.An implementation of
WeldInjectionPointAttributes that infers the attributes by reading
EnhancedAnnotatedParameter.Provides message localization service for the
.
Bean for InjectionPoint metadata
Factory class that producer
InjectionPoint instances for fields, parameters, methods and constructors.Serializable holder for
InjectionPoint.Helper class for
InjectionPoint processing.Factory capable of producing
InjectionTarget implementations for a given combination of AnnotatedType and
Bean objects.Carries extended metadata -
EnhancedAnnotatedType for a given InjectionTarget.Implementations of this interface are capable of performing field/method injection as defined in
InjectionTarget.inject(Object, CreationalContext).Helper implementation for Instance for getting instances
Implementation of this interface is capable of producing Java objects.
Allows an interceptor to obtain information about the bean it intercepts.
Annotation literal for
Intercepted.Generates proxies used to apply interceptors to custom bean instances and return values of producer methods.
Factory for producing subclasses that are used by the combined interceptors and decorators stack.
Holds interceptor metadata and interceptor instances throughout the lifecycle of the intercepted instance.
A class that holds the interception (and decoration) contexts which are currently in progress.
Allows to share data required for effective
InterceptionFactory implementation.Instances of this class are not suitable for sharing between threads.
Describes the
InterceptorClassMetadatas that apply to a particular entity.This builder shouldn't be reused.
Initializes
InterceptionModel for a Bean or a non-contextual component.A wrapper over
SubclassedComponentInstantiator that registers interceptors within the method handler.Annotation literal for
InterceptorBindingMetadata about an interceptor component.
Allows to configure a new
Interceptor instance.Produces instances of interceptor classes.
Represents an invocation of interceptor's methods on an interceptor instance.
Log messages for interceptors.
Warning this class consists of generated code.
Metadata about a type that may have interceptor methods.
Allows an interceptor to obtain information about itself.
Interceptor class metadata.
InterceptorMetadata reader.
Helper class for working with interceptors and interceptor bindings.
An extended version of
InvalidObjectException that supports
localization.Utility class that captures invariant Java assignability rules (used with generics).
An implementation of
AnnotatedMethod used at runtime for invoking Java methods.Log messages for
Invoker, InvokerBuilder
and related Weld classes.Warning this class consists of generated code.
Delegating implementation of
Bean.Delegating implementation of
Decorator.Delegating implementation of
Interceptor.Static utility methods for
Iterable.Used for decomposition of loops in which independent tasks are processed sequentially.
Static utility methods for
Iterator.Jetty Container.
Message IDs: 001200 - 001299
Warning this class consists of generated code.
Utility class for JSF related components, concepts etc.
Represents a lazily computed value.
LazyValueHolder that implements Serializable.Implementations of this interface are capable of performing
PostConstruct / PreDestroy lifecycle callback
invocations.This is the original listener which had to be defined in web.xml.
Provides a set-like read-only view on a given
List.Provides a view of type List for a List.
A representation of a creation lock on a bean instance
Helper class for bean store creation locking.
JBoss Logging is not using message keys and so it's not possible to reference the log message (a logger method annotated with
LogMessage and
Message) and use it as a method parameter or construct it lazily.Represents a simple bean
Lifecycle management for built in contexts.
Provides management operations for conversations, including locking, and expiration management.
A marker class we can use to ensure that our method will not collide with a
user provided method
Serves several functions.
Meta model for the merged stereotype for a bean
JBoss Logging is not using message keys and so it's not possible to reference the message (a message method annotated with
Message) and use it as a
method parameter or construct it lazily.Metadata singleton for holding EJB metadata, scope models etc.
Log messages for Meta Data.
Warning this class consists of generated code.
The interface implemented by the invocation handler of a proxy
instance.
Serializable holder for
Method.Data that is needed when working with a method in bytecode
Wraps a method whose parameters may be injected.
Encapsulates various strategies for invoking a method injection point.
Holds information about classes that have missing dependencies (class X references class Y and class Y is not
on classpath).
Holds information about interceptors, decorators and alternatives that are enabled in this module.
A collection-like structure that maps keys to collections of values.
Multimap utilities.
An implementation of
BoundRequest backed by a pair of maps.Implementation of name based bean resolution
Annotation literal for
NamedA localized message version of the
.
An implementation of
InjectionTarget for classes that do not fulfill bean class requirements (e.g. are abstract or
non-static inner classes).This implementation never invokes
PostConstruct / PreDestroy callbacks.Fallback
SecurityServices implementation that only used in the integrator does not provide one.Annotation literal for
NormalScopeAllows a container lifecycle event to be notified before and after the event is delivered to an
Extension.This exception occurs in cases where an object instance was expected, but
the reference was null.
Bound factory class that produces implicit observers for observer methods.
Reference implementation for the ObserverMethod interface, which represents an observer method.
Provides event-related operations such as observer method resolution and event delivery.
There are two different strategies of exception handling for observer methods.
Pluggable factory for
ObserverNotifier.Wraps a passivating context with a wrapper that guarantees that each call to the context is done with serializable
Contextual.InterceptorFactory that uses an
InjectionTarget as a factory for interceptor instances.Container lifecycle event for each Java class or interface discovered by the container.
Container lifecycle event that allows bean metadata (
BeanAttributes) to be changed before the bean is registered.Implementation of the event used to notify observers for each observer method that is added.
This event is used to notify observers for each synthetic observer method that is added.
Represents a producer field
Producer implementation for producer fields.Represents a producer method bean
Producer implementation for producer methods.Holds enhanced protection domains for proxy classes.
Allows certain bean class methods to be ignored when creating a proxy / subclass.
Utilities for working with proxies.
General interface for all proxies adding functionality that can change
the behavior of the proxy during runtime.
A wrapper on a
ConstructorInjectionPoint, to be used if a proxy subclass is instantiated instead of the
original (e.g. because the original is an abstract Decorator)Main factory to produce proxy classes and instances for Weld beans.
Implementations of this interface are capable of creating instances of a given proxy class.
A general purpose MethodHandler for all proxies which routes calls to the
BeanInstance associated with this proxy or handler.The interface implemented by proxy classes.
Optimized representation of a qualifier.
Annotation literal for
Qualifier?Model of a binding type
Represents cached metadata about an annotation class.
Log messages relating to reflection
Message ids: 000600 - 000699
Warning this class consists of generated code.
Utility class for static reflection-type operations
The built in request context is associated with
RequestScoped and is a managed context which can be activated,
invalidated and deactivated.Caches beans over the life of a request, to allow for efficient bean lookups from proxies.
An item that can be cached for the lifetime of a request.
Wrapper over
ReflectionCache capable of determining whether a given class
has a given annotation or not, as defined by the CDI 1.1 specification (11.5.6).Log messages for resolution classes.
Warning this class consists of generated code.
Something that is resolvable by the resolver.
Immutable information about observer methods resolved for a type/qualifiers combination.
High-level representation of a resource field and setter method.
Factory class that produces
ResourceInjection instances for resource fields and setter methods.Abstract stateless resource injection processor.
Injector that adds support for resource field and setter injection.Abstract base class with functions specific to RI built-in beans
Contains all the data that is needed when working with a method in bytecode
Annotation literal for
Scope?Model of a scope
Algorithm taken from Apache Ant's SelectorUtils class and modified to handle
class hierarchies.
A wrapper mostly for client proxies which provides header information useful
to generate the client proxy class in a VM before the proxy object is
deserialized.
Produces wrappers for
Contextuals which are serializable.Holds a value that is likely to be serialized.
Log messages for serialization.
Warning this class consists of generated code.
This class handles looking up service providers on the class path.
Handles the paths to resources within a web application if a WAR archive is not extracted to the file system.
Bean implementation representing an enterprise session bean.
The built in session context is associated with
SessionScoped.A
MapBeanStore whose LockStore is associated with the key "org.jboss.weld.context.beanstore.LockStore" in the provided map and so
may be shared across several
stores used within a single "session".Static utility methods for
Set.Allows classes to share Maps/Sets to conserve memory.
A simple naming scheme (with a solid prefix) which makes use of
BeanIdentifierIndex if possible.Provides convenient way to access the CDI container.
Simple
InvocationContext implementation whose SimpleInvocationContext.proceed() invokes the target method directly without calling
any interceptors.A utility which can prefix/de-prefix a String based identifier
The built in singleton context, associated with
Singleton.Marker interface for lightweight implementations of
AnnotatedType.Holds
SlimAnnotatedType and additional information attached to the type.Stores
SlimAnnotatedTypes.Holds information about specialized beans.
Provides operations for resolving specialized beans.
Represents a method/constructor parameter, which is not an injection point.
The interface implemented by the invocation handler of a proxy instance.
A resource producer field that is static (not injected).
Annotation literal for
Stereotype?A meta model for a stereotype, allows us to cache a stereotype and to
validate it
A wrapper over
SubclassedComponentInstantiator that registers decorators using the enhanced subclass.Instantiates an enhanced subclass of a given component class.
Creates a container-provided implementation of the
Bean interfaces based on given BeanAttributes,
Class and Producer implementations.Represents a class bean created based on extension-provided
InjectionTarget implementation.Represents a
Decorator created based on extension-provided InjectionTarget implementation.A synthetic extension.
Marker interface for synthetic observer methods.
Represents a producer field or producer method created based on extension-provided
Producer implementation.If a configuration property needs to be accessed before the Weld container initializes, the system property is so far the
only option.
A simple
BeanInstance which always maintains a specific bean instance that is being proxied.Component's target class interceptor metadata.
A stack that is kept in thread-local.
Reference to a thread-local stack.
Implementation of
ExtendedExecutorServices that uses a fixed thread pool.Tomcat 7.x and 8.x container.
Message IDs: 001100 - 001199
Warning this class consists of generated code.
An ELResolver that behaves as though it is invisible, meaning it's
idempotent to the chain and the next ELResolver in the line will be
consulted.
LazyValueHolder that calculates a type closure.A util for deciding whether two
Types are the same (not necessarily equal in the java sense).Utility class for Types
Implementation of type safe bean resolution
This class is thread-safe.
Wrapper for extension-provided
AnnotatedType.A serialization proxy for
UnbackedAnnotatedMembers.Qualifier used with all for all of the unbound contexts Weld offers.
Annotation literal for
BoundMessage IDs: 001300 - 001399
Warning this class consists of generated code.
Provides message localization service for the
.
Provides message localization service for the
.
Thrown if a simple bean is dependent scoped and injected into a stateful
session bean, into a non-transient field, bean constructor parameter or
initializer method parameter of a bean which declares a passivating scope, or
into a parameter of a producer method which declares a passivating scope
An
UnsupportedOperationException with support for
localized messages in Weld.Error messages relating to utility classes
Message ids: 000800 - 000899
Warning this class consists of generated code.
Checks a list of beans for DeploymentExceptions and their subclasses
Log messages for validation related classes.
Warning this class consists of generated code.
Represents a value.
Message Ids: 000900 - 000999
Warning this class consists of generated code.
Allows a type annotated with
Vetoed to be registered, i.e.LazyValueHolder that uses WeakReference.Web application bean archive scanner.
Represents an enhanced version of
AfterBeanDiscovery.Enriched version of
AlterableContext which allows to capture all instances from given context or to set them to
previously obtained values.A
Bean implementation provided by Weld.Represents an enhanced version of
BeanConfiguratorCommon bootstrapping functionality that is run at application startup and
detects and register beans
ResourceLoader implementation that uses the classloader that loaded this class to load other resources.An extension to
WeldConstruct interface which denotes a client proxy object.An abstraction allowing access to
Bean metadata as well as the contextual instanceCollection utilities.
Represents an immutable per-deployment Weld configuration.
Marker interface denoting that the instance is an internal Weld contruct.
Sub-interface of
Decorator that contains metadata information about Weld-deployed
Decorators (including custom decorators).Jetty Eclipse Weld support for jetty >=9.4.20
This class is a default implementation of ProxyServices that will only be loaded if no other implementation is detected.
Enriched version of
Event.A general run-time exception used by the JSR-299 reference implementation Weld.
Exception message that produces a list of exceptions and their stack traces
for logging.
Interface for all exception messages in Weld.
Simple message object that just contains a String already formatted
and localized.
Forwards all calls in turn to two delegates: first to InstanceManager, then to WeldInstanceManager
Representation of properties of an
InjectionPoint, which can be modified by an extension in the
ProcessInjectionPoint phase.Default
WeldInjectionTargetBuilder implementation.Represents an enhanced version of
Instance.Deprecated.
Represents an enhanced version of
InvocationContext.Weld's
InvocationContext implementation.Builder of
Invokers that allows configuring input lookups, input and output
transformations, and invoker wrapping.Weld specific version of
InvokerFactory.Weld module that provides JSF integration.
A source of localized log/bundle messages and exceptions.
Warning this class consists of generated code.
A Weld module is a unit of code that extends capabilities of Weld.
Context object for the
postContextRegistration phaseContext object for the
postServiceRegistration phaseContext object for the
preBeanRegistration phaseThis service takes core of
WeldModules registered with Weld.The
Event.fireAsync(Object, NotificationOptions) method allows to configure the notification
of asynchronous observer methods.Represents an enhanced version of
ProcessManagedBean.Undertow extension that hooks into undertow's instance creation and delegates to Weld.
Message IDs: 001000 - 001099
Warning this class consists of generated code.
Common bootstrapping functionality that is run at application startup and
detects and register beans
This optional extension collects all injection points
of Java EE components,
with
Instance required type,
so that Weld is able to identify unused beans better.Implementation of
WildcardType.Used within
IsolatedForwardingBean and its subclasses as a value holder.Marker interface indicating that this Contextual wraps another contextual.
Error messages relating to XML parser
Message ids: 001200 - 001299
Warning this class consists of generated code.