abstract public  void addComponent(String componentType,
    String componentClass)
Register a new mapping of component type to the name of the
corresponding UIComponent  class. This allows subsequent calls
to createComponent() to serve as a factory for
UIComponent  instances.

 abstract public  void addConverter(String converterId,
    String converterClass)
Register a new mapping of converter id to the name of the
corresponding Converter  class. This allows subsequent calls
to createConverter() to serve as a factory for
Converter  instances.

 abstract public  void addConverter(Class targetClass,
    String converterClass)
Register a new converter class that is capable of performing
conversions for the specified target class.

 public  void addELContextListener(ELContextListener listener) 
{
        Application app = getRIApplicationImpl();
        if (app != null) {
            app.addELContextListener(listener);
        } else {
            throw new UnsupportedOperationException();
        }
}

Provide a way for Faces applications to register an ELContextListener that will be notified on creation of ELContext instances. This listener will be called once per request.

An implementation is provided that throws UnsupportedOperationException so that users that decorate the Application continue to work.

 public  void addELResolver(ELResolver resolver) 
{
        Application app = getRIApplicationImpl();
        if (app != null) {
            app.addELResolver(resolver);
        } else {
            throw new UnsupportedOperationException();
        }
}

Cause an the argument resolver to be added to the resolver chain as specified in section 5.5.1 of the JavaServer Faces Specification.

It is not possible to remove an ELResolver registered with this method, once it has been registered.

It is illegal to register an ELResolver after the application has received any requests from the client. If an attempt is made to register a listener after that time, an IllegalStateException must be thrown. This restriction is in place to allow the JSP container to optimize for the common case where no additional ELResolvers are in the chain, aside from the standard ones. It is permissible to add ELResolvers before or after initialization to a CompositeELResolver that is already in the chain.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend Application .

 abstract public  void addValidator(String validatorId,
    String validatorClass)
Register a new mapping of validator id to the name of the
corresponding Validator  class. This allows subsequent calls
to createValidator() to serve as a factory for
Validator  instances.

 abstract public UIComponent createComponent(String componentType) throws FacesException
Instantiate and return a new UIComponent  instance of the
class specified by a previous call to addComponent() for
the specified component type.

 abstract public UIComponent createComponent(ValueBinding componentBinding,
    FacesContext context,
    String componentType) throws FacesExceptionDeprecated! This -  has been replaced by #createComponent(javax.el.ValueExpression,javax.faces.context.FacesContext,java.lang.String) .

Wrap the argument componentBinding in an
implementation of ValueExpression  and call through to
#createComponent(javax.el.ValueExpression,javax.faces.context.FacesContext,java.lang.String) .

 public UIComponent createComponent(ValueExpression componentExpression,
    FacesContext context,
    String componentType) throws FacesException 
{
        if (null == componentExpression || null == context ||
            null == componentType) {
        	// PENDING - i18n
            StringBuilder builder = new StringBuilder(64);
            builder.append("null parameters - ");
            builder.append("componentExpression: ").append(componentExpression);
            builder.append(", context: ").append(context);
            builder.append(", componentType: ").append(componentType);
            throw new NullPointerException(builder.toString());
        }
        Object result;
        boolean createOne = false;
        try {
            if (null != (result = 
                componentExpression.getValue(context.getELContext()))) {
                // if the result is not an instance of UIComponent
                createOne = (!(result instanceof UIComponent));
                // we have to create one.
            }
            if (null == result || createOne) {
                result = this.createComponent(componentType);
                componentExpression.setValue((context.getELContext()), result);
            }
        } catch (ELException elex) {
            throw new FacesException(elex);
        }
        return (UIComponent) result;
}

Call the getValue() method on the specified ValueExpression . If it returns a UIComponent instance, return it as the value of this method. If it does not, instantiate a new UIComponent instance of the specified component type, pass the new component to the setValue() method of the specified ValueExpression , and return it.

 abstract public Converter createConverter(String converterId)
Instantiate and return a new Converter  instance of the
class specified by a previous call to addConverter()
for the specified converter id. If there is no such registration
for this converter id, return null.

 abstract public Converter createConverter(Class targetClass)
Instantiate and return a new Converter  instance of the
class that has registered itself as capable of performing conversions
for objects of the specified type. If no such Converter  class
can be identified, return null.

To locate an appropriate Converter  class, the following
algorithm is performed, stopping as soon as an appropriate Converter  class is found:

Locate a Converter  registered for the target class itself.

Locate a Converter  registered for interfaces that are
implemented by the target class (directly or indirectly).
Locate a Converter  registered for the superclass (if any)
of the target class, recursively working up the inheritance
hierarchy.


If the Converter has a single argument constructor that
accepts a Class, instantiate the Converter
using that constructor, passing the argument targetClass as
the sole argument. Otherwise, simply use the zero-argument constructor.

 abstract public MethodBinding createMethodBinding(String ref,
    Class[] params) throws ReferenceSyntaxExceptionDeprecated! This -  has been replaced by calling #getExpressionFactory  then ExpressionFactory#createMethodExpression .

Call #getExpressionFactory  then call ExpressionFactory#createMethodExpression , passing the given
arguments, and wrap the result in a MethodBinding
implementation, returning it.

 abstract public Validator createValidator(String validatorId) throws FacesException
Instantiate and return a new Validator  instance of the
class specified by a previous call to addValidator()
for the specified validator id.

 abstract public ValueBinding createValueBinding(String ref) throws ReferenceSyntaxExceptionDeprecated! This -  has been replaced by calling #getExpressionFactory  then ExpressionFactory#createValueExpression .

Call #getExpressionFactory  then call ExpressionFactory#createValueExpression , passing the argument
ref, Object.class for the expectedType,
and null, for the fnMapper.

 public Object evaluateExpressionGet(FacesContext context,
    String expression,
    Class expectedType) throws ELException 
{
        Application app = getRIApplicationImpl(context);
        if (app != null) {
            //noinspection TailRecursion
            return app.evaluateExpressionGet(context, expression, expectedType);
        }
        throw new UnsupportedOperationException();
}

Get a value by evaluating an expression.

Call #getExpressionFactory then call ExpressionFactory#createValueExpression passing the argument expression and expectedType. Call FacesContext#getELContext and pass it to ValueExpression#getValue , returning the result.

An implementation is provided that throws UnsupportedOperationException so that users that decorate the Application continue to work.

 abstract public ActionListener getActionListener()
Return the default ActionListener  to be registered for
all javax.faces.component.ActionSource  components in this
appication. If not explicitly set, a default implementation must
be provided that performs the

following functions:

The processAction() method must first call
FacesContext.renderResponse() in order to bypass
any intervening lifecycle phases, once the method returns.
The processAction() method must next determine
the logical outcome of this event, as follows:

If the originating component has a non-null
action property, retrieve the MethodBinding  from the property, and call
invoke() on it. Convert the returned value (if
any) to a String, and use it as the logical outcome.

Otherwise, the logical outcome is null.


The processAction() method must finally retrieve
the NavigationHandler instance for this
application and call NavigationHandler#handleNavigation  passing:



the FacesContext  for the current request

If there is a MethodBinding instance for the
action property of this component, the result of
calling MethodBinding#getExpressionString  on it, null
otherwise

the logical outcome as determined above






Note that the specification for the default
ActionListener contiues to call for the use of a
deprecated property (action) and
class (MethodBinding). Unfortunately, this is
necessary because the default ActionListener must
continue to work with components that do not implement javax.faces.component.ActionSource2 , and only implement javax.faces.component.ActionSource .

 abstract public Iterator getComponentTypes()
Return an Iterator over the set of currently defined
component types for this Application.

 abstract public Iterator getConverterIds()
Return an Iterator over the set of currently registered
converter ids for this Application.

 abstract public Iterator getConverterTypes()
Return an Iterator over the set of Class
instances for which Converter  classes have been explicitly
registered.

 abstract public Locale getDefaultLocale()
Return the default Locale for this application. If
not explicitly set, null is returned.

 abstract public String getDefaultRenderKitId()
Return the renderKitId to be used for rendering
this application. If not explicitly set, null is
returned.

 public ELContextListener[] getELContextListeners() 
{
        Application app = getRIApplicationImpl();
        if (app != null) {
            //noinspection TailRecursion
            return app.getELContextListeners();
        } else {
            throw new UnsupportedOperationException();
        }
}

If no calls have been made to #addELContextListener , this method must return an empty array.

Otherwise, return an array representing the list of listeners added by calls to #addELContextListener .

An implementation is provided that throws UnsupportedOperationException so that users that decorate the Application continue to work.

 public ELResolver getELResolver() 
{
        Application app = getRIApplicationImpl();
        if (app != null) {
            //noinspection TailRecursion
            return app.getELResolver();
        }
        throw new UnsupportedOperationException();
}

Return the singleton ELResolver instance to be used for all EL resolution. This is actually an instance of javax.el.CompositeELResolver that must contain the following ELResolver instances in the following order:

1. ELResolver instances declared using the <el-resolver> element in the application configuration resources.

2. An implementation that wraps the head of the legacy VariableResolver chain, as per section VariableResolver ChainWrapper in Chapter 5 in the spec document.

3. An implementation that wraps the head of the legacy PropertyResolver chain, as per section PropertyResolver ChainWrapper in Chapter 5 in the spec document.

4. Any ELResolver instances added by calls to #addELResolver .

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend Application .

 public ExpressionFactory getExpressionFactory() 
{
        Application app = getRIApplicationImpl();
        if (app != null) {
            //noinspection TailRecursion
            return app.getExpressionFactory();
        }
        throw new UnsupportedOperationException();
}

Return the ExpressionFactory instance for this application. This instance is used by the convenience method #evaluateExpressionGet .

The implementation must return the ExpressionFactory from the JSP container by calling JspFactory.getDefaultFactory().getJspApplicationContext(servletContext).getExpressionFactory().

An implementation is provided that throws UnsupportedOperationException so that users that decorate the Application continue to work.

 abstract public String getMessageBundle()
Return the fully qualified class name of the
ResourceBundle to be used for JavaServer Faces messages
for this application. If not explicitly set, null
is returned.

 abstract public NavigationHandler getNavigationHandler()
Return the NavigationHandler  instance that will be passed
the outcome returned by any invoked application action for this
web application. If not explicitly set, a default implementation
must be provided that performs the functions described in the
NavigationHandler  class description.

 abstract public PropertyResolver getPropertyResolver()Deprecated! This -  has been replaced by #getELResolver .

Return a PropertyResolver  instance that wraps the
ELResolver  instance that Faces provides to the unified EL
for the resolution of expressions that appear programmatically in
an application.

Note that this no longer returns the default
PropertyResolver since that class is now a no-op
that aids in allowing custom PropertyResolvers to
affect the EL resolution process.

 public ResourceBundle getResourceBundle(FacesContext ctx,
    String name) 
{
        Application app = getRIApplicationImpl(ctx);
        if (app != null) {
            //noinspection TailRecursion
            return app.getResourceBundle(ctx, name);
        }
        throw new UnsupportedOperationException();
}

Find a ResourceBundle as defined in the application configuration resources under the specified name. If a ResourceBundle was defined for the name, return an instance that uses the locale of the current javax.faces.component.UIViewRoot .

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 abstract public StateManager getStateManager()
Return the StateManager  instance that will be utilized
during the Restore View and Render Response
phases of the request processing lifecycle. If not explicitly set,
a default implementation must be provided that performs the functions
described in the StateManager  description
in the JavaServer Faces Specification.

 abstract public Iterator getSupportedLocales()
Return an Iterator over the supported
Locales for this appication.

 abstract public Iterator getValidatorIds()
Return an Iterator over the set of currently registered
validator ids for this Application.

 abstract public VariableResolver getVariableResolver()Deprecated! This -  has been replaced by #getELResolver .

Return the VariableResolver  that wraps the ELResolver  instance that Faces provides to the unified EL for
the resolution of expressions that appear programmatically in an
application. The implementation of the
VariableResolvermust pass null as the
base argument for any methods invoked on the underlying
ELResolver.

Note that this method no longer returns the default
VariableResolver, since that class now is a no-op
that aids in allowing custom VariableResolvers to
affect the EL resolution process.

 abstract public ViewHandler getViewHandler()
Return the ViewHandler  instance that will be utilized
during the Restore View and Render Response
phases of the request processing lifecycle. If not explicitly set,
a default implementation must be provided that performs the functions
described in the ViewHandler  description in the
JavaServer Faces Specification.

 public  void removeELContextListener(ELContextListener listener) 
{
        Application app = getRIApplicationImpl();
        if (app != null) {
            app.removeELContextListener(listener);
        } else {
            throw new UnsupportedOperationException();
        }
}

Remove the argument listener from the list of ELContextListener s. If listener is null, no exception is thrown and no action is performed. If listener is not in the list, no exception is thrown and no action is performed.

An implementation is provided that throws UnsupportedOperationException so that users that decorate the Application continue to work.

 abstract public  void setActionListener(ActionListener listener)
Set the default ActionListener  to be registered for all
javax.faces.component.ActionSource  components.

 abstract public  void setDefaultLocale(Locale locale)
Set the default Locale for this application.

 abstract public  void setDefaultRenderKitId(String renderKitId)
Set the renderKitId to be used to render this
application. Unless the client has provided a custom ViewHandler 
that supports the use of multiple javax.faces.render.RenderKit 
instances in the same application, this method must only be called at
application startup, before any Faces requests have been processed.
This is a limitation of the current Specification, and may be lifted in
a future release.

 abstract public  void setMessageBundle(String bundle)
Set the fully qualified class name of the ResourceBundle
to be used for JavaServer Faces messages for this application. See the
JavaDocs for the java.util.ResourceBundle class for more
information about the syntax for resource bundle names.

 abstract public  void setNavigationHandler(NavigationHandler handler)
Set the NavigationHandler  instance that will be passed
the outcome returned by any invoked application action for this
web application.

 abstract public  void setPropertyResolver(PropertyResolver resolver)Deprecated! The -  recommended way to affect the execution of the EL
is to provide an <el-resolver> element at the
right place in the application configuration resources which will
be considered in the normal course of expression evaluation.
This method now will cause the argument resolver to
be wrapped inside an implementation of ELResolver  and
exposed to the EL resolution system as if the user had called
#addELResolver .

Set the PropertyResolver  instance that will be utilized
to resolve method and value bindings.

This method is now deprecated but the implementation must
cause the argument to be set as the head of the legacy
PropertyResolver chain, replacing any existing value
that was set from the application configuration resources.

It is illegal to call this method after
the application has received any requests from the client. If an
attempt is made to register a listener after that time it must have
no effect. 

 abstract public  void setStateManager(StateManager manager)
Set the StateManager  instance that will be utilized
during the Restore View and Render Response
phases of the request processing lifecycle.

 abstract public  void setSupportedLocales(Collection locales)
Set the Locale instances representing the supported
Locales for this application.

 abstract public  void setVariableResolver(VariableResolver resolver)Deprecated! The -  recommended way to affect the execution of the EL
is to provide an <el-resolver> element at the

right place in the application configuration resources which will
be considered in the normal course of expression evaluation.
This method now will cause the argument resolver to
be wrapped inside an implementation of ELResolver  and
exposed to the EL resolution system as if the user had called
#addELResolver .

Set the VariableResolver  instance that will be consulted
to resolve method and value bindings.

This method is now deprecated but the implementation must
cause the argument to be set as the head of the legacy
VariableResolver chain, replacing any existing value
that was set from the application configuration resources.

It is illegal to call this method after
the application has received any requests from the client. If an
attempt is made to register a listener after that time it must have
no effect.

 abstract public  void setViewHandler(ViewHandler handler)
Set the ViewHandler  instance that will be utilized
during the Restore View and Render Response
phases of the request processing lifecycle.