/*

  * 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;

     }

 }