All Classes and Interfaces
Class
Description
An exception that may be thrown by event listeners to terminate the processing of the current event.
This is the base
ConfigProcessor that all concrete ConfigProcessor implementations should
extend.Base class for defining TagLibraries in Java
An
ActionEvent represents the activation of a user interface component (such as a UICommand).
A listener interface for receiving
ActionEvents.Register an ActionListener instance on the UIComponent associated with the closest parent UIComponent custom action.
Register an ActionListener instance on the UIComponent associated with the closest parent UIComponent custom action.
This action listener implementation processes action events during the Apply Request Values or Invoke
Application phase of the request processing lifecycle (depending upon the
immediate property of the
ActionSource that queued this event.
Provides a simple implementation of
ActionListener that can be subclassed by developers wishing to provide
specialized behavior to an existing ActionListener instance.
ActionSource is an interface that may be implemented by any concrete
UIComponent that wishes
to be a source of ActionEvents, including the ability to invoke application actions via the default
ActionListener mechanism.
ActionSource2 extends
ActionSource and provides a JavaBeans
"action" property.
A VDL handler that exposes
ActionListener to a page author.
A marker interface for VDL tags that represent
<composite:actionSource/> for use by the
composite component page author.
An instance of this class is added as a
ClientBehavior to a component using the
ClientBehaviorHolder.addClientBehavior(java.lang.String, jakarta.faces.component.behavior.ClientBehavior) contract that components implement.
AjaxBehaviorEvent represents the component behavior
specific to
Ajax).
By implementing this class, an object indicates that it is a listener for one or more kinds of
BehaviorEvents.
An instance of the class is used to manage
AjaxBehavior instances.
A specialized implementation of
ExceptionHandler for Faces that handles exceptions by writing error
information to the partial response.
Enable one or more components in the view to perform Ajax operations.
This class represents the central point for annotation handling within a web application.
An integration point for integrators to provide custom annotation scanning.
This class is responsible for ensuring that the class file bytes of classes contained within the web application are
scanned for any of the known Faces configuration Annotations:
jakarta.faces.component.FacesBehavior
jakarta.faces.render.FacesBehaviorRenderer
jakarta.faces.component.FacesComponent
jakarta.faces.convert.FacesConverter
jakarta.faces.validator.FacesValidator
jakarta.faces.render.FacesRenderer
jakarta.faces.event.NamedEvent
jakarta.faces.view.facelets.FaceletsResourceResolver
Application represents a per-web-application singleton object where applications based
on Jakarta Faces (or implementations wishing to provide extended functionality) can register application-wide
singletons that provide functionality required by Jakarta Faces.
Break out the things that are associated with the Application, but need to be present even when the user has replaced
the Application instance.
This
ConfigProcessor handles all elements defined under /faces-config/application.
This class defines a
java.util.ServiceLoader service which enables programmatic configuration of the Jakarta
Server Faces runtime using the existing Application Configuration Resources schema.
ApplicationFactory is a factory object that
creates (if needed) and returns
Application instances.Default implementation of
ApplicationFactory.Application represents a per-web-application singleton object where applications based on
Faces (or implementations wishing to provide extended functionality) can register application-wide singletons that
provide functionality required by Faces.
The presence of this annotation (along with
@Inject) on a field of type Map<String,
Object> causes the map returned from ExternalContext.getApplicationMap() to be
injected as the value of that field.
Supports inline instantiation of the
ApplicationMap qualifier.
The ApplicationMapProducer is the CDI producer that allows injection of the application map using @Inject and allows
EL resolving of #{applicationScope}
An ObjectInputStream that can deserialize objects relative to the current application's class loader.
The ApplicationProducer is the CDI producer that allows EL resolving of #{application}
Contains an application level resource bundle name and its associated descriptions, if any.
This class maintains per-application information pertaining to partail or full state saving as a whole or partial
state saving with some views using full state saving.
Provides a simple implementation of
Application that can be
subclassed by developers wishing to provide specialized behavior to an existing Application instance.ApplyRequestValuesPhase executes
processDecodes on each component in the tree so that it may update it's
current value from the information included in the current request (parameters, headers, c cookies and so on.)
ArrayDataModel is a convenience implementation of
DataModel that wraps an array of Java
objects.
This class holds collection of
BehaviorHandler instances, attached to the composite component.
The abstract base interface for a handler representing an attached object in a VDL page.
Within the declaration of a composite component, an
AttachedObjectTarget allows the
composite component author to expose the semantics of an inner component to the page author without
exposing the rendering or implementation details of the inner component.Sets the specified name and attribute on the parent UIComponent.
An interface that allows other code to identify FaceletHandlers that correspond to component attributes.
This class contains mappings between the standard components and the passthrough attributes associated with them.
Base class for concrete Grid and Table renderers.
Various utility methods for use with the Jakarta Bean Validation API in Jakarta Faces.
A Validator that delegates validation of the
bean property to the Bean Validation API.
The Behavior interface is the root API of the component behavior model.
BehaviorBase is a convenience base class that provides a default implementation of the
Behavior contract.
Convey the id of a behavior declared in a view.
ConfigAnnotationHandler for FacesBehavior annotated classes.
This
ConfigProcessor handles all elements defined under /faces-config/behavior.
BehaviorEvent is the event that can be generated from
component
Behavior.
The
FaceletHandler that corresponds to attached objects that represent an instance of
ClientBehavior that must be added to the parent component, which must
implement ClientBehaviorHolder, with a call to
ClientBehaviorHolder.addClientBehavior(java.lang.String, jakarta.faces.component.behavior.ClientBehavior).
Represent an attached object that is a
BehaviorHolder in a VDL page.
Represent a
BehaviorHolder attached object target in a VDL page.
A generic base interface for event listeners for various types of
BehaviorEvents.Converter implementation for java.math.BigDecimal values.Converter implementation for java.math.BigInteger values.
This
Renderer is responsible for rendering the standard HTML body element as well as rendering any
resources that should be output before the body tag is closed.Converter implementation for java.lang.Boolean (and boolean primitive) values.ButtonRenderer is a class that renders the current value of
UICommand as a Button.
This utility class is to provide both encryption and decryption
Ciphers to
ResponseStateManager implementations wishing to provide encryption support.
This utility class is to provide both encryption and decryption
Ciphers to
ResponseStateManager implementations wishing to provide encryption support.Converter implementation for java.lang.Byte (and byte primitive) values.A concurrent caching mechanism.
Factory interface for creating various cacheable objects.
A delegate to the CDI managed converter.
The CDI extension.
A static utility class for CDI.
A delegate to the CDI managed validator.
Maintains an ordered composite list of child
ELResolver for Faces.Converter implementation for java.lang.Character (and char primitive) values.CheckboxRenderer is a class that renders the current value of
UISelectBoolean as a checkbox.
A
ResourceHelper implementation for finding/serving resources found on the classpath within the
META-INF/resources directory.
ClientBehavior is the base contract for
Behaviors that attach script content to client-side
events exposed by ClientBehaviorHolder components.
ClientBehaviorBase is a convenience base class that implements the default concrete behavior of all
methods defined by
ClientBehavior.
ClientBehaviorContext provides context information that may be useful
to
ClientBehavior.getScript(jakarta.faces.component.behavior.ClientBehaviorContext) implementations.
Parameter instances represent name/value pairs that "submitting" ClientBehavior implementations
should include when posting back into the Faces lifecycle.
An enum that specifies hints that describes the behavior of ClientBehavior implementations.
The ClientBehaviorHolder interface may be implemented by any concrete
UIComponent that wishes to support client behaviors as defined by
ClientBehavior.
A ClientBehaviorRenderer produces the client-side script that implements a
ClientBehavior's client-side logic.ClientResourceInfo is a simple wrapper class for information pertinent to building a complete resource
path using a Library.
This
StateHelper provides the functionality associated with client-side state saving.A simple
Writer implementation to encapsulate a StringBuilder instance.
This class represents a client window, which may be a browser tab, browser window, browser pop-up, portlet, or
anything else that can display a
UIComponent hierarchy rooted at a
UIViewRoot.
Create
ClientWindow instances based on the incoming request.The CDI context for CDI ClientWindowScoped beans.
The manager that deals with CDI ClientWindowScoped beans.
ClientWindowScoped is a CDI scope that causes the runtime to consider classes
with this annotation to be in the scope of the current
ClientWindow.The manager that deals with non-CDI and CDI ClientWindowScoped beans.
Wrapper for
ClientWindowCopier that copies an object using the
Cloneable facility.
CollectionDataModel is a convenience implementation of
DataModel that wraps an
Collection of Java objects.CommandLinkRenderer is a class that renders the current value of
UICommand as a HyperLink that
acts like a Button.CommandScriptRenderer is a class that renders the current value of
UICommand as a Script that acts
like an Ajax Button.A Compiler instance may handle compiling multiple sources
Passed to the constructor of
ComponentHandler.ConfigAnnotationHandler for FacesComponent annotated classes.
This
ConfigProcessor handles all elements defined under /faces-config/component.
Public base class for markup element instances that map to
UIComponent instances in the view.
Typed
FacesException for the SearchExpressionHandler, if a component can't be resolved.
The Component producer is the CDI producer that allows EL resolving of
#{component}This class overrides key methods from
ComponentTagHandlerDelegateImpl in order to properly find existing
component resources as well as properly handling the case when this concrete implementations of this class are
applied more than once for a particular request.Utility class to enable partial state saving of components that have been dynamically added to the view.
ComponentSystemEvent is the base class for
SystemEvents that are specific to a UIComponent instance.Utility class for dealing with
UIComponent events.
Implementors of this class do not need an
isListenerForSource() method because they are only installed
on specific component instances, therefore the isListenerForSource() method is implicit.
This class is responsible for adding default validators and/or validators that wrap multiple
EditableValueHolder instances within the view.Generic information container for a validator at a particular nesting Level.
A property descriptor for a composite component attribute.
This
ELResolver will handle the resolution of attrs when processing a composite component
instance.This interface must be implemented by the
Map returned by the composite component
ELResolver, described in
section 5.4.3.1 "faces.CompositeComponentAttributesELResolver" of the Jakarta Faces Specification Document,
when evaluating #{cc.attrs} expressions.
The Composite Component producer is the CDI producer that allows EL resolving of
#{cc}CompositeComponentStackManager is responsible for managing the two different composite component stacks
currently used by Mojarra.
Facelet handler responsible for, building the component tree representation of a composite component based on the
metadata contained in the composite interface and implementation sections of the composite component template.
A FaceletHandler that is derived of 1 or more, inner FaceletHandlers.
This
Renderer is responsible for rendering the content of a facet defined within the using page
template in the desired location within the composite component implementation section.Composite FunctionMapper that attempts to load the Method from the first FunctionMapper, then the second if
null.
This
Renderer is responsible for rendering the children defined within the composite implementation
section of a composite component template.A TagDecorator that is composed of 1 or more TagDecorator instances.
A TagLibrary that is composed of 1 or more TagLibrary children.
Composite VariableMapper that attempts to load the ValueExpression from the first VariableMapper, then the second if
null.Defines a concurrent cache with a factory for creating new object instances.
Factory interface for creating various cacheable objects.
Implementations of the interface will be called during application initialization to process any configuration
annotations within the web application.
This class manages the initialization of each web application that uses Faces.
This interface provides a CoR structure for processing Faces configuration resources.
ConfigurableNavigationHandler extends the contract of
NavigationHandler to allow runtime inspection of the NavigationCases that make up the rule-base for
navigation.
Provides a simple implementation of
ConfigurableNavigationHandler
that can be subclassed by developers wishing to provide specialized behavior to an existing
ConfigurableNavigationHandler instance.
This represents any configuration processing problems that could occur.
Classes that implement this interface return zero or more
URLs which refer to application configuration
resources.Factory class for creating
ConfigurationResourceProvider instances using the Java services discovery
mechanism.Parse all relevant Faces configuration resources, and configure the Mojarra runtime
environment.
A simple callback interace that enables taking action on a specific UIComponent (either facet or child) in the view
while preserving any contextual state for that component instance in the view.
The enumeration of all our context-param entries.
A utility class for dealing with context-param entries.
This specialized
MethodExpression enables the evaluation of composite component expressions.
This specialized
ValueExpression enables the evaluation of composite component expressions.Register a DateTimeConverter instance on the UIComponent associated with the closest parent UIComponent custom
action.
Register a named Converter instance on the UIComponent associated with the closest parent UIComponent custom action.
Converter is an interface
describing a Java class that can perform Object-to-String and String-to-Object conversions between model data objects
and a String representation of those objects that is suitable for rendering.
A Facelet version of the Jakarta Server Pages
ConverterTag.ConfigAnnotationHandler for FacesConverter annotated classes.
This
ConfigProcessor handles all elements defined under /faces-config/converter.
ConverterException is an exception thrown by the
getAsObject() or
getAsText() method of a Converter, to indicate that the requested conversion cannot be
performed.
Handles setting a
Converter instance on a ValueHolder
parent.Abstract base for a
PropertyEditor that delegates to a faces Converter that was registered by-type
in a faces-config descriptor.
Factory for dynamically generating PropertyEditor classes that extend
ConverterPropertyEditorBase and replace
any references to the target class from the template with a supplied target class.Default template class for the dynamic generation of target-class specific PropertyEditor implementations.
Register a NumberConverter instance on the UIComponent associated with the closest parent UIComponent custom action.
Interface that is to be implement by classes that know how to copy an object.
Copier that copies an object using its copy constructor.
For Tag details, see Faces Core
taglib
documentation.
DataModel is an abstraction around arbitrary data binding
technologies that can be used to adapt a variety of data sources for use by Jakarta Faces components that
support per-row processing for their child components (such as
UIData.
The DataModelClassesMapProducer is the CDI producer that allows UIData, UIRepeat and possible other components that
need a DataModel wrapper for a given type to obtain a Map of types to DataModel implementations capable of wrapping
that type.
DataModelEvent represents an event of interest to registered listeners that occurred on the
specified
DataModel.
DataModelListener represents an event listener that wishes to be notified of
DataModelEvents
occurring on a particular DataModel instance.Converter implementation for
java.util.Date values.Create and configure DocumentBuilderFactory instances.
DebugUtil is a class ...
Default FaceletFactory implementation.
Default implementation of the FunctionMapper
Default instance of a VariableMapper backed by a Map
Scanner implementation responsible for EJB annotations.Scanner implementation responsible for PersistenceContext annotations.Scanner implementation responsible for PersistenceUnit annotations.Scanner implementation responsible for link Resource annotations.
Enable the Jakarta Faces implementation to provide the
appropriate behavior for the kind of
MetaTagHandler subclass for each kind of element in the view, while
providing a base-class from which those wanting to make a Java language custom tag handler can inherit.Maintains an ordered composite list of child
ELResolver for Faces.Utility class for displaying Facelet error/debug information.
InjectionProviders that implement this interface can be configured via
META-INF/services/com.sun.faces.spi.injectionprovider.
Doctype is an interface that must be implemented by any
UIComponent that represents a document type declaration.Associates a Document with a source URL.
This class is used by the config system to order
faces-config documents found on the classpath or
configured explicitly via the jakarta.faces.CONFIG_FILES context init parameter.Converter implementation for java.lang.Double (and double primitive) values.
DoubleRangeValidator is a
Validator
that checks the value of the corresponding component against specified minimum and maximum values.
EditableValueHolder is an extension of
ValueHolder that describes additional features supported by editable components, including
ValueChangeEvents
and Validators.
A VDL handler that exposes
Validator or
ValueChangeListener to a page author.
A marker interface for VDL tags that represent
<composite:editableValueHolder/> for use by the
composite component page author.Concrete implementation of
ELContext.
How this implementation works
This class is used to register the Faces
ELResolver stack with the Jakarta Server Pages container.Handles parsing EL Strings in accordance with the EL-API Specification.
Utility class for EL related methods.
Converter implementation for
java.lang.Enum (and enum primitive) values.This is the TagHandler for the f:event tag.
Represent a logical association between a SystemEvent and a Source.
ExceptionHandler is the central point for handling unexpected
Exceptions that are thrown during the Faces lifecycle.
ExceptionHandlerFactory is a factory object that creates (if needed)
and returns a new
ExceptionHandler instance.Default ExceptionHandlerFactory implementation.
The default implementation of
ExceptionHandler for Faces.
Provides a simple implementation of
ExceptionHandler that can be
subclassed by developers wishing to provide specialized behavior to an existing ExceptionHandler instance.
The system event facility will create an instance of this class whenever
Application.publishEvent(jakarta.faces.context.FacesContext, java.lang.Class<? extends jakarta.faces.event.SystemEvent>, java.lang.Object) is called with ExceptionQueuedEvent.class as
systemEventClass argument.
This helper class provides context to the
ExceptionQueuedEvent regarding the state of the system at the point
in time when the ExceptionQueuedEvent occurs and links the ExceptionQueuedEvent to the
ExceptionHandler by virtue of implementing SystemEventListener.This class implements an abstract ConcurrentCache with objects in the cache potentially expiring.
Interface for checking whether a cached object expired
This class
allows the Faces API to be unaware of the nature of its containing application environment.
ExternalContextFactory is a factory object that
creates (if needed) and returns new
ExternalContext instances, initialized for the processing of the
specified request and response objects.
This implementation of
ExternalContext is specific to the servlet implementation.
The ExternalContextProducer is the CDI producer that allows injection of the ExternalContext using @Inject and allows
EL resolving of #{externalContext}
Provides a simple implementation of
ExternalContext that can be subclassed by developers wishing to provide specialized behavior to an existing
ExternalContext instance.
The parent or root object in a FaceletHandler composition.
This API defines the facility by which the Facelets
ViewDeclarationLanguage creates and caches instances of Facelets.
Factory interface for creating Facelet or View Metadata Facelet instances.
Allows customization of the implementation of
FaceletCache.Default implementation of
FaceletCacheFactory.
Classes that implement this interface return zero or more
URLs which refer to application configuration
resources (i.e.
Context representative of a single request from a Facelet.
An Exception from the Facelet implementation
A state management strategy for FSS.
This is the root class for markup elements in Facelets VDL.
The state management strategy for PSS.
Root class for all tag handlers that represent attached objetcts in a Facelets page.
This
ConfigProcessor handles all elements defined under /faces-taglib.This
ViewHandlingStrategy handles Facelets/PDL-based views.Simple no-op writer.
The presence of this annotation on a class automatically registers the class with the runtime as a
Behavior.
Supports inline instantiation of the
FacesBehavior qualifier.
The presence of this annotation on a class automatically registers the class with the runtime as a
ClientBehaviorRenderer.
The presence of this annotation on a class that extends
UIComponent
must cause the runtime to register this class as a component suitable for inclusion in a view.Maintains an ordered composite list of child
ELResolver for Faces.
Faces indicates this CompositeELResolver instance is the Faces chain, specified in section 5.6.2 of the spec.
The presence of this annotation on a class deployed within an application
guarantees activation of Jakarta Faces and its CDI specific features, even when
/WEB-INF/faces-config.xml is absent and FacesServlet is not explicitly registered.
Supports inline instantiation of the
FacesConfig qualifier.Deprecated, for removal: This API element is subject to removal in a future version.
It has no effect anymore as per Jakarta Faces version 4.0; the actual impl version should be leading.
This
ConfigProcessor handles all elements defined under /faces-config/factory.
Wrapper around the
/WEB-INF/faces-config.xml, if present, to expose information relevant to the
intialization of the runtime.
Classes that implement this interface return zero or more
URLs which refer to application configuration
resources (i.e.
FacesContext contains all of
the per-request state information related to the processing of a single Jakarta Faces request, and the
rendering of the corresponding response.
FacesContextFactory is a
factory object that creates (if needed) and returns new
FacesContext instances, initialized for the
processing of the specified request and response objects.
The FacesContextProducer is the CDI producer that allows injection of the FacesContext using @Inject and allows EL
resolving of #{facesContext}
Provides a simple implementation
of
FacesContext that can be subclassed by developers wishing to provide specialized behavior to an existing
FacesContext instance.
The presence of this annotation on a class automatically registers the
class with the runtime as a
Converter.
Supports inline instantiation of the
FacesConverter qualifier.
Supports inline instantiation of the
FacesDataModel qualifier.
FacesEvent is the base class for user interface and application events that can be fired by
UIComponents.
This class encapsulates general Jakarta Faces exceptions.
This
ConfigProcessor handles all elements defined under /faces-config/flow-definition.Initializes Jakarta Faces if at least one of the following conditions is met:
The
Set of classes passed to this initializer contains an user-defined Faces type, or
FacesServlet has been explicitly mapped ,or
/WEB-INF/faces-config.xml exists
If it is met, and the FacesServlet has not been explicitly mapped,
then add mappings *.xhtml, /faces, *.jsf, and *.faces for the FacesServlet.Extra ServletContainerInitializer that picks up the Resource.class annotation.
A generic base interface for event listeners for various types of
FacesEvents.An
enum of all application Loggers.
FacesMessage represents a single validation (or other) message, which is typically associated with a
particular component in the view.
Class used to represent message severity levels in a typesafe enumeration.
The presence of this annotation on a class automatically registers the class with the runtime as a
Renderer.Central place to store all data regarding Faces and related schemas and their namespaces.
Constants for individual schema files
FacesServlet is a Jakarta Servlet servlet that manages the request processing
lifecycle for web applications that are utilizing Jakarta Faces to construct the user interface.
The presence of this annotation on a class automatically registers the
class with the runtime as a
Validator.
Supports inline instantiation of the
FacesValidator qualifier.
Any wrapper class in Jakarta Faces that must provide access to the
object it wraps must implement this interface.
Register a named facet on the UIComponent associated with the closest parent UIComponent custom action.
An interface that allows other code to identify FaceletHandlers that correspond to component facets.
This
ConfigProcessor handles all elements defined under /faces-config/factory.
FactoryFinder implements the standard discovery algorithm for all factory objects
specified in the Jakarta Faces APIs.
This is based on
StringWriter but backed by a StringBuilder instead.This class is the default implementation of AnnotationProvider referenced by the AnnotationProviderFactory.
Scans the class files within a web application returning a
Set of classes that have been annotated with
a standard Faces annotation (possibly limited to the annotations that denote configurable elements)
This
Callable will be used by getXMLDocuments
It represents one or more URIs to configuration resources that require processing.
The Flash concept is taken from Ruby on Rails and provides
a way to pass temporary objects between the user views generated by the faces lifecycle.
Provide a feature semantically identical to the
"flash" concept in Ruby on
Rails.
FlashFactory is a factory object that creates (if
needed) and returns
Flash instances.Default implementation of
FlashFactory.
The Flash producer is the CDI producer that allows EL resolving of #{flash}
Converter implementation for java.lang.Float (and float primitive) values.
Flow is the runtime representation of a Faces Flow.
A Java language API for building
Flows.
The presence of this annotation on a CDI producer method for the
FlowDefinition annotation causes the
FlowBuilder to be passed to that method.
Supports inline instantiation of the
FlowBuilderParameter qualifier.
Create a flow call node in the current
Flow.A flow call node.
The presence of this annotation on a CDI producer method indicates that the method will produce a flow.
Supports inline instantiation of the
FlowDefinition qualifier.
FlowHandler is the main entry point that enables the runtime to
interact with the faces flows feature.
FlowHandlerFactory is used by the
Application to create the
singleton instance of FlowHandler.
FlowHandlerFactoryWrapper provides a simple implementation of
FlowHandlerFactory that can be
subclassed by developers wishing to provide specialized behavior to an existing FlowHandlerFactory instance.
The presence of this annotation (along with
@Inject) on a field of type Map<Object,
Object> causes the map returned from FlowHandler.getCurrentFlowScope() to be
injected as the value of that field.
Supports inline instantiation of the
ApplicationMap qualifier.
The Flow map producer is the CDI producer that allows injection of the flow map using
@Inject.
FlowNode is the base class for all nodes in a faces flow graph.
FlowScoped is a CDI scope that causes the runtime to consider classes
with this annotation to be in the scope of the specified
Flow.FormRenderer is a class that renders a
UIForm as a Form.
A VisitContext implementation that is used when performing a full component tree visit.
This
TagLibrary exposes the public static methods defined on the
functionsClass provided to the constructor as EL functions.GridRenderer is a class that renders
UIPanel component as a "Grid".Arbitrary grouping "renderer" that simply renders its children recursively in the
encodeEnd() method.
The presence of this annotation (along with
@Inject) on a field of type Map<String,
String> causes the map returned from ExternalContext.getRequestHeaderMap() to
be injected as the value of that field.
Supports inline instantiation of the
HeaderMap qualifier.
The Header map producer is the CDI producer that allows injection of the header map using @Inject.
The presence of this annotation (along with
@Inject) on a field of type Map<String,
String[]> causes the map returned from
ExternalContext.getRequestHeaderValuesMap() to be injected as the value of that field.
Supports inline instantiation of the
HeaderValuesMap qualifier.
The Header values map producer is the CDI producer that allows injection of the header values map using @Inject.
/**
HiddenRenderer is a class that renders the current value of
UIInput component as a HTML hidden
variable.This interface is for Faces to check if the app server has HA enabled.
HtmlBasicInputRenderer is a base class for implementing renderers that support UIInput type components
HtmlBasicRenderer is a base class for implementing renderers for HtmlBasicRenderKit.
Structure to hold common info used by Select* components to reduce the number of times component attributes are
evaluated when rendering options.
Simple class to encapsulate the name and value of a
UIParameter.NONE
The property keys.
Represents a column that will be rendered in an HTML
table element.The property keys.
Represents an HTML
input element for a button of type submit or reset.Properties used by this component
Represents an HTML
a element for a hyperlink that acts like a submit button.Properties used by this component
Represents an HTML
script element for a function that acts like an ajax form submit.The property keys.
Represents a set of repeating data (segregated into columns by child UIColumn components) that will be rendered in an
HTML
table element.The property keys.
NONE
The property keys.
Represents an HTML
form element.Properties used by this component
Represents an HTML
img element, used to retrieve and render a graphical image.Properties used by this component
NONE
The property keys.
Represents an HTML
input element of type file.Properties used by this component
Represents an HTML
input element of type hidden.Properties used by this component
Represents an HTML
input element of type password.Properties used by this component
Represents an HTML
input element of type text.The property keys.
Represents an HTML
textarea element.Properties used by this component
By default, the
rendererType property must be set to "jakarta.faces.Message".Properties used by this component
By default, the
rendererType property must be set to "jakarta.faces.Messages".The property keys.
Represents an HTML
input element of type "button" or image that may be used to link to a URL handled by
the Faces Servlet resolved preemptively using the logical outcome defined by the outcome property.The property keys.
Represents an HTML
a (hyperlink) element that may be used to link to a URL handled by the Faces Servlet
resolved preemptively using the logical outcome defined by the outcome property.The property keys.
Represents a component that looks up a localized message in a resource bundle, optionally uses it as a
MessageFormat pattern string and substitutes in parameter values from nested UIParameter
components, and renders the result.The property keys.
Represents an HTML
label element, used to define an accessible label for a corresponding input element.The property keys.
Represents an HTML
a (hyperlink) element that may be used to link to an arbitrary URL defined by the
value property.The property keys.
Renders the component value as text, optionally wrapping in a
span element if I18N attributes, CSS
styles or style classes are specified.The property keys.
Renders child components in a table, starting a new row after the specified number of columns.
Properties used by this component
Causes all child components of this component to be rendered.
Properties used by this component
HtmlResponseWriter is an Html specific implementation of the
ResponseWriter abstract
class.
Represents an HTML
input element of type
checkbox.The property keys.
Represents a multiple-selection component that is rendered as a set
of HTML
input elements of type checkbox.Properties used by this component
Represents a multiple-selection component that is rendered as an HTML
select element, showing either all
available options or the specified number of options.Properties used by this component
Represents a multiple-selection component that is rendered as an HTML
select element, showing a single
available option at a time.The property keys.
Represents a single-selection component that is rendered as an HTML
select element, showing either all
available options or the specified number of options.Properties used by this component
Represents a single-selection component that is rendered as an HTML
select element, showing a single
available option at a time.Properties used by this component
Represents a single-selection component that is rendered as a set of
HTML
input elements of type radio.The property keys.
Utility class for HTML.
Used to provide aliases to Facelets generated unique IDs with tend to be womewhat long.
ImageRenderer is a class that handles the rendering of the graphic ImageTag
A special, minimal implementation of FacesContext used at application initialization time.
The presence of this annotation (along with
@Inject) on a field of type Map<String,
String> causes the map returned from ExternalContext.getInitParameterMap() to
be injected as the value of that field.
Supports inline instantiation of the
InitParameterMap qualifier.
The init parameter map producer is the CDI producer that allows injection of the init parameter map using @Inject.
This
ApplicationFactory is responsible for injecting the default
Application instance into the top-level Application as configured by the runtime.This
FacesContextFactory is responsible for injecting the default FacesContext instance into the
top-level FacesContext as configured by the runtime.
This is a work around in order to be able to get
InjectionPoint in CdiProducer.
This interface defines an integration point for Jakarta EE vendors.
Wraps any exception thrown by an implementation of
InjectionProvider.
A factory for creating
InjectionProvider instances.This
TagHandler is responsible for relocating children defined within a composite component to a
component within the composite component's composite:implementation section.This
TagHandler is responsible for relocating Facets defined within a composite component to a component
within the composite component's composite:implementation section.Converter implementation for java.lang.Integer (and int primitive) values.Lifetime And Scope
IterableDataModel is an implementation of
DataModel that wraps an Iterable.An abstract RuntimeAnnotationHandler that is capable of dealing with JNDI.
Generic JSON encoder using jakarta.json API.
The JSTL c library.
Implementations of JSTL Functions
LabelRenderer renders Label element.
LengthValidator is a
Validator that checks the number of
characters in the String representation of the value of the associated component.LibraryInfo is a simple wrapper class for information pertinent to building a complete resource path
using a Library and/or Contract.
Lifecycle manages the processing of the entire lifecycle of a
particular Jakarta Faces request.
This
ConfigProcessor handles all elements defined under /faces-config/lifecycle.
LifecycleFactory is a factory object that creates
(if needed) and returns
Lifecycle instances.LifecycleFactoryImpl is the stock implementation of Lifecycle in Mojarra.
LifecycleImpl is the stock implementation of the standard Lifecycle in the Jakarta Faces RI.
LinkRenderer acts as superclass for CommandLinkRenderer and OutputLinkRenderer.
ListRenderer is a class that renders the current value of
UISelectOne or UISelectMany
component as a list of options.
ListDataModel is a convenience implementation of
DataModel that wraps an List
of Java objects.
Classes tagged with this annotation are installed as listeners using the method
Application.subscribeToEvent(java.lang.Class<? extends jakarta.faces.event.SystemEvent>, java.lang.Class<?>, jakarta.faces.event.SystemEventListener) or
UIComponent.subscribeToEvent(java.lang.Class<? extends jakarta.faces.event.SystemEvent>, jakarta.faces.event.ComponentSystemEventListener) (depending on the circumstances, described below).
Container annotation to specify multiple
ListenerFor annotations on a single class.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.
An object that represents the Location of a tag or attribute of a tag in a View Declaration Language file.
Converter implementation for java.lang.Long (and long primitive) values.
LongRangeValidator is a
Validator that checks the value
of the corresponding component against specified minimum and maximum values.A special implementation of
LinkedHashMap to provide LRU functionality.
The presence of this annotation (along with
@Inject) on a field of any type causes the value returned from
evaluating an expression language expression to be injected as the value of that field.
Supports inline instantiation of the
ManagedProperty qualifier.
The ManagedPropertyProducer is the CDI producer that allows evaluation of arbitrary EL expressions.
MenuRenderer is a class that renders the current value of
UISelectOne or UISelectMany
component as a list of menu options.
supported filters:
package and protection.
supported filters:
package and protection.
MessageRenderer handles rendering for the Message
MessagesRenderer handles rendering for the Messages
This class contains all message constants and utility methods for creating
FacesMessage instances or
localized Strings for said constants.
There are concrete subclasses within the implementation that map concepts in the Facelet VDL page to Jakarta Server
Faces Java API calls the appropriate instances.
This is a specialized
FacetHandler to enable f:metadata support.This resource providers finds all .taglib.xml files in the system.
The root class of the abstraction that dictates how attributes on a markup element in a Facelets VDL page are wired
to the Jakarta Faces API object instance associated with that element.
A mutable set of rules to be used in auto-wiring state to a particular object instance.
Every kind of markup element in Facelets VDL that has attributes that need to take action on a Jakarta Faces
Java API artifact is associated with an instance of this class.
A base tag for wiring state to an object instance based on rules populated at the time of creating a MetaRuleset.
Create a method call node in the current
Flow.
Represents a method call node in the flow graph.
MethodExpressionValidator is a
Validator that wraps a
MethodExpression, and it performs validation by executing a method on an object identified by the
MethodExpression.Optional Rule for binding Method[Binding|Expression] properties
This code is based off the source for ConcurrentHashMap from JDK 5 with the ability of mapping multiple keys to a
single value.
Copier that copies an object trying a variety of strategies until one succeeds.
This
ViewHandler implementation handles the Facelets VDL-based views.
NavigationCase represents a
<navigation-case> in
the navigation rule base, as well as the <from-view-id> with
which this <navigation-case> is a sibling.
The presence of this annotation on a class automatically registers the class with the runtime as a
ComponentSystemEvent for use with the <f:event /> tag in a page.This class handles the processing the NamedEvent annotation.
Note: New, relevant spec'd ComponentSystemEvents must be added to the constructor
NamingContainer is an interface that must be implemented by any
UIComponent that wants to be a naming container.
NavigationCase represents a
<navigation-case> in
the navigation rule base, as well as the <from-view-id> with
which this <navigation-case> is a sibling.
Create a navigation case in the current
Flow.
Provides a simple implementation of
NavigationCase that can be
subclassed by developers wishing to provide specialized behavior to an existing NavigationCase instance.
This
ConfigProcessor handles all elements defined under /faces-config/navigation-rule.
A NavigationHandler is passed the
outcome string returned by an application action invoked for this application, and will use this (along with related
state information) to choose the view to be displayed next.
NavigationHandlerImpl is the class that implements default navigation handling.
NavigationHandlerWrapper provides a simple implementation of
NavigationHandler that can be subclassed by developers wishing to provide specialized behavior to an existing
NavigationHandler instance.Copier that doesn't actually copy an object fully, but just returns a new instance of the same type.
Base interface for building all kinds of flow nodes.
Converter implementation for java.lang.Number
values.OutputLinkRenderer is a class ...
OutputMessageRenderer is a class that renderes UIOutput
Represents a parameter in any of several places where parameters are needed when processing flows.
ParameterizedTypeImpl is a basic implementation of the ParameterizedType interface.
This
Callable will be used by getXMLDocuments
It represents a single configuration resource (such as faces-config.xml) to be parsed into a DOM.
PartialResponseWriter decorates an existing
ResponseWriter to support the generation of
a partial response suitable for Ajax operations.
Components that want to leverage the partial state saving feature must implement this interface instead of
implementing
StateHolder, from which this interface inherits.
PartialViewContext contains
methods and properties that pertain to partial request processing and partial response rendering on a view.
PartialViewContextFactory is a factory object that creates (if needed) and
returns new
PartialViewContext instances.
Factory to vend the default
PartialViewContext instance.
Provides a simple implementation of
PartialViewContext that can be subclassed by developers wishing to provide specialized behavior to an
existing PartialViewContext instance.
A VisitContext implementation that is used when performing a partial component tree visit.
Sets the specified name and attribute on the parent UIComponent.
Causes all child components of this component to be rendered.
A Phase is a single step in the processing of a Jakarta Faces request throughout its entire
Lifecycle.
PhaseEvent represents the beginning or ending of processing for a particular phase of the request
processing lifecycle, for the request encapsulated by the specified
FacesContext.
Typesafe enumeration of the legal values that may be returned by the
getPhaseId() method of the FacesEvent interface.
An interface implemented by objects that wish to be notified at the beginning and ending of processing for each
standard phase of the request processing lifecycle.
When an instance of this event is passed to
SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener
implementation may assume that the source of this event instance is a UIComponent instance and
that either that instance or an ancestor of that instance was just added to the view.
This event must be published by the runtime after all configuration resources have been parsed and processed.
This class is provided to allow custom scopes to publish a "post construct" event in the same way that other scopes
do to let the application become aware of the beginning of the scope.
This event must be published by a call to {jakarta.faces.application.Application#publishEvent} when the view map is
first created.
This event must be published by a call to
Application.publishEvent(jakarta.faces.context.FacesContext, java.lang.Class<? extends jakarta.faces.event.SystemEvent>, java.lang.Object) when a value is
kept in the flash.
This event must be published by a call to
Application.publishEvent(jakarta.faces.context.FacesContext, java.lang.Class<? extends jakarta.faces.event.SystemEvent>, java.lang.Object) when a value is
stored in the flash.
When an instance of this event is passed to
SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or
ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the
source of this event instance is the UIViewRoot instance that has just been rendered.
When an instance of this event is passed to
SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or
ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the
source of this event instance is in a tree that has just had its state restored.
When an instance of this event is passed to
SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or
ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the
source of this event instance is the UIComponent instance that is that has just been validated.
This event must be published by a call to
Application.publishEvent(jakarta.faces.context.FacesContext, java.lang.Class<? extends jakarta.faces.event.SystemEvent>, java.lang.Object) before the flash
is cleared.
This event must be published by the runtime before the factories associated with this
Application
are released.
This class is provided to allow custom scopes to publish a "pre construct" event in the same way that other scopes do
to let the application become aware of the beginning of the scope.
This event must be published by a call to
Application.publishEvent(jakarta.faces.context.FacesContext, java.lang.Class<? extends jakarta.faces.event.SystemEvent>, java.lang.Object) when the
clear method is called on the map returned from UIViewRoot.getViewMap().
This event must be published by a call to
Application.publishEvent(jakarta.faces.context.FacesContext, java.lang.Class<? extends jakarta.faces.event.SystemEvent>, java.lang.Object) when a value is
removed from the flash.
When an instance of this event is passed to
SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or
ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the
source of this event instance is a UIComponent instance that is about to be removed from the
view.
When an instance of this event is passed to
SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or
ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the
source of this event instance is the UIComponent instance that is about to be rendered and that
it is safe to call UIComponent.getParent(), UIComponent.getClientId(), and other methods that depend upon
the component instance being in the view.
When an instance of this event is passed to
SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or
ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the
source of this event instance is the UIViewRoot instance that is about to be rendered.
When an instance of this event is passed to
SystemEventListener.processEvent(jakarta.faces.event.SystemEvent) or
ComponentSystemEventListener.processEvent(jakarta.faces.event.ComponentSystemEvent), the listener implementation may assume that the
source of this event instance is the UIComponent instance that is about to be validated.ProcessValidationsPhase executes
processValidators on each component in the tree.
This class enables a feature similar to the
RAILS_ENV feature of the Ruby on Rails web framework.Allows configuring ProjectStage at a server (or in GlassFish's case domain) level.
Helper class to aid the ConverterPropertyEditorBase in converting properties.
This exception is thrown by the runtime when a violation of the view protection mechanism is encountered.
This
ConfigProcessor handles all elements defined under /protected-views.
The CDI annotation
@Push allows you to inject a PushContext associated with a given
<f:websocket> channel in any container managed artifact in WAR.
Supports inline instantiation of the
Push qualifier.
CDI interface to send a message object to the push socket channel as identified by
@Push.ReadoRenderer is a class that renders the current value of
UISelectOne or UISelectMany
component as a list of radio buttonsKeeps track of all
<h:selectOneRadio group> detail.Used when a
<h:selectOneRadio group> doesn't have a select item; it will then get it via first radio of the group.
A set of utility methods to make working with Classes and Reflection a little easier.
A Validator that checks against a Regular Expression (which is the
pattern property).
A Renderer converts the internal representation of
UIComponents into the output stream (or writer) associated with the response we are creating for a particular
request.
RenderKit represents a collection of
Renderer
instances that, together, know how to render Jakarta Faces UIComponent instances for a specific
client.ConfigAnnotationHandler FacesRenderer annotated classes.This
ConfigProcessor handles all elements defined under /faces-config/render-kit.
RenderKitFactory is a factory object that
registers and returns
RenderKit instances.RenderKitImpl is a class ...
A set of utilities for use in
RenderKits.Lifetime And Scope
The presence of this annotation (along with
@Inject) on a field of type Map<String,
Object> causes the map returned from ExternalContext.getRequestCookieMap() to
be injected as the value of that field.
Supports inline instantiation of the
RequestCookieMap qualifier.
The CookieMapProducer is the CDI producer that allows injection of the request cookie map using @Inject and allows
the EL resolving of #{cookie}
The presence of this annotation (along with
@Inject) on a field of type Map<String,
Object> causes the map returned from ExternalContext.getRequestMap() to be
injected as the value of that field.
Supports inline instantiation of the
RequestMap qualifier.
The RequestMapProducer is the CDI producer that allows injection of the request map using @Inject.
The presence of this annotation (along with
@Inject) on a field of type Map<String,
String> causes the map returned from ExternalContext.getRequestParameterMap()
to be injected as the value of that field.
Supports inline instantiation of the
RequestParameterMap qualifier.
The request parameter map producer is the CDI producer that allows injection of the request parameter map
using @Inject.
The presence of this annotation (along with
@Inject) on a field of type Map<String,
String []> causes the map returned from
ExternalContext.getRequestParameterValuesMap() to be injected as the value of that field.
Supports inline instantiation of the
RequestParameterValuesMap qualifier.
The request parameter values map producer is the CDI producer that allows injection of the request parameter values
map using @Inject.
The RequestProducer is the CDI producer that allows EL resolving of #{request}
This helper class is used a central location for per-request state that is needed by Mojarra.
A Validator that checks for an empty value in the same way that UIInput checks for a value.
An instance of
Resource is a Java object representation of the artifact that is served up in response to a resource
request from the client.
This is the caching mechanism for caching ResourceInfo instances to offset the cost of looking up the resource.
Container annotation to specify multiple
ResourceDependency annotations on a single class.
Instances of
UIComponent or Renderer that have this
annotation (or ResourceDependencies attached at the class level will automatically have a resource dependency
added so that the named resource will be present in user agent's view of the UIViewRoot in which this
component or renderer is used.ELResolver to resolve expressions like the following:
#{resource['library:resource']}
#{resource['resource']}
ResourceHandler is the
run-time API by which
UIComponent and Renderer
instances, and the ViewDeclarationLanguage can reference
Resource instances. An implementation of this class must be thread-safe.This is the default implementation of
ResourceHandler.
The ResourceHandlerProducer is the CDI producer that allows you to inject the ResourceHandler and to do EL resolving
of #{resource}
Provides a simple
implementation of
ResourceHandler that can be subclassed by developers wishing to provide specialized
behavior to an existing ResourceHandler instance.
Implementations of this class contain the knowledge for finding and serving web application resources.
Default implementation of
Resource.This class is used to lookup
ResourceInfo instances and cache any that are successfully looked up to reduce
the computational overhead with the scanning/version checking.
Defines the resource traversal options.
ResponseStateManager is the helper class to
StateManager that knows the specific rendering technology being used to generate
the response.
A
ResonseStateManager implementation for the default HTML render kit.
ResponseStream is an interface describing an adapter to an underlying output mechanism for binary
output.
ResponseWriter is an abstract class describing an adapter
to an underlying output mechanism for character-based output.
Provides a simple implementation of
ResponseWriter that can be subclassed by developers wishing to provide specialized behavior to an existing
ResponseWriter instance.Lifetime And Scope
ResultSetDataModel is a convenience implementation of
DataModel that wraps a
ResultSet of Java objects.
Create a return node in the current
Flow.
Represents a return node in the flow graph.
This class contains literal strings used throughout the Faces RI.
Compiler implementation that uses SAX
ScalarDataModel is a convenience implementation of
DataModel that wraps an individual Java
object.
A structure that contains the name of the scope and the scope itself exposed as a
Map<String,
Object>.This class helps in letting code run within its own scope.
This
Renderer handles the rendering of script references.ComponentResourceDelegate for script references.ComponentHandler for h:outputScript references.
Base class for shared behavior between Script and Stylesheet renderers.
A context object that is used to hold state relating to resolve a search expression.
Provide for separation of interface and implementation for the
SearchExpressionContext contract.The SearchExpressionHandler is responsible for resolving search
expression(s)
Provides a simple implementation of
SearchExpressionHandler that can be subclassed by developers wishing to
provide specialized behavior to an existing SearchExpressionHandler instance.
An enum that specifies hints that impact the behavior of a component tree search.
SearchKeywordContext provides context information that may be useful to
SearchKeywordResolver.resolve(jakarta.faces.component.search.SearchKeywordContext, jakarta.faces.component.UIComponent, java.lang.String) implementations.
A SearchKeywordResolver is responsible for resolving a single keyword.
SecretRenderer is a class that renders the current value of
UIInput component as a password field.
SelectItem represents a single item
in the list of supported items associated with a
UISelectMany or UISelectOne component.
SelectItemGroup is a subclass of
SelectItem that identifies a set of options that will be
made available as a subordinate "submenu" or "options list", depending upon the requirements of the
UISelectMany or UISelectOne renderer that is actually used.
Package private class for iterating over the set of
SelectItems for a parent UISelectMany or
UISelectOne.Helper for
UISelectItemGroup and UISelectItemGroupsSelectManyCheckboxListRenderer is a class that renders the current value of
UISelectMany component
as a list of checkboxes.Copier that copies an object by serializing and subsequently deserializing it again.
This interface provides a mechanism to allow the use of alternate Java Serialization implementations.
A factory for creating
SerializationProvider instances.This
StateHelper provides the functionality associated with server-side state saving, though in
actuality, it is a hybrid between client and server.
The presence of this annotation (along with
@Inject) on a field of type Map<String,
Object> causes the map returned from ExternalContext.getSessionMap() to be
injected as the value of that field.
Supports inline instantiation of the
SessionMap qualifier.
The SessionProducer is the CDI producer that allows injection of the session map using @Inject.
The SessionProducer is the CDI producer that allows EL resolving of #{session}
Simplified implementation of c:set
Converter implementation for java.lang.Short (and short primitive) values.Context for dealing with partial state saving mechanics.
Common code for the default
StateHelper implementations.
Define a
Map-like contract that makes it easier for components to implement PartialStateHolder.
This interface is implemented by classes that need to save their
state between requests.
Encapsulate the saving and restoring of the view to enable the VDL to take
over the responsibility for handling this feature.
StateManager directs the process of saving and restoring the view between requests.
A
StateManager implementation to meet the requirements of the specification.
Provides a simple implementation of
StateManager that can be
subclassed by developers wishing to provide specialized behavior to an existing StateManager instance.
This
Renderer handles the rendering of stylesheet references.ComponentResourceDelegate for stylesheet references.ComponentHandler for h:outputStylesheet references.
Create a switch node in the current
Flow.
Represents a case within a switch node in the flow graph.
Create a case in the current switch.
Represents a switch node in the flow graph.
SystemEvent is the base class for non-application
specific events that can be fired by arbitrary objects.
Utility class for dealing with application events.
Simple wrapper class for application level SystemEvents.
By implementing this class, an object indicates that it is a listener for one or more kinds of
SystemEvents.
Classes that implement this interface agree to maintain a list of
SystemEventListener instances for each kind
of SystemEvent they can generate.
Render a
UIData component as a two-dimensional table.
The runtime must create an instance of this class for each element in the Facelets XHTML view.
Representation of an XML attribute name=value pair on an XML element in a
Facelet file.
An Exception caused by a
TagAttributeRepresentation of a Tag's attribute in a Facelet File
A set of TagAttributes, usually representing all attributes on a Tag.
A set of TagAttributesImpl, usually representing all attributes on a Tag.
Passed to the constructor of
TagHandler subclass, it defines the document definition of the handler we are
instantiating.
Provides the ability to completely change the Tag
before it's processed for compiling with the associated
TagHandler.
An Exception caused by a
Tag
Foundation class for
FaceletHandlers associated with a
markup element in a Facelet document.
Abstract class that defines methods relating to helping tag handler
instances.
Abstract factory for creating instances of
TagHandlerDelegate.Default implementation of
TagHandlerDelegateFactory.A library of Tags associated with one or more namespaces.
Concrete implementation for defining Facelet tag libraries in Java.
FaceletHandlers can implement this contract and push themselves into the FaceletContext for participating in
templating.
TextareaRenderer is a class that renders the current value of
UIInput component as a Textarea.
An interface that allows other code to identify FaceletHandlers that may provide text (String) content.
TextRenderer is a class that renders the current value of
UIInput or UIOutput
component as a input field or static text.This class is a simple wrapper for timing method calls.
Define a
Map-like contract that makes it easier for components to implement
TransientStateHolder.
This interface is implemented by classes that need to save state that is expected to be available only within the
scope of the current request.
UIColumn is a
UIComponent that represents a single column of data within a parent
UIData component.
UICommand is a
UIComponent that represents a user interface component which, when activated
by the user, triggers an application specific "command" or "action".
UIComponent is the base class for all user interface components in Jakarta Server
Faces.
UIComponentBase is a
convenience base class that implements the default concrete behavior of all methods defined by
UIComponent.
UIData is a
UIComponent that supports data binding to a collection of data objects represented by a DataModel
instance, which is the current value of this component itself (typically established via a ValueExpression).
UIForm is a
UIComponent that represents an input form to be
presented to the user, and whose child components represent (among other things) the input fields to be included when
the form is submitted.
UIGraphic is a
UIComponent that displays a graphical image to the user.
UIInput is a
UIComponent that represents a component that both
displays output to the user (like UIOutput components do) and processes request parameters on the subsequent
request that need to be decoded.
This component is responsible for displaying messages for a specific
UIComponent, identified by a clientId or component id
relative to the closest ancestor NamingContainer.
The renderer for this component is responsible for obtaining the messages from the
FacesContext and
displaying them to the user.
UINamingContainer is a convenience base class for components that wish
to implement
NamingContainer functionality.
This component is paired with the
jakarta.faces.Button or
jakarta.faces.Link renderers and encapsulates properties relating to the rendering of outcomes directly
to the response.
UIOutput is a
UIComponent that has a
value, optionally retrieved from a model tier bean via a value expression, that is displayed to the user.
UIPanel is a
UIComponent that manages the layout of its child components.
UIParameter is a
UIComponent that represents an optionally named configuration parameter for
a parent component.
UISelectItem is a component that may be
nested inside a
UISelectMany or UISelectOne component, and causes the addition of a
SelectItem instance to the list of available options for the parent component.
UISelectItemGroup is a component that may be nested inside a
UISelectMany or UISelectOne component, and causes the addition
of one SelectItemGroup of one or more SelectItem instances to the list of available options in the parent component.
UISelectItemGroups is a component that may be nested inside a
UISelectMany or UISelectOne component, and causes the addition
of one or more SelectItemGroup of one or more SelectItem instances to the list of available options in the parent component.
UISelectItems is a component that may be nested inside a
UISelectMany or UISelectOne
component, and causes the addition of one or more SelectItem instances to the list of available options in
the parent component.
UISelectMany is a
UIComponent that
represents the user's choice of a zero or more items from among a discrete set of available options.
UISelectOne is a
UIComponent that represents the user's choice
of zero or one items from among a discrete set of available options.
UIViewAction represents a method invocation that occurs during the
request processing lifecycle, usually in response to an initial request, as opposed to a postback.
UIViewParameter represents a binding between a
request parameter and a model property or
UIViewRoot property.
Inner class to encapsulate a
UIViewParameter instance so that it may be safely referenced regardless of
whether or not the current view is the same as the view in which this UIViewParameter resides.
UIViewRoot is the UIComponent that represents the root of
the UIComponent tree.
The
<f:websocket> tag opens an one-way (server to client) websocket based push connection in
client side which can be reached from server side via PushContext interface injected in any CDI/container
managed artifact via @Push annotation.
UniqueIdVendor is an interface implemented by
UIComponents that also implement
NamingContainer so that they can provide unique ids based on their own clientId.Components implementing this interface are ignored by the algorithm - especially in
the implementation of
@child(n), @next and @previous.
This exception indicates a failure to update the model and is created to wrap any exception that occurs during
UIInput.updateModel(jakarta.faces.context.FacesContext).UpdateModelValuesPhase executes
processUpdates on each component in the tree so that it may have a
chance to update its model value.Util is a class ...
ValidateFormComponentNesting performs component tree validation to assure
ActionSource ,
ActionSource2 and EditableValueHolder components are placed inside a form.Register a named Validator instance on the UIComponent associated with the closest parent UIComponent custom action.
A Validator implementation is a class that can perform validation
(correctness checks) on a
EditableValueHolder.
Used in creating
ValidatorHandler and all implementations.ConfigAnnotationHandler for FacesValidator annotated classes.
This
ConfigProcessor handles all elements defined under /faces-config/valiator.
A ValidatorException is an exception thrown by the
validate() method of a Validator to indicate that validation failed.
Handles setting a
Validator instance on an
EditableValueHolder parent.
A
ValueChangeEvent is a notification that the local value of the source component has been change as a result
of user interface activity.
A listener interface for receiving
ValueChangeEvents.Register an ValueChangeListener instance on the UIComponent associated with the closest parent UIComponent custom
action.
ValueHolder is an interface that may be implemented by any concrete
UIComponent that wishes to support a local value, as well as access data in the model tier via a value
expression, and support conversion between String and the model tier data's native data type.
A VDL handler that exposes
Converter to a page author.
A marker interface for VDL tags that represent
<composite:valueHolder/> for use by the
composite component page author.Utility class for wrapping another VariableMapper with a new context, represented by a
Map.This class backs the
com.sun.faces.verifyObjects feature which provides basic validation of Components,
Converters, and Validators.Represent the current Faces object types we validate.
Metadata pertaining to versions.
The presence of this annotation on a target (type, method, parameter or field) within an application is used to indicate that
this target is somehow handling a Faces View Id or Ids.
Supports inline instantiation of the
View annotation.
Create a view node in the current
Flow.
The contract that a view
declaration language must implement to interact with the Jakarta Faces runtime.
ViewDeclarationLanguageFactory is a factory object
that creates (if needed) and returns a new
ViewDeclarationLanguage instance based on the VDL found in a
specific view.Default implementation of
ViewDeclarationLanguageFactory.
Provides a simple implementation of
ViewDeclarationLanguage that
can be subclassed by developers wishing to provide specialized behavior to an existing
ViewDeclarationLanguage instance.
Implementations must throw this
FacesException when attempting to restore the view
StateManagementStrategy.restoreView(FacesContext, String, String) results in failure on postback.Container for all Jakarta Faces core and custom component actions used on a page.
ViewHandler is the pluggablity mechanism for allowing implementations of or applications using the
Jakarta Faces Specification to provide their own handling of the activities in the Render Response
and Restore View phases of the request processing lifecycle.
This class is used by
ViewHandler.createView(jakarta.faces.context.FacesContext, java.lang.String) to obtain the text that exists after
the <f:view> tag.
Provides a simple implementation of
ViewHandler that can be
subclassed by developers wishing to provide specialized behavior to an existing ViewHandler instance.
This represents how a particular page description language is to be rendered/restored.
Interface for working with multiple
ViewHandlingStrategy implementations.Indicates that no
ViewHandlingStrategy instances were found appropriate to a
particulare view ID.
The presence of this annotation (along with
@Inject) on a field of type Map<String,
Object> causes the map returned from UIViewRoot.getViewMap() to be injected
as the value of that field.
Supports inline instantiation of the
ViewMap qualifier.
Marker interface for
SystemEvents that indicate the view map has been created
(PostConstructViewMapEvent, or destroyed (PreDestroyViewMapEvent).
The ViewMapProducer is the CDI producer that allows injection of the view map using @Inject and allows EL resolving
of #{viewScope}
Used to hold metadata for classes that are members of views.
ViewMetadata is reponsible for extracting and providing view parameter metadata from VDL views.
ViewNode is the class that represents a VDL view in a faces flow graph.
The ViewProducer is the CDI producer that allows you to inject the UIViewRoot and to do EL resolving of #{view}
Superclass of
Resource that is only for use with views.The CDI context for CDI ViewScoped beans.
The manager that deals with CDI ViewScoped beans.
When this annotation, along with
jakarta.inject.Named is found on a class, the runtime must place the bean in a CDI scope such that it remains active
as long as NavigationHandler.handleNavigation(jakarta.faces.context.FacesContext, java.lang.String, java.lang.String) does not cause a navigation to a view
with a viewId that is different than the viewId of the current view.The ViewScope event listener.
The CDI extension that makes ViewScoped beans work in a CDI context.
The manager that deals with non-CDI and CDI ViewScoped beans.
Defines the view traversal options.
A simple callback interface that enables taking action on a specific UIComponent (either facet or child) during a
component tree visit.
A context object that is used to hold state relating to performing a component tree visit.
Provide for separation of interface and implementation for the
VisitContext contract.
Default implementation of
VisitContextFactory.
Provides a simple implementation of
VisitContext that can be
subclassed by developers wishing to provide specialized behavior to an existing VisitContext instance.
An enum that specifies hints that impact the behavior of a component tree
visit.
An enum that specifies the possible results of a call to
VisitCallback.visit(jakarta.faces.component.visit.VisitContext, jakarta.faces.component.UIComponent).
Central location for web application lifecycle events.
A
ResourceHelper implementation for finding/serving resources found within
<contextroot>/resources directory of a web application.Class Documentation
An
enum of all boolean context initalization parameters recognized by the implementation.
An
enum of all possible values for the disableUnicodeEscaping configuration parameter.
An
enum of all non-boolean context initalization parameters recognized by the implementation.
An
enum of all environment entries (specified in the web.xml) recognized by the implemenetation.
This
InjectionProvider will be used if the PostConstruct and PreDestroy
annotations are present, but no specific InjectionProvider has been configured.A simple PrintWriter implementation to allow us to query whether or not the writer has been flushed or closed.
This web socket channel manager holds all application and session scoped web socket channel identifiers registered by
<f:websocket>.This helps the web socket channel manager to hold view scoped web socket channel identifiers registered by
<f:websocket>.
This web socket server endpoint handles web socket requests coming from
<f:websocket>.
This web socket event will be fired when a new
<f:websocket> has been
@WebsocketEvent.Opened or @WebsocketEvent.Closed.
Indicates that a
<f:websocket> has closed.
Supports inline instantiation of the
WebsocketEvent.Closed qualifier.
Indicates that a
<f:websocket> has opened.
Supports inline instantiation of the
WebsocketEvent.Opened qualifier.
This Faces listener for
UIViewRoot ensures that the necessary JavaScript code to open or close the
WebSocket is properly rendered depending on rendered and connected attributes.WebsocketRenderer is a class that renders the
faces.push.init() script and decodes any client
behaviors triggered by UIWebsocket.
This web socket session manager holds all web socket sessions by their channel identifier.
This web socket user manager holds all web socket users registered by
<f:websocket>.