patternstructfiller.java

来自「一个java 代码生成器」· Java 代码 · 共 206 行

/**
 * Copyright (c) 2002, Siddhartha P. Chandurkar [e-mail]
 * All rights reserved.
 * Licensed under the Academic Free License version 1.1
 * See the file LICENSE.TXT for details.
 * LICENSE.txt is located in the directory  <install-directory>\Jenerator
 * of your Jenertaor Installation.
 *
 */
package com.jenerator.struct.pattern;

import com.jenerator.struct.Filler;
import com.jenerator.util.Configurator;
import org.apache.log4j.Logger;

/**
 * PatternStructFiller
 *
 * @author Siddhartha P. Chandurkar
 * @version 0.9.0
 *
 */
public class PatternStructFiller implements Filler {

    private PatternStruct patternStruct;
    private String type;
    private String visitorElementName;
    private Logger log = Logger.getLogger(PatternStructFiller.class.getName());

    /**
     * Fills the structure with the node name and the node value
     * @param	String	nodeName	The name of the node
     * @param	String  nodeValue	The value of the node
     * @param	String 	parent		The parent node of the node which
     *								represents the nodeName
     */
    public void fill(String nodeName, String nodeValue, String parentName) {
        if (nodeName.equals("type") && parentName.equals("gof-pattern")) {
            if (nodeValue.equalsIgnoreCase("Singleton")) {
                type = "Singleton";
                patternStruct = new SingletonStruct();
                patternStruct.setType(type);
                log.debug("Parsing for Singleton");
            } else if (nodeValue.equalsIgnoreCase("Composite")) {
                log.debug("Parsing for Composite");
                type = "Composite";
                patternStruct = new CompositeStruct();
                patternStruct.setType(type);
            } else if (nodeValue.equalsIgnoreCase("TemplateMethod")) {
                log.debug("Parsing for TemplateMethod");
                type = "TemplateMethod";
                patternStruct = new TemplateMethodStruct();
                patternStruct.setType(type);
            } else if (nodeValue.equalsIgnoreCase("Strategy")) {
                log.debug("Parsing for Strategy");
                patternStruct = new StrategyStruct();
                patternStruct.setType(type);
            } else if (nodeValue.equalsIgnoreCase("Command")) {
                log.debug("Parsing for Command");
                patternStruct = new CommandStruct();
                patternStruct.setType(type);
            } else if (nodeValue.equalsIgnoreCase("Visitor")) {
                log.debug("Parsing for Visitor");
                patternStruct = new VisitorStruct();
                patternStruct.setType(type);
            }
        } else if (nodeName.equals("type") && parentName.equals("ejb-pattern")) {
            if (nodeValue.equalsIgnoreCase("EjbHomeFactory")) {
                log.debug("Parsing for EjbHomeFactory");
                type = "EjbHomeFactory";
                patternStruct = new EjbHomeFactoryStruct();
                patternStruct.setType(type);
            } else if (nodeValue.equalsIgnoreCase("ServiceLocator")) {
                log.debug("Parsing for ServiceLocator");
                type = "ServiceLocator";
                patternStruct = new ServiceLocatorStruct();
                patternStruct.setType(type);
            } else if (nodeValue.equalsIgnoreCase("ValueListHandler")) {
                log.debug("Parsing for ValueListHandler");
                type = "ValueListHandler";
                patternStruct = new ValueListHandlerStruct();
                patternStruct.setType(type);
            } else if (nodeValue.equalsIgnoreCase("GenericAttributeAccess")) {
                log.debug("Parsing for GenericAttributeAccess");
                type = "GenericAttributeAccess";
                patternStruct = new GenericAttributeAccessStruct();
                patternStruct.setType(type);
            }

        } else if (nodeName.equals("package")) {
            patternStruct.setPackageName(nodeValue);

        } else if (nodeName.equals("name")) {
            if (type.equals("Singleton")) {
                log.debug("class -name Singleton");
                ((SingletonStruct) patternStruct).setName(nodeValue);
            } else if (type.equals("EjbHomeFactory")) {
                log.debug("class -name EjbHomeFactory");
                ((EjbHomeFactoryStruct) patternStruct).setName(nodeValue);
            } else if (type.equals("ServiceLocator")) {
                log.debug("class -name ServiceLocator");
                ((ServiceLocatorStruct) patternStruct).setName(nodeValue);
            } else if (type.equals("ValueListHandler")) {
                log.debug("class -name ValueListHandler");
                ((ValueListHandlerStruct) patternStruct).setName(nodeValue);
            } else if (type.equals("GenericAttributeAccess")) {
                log.debug("class -name ValueListHandler");
                ((GenericAttributeAccessStruct) patternStruct).setName(nodeValue);
            }

        }//For Composite Pattern
        else if (nodeName.equals("composite-name")) {
            log.debug("Composite - name ");
            ((CompositeStruct) patternStruct).setCompositeName(nodeValue);
        } else if (nodeName.equals("component-name")) {
            log.debug("Component - name ");
            ((CompositeStruct) patternStruct).setComponentName(nodeValue);
        } else if (nodeName.equals("component-operation-name")) {
            log.debug("Component - Operation - name ");
            ((CompositeStruct) patternStruct).setComponentOperationName(nodeValue);
        } else if (nodeName.equals("leaf-name")) {
            log.debug("Leaf - name " + nodeValue);
            ((CompositeStruct) patternStruct).addLeafName(nodeValue);
        }//For TemplateMethodPattern
        else if (nodeName.equals("class-name") && parentName.equals("abstract-class")) {
            log.debug("Abstract class name " + nodeValue);
            ((TemplateMethodStruct) patternStruct).setAbstractClassName(nodeValue);
        } else if (nodeName.equals("template-method")) {
            log.debug("template - method " + nodeValue);
            ((TemplateMethodStruct) patternStruct).setTemplateMethod(nodeValue);
        } else if (nodeName.equals("operation-name") && parentName.equals("primitive-operations")) {
            log.debug("Operation name " + nodeValue);
            ((TemplateMethodStruct) patternStruct).addPrimitiveOperation(nodeValue);
        } else if (nodeName.equals("concrete-class-name")) {
            log.debug("concrete -class - name " + nodeValue);
            ((TemplateMethodStruct) patternStruct).setConcreteClassName(nodeValue);
        }//For Strategy Pattern
        else if (nodeName.equals("interface-name") && parentName.equals("strategy-interface")) {
            log.debug("Strategy interface name" + nodeValue);
            ((StrategyStruct) patternStruct).setStrategyInterfaceName(nodeValue);
        } else if (nodeName.equals("algorithm-operation-name") && parentName.equals("strategy-interface")) {
            log.debug("Algorithm - operation - name " + nodeValue);
            ((StrategyStruct) patternStruct).setAlgorithmOperationName(nodeValue);
        } else if (nodeName.equals("concrete-strategy-name") && parentName.equals("concrete-strategies")) {
            log.debug("Concrete Strategies name " + nodeValue);
            ((StrategyStruct) patternStruct).addConcreteStrategie(nodeValue);
        }//For Command Pattern
        else if (nodeName.equals("abstract-command")) {
            log.debug("abstract - command " + nodeValue);
            ((CommandStruct) patternStruct).setAbstractCommandName(nodeValue);
        } else if (nodeName.equals("receiver-name")) {
            log.debug("receiver-name" + nodeValue);
            ((CommandStruct) patternStruct).setReceiverName(nodeValue);
        } else if (nodeName.equals("action")) {
            log.debug("action" + nodeValue);
            ((CommandStruct) patternStruct).setAction(nodeValue);
        } else if (nodeName.equals("command")) {
            log.debug("command " + nodeValue);
            ((CommandStruct) patternStruct).addCommand(nodeValue);
        }//For Visitor Pattern
        else if (nodeName.equals("abstract-visitor-name")) {
            log.debug("abstract visitor name" + nodeValue);
            ((VisitorStruct) patternStruct).setAbstractVisitorName(nodeValue);
        } else if (nodeName.equals("concrete-visitor-name")) {
            log.debug("concrete visitor name" + nodeValue);
            ((VisitorStruct) patternStruct).addConcreteVisitor(nodeValue);
        } else if (nodeName.equals("abstract-element-name")) {
            log.debug("abstract element name" + nodeValue);
            ((VisitorStruct) patternStruct).setAbstractElementName(nodeValue);
        } else if (nodeName.equals("concrete-element-name")) {
            log.debug("concrete element name" + nodeValue);
            visitorElementName = nodeValue;
        } else if (nodeName.equals("element-operation-name")) {
            log.debug("concrete element name" + nodeValue);
            ((VisitorStruct) patternStruct).addConcreteElement(visitorElementName, nodeValue);
        }


    }

    /**
     * Indicates that it is the start of the node. so that the structure
     * to be filled can be instantiated
     * @param	boolean	flag		Indicating that it is the starting
     *								of the node
     */
    public void setStartOfNode(boolean flag) {
        if (flag == true) {

        } else {
            log.debug("End of element");
            Configurator.getInstance().getConfigStructs().addPatternStruct(patternStruct);
            patternStruct = null;
        }
    }

    /**
     * Sets the root element, so that the appropriate structure can
     * be instantiated
     * @param	String	rootElement	The rootElement from where the parsing
     *								has started.
     */
    public void setRootElement(String rootElement) {
    }
}