/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.myfaces.config.impl.digester;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.faces.render.RenderKitFactory;
import org.apache.myfaces.config.FacesConfigDispenser;
import org.apache.myfaces.config.element.Behavior;
import org.apache.myfaces.config.element.ClientBehaviorRenderer;
import org.apache.myfaces.config.element.FaceletsProcessing;
import org.apache.myfaces.config.element.FacesConfigExtension;
import org.apache.myfaces.config.element.ManagedBean;
import org.apache.myfaces.config.element.NavigationRule;
import org.apache.myfaces.config.element.Renderer;
import org.apache.myfaces.config.element.Application;
import org.apache.myfaces.config.element.ComponentTagDeclaration;
import org.apache.myfaces.config.element.ContractMapping;
import org.apache.myfaces.config.element.Converter;
import org.apache.myfaces.config.element.FacesConfig;
import org.apache.myfaces.config.element.FacesFlowDefinition;
import org.apache.myfaces.config.element.Factory;
import org.apache.myfaces.config.element.LocaleConfig;
import org.apache.myfaces.config.element.NamedEvent;
import org.apache.myfaces.config.element.RenderKit;
import org.apache.myfaces.config.element.ResourceBundle;
import org.apache.myfaces.config.element.SystemEventListener;
import org.apache.myfaces.config.element.ViewPoolMapping;
import org.apache.myfaces.config.element.facelets.FaceletTagLibrary;
import org.apache.myfaces.config.impl.digester.elements.RenderKitImpl;
/**
* @author <a href="mailto:oliver@rossmueller.com">Oliver Rossmueller</a>
*/
public class DigesterFacesConfigDispenserImpl extends FacesConfigDispenser
{
/**
*
*/
private static final long serialVersionUID = 3550379003287939559L;
// Factories
private List<String> applicationFactories = new ArrayList<String>();
private List<String> exceptionHandlerFactories = new ArrayList<String>();
private List<String> externalContextFactories = new ArrayList<String>();
private List<String> facesContextFactories = new ArrayList<String>();
private List<String> lifecycleFactories = new ArrayList<String>();
private List<String> viewDeclarationLanguageFactories = new ArrayList<String>();
private List<String> partialViewContextFactories = new ArrayList<String>();
private List<String> renderKitFactories = new ArrayList<String>();
private List<String> tagHandlerDelegateFactories = new ArrayList<String>();
private List<String> visitContextFactories = new ArrayList<String>();
private List<String> faceletCacheFactories = new ArrayList<String>();
private List<String> flashFactories = new ArrayList<String>();
private List<String> clientWindowFactories = new ArrayList<String>();
private List<String> flowHandlerFactories = new ArrayList<String>();
private String defaultRenderKitId;
private String messageBundle;
private String partialTraversal;
private String facesVersion;
private LocaleConfig localeConfig;
private Map<String, String> components = new HashMap<String, String>();
private Map<String, String> converterByClass = new HashMap<String, String>();
private Map<String, String> converterById = new HashMap<String, String>();
private Map<String, String> validators = new HashMap<String, String>();
private List<Behavior> behaviors = new ArrayList<Behavior>();
private Map<String, Converter> converterConfigurationByClassName = new HashMap<String, Converter>();
private Map<String, RenderKit> renderKits
= new LinkedHashMap<String, RenderKit>();
private List<String> actionListeners = new ArrayList<String>();
private List<String> elResolvers = new ArrayList<String>();
private List<String> lifecyclePhaseListeners = new ArrayList<String>();
private List<String> navigationHandlers = new ArrayList<String>();
private List<String> propertyResolver = new ArrayList<String>();
private List<String> resourceHandlers = new ArrayList<String>();
private List<String> stateManagers = new ArrayList<String>();
private List<String> variableResolver = new ArrayList<String>();
private List<String> viewHandlers = new ArrayList<String>();
private List<String> defaultValidatorIds = new ArrayList<String>();
private List<String> defaultAnnotatedValidatorIds = new ArrayList<String>();
private List<ManagedBean> managedBeans = new ArrayList<ManagedBean>();
private List<NavigationRule> navigationRules = new ArrayList<NavigationRule>();
private List<ResourceBundle> resourceBundles = new ArrayList<ResourceBundle>();
private List<SystemEventListener> systemEventListeners = new ArrayList<SystemEventListener>();
private List<NamedEvent> namedEvents = new ArrayList<NamedEvent>();
private Map<String, FaceletsProcessing> faceletsProcessingByFileExtension
= new HashMap<String, FaceletsProcessing>();
private List<FacesFlowDefinition> facesFlowDefinitions = new ArrayList<FacesFlowDefinition>();
private List<String> protectedViewUrlPatterns = new ArrayList<String>();
private List<ContractMapping> resourceLibraryContractMappings = new ArrayList<ContractMapping>();
private List<ComponentTagDeclaration> componentTagDeclarations = new ArrayList<ComponentTagDeclaration>();
private List<FaceletTagLibrary> faceletTagLibraries = new ArrayList<FaceletTagLibrary>();
private List <String> resourceResolvers = new ArrayList<String>();
private List<ViewPoolMapping> viewPoolMappings = new ArrayList<ViewPoolMapping>();
// Unmodifiable list/maps to avoid modifications
private transient List<String> umapplicationFactories;
private transient List<String> umexceptionHandlerFactories;
private transient List<String> umexternalContextFactories;
private transient List<String> umfacesContextFactories;
private transient List<String> umlifecycleFactories;
private transient List<String> umviewDeclarationLanguageFactories;
private transient List<String> umpartialViewContextFactories;
private transient List<String> umrenderKitFactories;
private transient List<String> umtagHandlerDelegateFactories;
private transient List<String> umvisitContextFactories;
private transient List<String> umfaceletCacheFactories;
private transient List<String> umflashFactories;
private transient List<String> umclientWindowFactories;
private transient List<String> umflowHandlerFactories;
private transient List<Behavior> umbehaviors;
private transient List<String> umactionListeners;
private transient List<String> umelResolvers;
private transient List<String> umlifecyclePhaseListeners;
private transient List<String> umnavigationHandlers;
private transient List<String> umpropertyResolver;
private transient List<String> umresourceHandlers;
private transient List<String> umstateManagers;
private transient List<String> umvariableResolver;
private transient List<String> umviewHandlers;
private transient List<ManagedBean> ummanagedBeans;
private transient List<NavigationRule> umnavigationRules;
private transient List<ResourceBundle> umresourceBundles;
private transient List<SystemEventListener> umsystemEventListeners;
private transient List<NamedEvent> umnamedEvents;
private transient List<FacesFlowDefinition> umfacesFlowDefinitions;
private transient List<String> umprotectedViewUrlPatterns;
private transient List<ContractMapping> umresourceLibraryContractMappings;
private transient List<ComponentTagDeclaration> umcomponentTagDeclarations;
private transient List<FaceletTagLibrary> umfaceletTagLibraries;
private transient List <String> umresourceResolvers;
private transient List<ViewPoolMapping> umviewPoolMappings;
/**
* Add another unmarshalled faces config object.
*
* @param config
* unmarshalled faces config object
*/
public void feed(FacesConfig config)
{
for (Factory factory : config.getFactories())
{
applicationFactories.addAll(factory.getApplicationFactory());
exceptionHandlerFactories.addAll(factory.getExceptionHandlerFactory());
externalContextFactories.addAll(factory.getExternalContextFactory());
facesContextFactories.addAll(factory.getFacesContextFactory());
lifecycleFactories.addAll(factory.getLifecycleFactory());
viewDeclarationLanguageFactories.addAll(factory.getViewDeclarationLanguageFactory());
partialViewContextFactories.addAll(factory.getPartialViewContextFactory());
renderKitFactories.addAll(factory.getRenderkitFactory());
tagHandlerDelegateFactories.addAll(factory.getTagHandlerDelegateFactory());
visitContextFactories.addAll(factory.getVisitContextFactory());
faceletCacheFactories.addAll(factory.getFaceletCacheFactory());
flashFactories.addAll(factory.getFlashFactory());
clientWindowFactories.addAll(factory.getClientWindowFactory());
flowHandlerFactories.addAll(factory.getFlowHandlerFactory());
}
components.putAll(config.getComponents());
validators.putAll(config.getValidators());
behaviors.addAll (config.getBehaviors());
for (Application application : config.getApplications())
{
if (!application.getDefaultRenderkitId().isEmpty())
{
defaultRenderKitId =
application.getDefaultRenderkitId().get(application.getDefaultRenderkitId().size() - 1);
}
if (!application.getMessageBundle().isEmpty())
{
messageBundle = application.getMessageBundle().get(application.getMessageBundle().size() - 1);
}
if (!application.getLocaleConfig().isEmpty())
{
localeConfig = application.getLocaleConfig().get(application.getLocaleConfig().size() - 1);
}
if (!application.getPartialTraversal().isEmpty())
{
partialTraversal = application.getPartialTraversal().get (application.getPartialTraversal().size() - 1);
}
actionListeners.addAll(application.getActionListener());
navigationHandlers.addAll(application.getNavigationHandler());
resourceHandlers.addAll(application.getResourceHandler());
viewHandlers.addAll(application.getViewHandler());
stateManagers.addAll(application.getStateManager());
propertyResolver.addAll(application.getPropertyResolver());
variableResolver.addAll(application.getVariableResolver());
resourceBundles.addAll(application.getResourceBundle());
elResolvers.addAll(application.getElResolver());
resourceLibraryContractMappings.addAll(application.getResourceLibraryContractMappings());
// Jsf 2.0 spec section 3.5.3 says this:
// ".... Any configuration resource that declares a list of default
// validators overrides any list provided in a previously processed
// configuration resource. If an empty <default-validators/> element
// is found in a configuration resource, the list
// of default validators must be cleared....."
if (application.isDefaultValidatorsPresent())
{
// we have a <default-validators> element, so any existing
// default validators should be removed
defaultValidatorIds.clear();
// now add all default-validator entries (could be zero)
defaultValidatorIds.addAll(application.getDefaultValidatorIds());
}
else
{
//If isDefaultValidatorsPresent() is false, and there are still
//default validators, it means they were added using annotations, so
//they are not affected by the empty entry according to section 3.5.3
defaultAnnotatedValidatorIds.addAll(application.getDefaultValidatorIds());
}
systemEventListeners.addAll(application.getSystemEventListeners());
}
for (Converter converter : config.getConverters())
{
if (converter.getConverterId() != null)
{
converterById.put(converter.getConverterId(),converter
.getConverterClass());
}
if (converter.getForClass() != null)
{
converterByClass.put(converter.getForClass(),converter
.getConverterClass());
}
converterConfigurationByClassName.put(converter.getConverterClass(), converter);
}
for (RenderKit renderKit : config.getRenderKits())
{
String renderKitId = renderKit.getId();
if (renderKitId == null)
{
renderKitId = RenderKitFactory.HTML_BASIC_RENDER_KIT;
}
RenderKit existing = renderKits.get(renderKitId);
if (existing == null)
{
existing = new RenderKitImpl();
existing.merge(renderKit);
renderKits.put(renderKitId, existing);
}
else
{
existing.merge(renderKit);
}
}
for (FacesConfigExtension extension : config.getFacesConfigExtensions())
{
for (FaceletsProcessing faceletsProcessing : extension.getFaceletsProcessingList())
{
if (faceletsProcessing.getFileExtension() != null && faceletsProcessing.getFileExtension().length() > 0)
{
faceletsProcessingByFileExtension.put(faceletsProcessing.getFileExtension(), faceletsProcessing);
}
}
}
for (ComponentTagDeclaration declaration : config.getComponentTagDeclarations().values())
{
componentTagDeclarations.add(declaration);
}
faceletTagLibraries.addAll(config.getFaceletTagLibraryList());
lifecyclePhaseListeners.addAll(config.getLifecyclePhaseListener());
managedBeans.addAll(config.getManagedBeans());
navigationRules.addAll(config.getNavigationRules());
facesVersion = config.getVersion();
namedEvents.addAll(config.getNamedEvents());
facesFlowDefinitions.addAll(config.getFacesFlowDefinitions());
protectedViewUrlPatterns.addAll(config.getProtectedViewsUrlPatternList());
resourceResolvers.addAll(config.getResourceResolversList());
for (FacesConfigExtension extension : config.getFacesConfigExtensions())
{
viewPoolMappings.addAll(extension.getViewPoolMappings());
}
}
/**
* Add another ApplicationFactory class name
*
* @param factoryClassName
* a class name
*/
public void feedApplicationFactory(String factoryClassName)
{
applicationFactories.add(factoryClassName);
}
public void feedExceptionHandlerFactory(String factoryClassName)
{
exceptionHandlerFactories.add(factoryClassName);
}
public void feedExternalContextFactory(String factoryClassName)
{
externalContextFactories.add(factoryClassName);
}
/**
* Add another FacesContextFactory class name
*
* @param factoryClassName
* a class name
*/
public void feedFacesContextFactory(String factoryClassName)
{
facesContextFactories.add(factoryClassName);
}
/**
* Add another LifecycleFactory class name
*
* @param factoryClassName
* a class name
*/
public void feedLifecycleFactory(String factoryClassName)
{
lifecycleFactories.add(factoryClassName);
}
public void feedViewDeclarationLanguageFactory(String factoryClassName)
{
viewDeclarationLanguageFactories.add(factoryClassName);
}
public void feedPartialViewContextFactory(String factoryClassName)
{
partialViewContextFactories.add(factoryClassName);
}
/**
* Add another RenderKitFactory class name
*
* @param factoryClassName
* a class name
*/
public void feedRenderKitFactory(String factoryClassName)
{
renderKitFactories.add(factoryClassName);
}
public void feedTagHandlerDelegateFactory(String factoryClassName)
{
tagHandlerDelegateFactories.add(factoryClassName);
}
public void feedVisitContextFactory(String factoryClassName)
{
visitContextFactories.add(factoryClassName);
}
/**
* @return Collection over ApplicationFactory class names
*/
public Collection<String> getApplicationFactoryIterator()
{
if (umapplicationFactories == null)
{
umapplicationFactories = Collections.unmodifiableList(applicationFactories);
}
return umapplicationFactories;
}
public Collection<String> getExceptionHandlerFactoryIterator()
{
if (umexceptionHandlerFactories == null)
{
umexceptionHandlerFactories = Collections.unmodifiableList(exceptionHandlerFactories);
}
return umexceptionHandlerFactories;
}
public Collection<String> getExternalContextFactoryIterator()
{
if (umexternalContextFactories == null)
{
umexternalContextFactories = Collections.unmodifiableList(externalContextFactories);
}
return umexternalContextFactories;
}
/**
* @return Collection over FacesContextFactory class names
*/
public Collection<String> getFacesContextFactoryIterator()
{
if (umfacesContextFactories == null)
{
umfacesContextFactories = Collections.unmodifiableList(facesContextFactories);
}
return umfacesContextFactories;
}
/**
* @return Collection over LifecycleFactory class names
*/
public Collection<String> getLifecycleFactoryIterator()
{
if (umlifecycleFactories == null)
{
umlifecycleFactories = Collections.unmodifiableList(lifecycleFactories);
}
return umlifecycleFactories;
}
public Collection<String> getViewDeclarationLanguageFactoryIterator()
{
if (umviewDeclarationLanguageFactories == null)
{
umviewDeclarationLanguageFactories = Collections.unmodifiableList(viewDeclarationLanguageFactories);
}
return umviewDeclarationLanguageFactories;
}
public Collection<String> getPartialViewContextFactoryIterator()
{
if (umpartialViewContextFactories == null)
{
umpartialViewContextFactories = Collections.unmodifiableList(partialViewContextFactories);
}
return umpartialViewContextFactories;
}
/**
* @return Collection over RenderKit factory class names
*/
public Collection<String> getRenderKitFactoryIterator()
{
if (umrenderKitFactories == null)
{
umrenderKitFactories = Collections.unmodifiableList(renderKitFactories);
}
return umrenderKitFactories;
}
public Collection<String> getTagHandlerDelegateFactoryIterator()
{
if (umtagHandlerDelegateFactories == null)
{
umtagHandlerDelegateFactories = Collections.unmodifiableList(tagHandlerDelegateFactories);
}
return umtagHandlerDelegateFactories;
}
public Collection<String> getVisitContextFactoryIterator()
{
if (umvisitContextFactories == null)
{
umvisitContextFactories = Collections.unmodifiableList(visitContextFactories);
}
return umvisitContextFactories;
}
/**
* @return Collection over ActionListener class names
*/
public Collection<String> getActionListenerIterator()
{
if (umactionListeners == null)
{
umactionListeners = Collections.unmodifiableList(actionListeners);
}
return umactionListeners;
}
/**
* @return the default render kit id
*/
public String getDefaultRenderKitId()
{
return defaultRenderKitId;
}
/**
* @return Collection over message bundle names
*/
public String getMessageBundle()
{
return messageBundle;
}
/**
* @return Collection over NavigationHandler class names
*/
public Collection<String> getNavigationHandlerIterator()
{
if (umnavigationHandlers == null)
{
umnavigationHandlers = Collections.unmodifiableList(navigationHandlers);
}
return umnavigationHandlers;
}
/**
* @return the partial traversal class name
*/
public String getPartialTraversal ()
{
return partialTraversal;
}
/**
* @return Collection over ResourceHandler class names
*/
@Override
public Collection<String> getResourceHandlerIterator()
{
if (umresourceHandlers == null)
{
umresourceHandlers = Collections.unmodifiableList(resourceHandlers);
}
return umresourceHandlers;
}
/**
* @return Collection over ViewHandler class names
*/
@Override
public Collection<String> getViewHandlerIterator()
{
if (umviewHandlers == null)
{
umviewHandlers = Collections.unmodifiableList(viewHandlers);
}
return umviewHandlers;
}
/**
* @return Collection over StateManager class names
*/
@Override
public Collection<String> getStateManagerIterator()
{
if (umstateManagers == null)
{
umstateManagers = Collections.unmodifiableList(stateManagers);
}
return umstateManagers;
}
/**
* @return Collection over PropertyResolver class names
*/
@Override
public Collection<String> getPropertyResolverIterator()
{
if (umpropertyResolver == null)
{
umpropertyResolver = Collections.unmodifiableList(propertyResolver);
}
return umpropertyResolver;
}
/**
* @return Collection over VariableResolver class names
*/
@Override
public Collection<String> getVariableResolverIterator()
{
if (umvariableResolver == null)
{
umvariableResolver = Collections.unmodifiableList(variableResolver);
}
return umvariableResolver;
}
/**
* @return the default locale name
*/
@Override
public String getDefaultLocale()
{
if (localeConfig != null)
{
return localeConfig.getDefaultLocale();
}
return null;
}
/**
* @return Collection over supported locale names
*/
@Override
public Collection<String> getSupportedLocalesIterator()
{
Collection<String> locale;
if (localeConfig != null)
{
locale = Collections.unmodifiableCollection(localeConfig.getSupportedLocales());
}
else
{
locale = Collections.emptyList();
}
return locale;
}
/**
* @return Collection over all defined component types
*/
@Override
public Collection<String> getComponentTypes()
{
return Collections.unmodifiableCollection(components.keySet());
}
@Override
public Map<String, String> getComponentClassesByType()
{
return Collections.unmodifiableMap(components);
}
/**
* @return component class that belongs to the given component type
*/
@Override
public String getComponentClass(String componentType)
{
return components.get(componentType);
}
/**
* @return Collection over all defined converter ids
*/
@Override
public Collection<String> getConverterIds()
{
return Collections.unmodifiableCollection(converterById.keySet());
}
@Override
public Map<String, String> getConverterClassesById()
{
return Collections.unmodifiableMap(converterById);
}
/**
* @return Collection over all classes with an associated converter
*/
@Override
public Collection<String> getConverterClasses()
{
return Collections.unmodifiableCollection(converterByClass.keySet());
}
@Override
public Map<String, String> getConverterClassesByClass()
{
return Collections.unmodifiableMap(converterByClass);
}
@Override
public Collection<String> getConverterConfigurationByClassName()
{
return Collections.unmodifiableCollection(converterConfigurationByClassName.keySet());
}
@Override
public Converter getConverterConfiguration(String converterClassName)
{
return converterConfigurationByClassName.get(converterClassName);
}
/**
* @return converter class that belongs to the given converter id
*/
@Override
public String getConverterClassById(String converterId)
{
return converterById.get(converterId);
}
/**
* @return converter class that is associated with the given class name
*/
@Override
public String getConverterClassByClass(String className)
{
return converterByClass.get(className);
}
/**
* @return Collection over all defined default validator ids
*/
@Override
public Collection<String> getDefaultValidatorIds ()
{
List<String> allDefaultValidatorIds = new ArrayList<String>();
allDefaultValidatorIds.addAll(defaultAnnotatedValidatorIds);
allDefaultValidatorIds.addAll(defaultValidatorIds);
return Collections.unmodifiableCollection(allDefaultValidatorIds);
}
/**
* @return Collection over all defined validator ids
*/
@Override
public Collection<String> getValidatorIds()
{
return Collections.unmodifiableCollection(validators.keySet());
}
@Override
public Map<String, String> getValidatorClassesById()
{
return Collections.unmodifiableMap(validators);
}
/**
* @return validator class name that belongs to the given validator id
*/
@Override
public String getValidatorClass(String validatorId)
{
return validators.get(validatorId);
}
/**
* @return Collection over {@link org.apache.myfaces.config.element.ManagedBean ManagedBean}s
*/
@Override
public Collection<ManagedBean> getManagedBeans()
{
if (ummanagedBeans == null)
{
ummanagedBeans = Collections.unmodifiableList(managedBeans);
}
return ummanagedBeans;
}
/**
* @return Collection over {@link org.apache.myfaces.config.element.NavigationRule NavigationRule}s
*/
@Override
public Collection<NavigationRule> getNavigationRules()
{
if (umnavigationRules == null)
{
umnavigationRules = Collections.unmodifiableList(navigationRules);
}
return umnavigationRules;
}
/**
* @return Collection over all defined renderkit ids
*/
@Override
public Collection<String> getRenderKitIds()
{
return Collections.unmodifiableCollection(renderKits.keySet());
}
/**
* @return renderkit class name for given renderkit id
*/
@Override
public Collection<String> getRenderKitClasses(String renderKitId)
{
return renderKits.get(renderKitId).getRenderKitClasses();
}
/**
* @return Iterator over
* {@link org.apache.myfaces.config.element.ClientBehaviorRenderer ClientBehaviorRenderer}s
* for the given renderKitId
*/
@Override
public Collection<ClientBehaviorRenderer> getClientBehaviorRenderers (String renderKitId)
{
return renderKits.get (renderKitId).getClientBehaviorRenderers();
}
/**
* @return Collection over {@link org.apache.myfaces.config.element.Renderer Renderer}s for the given renderKitId
*/
@Override
public Collection<Renderer> getRenderers(String renderKitId)
{
return renderKits.get(renderKitId).getRenderer();
}
/**
* @return Collection over {@link javax.faces.event.PhaseListener} implementation class names
*/
@Override
public Collection<String> getLifecyclePhaseListeners()
{
if (umlifecyclePhaseListeners == null)
{
umlifecyclePhaseListeners = Collections.unmodifiableList(lifecyclePhaseListeners);
}
return umlifecyclePhaseListeners;
}
@Override
public Collection<ResourceBundle> getResourceBundles()
{
if (umresourceBundles == null)
{
umresourceBundles = Collections.unmodifiableList(resourceBundles);
}
return umresourceBundles;
}
@Override
public Collection<String> getElResolvers()
{
if (umelResolvers == null)
{
umelResolvers = Collections.unmodifiableList(elResolvers);
}
return umelResolvers;
}
@Override
public Collection<SystemEventListener> getSystemEventListeners()
{
if (umsystemEventListeners == null)
{
umsystemEventListeners = Collections.unmodifiableList(systemEventListeners);
}
return umsystemEventListeners;
}
@Override
public Collection<Behavior> getBehaviors ()
{
if (umbehaviors == null)
{
umbehaviors = Collections.unmodifiableList(behaviors);
}
return umbehaviors;
}
@Override
public String getFacesVersion ()
{
return facesVersion;
}
@Override
public Collection<NamedEvent> getNamedEvents()
{
if (umnamedEvents == null)
{
umnamedEvents = Collections.unmodifiableList(namedEvents);
}
return umnamedEvents;
}
@Override
public Collection<FaceletsProcessing> getFaceletsProcessing()
{
return Collections.unmodifiableCollection(faceletsProcessingByFileExtension.values());
}
@Override
public FaceletsProcessing getFaceletsProcessingConfiguration(String fileExtension)
{
return faceletsProcessingByFileExtension.get(fileExtension);
}
@Override
public void feedFaceletCacheFactory(String factoryClassName)
{
faceletCacheFactories.add(factoryClassName);
}
@Override
public Collection<String> getFaceletCacheFactoryIterator()
{
if (umfaceletCacheFactories == null)
{
umfaceletCacheFactories = Collections.unmodifiableList(faceletCacheFactories);
}
return umfaceletCacheFactories;
}
@Override
public void feedFlashFactory(String factoryClassName)
{
flashFactories.add(factoryClassName);
}
@Override
public Collection<String> getFlashFactoryIterator()
{
if (umflashFactories == null)
{
umflashFactories = Collections.unmodifiableList(flashFactories);
}
return umflashFactories;
}
@Override
public Collection<String> getFlowHandlerFactoryIterator()
{
if (umflowHandlerFactories == null)
{
umflowHandlerFactories = Collections.unmodifiableList(flowHandlerFactories);
}
return umflowHandlerFactories;
}
@Override
public void feedClientWindowFactory(String factoryClassName)
{
clientWindowFactories.add(factoryClassName);
}
@Override
public Collection<String> getClientWindowFactoryIterator()
{
if (umclientWindowFactories == null)
{
umclientWindowFactories = Collections.unmodifiableList(clientWindowFactories);
}
return umclientWindowFactories;
}
@Override
public Collection<FacesFlowDefinition> getFacesFlowDefinitions()
{
if (umfacesFlowDefinitions == null)
{
umfacesFlowDefinitions = Collections.unmodifiableList(facesFlowDefinitions);
}
return umfacesFlowDefinitions;
}
@Override
public Collection<String> getProtectedViewUrlPatterns()
{
if (umprotectedViewUrlPatterns == null)
{
umprotectedViewUrlPatterns = Collections.unmodifiableList(protectedViewUrlPatterns);
}
return umprotectedViewUrlPatterns;
}
@Override
public Collection<ContractMapping> getResourceLibraryContractMappings()
{
if (umresourceLibraryContractMappings == null)
{
umresourceLibraryContractMappings = Collections.unmodifiableList(resourceLibraryContractMappings);
}
return umresourceLibraryContractMappings;
}
@Override
public Collection<ComponentTagDeclaration> getComponentTagDeclarations()
{
if (umcomponentTagDeclarations == null)
{
umcomponentTagDeclarations = Collections.unmodifiableList(componentTagDeclarations);
}
return umcomponentTagDeclarations;
}
@Override
public Collection<String> getResourceResolvers()
{
if (umresourceResolvers == null)
{
umresourceResolvers = Collections.unmodifiableList(resourceResolvers);
}
return umresourceResolvers;
}
@Override
public Collection<FaceletTagLibrary> getTagLibraries()
{
if (umfaceletTagLibraries == null)
{
umfaceletTagLibraries = Collections.unmodifiableList(faceletTagLibraries);
}
return umfaceletTagLibraries;
}
@Override
public Collection<ViewPoolMapping> getViewPoolMappings()
{
if (umviewPoolMappings == null)
{
umviewPoolMappings = Collections.unmodifiableList(viewPoolMappings);
}
return umviewPoolMappings;
}
}