| Method from com.sun.faces.application.ApplicationImpl Detail: |
|---|
 public void addComponent(String componentType,
String componentClass) {
if (componentType == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "componentType");
throw new NullPointerException(message);
}
if (componentClass == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "componentClass");
throw new NullPointerException(message);
}
componentMap.put(componentType, componentClass);
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("added component of type ''{0}'' and class ''{1}''",
componentType,
componentClass));
}
}
|
public void addConverter(String converterId,
String converterClass) {
if (converterId == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "converterId");
throw new NullPointerException(message);
}
if (converterClass == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "converterClass");
throw new NullPointerException(message);
}
converterIdMap.put(converterId, converterClass);
Class< ? >[] types = STANDARD_CONV_ID_TO_TYPE_MAP.get(converterId);
if (types != null) {
for (Class< ? > clazz : types) {
// go directly against map to prevent cyclic method calls
converterTypeMap.put(clazz, converterClass);
addPropertyEditorIfNecessary(clazz);
}
}
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("added converter of type ''{0}'' and class ''{1}''",
converterId,
converterClass));
}
} |
public void addConverter(Class targetClass,
String converterClass) {
if (targetClass == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "targetClass");
throw new NullPointerException(message);
}
if (converterClass == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "converterClass");
throw new NullPointerException(message);
}
String converterId = STANDARD_TYPE_TO_CONV_ID_MAP.get(targetClass);
if (converterId != null) {
addConverter(converterId, converterClass);
} else {
converterTypeMap.put(targetClass, converterClass);
addPropertyEditorIfNecessary(targetClass);
}
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("added converter of class type ''{0}''", converterClass));
}
} |
public void addELContextListener(ELContextListener listener) {
if (listener != null) {
if (elContextListeners == null) {
//noinspection CollectionWithoutInitialCapacity
elContextListeners = new ArrayList< ELContextListener >();
}
elContextListeners.add(listener);
}
} |
public void addELResolver(ELResolver resolver) {
if (associate.hasRequestBeenServiced()) {
throw new IllegalStateException(
MessageUtils.getExceptionMessageString(
MessageUtils.APPLICATION_INIT_COMPLETE_ERROR_ID));
}
if (elResolvers == null) {
//noinspection CollectionWithoutInitialCapacity
elResolvers = new ArrayList< ELResolver >();
}
elResolvers.add(resolver);
} |
public void addValidator(String validatorId,
String validatorClass) {
if (validatorId == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "validatorId");
throw new NullPointerException(message);
}
if (validatorClass == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "validatorClass");
throw new NullPointerException(message);
}
validatorMap.put(validatorId, validatorClass);
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("added validator of type ''{0}'' class ''{1}''",
validatorId,
validatorClass));
}
} |
public UIComponent createComponent(String componentType) throws FacesException {
if (componentType == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "componentType");
throw new NullPointerException(message);
}
UIComponent returnVal;
try {
returnVal = (UIComponent) newThing(componentType, componentMap);
} catch (Exception ex) {
if (logger.isLoggable(Level.WARNING)) {
logger.log(Level.WARNING,
"jsf.cannot_instantiate_component_error", componentType);
}
throw new FacesException(ex);
}
if (returnVal == null) {
Object[] params = {componentType};
if (logger.isLoggable(Level.SEVERE)) {
logger.log(Level.SEVERE,
"jsf.cannot_instantiate_component_error", params);
}
throw new FacesException(MessageUtils.getExceptionMessageString(
MessageUtils.NAMED_OBJECT_NOT_FOUND_ERROR_MESSAGE_ID, params));
}
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE, MessageFormat.format("Created component with component type of ''{0}''",
componentType));
}
return returnVal;
} |
public UIComponent createComponent(ValueExpression componentExpression,
FacesContext context,
String componentType) throws FacesException {
if (null == componentExpression) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "componentExpression");
throw new NullPointerException(message);
}
if (null == context) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "context");
throw new NullPointerException(message);
}
if (null == componentType) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "componentType");
throw new NullPointerException(message);
}
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 (Exception ex) {
throw new FacesException(ex);
}
return (UIComponent) result;
} |
public UIComponent createComponent(ValueBinding componentBinding,
FacesContext context,
String componentType) throws FacesException {
if (null == componentBinding) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "componentBinding");
throw new NullPointerException(message);
}
if (null == context) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "context");
throw new NullPointerException(message);
}
if (null == componentType) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "componentType");
throw new NullPointerException(message);
}
Object result;
boolean createOne = false;
try {
if (null != (result = componentBinding.getValue(context))) {
// 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);
componentBinding.setValue(context, result);
}
} catch (Exception ex) {
throw new FacesException(ex);
}
return (UIComponent) result;
} |
public Converter createConverter(String converterId) {
if (converterId == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "convertedId");
throw new NullPointerException(message);
}
Converter returnVal = (Converter) newThing(converterId, converterIdMap);
if (returnVal == null) {
Object[] params = {converterId};
if (logger.isLoggable(Level.SEVERE)) {
logger.log(Level.SEVERE,
"jsf.cannot_instantiate_converter_error", converterId);
}
throw new FacesException(MessageUtils.getExceptionMessageString(
MessageUtils.NAMED_OBJECT_NOT_FOUND_ERROR_MESSAGE_ID, params));
}
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("created converter of type ''{0}''", converterId));
}
return returnVal;
} |
public Converter createConverter(Class targetClass) {
if (targetClass == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "targetClass");
throw new NullPointerException(message);
}
Converter returnVal = (Converter) newConverter(targetClass,
converterTypeMap,targetClass);
if (returnVal != null) {
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("Created converter of type ''{0}''",
returnVal.getClass().getName()));
}
return returnVal;
}
//Search for converters registered to interfaces implemented by
//targetClass
Class[] interfaces = targetClass.getInterfaces();
if (interfaces != null) {
for (int i = 0; i < interfaces.length; i++) {
returnVal = createConverterBasedOnClass(interfaces[i], targetClass);
if (returnVal != null) {
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("Created converter of type ''{0}''",
returnVal.getClass().getName()));
}
return returnVal;
}
}
}
//Search for converters registered to superclasses of targetClass
Class superclass = targetClass.getSuperclass();
if (superclass != null) {
returnVal = createConverterBasedOnClass(superclass, targetClass);
if (returnVal != null) {
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("Created converter of type ''{0}''",
returnVal.getClass().getName()));
}
return returnVal;
}
}
return returnVal;
} |
protected Converter createConverterBasedOnClass(Class targetClass,
Class baseClass) {
Converter returnVal = (Converter) newConverter(targetClass,
converterTypeMap, baseClass);
if (returnVal != null) {
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("Created converter of type ''{0}''",
returnVal.getClass().getName()));
}
return returnVal;
}
//Search for converters registered to interfaces implemented by
//targetClass
Class[] interfaces = targetClass.getInterfaces();
if (interfaces != null) {
for (int i = 0; i < interfaces.length; i++) {
returnVal = createConverterBasedOnClass(interfaces[i], null);
if (returnVal != null) {
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("Created converter of type ''{0}''",
returnVal.getClass().getName()));
}
return returnVal;
}
}
}
//Search for converters registered to superclasses of targetClass
Class superclass = targetClass.getSuperclass();
if (superclass != null) {
returnVal = createConverterBasedOnClass(superclass, null);
if (returnVal != null) {
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("Created converter of type ''{0}''",
returnVal.getClass().getName()));
}
return returnVal;
}
}
return returnVal;
} |
public MethodBinding createMethodBinding(String ref,
Class[] params) {
MethodExpression result;
if (ref == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "ref");
throw new NullPointerException(message);
}
if (!(ref.startsWith("#{") && ref.endsWith("}"))) {
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("Expression ''{0}'' does not follow the syntax #{...}", ref));
}
throw new ReferenceSyntaxException(ref);
}
FacesContext context = FacesContext.getCurrentInstance();
try {
// return a MethodBinding that wraps a MethodExpression.
if (null == params) {
params = RIConstants.EMPTY_CLASS_ARGS;
}
result =
getExpressionFactory().
createMethodExpression(context.getELContext(), ref, null,
params);
} catch (ELException elex) {
throw new ReferenceSyntaxException(elex);
}
return (new MethodBindingMethodExpressionAdapter(result));
} |
public Validator createValidator(String validatorId) throws FacesException {
if (validatorId == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "validatorId");
throw new NullPointerException(message);
}
Validator returnVal = (Validator) newThing(validatorId, validatorMap);
if (returnVal == null) {
Object[] params = {validatorId};
if (logger.isLoggable(Level.SEVERE)) {
logger.log(Level.SEVERE,
"jsf.cannot_instantiate_validator_error", params);
}
throw new FacesException(MessageUtils.getExceptionMessageString(
MessageUtils.NAMED_OBJECT_NOT_FOUND_ERROR_MESSAGE_ID, params));
}
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("created validator of type ''{0}''",
validatorId));
}
return returnVal;
} |
public ValueBinding createValueBinding(String ref) throws ReferenceSyntaxException {
if (ref == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "ref");
throw new NullPointerException(message);
}
ValueExpression result;
FacesContext context = FacesContext.getCurrentInstance();
// return a ValueBinding that wraps a ValueExpression.
try {
result= getExpressionFactory().
createValueExpression(context.getELContext(),ref,
Object.class);
} catch (ELException elex) {
throw new ReferenceSyntaxException(elex);
}
return (new ValueBindingValueExpressionAdapter(result));
} |
public Object evaluateExpressionGet(FacesContext context,
String expression,
Class expectedType) throws ELException {
ValueExpression ve =
getExpressionFactory().createValueExpression(context.getELContext(),
expression,expectedType);
return (ve.getValue(context.getELContext()));
} |
public ActionListener getActionListener() {
return actionListener;
} |
public List getApplicationELResolvers() {
return elResolvers;
} |
public Iterator getComponentTypes() {
return componentMap.keySet().iterator();
} |
public Iterator getConverterIds() {
return converterIdMap.keySet().iterator();
} |
public Iterator getConverterTypes() {
return converterTypeMap.keySet().iterator();
} |
public Locale getDefaultLocale() {
return defaultLocale;
} |
public String getDefaultRenderKitId() {
return defaultRenderKitId;
} |
public ELContextListener[] getELContextListeners() {
if (elContextListeners != null ) {
return (elContextListeners.toArray(
new ELContextListener[elContextListeners.size()]));
} else {
return (EMPTY_EL_CTX_LIST_ARRAY);
}
} |
public ELResolver getELResolver() {
if (compositeELResolver == null) {
compositeELResolver =
new FacesCompositeELResolver(
FacesCompositeELResolver.ELResolverChainType.Faces);
ELUtils.buildFacesResolver(compositeELResolver, associate);
}
return compositeELResolver;
} |
public ExpressionFactory getExpressionFactory() {
return associate.getExpressionFactory();
} |
public String getMessageBundle() {
return messageBundle;
} |
public NavigationHandler getNavigationHandler() {
return navigationHandler;
} Return the NavigationHandler instance
installed present in this application instance. If
an instance does not exist, it will be created. |
public PropertyResolver getPropertyResolver() {
return propertyResolver;
} |
public ResourceBundle getResourceBundle(FacesContext context,
String var) {
if (null == context || null == var) {
throw new FacesException("context or var is null.");
}
return associate.getResourceBundle(context, var);
} |
public StateManager getStateManager() {
return stateManager;
} |
public Iterator getSupportedLocales() {
if (null != supportedLocales) {
return supportedLocales.iterator();
} else {
return Collections.< Locale >emptyList().iterator();
}
} |
public Iterator getValidatorIds() {
return validatorMap.keySet().iterator();
} |
public VariableResolver getVariableResolver() {
return variableResolver;
} |
public ViewHandler getViewHandler() {
return viewHandler;
} |
protected Object newConverter(Class key,
Map map,
Class targetClass) {
assert (key != null && map != null);
Object result = null;
Class clazz = null;
Object value;
value = map.get(key);
if (value == null) {
return null;
}
assert (value instanceof String || value instanceof Class);
if (value instanceof String) {
String cValue = (String) value;
try {
clazz = Util.loadClass(cValue, value);
if (!associate.isDevModeEnabled()) {
map.put(key, clazz);
}
assert (clazz != null);
} catch (Throwable t) {
throw new FacesException(t.getMessage(), t);
}
} else {
clazz = (Class) value;
}
Constructor ctor =
ReflectionUtils.lookupConstructor(clazz, Class.class);
Throwable cause = null;
if (ctor != null) {
try {
result = ctor.newInstance(targetClass);
} catch (Exception e) {
cause = e;
}
} else {
try {
result = clazz.newInstance();
} catch (Exception e) {
cause = e;
}
}
if (null != cause) {
throw new FacesException((MessageUtils.getExceptionMessageString(
MessageUtils.CANT_INSTANTIATE_CLASS_ERROR_MESSAGE_ID,
clazz.getName())), cause);
}
return result;
} The same as newThing except that a single argument constructor
that accepts a Class is looked for before calling the no-arg version.
PRECONDITIONS: the values in the Map are either Strings
representing fully qualified java class names, or java.lang.Class
instances.
ALGORITHM: Look in the argument map for a value for the argument
key. If found, if the value is instanceof String, assume the String
specifies a fully qualified java class name and obtain the
java.lang.Class instance for that String using Util.loadClass().
Replace the String instance in the argument map with the Class
instance. If the value is instanceof Class, proceed. Assert that the
value is either instanceof java.lang.Class or java.lang.String.
Now that you have a java.lang.class, call its newInstance and
return it as the result of this method.
|
protected Object newThing(String key,
Map map) {
assert (key != null && map != null);
Object result;
Class clazz = null;
Object value;
value = map.get(key);
if (value == null) {
return null;
}
assert (value instanceof String || value instanceof Class);
if (value instanceof String) {
String cValue = (String) value;
try {
clazz = Util.loadClass(cValue, value);
if (!associate.isDevModeEnabled()) {
map.put(key, clazz);
}
assert (clazz != null);
} catch (Throwable t) {
throw new FacesException(t.getMessage(), t);
}
} else {
clazz = (Class) value;
}
try {
result = clazz.newInstance();
} catch (Throwable t) {
throw new FacesException((MessageUtils.getExceptionMessageString(
MessageUtils.CANT_INSTANTIATE_CLASS_ERROR_MESSAGE_ID,
clazz.getName())), t);
}
return result;
} PRECONDITIONS: the values in the Map are either Strings
representing fully qualified java class names, or java.lang.Class
instances.
ALGORITHM: Look in the argument map for a value for the argument
key. If found, if the value is instanceof String, assume the String
specifies a fully qualified java class name and obtain the
java.lang.Class instance for that String using Util.loadClass().
Replace the String instance in the argument map with the Class
instance. If the value is instanceof Class, proceed. Assert that the
value is either instanceof java.lang.Class or java.lang.String.
Now that you have a java.lang.class, call its newInstance and
return it as the result of this method.
|
public void removeELContextListener(ELContextListener listener) {
if (listener != null && elContextListeners != null) {
elContextListeners.remove(listener);
}
} |
public synchronized void setActionListener(ActionListener listener) {
if (listener == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "listener");
throw new NullPointerException(message);
}
this.actionListener = listener;
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("set ActionListener Instance to ''{0}''",
actionListener.getClass().getName()));
}
} |
public synchronized void setDefaultLocale(Locale locale) {
if (locale == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "locale");
throw new NullPointerException(message);
}
defaultLocale = locale;
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE, (MessageFormat.format("set defaultLocale ''{0}''",
defaultLocale.getClass().getName())));
}
} |
public void setDefaultRenderKitId(String renderKitId) {
defaultRenderKitId = renderKitId;
} |
public synchronized void setMessageBundle(String messageBundle) {
this.messageBundle = messageBundle;
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE, MessageFormat.format("set messageBundle ''{0}''",
messageBundle));
}
} |
public synchronized void setNavigationHandler(NavigationHandler handler) {
if (handler == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "handler");
throw new NullPointerException(message);
}
this.navigationHandler = handler;
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("set NavigationHandler Instance to ''{0}''",
navigationHandler.getClass().getName()));
}
} Set a NavigationHandler instance for this
application instance. |
public void setPropertyResolver(PropertyResolver resolver) {
// Throw Illegal State Exception if a PropertyResolver is set after
// a request has been processed.
if (associate.hasRequestBeenServiced()) {
throw new IllegalStateException(
MessageUtils.getExceptionMessageString(
MessageUtils.APPLICATION_INIT_COMPLETE_ERROR_ID));
}
if (resolver == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "resolver");
throw new NullPointerException(message);
}
propertyResolver.setDelegate(ELUtils.getDelegatePR(associate, true));
associate.setLegacyPropertyResolver(resolver);
propertyResolver = new PropertyResolverImpl();
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("set PropertyResolver Instance to ''{0}''", resolver.getClass().getName()));
}
} |
public synchronized void setStateManager(StateManager manager) {
if (manager == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "manager");
throw new NullPointerException(message);
}
if (associate.isResponseRendered()) {
// at least one response has been rendered.
if (logger.isLoggable(Level.SEVERE)) {
logger.log(Level.SEVERE,
"jsf.illegal_attempt_setting_statemanager_error");
}
throw new IllegalStateException(MessageUtils.getExceptionMessageString(
MessageUtils.ILLEGAL_ATTEMPT_SETTING_STATEMANAGER_ID));
}
stateManager = manager;
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE, MessageFormat.format("set StateManager Instance to ''{0}''",
stateManager.getClass().getName()));
}
} |
public synchronized void setSupportedLocales(Collection newLocales) {
if (null == newLocales) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "newLocales");
throw new NullPointerException(message);
}
supportedLocales = new ArrayList< Locale >(newLocales);
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE, MessageFormat.format("set Supported Locales ''{0}''",
supportedLocales.toString()));
}
} |
public void setVariableResolver(VariableResolver resolver) {
// Throw Illegal State Exception if a PropertyResolver is set after
// a request has been processed.
if (associate.hasRequestBeenServiced()) {
throw new IllegalStateException(
MessageUtils.getExceptionMessageString(
MessageUtils.APPLICATION_INIT_COMPLETE_ERROR_ID));
}
if (resolver == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "resolver");
throw new NullPointerException(message);
}
variableResolver.setDelegate(ELUtils.getDelegateVR(associate, true));
associate.setLegacyVariableResolver(resolver);
variableResolver = new VariableResolverImpl();
if (logger.isLoggable(Level.FINE)) {
logger.fine(MessageFormat.format("set VariableResolver Instance to ''{0}''",
variableResolver.getClass().getName()));
}
} |
public synchronized void setViewHandler(ViewHandler handler) {
if (handler == null) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "handler");
throw new NullPointerException(message);
}
if (associate.isResponseRendered()) {
// at least one response has been rendered.
if (logger.isLoggable(Level.SEVERE)) {
logger.log(Level.SEVERE,
"jsf.illegal_attempt_setting_viewhandler_error");
}
throw new IllegalStateException(MessageUtils.getExceptionMessageString(
MessageUtils.ILLEGAL_ATTEMPT_SETTING_VIEWHANDLER_ID));
}
viewHandler = handler;
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE, MessageFormat.format("set ViewHandler Instance to ''{0}''", viewHandler.getClass().getName()));
}
} |
javax.faces.application.Application
Save This Page