All Classes and Interfaces
Class
Description
Helper Map implementation for use with different Attribute Maps.
Extended FaceletCache contract that supports additional Myfaces specific concepts
that are necessary to implement.
This class contains methods that belongs to original FaceletContext shipped in
facelets code before 2.0, but does not take part from api, so are considered
implementation details.
Base class for defining TagLibraries in Java
Helper Map implementation for use with different Attribute Maps.
This component hold f:websocket client behavior and other properties.
Register an ActionListener instance on the UIComponent associated with the closest parent UIComponent custom action.
Deprecated, for removal: This API element is subject to removal in a future version.
Wraps a method expression in a AjaxBehaviorListener
Specialized Ajax Handler, according to Faces 2.0 rev A section 13.3.7.
This tag creates an instance of AjaxBehavior, and associates it with the nearest
parent UIComponent that implements ClientBehaviorHolder interface.
Contains the metadata information to reference a resource
Configure all annotations that needs to be defined at startup.
This interface provide a way to override myfaces annotation scanning algorithm that
needs to be found at startup:
FacesComponent
FacesBehavior
FacesConverter
NamedEvent
FacesRenderer
FacesBehaviorRenderer
FacesValidator
Factory that provide AnnotationProvider instances
Wrapper class that all AnnotationProvider instances should extend.
Literal for the
Any annotation.DOCUMENT ME!
Encapsulates information needed by the ImplicitObjectResolver
ServletContext attributes as a Map.
Encapsulates information needed by the ImplicitObjectResolver
Utility class for managing arrays
composite:actionSource, composite:valueHolder and composite:editableValueHolder
do the same: register an AttachedObjectTarget on the "targetList" mentioned on
ViewDeclarationLanguage.retargetAttachedObjects.
Sets the specified name and attribute on the parent UIComponent.
This class is used as a double wrapper for NavigationHandler
and ConfigurableNavigationHandler to be backwards compatible
to the pre Faces 2.0 NavigationHandlers which are not
ConfigurableNavigationHandlers (since Faces 2.0 the standard
NavigationHandler implementation has to inherit from
ConfigurableNavigationHandler).
A ResourceHandlerSupport implementation for use with standard Java Servlet engines,
ie an engine that supports jakarta.servlet, and uses a standard web.xml file.
Model for <behavior> config element.
Implementation of model for <behavior> element.
Indicate the current ValueExpression can be assumed to be cacheable when it is
being tracked by DefaultVariableMapper.
Catches any Throwable that occurs in its body and optionally
exposes it.
Delegation pattern to avoid direct instantiation
Comparator for ELResolvers that shifts the ELResolver from CDI to the last place.
Lookup code for Contextual Instances.
Simple conditional tag that establishes a context for
mutually exclusive conditional operations, marked by
<when> and <otherwise>
Subtag of <choose> that follows <when> tags
and runs only if all of the prior conditions evaluated to
'false'
Subtag of <choose> that includes its body if its
condition evalutes to 'true'
A resource loader implementation which loads resources from the thread ClassLoader.
MyFaces specific listener used to clear all component binding if
normal navigation occur during a POST request.
This wrapper is used in
FaceletViewDeclarationLanguage#retargetAttachedObjects(FacesContext, UIComponent, List<AttachedObjectHandler>)
to redirect the client behavior attached object when there is a chain of composite components.
This class has two usages:
1.
Config holder for <client-behavior-renderer> element.
Config holder for <client-behavior-renderer> element.
Contains information about whether the user has
JavaScript enabled on his client, etc.
Minimal implementation of ClientWindowScope.
This class contains utility methods to detect special cases to be handled on "script" or
"style" tags by HtmlResponseWriterImpl.
A Compiler instance may handle compiling multiple sources
Constant declarations for Faces tags
This interface provide a way to delegate component creation
from ComponentTagHandlerDelegate.
This interface identify tag handlers that does not generate components, but
it has components inside them and by that reason it should be considered
into cc:insertChildren logic.
Encapsulates information needed by the ImplicitObjectResolver
This class is used in cases where alternate implementations of h:outputScript and h:outputStylesheet
components are used overriding a tag handler and providing a new tag name, but preserving the componentType
and rendererType.
Dummy class that is used as a container for resources
(see Faces 2.0 rev A UIViewRoot.addComponentResource javadoc)
Enum used inside the key PartialStateManagementStrategy.COMPONENT_ADDED_AFTER_BUILD_VIEW
on the component attribute map to indicate if the component should be
add, removed and add o it was already added to PartialStateManagementStrategy.CLIENTIDS_ADDED
and PartialStateManagementStrategy.CLIENTIDS_REMOVED
Implementation of the tag logic used in the Faces specification.
Implementation of BeanInfo object used by composite components.
This handler wraps a composite component definition.
Composite component attribute EL resolver.
Utility class for composite components when used in EL Expressions --> #{cc}
Encapsulates information needed by the ImplicitObjectResolver
Serializable implementation of PropertyDescriptor
This handler is responsible for apply composite components.
Composite FunctionMapper that attempts to load the Method from the first FunctionMapper, then the second if
null.The value inside composite component attribute map with the key
Resource.COMPONENT_RESOURCE_KEY should be a Serializable.
This class create composite component tag handlers for "http://java.sun.com/jsf/composite/"
namespace.
TagAttribute utils for <composite:xxx> TagHandlers.
A TagDecorator that is composed of 1 or more TagDecorator instances.
A TagLibrary that is composed of 1 or more TagLibrary children.
A LRU cache implementation based upon ConcurrentHashMap and other techniques to reduce
contention and synchronization overhead to utilize multiple CPU cores more effectively.
Identification inferface for types that know about
Location
and XML attribute name/value pair.A exception wrapper that "knows" interesting info about place where problem occurred.
This data holder contains all necessary data you need to
store a Contextual Instance in a CDI Context.
This Storage holds all information needed for storing Contextual Instances in a Context.
Indicates if a resource has been served from a contract.
ResourceLoaders that are able to handle contract aware resources
must extends from this class.
Deprecated.
use
Register a named Converter instance on the UIComponent associated with the closest parent UIComponent custom action.
Handles setting a Converter instance on a ValueHolder.
TODO: Move to util package and rename to better name
Register a NumberConverter instance on the UIComponent associated with the closest parent UIComponent custom action.
Encapsulates information needed by the ImplicitObjectResolver
HttpServletRequest Cookies as Map.
For Tag details, see Faces Core taglib documentation.
This listener must be attached to PostAddToViewEvent, so when composite component is
added to the view, the algorithm that create the composite component content is executed.
This factory generate a key composed by a counter and a random number.
Comparator for ELResolvers that shifts the Resolvers from
the faces-config to the front.
Comparator for ELResolvers that shifts the Resolvers from
the faces-config to the back.
CyclicDependencyException is thrown any time the DAG verifier finds a cycle.
PhaseListener to create extended debug information.
Utilities for logging.
The decorate tag acts the same as a composition tag, but it will not trim
everything outside of it.
Default implementation of
ContextAwareExceptionWrapper, used for delegationCreate the el resolver for faces.
Default FaceletFactory implementation.
Default impl of the FacesConfigurationMerger-SPI.
Default implementation of the FunctionMapper
Literal for the
Default annotation.A ResourceHandlerSupport implementation for use with standard Java Servlet engines,
ie an engine that supports jakarta.servlet, and uses a standard web.xml file.
Default implementation of TagDecorator as described in Faces 2.2 javadoc of
jakarta.faces.view.facelets.TagDecorator
Default instance of a VariableMapper backed by a Map
The default WebXmlProvider implementation.
The default implementation of WebXmlProviderFactory.
The define tag can be used within tags that allow templating.
DirectedAcyclicGraphVerifier provides methods to verify that any set of
vertices has no cycles.
Indicates duplicate id as specified in spec 7.7.3 State Saving Methods.
NOTE: Copy of org.apache.abdera.i18n.text.io.DynamicPushbackInputStream
PushbackInputStream implementation that performs dynamic resizing of the unread buffer
This implementation is just the default html response writer with the early flush logic.
The ELResolverBuilder is responsible to build the el resolver which is used by the application through
Application.getELResolver() according to 1.2 spec
section 5.6.2Handles parsing EL Strings in accordance with the EL-API Specification.
This class provides utility methods to generate the
MyFaces error and debug pages.
This bean aims to generate the error page html for inclusion on a facelet error page via
<ui:include src="jakarta.faces.error.xhtml" />.
Registers a listener for a given system event class on the UIComponent associated with this tag.
DOCUMENT ME!
Deprecated.
Since 4.1
A resource loader implementation which loads resources from the webapp root.
This provides some functionality for determining some things about the
native request object that is not provided by Faces.
Utility class for determining which specifications are available
in the current process.
Locate facelet taglib xml files through classpath.
Factory that provide FaceletConfigResourceProvider instances
FaceletFactory for producing Facelets relative to the context of the underlying implementation.
Perform initialization steps for facelets compiler
Utility class for facelets (which need access to the compiler package).
Utility methods used in FaceletsViewDeclarationLanguage
This class represents the abstraction of Facelets as a ViewDeclarationLanguage.
This bean is used to store the ServletContext, so CDI beans can get it later.
Subsumes several unmarshalled faces config objects and presents a simple interface
to the combined configuration data.
SAX EntityResolver to provide Faces-specific resources (DTDs) for well-known identifiers.
Locate faces-config xml files through classpath.
Factory that provide FacesConfigResourceProvider instances
Parses a single InputStream into an unmarshalled faces config Object, that can
be processed by a respective FacesConfigDispenser.
SPI that uses the FacesConfigurationProvider-SPI to get all FacesConfig data
and then it combines it into one FacesConfigData instance.
SPI to provide a FacesConfigurationMergerFactory implementation and thus
a custom FacesConfigurationMerger instance.
This interface provide a way to merge and store all Faces config information retrieved
from faces-config files, META-INF/service files and annotations that works as base
point to initialize MyFaces.
SPI to provide a FacesConfigurationProviderFactory implementation and thus
a custom FacesConfigurationProvider instance.
To wrap the default FacesConfigurationProvider, use a constructor like
CustomFacesConfigurationProvider(FacesConfigurationProvider fcp)
and extend it from FacesConfigurationProviderWrapper
Configures everything for a given context.
DOCUMENT ME!
Provides a base implementation of the FacesContext for the use
in FacesContextImpl and StartupFacesContextImpl.
Encapsulates information needed by the ImplicitObjectResolver
ELContext used for Faces.
SPI to provide a FacesFlowProviderFactory implementation and thus
a custom FacesFlowProvider instance.
Simple Factory to get a FacesInitializer implementation either from a web.xml
parameter or from a list of default implementations.
Performs common initialization tasks.
Resource loader coming in from our jakarta.faces library
The problem why we need a specialized loader is:
we have to append/change the mapping information in Development mode
(and remove it if present for prod mode)
according to the library name and request path
Both values are dynamic and the request path is dependent on the
patterns provided in the web.xml
Iterator to properly handle iterating and removing FacesMessage records.
Minimal implementation of FacesScope.
Represents a mapping entry of the FacesServlet in the web.xml
configuration file.
Wrapper for better performance
Define the facets used by this composite component.
Register a named facet on the UIComponent associated with the closest parent UIComponent custom action.
Provide an interface to override
FactoryFinder class
methods.FactoryFinder is a class with three methods:ByteArrayInputStream implementation that does not synchronize methods.
ByteArrayOutputStream implementation that doesn't synchronize methods
and doesn't copy the data on toByteArray().
StringWriter cannot be reused without create a new object over and over.
General filename and filepath manipulation utilities.
Resolver for Flash object
Implementation of Flash object
Wrapper that helps overriding toFlowDocumentId and fromOutcome, to build
correctly a navigation case that cause a flow action (enter into a flow
or return from a flow).
This class works as a reference that can be stored into session to
the current flow.
Implementation of FlowScope.
This holder will store the flow scope active ids and it's beans for the current
HTTP Session.
Encapsulates information needed by the ImplicitObjectResolver
The basic iteration tag, accepting many different
collection types and supporting subsetting and other
functionality
Objects of classes implementing this class can be made inmutable calling
freeze() method.
A VisitContext implementation that is used when performing a full component
tree visit.
Encapsulates information needed by the ImplicitObjectResolver
Encapsulates information needed by the ImplicitObjectResolver
Constant declarations for HTML rendering.
Renderer used by h:body component
Renderer used by h:body component
A buffer for content which should not directly be rendered to the page.
Rendered used by h:doctype tag
Converts Strings so that they can be used within HTML-Code.
X-CHECKED: tlddoc h:panelGrid 1.0 final
Renderer used by h:head component
X-CHECKED: tlddoc of h:selectManyListbox
Renderer used by h:outputScript component
see Spec.1.0 EA - Faces.7.6.4 Renderer Types for UIInput Components
Renderer used by h:outputStylesheet component
Common methods for renderers for components that subclass the standard
Faces HtmlDataTable component.
Class manages the styles from String lists.
Simple conditional tag, which evalutes its body if the
supplied condition is true and optionally exposes a Boolean
scripting variable representing the evaluation of this condition
There are unicodes outside the ranges defined in the
XML 1.0 specification that break XML parsers
and therefore must be filtered out when writing partial responses.
Implementors of this class encapsulate the information needed to resolve the implicit object.
See Faces 1.2 spec sections 5.6.1.1 and 5.6.2.1
See Faces 2.2 section 5.6.2.8
The include tag can point at any Facelet which might use the composition tag,
component tag, or simply be straight XHTML/XML.
ServletContext init parameters as Map.
Encapsulates information needed by the ImplicitObjectResolver
Provide an interface to inject Faces artifacts using JavaEE annotations
as described in Faces 2.2 spec section 5.4
Insert or move the facet from the composite component body to the expected location.
The insert tag is used within your templates to declare spots of replicable data.
A specialized classloader for our internal resources
it enables el resolution on source level for our jsf.js files
and reserves a myfaces namespace in the resources for other custom files.
Holds the iteration state generated by c:forEach tag.
The ScriptContext offers methods and fields
to help with rendering out a script and keeping a
proper formatting.
A simple JSON encoder.
Library for JSTL Functions
Implementations of JSTL Functions
This factory generate a key composed by a counter and a random number.
Inspired by commons-lang LazyInitializer.
RenderKit instances implementing this interface are responsible of
create the renderer instance in a lazy way.
NOTE: This implementation is provided for compatibility reasons and
it is considered faulty.
The decorate tag acts the same as a composition tag, but it will not trim
everything outside of it.
The basic iteration tag, accepting many different
collection types and supporting subsetting and other
functionality
NOTE: This implementation is provided for compatibility reasons and
it is considered faulty.
The include tag can point at any Facelet which might use the composition tag,
component tag, or simply be straight XHTML/XML.
NOTE: This implementation is provided for compatibility reasons and
it is considered faulty.
NOTE: This implementation is provided for compatibility reasons and
it is considered faulty.
Simplified implementation of c:set
Sets the result of an expression evaluation in a 'scope'
NOTE: This implementation is provided for compatibility reasons and
it is considered faulty.
Implements the lifecycle as described in Spec.
Load a resource bundle localized for the Locale of the current view, and expose it (as a Map) in the request
attributes of the current request.
Identification inferface for types that know about
Location.A MethodExpression that contains the original MethodExpression and
the Location of the facelet file from which the MethodExpression was
created.
A ValueExpression that contains the original ValueExpression and
the Location of the facelet file from which the ValueExpression was
created.
Utility class to support multilingual FacesMessages using ResourceBundles.
A MetadataViewKey contains the necessary information that identifies a view
according to its specific attributes that makes its structure different.
Optional Rule for binding Method[Binding|Expression] properties
Holds all configuration init parameters (from web.xml) that are independent
from the core implementation.
This class is called by any Java EE 6 complaint container at startup.
Extended MyFaces-specific ExceptionHandler implementation.
Tried to deploy v0.4.2 on JBoss 3.2.1 and had a classloading problem again.
Derived FacesServlet that can be used for debugging purpose
and to fix the Weblogic startup issue (FacesServlet is initialized before ServletContextListener).
The NamedEventManager class is used to keep map a short name to ComponentSystemEvent classes
annotated with @NamedEvent.
Entry of the Collection returned by
NavigationRule.getNavigationCases().A navigation command is an operation to do by the navigation handler like
do a redirect, execute a normal navigation or enter or exit a flow.
Entry of the Collection returned by
RuntimeConfig.getNavigationRules().See SRV.14.5 Servlet Specification Version 2.5 JSR 154
and Common Annotations for the Java Platform JSR 250
Backward compatibility
Utility methods for OutcomeTarget components.
This class is used to encapsulate the information required at page scope.
This class encapsulates a FacesMessage to evaluate the label
expression on render response, where f:loadBundle is available
Encapsulates information needed by the ImplicitObjectResolver
Encapsulates information needed by the ImplicitObjectResolver
Double buffering partial response writer
to take care if embedded CDATA blocks in update delete etc...
This class implements partial state saving feature when facelets
is used to render pages.
A VisitContext implementation that is used when performing a partial
component tree visit.
Dummy library, so passthrough namespace can be recognized by facelet compiler.
MyFaces specific event used to clear all component binding if
normal navigation occur during a POST request.
A PriorityQueue maintains a partial ordering of its elements such that the
least element can always be found in constant time.
This listener must be attached to PostRestoreStateEvent so when the view is restored,
the algorithm refresh the component that was created using facelets, restoring the
transient markup.
Implement this interface, so ClientWindowFlashTokenLRUMap can remove the resources
associated with the client window / flash scope token, when an entry is discarded by
the LRU algorithm.
Interface used to indicate the component that needs to be found was relocated,
so it is necessary to provide a proper algorithm to find it.
Render the facet defined on the composite component body to the current location
RenderKitFactory implementation as defined in Spec.
Facelet alternative to c:forEach or h:dataTable
This class is used as the bean that contains all the status
information of UIRepeat during iteration.
HttpServletRequest headers as Map.
HttpServletRequest header values (multi-value headers) as Map of String[].
Encapsulates information needed by the ImplicitObjectResolver
ServletRequest attributes Map.
ServletRequest parameters as Map.
ServletRequest multi-value parameters as Map.
Encapsulates information needed by the ImplicitObjectResolver
See Faces 1.2 spec section 5.6.1.4
Holds the information that is static but can only be derived after
a Resource instance is created.
Utility class when used in EL Expressions --> #{resource}
DOCUMENT ME!
A utility class to isolate a ResourceHandler implementation from its
underlying implementation
Default implementation for resources
Encapsulates information needed by the ImplicitObjectResolver
Locate resource library contracts, implementing the behavior described in
Faces 2.2 section 11.4.2.1 related to discover the available resource library
contracts.
Factory that provide ResourceLibraryContractsProvider instances
Base class for resource loaders.
Contains the metadata information to reference a resource
Contains the metadata information to reference a resource
See Faces 2.0 spec section 5.6.1.3 and 5.6.2.4
A resource loader implementation which loads resources from the webapp root.
Holds all configuration information (from the faces-config xml files) that is needed later during runtime.
Compiler implementation that uses SAX
See Faces 1.2 spec section 5.6.2.7
Hierarchical counter to generate unique ids.
NOTE: This class should not be made Serializable.
Utility methods to manipulate SelectItem/SelectItems
This class provides an interface to override SPI handling done by
MyFaces.
Factory that provide a ServiceProviderFinder instance, that is used to locate
classes through SPI interface.
Implements the external context for servlet request.
Provides a base implementation of the ExternalContext for Servlet
environments.
NOTE: Class taken from tomcat 7 org.apache.catalina.util.SessionIdGenerator
and used here as an alternative for server side state token encryption.
Encapsulates information needed by the ImplicitObjectResolver
HttpSession attibutes as Map.
Encapsulates information needed by the ImplicitObjectResolver
Simplified implementation of c:set
Sets the result of an expression evaluation in a 'scope'
The MyFaces implementation of the
SetPropertyActionListener.Utils for SPI implementations.
A FacesContext implementation which will be set as the current instance
during container startup and shutdown and which provides a basic set of
FacesContext functionality.
Startup Listener for the myfaces init process
This interface allows to implement
Plugins which then can be hooked into the various stages
of our initialisation process to add various plugins
which depend on the various phases of the init
Initialise the MyFaces system.
An ExternalContext implementation for Servlet environments, which is used
by StartupFacesContextImpl at container startup and shutdown and which
provides ExternalContext functionality that does not require request and
response objects.
This class provides an interface to separate the state caching operations (saving/restoring)
from the renderkit specific stuff that HtmlResponseStateManager should do.
This class provides an interface to separate the state caching operations (saving/restoring)
from the renderkit specific stuff that HtmlResponseStateManager should do.
This Class exposes a handful of methods related to encryption,
compression and serialization of the view state.
A class for handling state insertion.
StreamCharBuffer is a multipurpose in-memory buffer that can replace JDK
in-memory buffers (StringBuffer, StringBuilder, StringWriter).
Interface for a Writer that gets initialized if it is used
Can be used for passing in to "connectTo" method of StreamCharBuffer
Provides optimized access to java.lang.String internals
- Optimized way of creating java.lang.String by reusing a char[] buffer -
Optimized way of writing String to java.io.Writer
java.lang.String creation reusing a char[] buffer requires Java 1.5+
System property "oam.stringchararrayaccessor.enabled" enables this hack.
Implements utility functions for the String class
Map that wraps another to provide an isolated namespace using
a prefix.
This wrapper is a switch to choose in a lazy way between ajax and
normal exceptionHandler wrapping, because FacesContext is initialized after
ExceptionHandler, so it is not safe to get it when
ExceptionHandlerFactory.getExceptionHandler() is called.
Representation of a Tag's attribute in a Facelet File
A set of TagAttributes, usually representing all attributes on a Tag.
This class was created to gather some code from latest Facelets not existing in latest Faces 2.0 spec.
A library of Tags associated with one or more namespaces.
Handles creating a
TagLibrary
from a URL source.ResourceLoader that uses a temporal folder to cache resources, avoiding the problem
described on MYFACES-3586 (Performance improvement in Resource loading -
HIGH CPU inflating bytes in ResourceHandlerImpl.handleResourceRequest).
ResourceLoader that uses a temporal folder to cache resources, avoiding the problem
described on MYFACES-3586 (Performance improvement in Resource loading -
HIGH CPU inflating bytes in ResourceHandlerImpl.handleResourceRequest).
FaceletHandlers can implement this contract and push themselves into the FaceletContext for participating in
templating.
This class is used to encapsulate the information required to resolve
facelets templates.
This is just a dummy template client that does nothing that is added by default
for each template context
A threadsafe implementation of
XorShiftRandom.An annotation lifecycle provider for Tomcat 7.
The debug tag will capture the component tree and variables when it is encoded,
storing the data for retrieval later.
NOTE: This implementation is provided for compatibility reasons and
it is considered faulty.
Converts characters outside of latin-1 set in a string to numeric character references.
Register a named Validator instance on the UIComponent associated with the closest parent UIComponent custom
action.
Handles setting a Validator instance on a EditableValueHolder.
Register an ValueChangeListener instance on the UIComponent associated with the closest parent UIComponent custom
action.
This MethodExpression contains a ValueExpression which resolves to
the "real" MethodExpression that should be invoked.
Defines an interface to detect when an EL expression has been
resolved by a facelets variable mapper and in that way allow cache it
if it is possible.
Utility class for wrapping another VariableMapper with a new context, represented by a
Map.Vertex is used to track dependencies and each node in a graph.
This is the default VDL factory used as of Faces 2.0, it tries to use Facelet VDL whenever possible.
This class represents a supported
ViewDeclarationLanguage in the application.Container for all JavaServer Faces core and custom component actions used on a page.
Faces 2.0 ViewHandler implementation
A ViewHandlerSupport implementation for use with standard Java Servlet engines,
ie an engine that supports jakarta.servlet, and uses a standard web.xml file.
Encapsulates information needed by the ImplicitObjectResolver
This class represents the default implementation of jakarta.faces.view.ViewMetaData.
Defines the view metadata.
This exception is thrown when a view is not present before start
one of the following phases: APPLY_REQUEST_VALUES, PROCESS_VALIDATIONS,
INVOKE_APPLICATION, UPDATE_MODEL_VALUES, RENDER_RESPONSE.
This class defines the necessary operations that a view pool should comply in
order to be used by MyFaces.
Fast pool using ConcurrentLinkedQueue, with uses an AtomicInteger as
count limit.
This class is reponsible for all processing tasks related to the view pool.
CDI Context to handle @
ViewScoped beans.Handle ViewScope related features.
Encapsulates information needed by the ImplicitObjectResolver
This wrapper has these objectives:
- Isolate the part that needs to be saved with the view (viewScopeId) from
the part that should remain into session (bean map).
Contains additional information associated to a view and restored each time
the view is built by first time.
Minimal implementation of ViewTransientScope.
Utility class to handle web config parameters
SPI to provide a custom WebConfigProvider implementation.
SPI to provide a WebConfigProviderFactory implementation and thus
a custom WebConfigProvider instance.
This map holds all tokens related to the current session and its associated metadata, that will
be used in the websocket handshake to validate if the incoming request is valid and to store
the user object into the Session object.
This map hold all tokens related to the current view.
This class ensures the Session instance is properly registered into WebsocketApplicationSessionHolder in case
of serialization/deserialization roundtrip.
Configuration for the org.apache.myfaces.extensions.cdi.core.api.scope.conversation.WindowContext
- it's customizable via the Alternative or Specializes mechanism of CDI.
A simple XORShift Random generator.
This component is the one that render the initialization at the end of body section.