org.apache.myfaces.config.impl.digester.DigesterFacesConfigDispenserImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of myfaces-impl Show documentation
Show all versions of myfaces-impl Show documentation
The private implementation classes of the Apache MyFaces Core JSF-2.0 Implementation
/*
* 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.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.Converter;
import org.apache.myfaces.config.element.FacesConfig;
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;
/**
* @author Oliver Rossmueller
*/
public class DigesterFacesConfigDispenserImpl extends FacesConfigDispenser
{
/**
*
*/
private static final long serialVersionUID = 3550379003287939559L;
// Factories
private List applicationFactories = new ArrayList();
private List exceptionHandlerFactories = new ArrayList();
private List externalContextFactories = new ArrayList();
private List facesContextFactories = new ArrayList();
private List lifecycleFactories = new ArrayList();
private List ViewDeclarationLanguageFactories = new ArrayList();
private List partialViewContextFactories = new ArrayList();
private List renderKitFactories = new ArrayList();
private List tagHandlerDelegateFactories = new ArrayList();
private List visitContextFactories = new ArrayList();
private String defaultRenderKitId;
private String messageBundle;
private String partialTraversal;
private String facesVersion;
private LocaleConfig localeConfig;
private Map components = new HashMap();
private Map converterByClass = new HashMap();
private Map converterById = new HashMap();
private Map validators = new HashMap();
private List behaviors = new ArrayList();
private Map converterConfigurationByClassName = new HashMap();
private Map renderKits = new LinkedHashMap();
private List actionListeners = new ArrayList();
private List elResolvers = new ArrayList();
private List lifecyclePhaseListeners = new ArrayList();
private List navigationHandlers = new ArrayList();
private List propertyResolver = new ArrayList();
private List resourceHandlers = new ArrayList();
private List stateManagers = new ArrayList();
private List variableResolver = new ArrayList();
private List viewHandlers = new ArrayList();
private List defaultValidatorIds = new ArrayList();
private List managedBeans = new ArrayList();
private List navigationRules = new ArrayList();
private List resourceBundles = new ArrayList();
private List systemEventListeners = new ArrayList();
private List namedEvents = new ArrayList();
/**
* 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());
}
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());
// 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 element, so any existing
// default validators should be removed
defaultValidatorIds.clear();
// now add all default-validator entries (could be zero)
defaultValidatorIds.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;
}
org.apache.myfaces.config.impl.digester.elements.RenderKit existing = renderKits.get(renderKitId);
if (existing == null)
{
existing = new org.apache.myfaces.config.impl.digester.elements.RenderKit();
existing.merge(renderKit);
renderKits.put(renderKitId, existing);
//renderKits.put(renderKitId, renderKit);
}
else
{
existing.merge(renderKit);
}
}
lifecyclePhaseListeners.addAll(config.getLifecyclePhaseListener());
managedBeans.addAll(config.getManagedBeans());
navigationRules.addAll(config.getNavigationRules());
facesVersion = config.getVersion();
namedEvents.addAll(config.getNamedEvents());
}
/**
* 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 getApplicationFactoryIterator()
{
return applicationFactories;
}
public Collection getExceptionHandlerFactoryIterator()
{
return exceptionHandlerFactories;
}
public Collection getExternalContextFactoryIterator()
{
return externalContextFactories;
}
/**
* @return Collection over FacesContextFactory class names
*/
public Collection getFacesContextFactoryIterator()
{
return facesContextFactories;
}
/**
* @return Collection over LifecycleFactory class names
*/
public Collection getLifecycleFactoryIterator()
{
return lifecycleFactories;
}
public Collection getViewDeclarationLanguageFactoryIterator()
{
return ViewDeclarationLanguageFactories;
}
public Collection getPartialViewContextFactoryIterator()
{
return partialViewContextFactories;
}
/**
* @return Collection over RenderKit factory class names
*/
public Collection getRenderKitFactoryIterator()
{
return renderKitFactories;
}
public Collection getTagHandlerDelegateFactoryIterator()
{
return tagHandlerDelegateFactories;
}
public Collection getVisitContextFactoryIterator()
{
return visitContextFactories;
}
/**
* @return Collection over ActionListener class names
*/
public Collection getActionListenerIterator()
{
return new ArrayList(actionListeners);
}
/**
* @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 getNavigationHandlerIterator()
{
return new ArrayList(navigationHandlers);
}
/**
* @return the partial traversal class name
*/
public String getPartialTraversal ()
{
return partialTraversal;
}
/**
* @return Collection over ResourceHandler class names
*/
public Collection getResourceHandlerIterator()
{
return new ArrayList(resourceHandlers);
}
/**
* @return Collection over ViewHandler class names
*/
public Collection getViewHandlerIterator()
{
return new ArrayList(viewHandlers);
}
/**
* @return Collection over StateManager class names
*/
public Collection getStateManagerIterator()
{
return new ArrayList(stateManagers);
}
/**
* @return Collection over PropertyResolver class names
*/
public Collection getPropertyResolverIterator()
{
return new ArrayList(propertyResolver);
}
/**
* @return Collection over VariableResolver class names
*/
public Collection getVariableResolverIterator()
{
return new ArrayList(variableResolver);
}
/**
* @return the default locale name
*/
public String getDefaultLocale()
{
if (localeConfig != null)
{
return localeConfig.getDefaultLocale();
}
return null;
}
/**
* @return Collection over supported locale names
*/
public Collection getSupportedLocalesIterator()
{
List locale;
if (localeConfig != null)
{
locale = localeConfig.getSupportedLocales();
}
else
{
locale = Collections.emptyList();
}
return locale;
}
/**
* @return Collection over all defined component types
*/
public Collection getComponentTypes()
{
return components.keySet();
}
/**
* @return component class that belongs to the given component type
*/
public String getComponentClass(String componentType)
{
return components.get(componentType);
}
/**
* @return Collection over all defined converter ids
*/
public Collection getConverterIds()
{
return converterById.keySet();
}
/**
* @return Collection over all classes with an associated converter
*/
public Collection getConverterClasses()
{
return converterByClass.keySet();
}
public Collection getConverterConfigurationByClassName()
{
return converterConfigurationByClassName.keySet();
}
public Converter getConverterConfiguration(String converterClassName)
{
return converterConfigurationByClassName.get(converterClassName);
}
/**
* @return converter class that belongs to the given converter id
*/
public String getConverterClassById(String converterId)
{
return converterById.get(converterId);
}
/**
* @return converter class that is associated with the given class name
*/
public String getConverterClassByClass(String className)
{
return converterByClass.get(className);
}
/**
* @return Collection over all defined default validator ids
*/
public Collection getDefaultValidatorIds ()
{
return defaultValidatorIds;
}
/**
* @return Collection over all defined validator ids
*/
public Collection getValidatorIds()
{
return validators.keySet();
}
/**
* @return validator class name that belongs to the given validator id
*/
public String getValidatorClass(String validatorId)
{
return validators.get(validatorId);
}
/**
* @return Collection over {@link org.apache.myfaces.config.element.ManagedBean ManagedBean}s
*/
public Collection getManagedBeans()
{
return managedBeans;
}
/**
* @return Collection over {@link org.apache.myfaces.config.element.NavigationRule NavigationRule}s
*/
public Collection getNavigationRules()
{
return navigationRules;
}
/**
* @return Collection over all defined renderkit ids
*/
public Collection getRenderKitIds()
{
return renderKits.keySet();
}
/**
* @return renderkit class name for given renderkit id
*/
public Collection getRenderKitClasses(String renderKitId)
{
return renderKits.get(renderKitId).getRenderKitClasses();
}
/**
* @return Iterator over {@link org.apache.myfaces.config.element.ClientBehaviorRenderer ClientBehaviorRenderer}s for the given renderKitId
*/
public Collection getClientBehaviorRenderers (String renderKitId)
{
return renderKits.get (renderKitId).getClientBehaviorRenderers();
}
/**
* @return Collection over {@link org.apache.myfaces.config.element.Renderer Renderer}s for the given renderKitId
*/
public Collection getRenderers(String renderKitId)
{
return renderKits.get(renderKitId).getRenderer();
}
/**
* @return Collection over {@link javax.faces.event.PhaseListener} implementation class names
*/
public Collection getLifecyclePhaseListeners()
{
return lifecyclePhaseListeners;
}
public Collection getResourceBundles()
{
return resourceBundles;
}
public Collection getElResolvers()
{
return elResolvers;
}
public Collection getSystemEventListeners()
{
return systemEventListeners;
}
public Collection getBehaviors ()
{
return behaviors;
}
public String getFacesVersion ()
{
return facesVersion;
}
public Collection getNamedEvents()
{
return namedEvents;
}
}