converterbeandefinitionparser.java

Please read your package and describe it at least 40 bytes in English. System will automatically de

/*
 * Copyright 2002-2004 the original author or authors.
 * 
 * Licensed 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 de.mindmatters.faces.spring.factory.aspectj;

import javax.faces.convert.Converter;

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.parsing.BeanComponentDefinition;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
import org.springframework.beans.factory.xml.BeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.beans.factory.xml.XmlReaderContext;
import org.w3c.dom.Element;

/**
 * {@link org.springframework.beans.factory.xml.BeanDefinitionParser}
 * implementation for parsing JSF converter tags and creating the appropriate
 * {@link ConverterDefinition} definitions.
 * 
 * @author Andreas Kuhrwahl
 * 
 */
final class ConverterBeanDefinitionParser implements BeanDefinitionParser {

    /**
     * {@inheritDoc}
     */
    public BeanDefinition parse(final Element element,
            final ParserContext parserContext) {
        Class converterClass = JsfBeanDefinitionParserUtils
                .createComponentClass(
                        element
                                .getAttribute(JsfBeanDefinitionParserUtils.CLASS_ATTRIBUTE),
                        Converter.class, parserContext);
        if (converterClass != null) {
            XmlReaderContext readerContext = parserContext.getReaderContext();
            if (element.hasAttribute(JsfBeanDefinitionParserUtils.ID_ATTRIBUTE)
                    || element
                            .hasAttribute(JsfBeanDefinitionParserUtils.FOR_CLASS_ATTRIBUTE)) {
                String converterRegistrar = null;
                boolean registerById = false;
                if (element
                        .hasAttribute(JsfBeanDefinitionParserUtils.ID_ATTRIBUTE)) {
                    if (element
                            .hasAttribute(JsfBeanDefinitionParserUtils.FOR_CLASS_ATTRIBUTE)) {
                        readerContext.error(
                                "Specify either 'id' or 'for-class', not both",
                                readerContext.extractSource(element));
                    } else {
                        registerById = true;
                        converterRegistrar = element
                                .getAttribute(JsfBeanDefinitionParserUtils.ID_ATTRIBUTE);
                    }
                } else {
                    converterRegistrar = element
                            .getAttribute(JsfBeanDefinitionParserUtils.FOR_CLASS_ATTRIBUTE);
                }
                if (converterRegistrar != null) {
                    String converterClassName = converterClass.getName();
                    AbstractBeanDefinition converter = parserContext
                            .getDelegate().parseBeanDefinitionElement(element,
                                    null, null);
                    converter.setBeanClass(converterClass);
                    converter.setSingleton(false);
                    converter.setRole(BeanDefinition.ROLE_SUPPORT);
                    BeanDefinitionHolder holder = new BeanDefinitionHolder(
                            converter, converterClassName);
                    parserContext.getDelegate()
                            .decorateBeanDefinitionIfRequired(element, holder);
                    BeanDefinitionReaderUtils.registerBeanDefinition(holder,
                            parserContext.getRegistry());
                    registerConverterDefinition(converterRegistrar,
                            converterClassName, registerById, parserContext);
                    parserContext.getReaderContext().fireComponentRegistered(
                            new BeanComponentDefinition(holder));
                }
            } else {
                readerContext.error("Specify either 'id' or 'for-class'",
                        readerContext.extractSource(element));
            }
        }
        return null;
    }

    /**
     * Creates and registers a {@link ConverterDefinition}.
     * 
     * @param converterRegistrar
     *            the registrar
     * @param converterClassName
     *            the converter class name
     * @param registerById
     *            <code>true</code> if the converter should be registered by
     *            id <code>false</code> if by class
     * @param parserContext
     *            the {@link ParserContext}
     */
    private void registerConverterDefinition(final String converterRegistrar,
            final String converterClassName, final boolean registerById,
            final ParserContext parserContext) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .rootBeanDefinition(ConverterDefinition.class);
        builder.addConstructorArg(converterRegistrar);
        builder.addConstructorArg(converterClassName);
        builder.addConstructorArg(String.valueOf(registerById));
        builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        BeanDefinitionReaderUtils.registerWithGeneratedName(builder
                .getBeanDefinition(), parserContext.getRegistry());
    }

}