templateunit.java

Jamon是一个Java文本模板引擎

/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (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.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Original Code is Jamon code, released February, 2003.
 *
 * The Initial Developer of the Original Code is Jay Sachs.  Portions
 * created by Jay Sachs are Copyright (C) 2003 Jay Sachs.  All Rights
 * Reserved.
 *
 * Contributor(s): Ian Robertson
 */

package org.jamon.codegen;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.jamon.ParserErrors;
import org.jamon.node.AnnotationNode;
import org.jamon.node.ClassNode;
import org.jamon.node.GenericsParamNode;
import org.jamon.node.ImportNode;
import org.jamon.node.Location;
import org.jamon.node.ParentArgNode;
import org.jamon.node.StaticImportNode;
import org.jamon.util.StringUtils;

public class TemplateUnit
    extends AbstractUnit
    implements InheritedUnit
{
    public TemplateUnit(String p_path, ParserErrors p_errors)
    {
        super(p_path, null, p_errors, null);
    }

    public int getInheritanceDepth()
    {
        return m_parentDescription == null
            ? 0
            : 1 + m_parentDescription.getInheritanceDepth();
    }


    /**
     * public for unit testing purposes
     **/

    public void setParentDescription(TemplateDescription p_parent)
    {
        m_parentDescription = p_parent;
        //FIXME - join them later.
        m_fragmentArgs.addAll(p_parent.getFragmentInterfaces());

        m_inheritedArgs = new InheritedArgs(getName(),
                                            getParentPath(),
                                            p_parent.getRequiredArgs(),
                                            p_parent.getOptionalArgs(),
                                            p_parent.getFragmentInterfaces(),
                                            getErrors());

        for (Iterator<AbstractArgument> i =
                new SequentialIterator<AbstractArgument>(
                        p_parent.getRequiredArgs().iterator(),
                        p_parent.getOptionalArgs().iterator(),
                        p_parent.getFragmentInterfaces().iterator());
             i.hasNext(); )
        {
            addArgName(i.next());
        }

        m_callNames.addAll(p_parent.getMethodUnits().keySet());
        m_abstractMethodNames.addAll(p_parent.getAbstractMethodNames());
        if (m_jamonContextType == null) {
            setJamonContextType(p_parent.getJamonContextType());
        }
    }

    public void addParentArg(ParentArgNode p_arg)
    {
        m_inheritedArgs.addParentArg(p_arg);
    }

    @Override
    public Iterator<FragmentArgument> getFragmentArgs()
    {
        return m_fragmentArgs.iterator();
    }

    @Override
    public List<FragmentArgument> getFragmentArgsList()
    {
        return m_fragmentArgs;
    }

    @Override
    public void addFragmentArg(FragmentArgument p_arg)
    {
        m_fragmentArgs.add(p_arg);
        m_declaredFragmentArgs.add(p_arg);
    }

    public Iterator<FragmentArgument> getDeclaredFragmentArgs()
    {
        return m_declaredFragmentArgs.iterator();
    }

    @Override
    public void addRequiredArg(RequiredArgument p_arg)
    {
        m_declaredRequiredArgs.add(p_arg);
    }

    @Override
    public void addOptionalArg(OptionalArgument p_arg)
    {
        m_declaredOptionalArgs.add(p_arg);
    }

    @Override
    public Iterator<RequiredArgument> getSignatureRequiredArgs()
    {
        return new SequentialIterator<RequiredArgument>
            (m_parentDescription.getRequiredArgs().iterator(),
             m_declaredRequiredArgs.iterator());
    }

    @Override
    public Iterator<OptionalArgument> getSignatureOptionalArgs()
    {
        return new SequentialIterator<OptionalArgument>
            (m_parentDescription.getOptionalArgs().iterator(),
             m_declaredOptionalArgs.iterator());
    }

    public String getOptionalArgDefault(OptionalArgument p_arg)
    {
        return m_declaredOptionalArgs.contains(p_arg)
            ? p_arg.getDefault()
            : m_inheritedArgs.getDefaultValue(p_arg);
    }

    @Override
    public Iterator<AbstractArgument> getVisibleArgs()
    {
        return m_inheritedArgs == null
            ? new SequentialIterator<AbstractArgument>(
                    getDeclaredRenderArgs(),
                    getDeclaredOptionalArgs())
            : new SequentialIterator<AbstractArgument>(
                    m_inheritedArgs.getVisibleArgs(),
                    getDeclaredRenderArgs(),
                    getDeclaredOptionalArgs());
    }

    public Iterator<OptionalArgument> getDeclaredOptionalArgs()
    {
        return m_declaredOptionalArgs.iterator();
    }

    public Collection<String> getTemplateDependencies()
    {
        return m_dependencies;
    }

    private void checkCallName(String p_name, Location p_location)
    {
        if (! m_callNames.add(p_name))
        {
            getErrors().addError(
                "multiple defs and/or methods named " + p_name, p_location);
        }
    }

    public void makeDefUnit(String p_defName, Location p_location)
    {
        checkCallName(p_defName, p_location);
        m_defs.put(p_defName, new DefUnit(p_defName, this, getErrors(), p_location));
    }

    public Iterator<DefUnit> getDefUnits()
    {
        return m_defs.values().iterator();
    }

    public DefUnit getDefUnit(String p_name)
    {
        return m_defs.get(p_name);
    }

    public void makeMethodUnit(
            String p_methodName, Location p_location, boolean p_isAbstract)
    {
        checkCallName(p_methodName, p_location);
        m_methods.put(p_methodName,
                      new DeclaredMethodUnit(
                          p_methodName, this, getErrors(), p_location, p_isAbstract));
        if(p_isAbstract)
        {
            m_abstractMethodNames.add(p_methodName);
        }
    }

    public OverriddenMethodUnit makeOverridenMethodUnit(
            String p_name, Location p_location)
    {
        DeclaredMethodUnit methodUnit = (DeclaredMethodUnit)
            m_parentDescription.getMethodUnits().get(p_name);
        if(methodUnit == null)
        {
            getErrors().addError(
                "There is no such method " + p_name + " to override",
                p_location);
            // Provide a dummy parent, to allow us to catch errors inside the
            // override
            methodUnit = new DeclaredMethodUnit(p_name, this, getErrors(), p_location);
        }

        m_abstractMethodNames.remove(p_name);
        OverriddenMethodUnit override =
            new OverriddenMethodUnit(methodUnit, this, getErrors(), p_location);
        m_overrides.add(override);
        return override;
    }

    public MethodUnit getMethodUnit(String p_name)
    {
        return (m_methods.containsKey(p_name)
               ? m_methods.get(p_name)
               : m_parentDescription.getMethodUnits().get(p_name));
    }

    public Iterator<MethodUnit> getSignatureMethodUnits()
    {
        return new SequentialIterator<MethodUnit>
            (getDeclaredMethodUnits(),
             m_parentDescription.getMethodUnits().values().iterator());
    }

    public Iterator<MethodUnit> getDeclaredMethodUnits()
    {