Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) 2003 The Visigoth Software Society. All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
  *
  * 3. The end-user documentation included with the redistribution, if
  *    any, must include the following acknowledgement:
  *       "This product includes software developed by the
  *        Visigoth Software Society (http://www.visigoths.org/)."
  *    Alternately, this acknowledgement may appear in the software itself,
  *    if and wherever such third-party acknowledgements normally appear.
  *
  * 4. Neither the name "FreeMarker", "Visigoth", nor any of the names of the 
  *    project contributors may be used to endorse or promote products derived
  *    from this software without prior written permission. For written
  *    permission, please contact visigoths@visigoths.org.
  *
  * 5. Products derived from this software may not be called "FreeMarker" or "Visigoth"
  *    nor may "FreeMarker" or "Visigoth" appear in their names
  *    without prior written permission of the Visigoth Software Society.
  *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED.  IN NO EVENT SHALL THE VISIGOTH SOFTWARE SOCIETY OR
  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * ====================================================================
  *
  * This software consists of voluntary contributions made by many
  * individuals on behalf of the Visigoth Software Society. For more
  * information on the Visigoth Software Society, please see
  * http://www.visigoths.org/
  */
 
 package freemarker.core;
 
 import java.util.*;
 
Objects that represent elements in the compiled tree representation of the template necessarily descend from this abstract class.
 
 abstract public class TemplateElement extends TemplateObject {
 
 
 // Only one of nestedBlock and nestedElements can be non-null.
 
 
     List nestedElements

    
Processes the contents of this TemplateElement and outputs the resulting text

Parameters:
env The runtime environment
 
     abstract void accept(Environment envthrows TemplateExceptionIOException;
 
     abstract public String getDescription();
     
 // Methods to implement TemplateNodeModel 
 
     public TemplateNodeModel getParentNode() {
 //        return parent;
          return null;
     }
     
     public String getNodeNamespace() {
         return null;
     }
     
     public String getNodeType() {
         return "element";
     }
    
        if ( != null) {
            return new SimpleSequence();
        }
        SimpleSequence result = new SimpleSequence();
        if ( != null) {
            result.add();
        } 
        return result;
    }
    
    public String getNodeName() {
        String classname = this.getClass().getName();
        int shortNameOffset = classname.lastIndexOf('.')+1;
        return classname.substring(shortNameOffset);
    }
    
// Methods so that we can implement the Swing TreeNode API.    
    public boolean isLeaf() {
        return  == null 
               && ( == null || .isEmpty());
    }
    public boolean getAllowsChildren() {
        return !isLeaf();
    }
    public int getIndex(TemplateElement node) {
        if ( instanceof MixedContent) {
            return .getIndex(node);
        }
        if ( != null) {
            if (node == ) {
                return 0;
            }
        }
        else if ( != null) {
            return .indexOf(node);
        }
        return -1;
    }
    public int getChildCount() {
        if ( instanceof MixedContent) {
            return .getChildCount();
        }
        if ( != null) {
            return 1;
        }
        else if ( != null) {
            return .size();
        }
        return 0;
    }
    public Enumeration children() {
        if ( instanceof MixedContent) {
            return .children();
        }
        if ( != null) {
            return Collections.enumeration(Collections12.singletonList());
        }
        else if ( != null) {
            return Collections.enumeration();
        }
        return Collections.enumeration(.);
    }
    public TemplateElement getChildAt(int index) {
        if ( instanceof MixedContent) {
            return .getChildAt(index);
        }
        if ( != null) {
            if (index == 0) {
                return ;
            }
            throw new ArrayIndexOutOfBoundsException("invalid index");
        }
        else if ( != null) {
            return(TemplateElement.get(index);
        }
        throw new ArrayIndexOutOfBoundsException("element has no children");
    }
    public void setChildAt(int indexTemplateElement element) {
        if( instanceof MixedContent) {
            .setChildAt(indexelement);
        }
        else if( != null) {
            if(index == 0) {
                 = element;
                element.parent = this;
            }
            else {
                throw new IndexOutOfBoundsException("invalid index");
            }
        }
        else if( != null) {
            .set(indexelement);
            element.parent = this;
        }
        else {
            throw new IndexOutOfBoundsException("element has no children");
        }
    }
    
    public TemplateElement getParent() {
        return ;
    }
    // Walk the tree and set the parent field in all the nested elements recursively.
    void setParentRecursively(TemplateElement parent) {
        this. = parent;
        int nestedSize =  == null ? 0 : .size();
        for (int i = 0; i < nestedSizei++) {
            ((TemplateElement.get(i)).setParentRecursively(this);
        }
        if ( != null) {
            .setParentRecursively(this);
        }
    }

    
We walk the tree and do some cleanup

Parameters:
stripWhitespace whether to clean up superfluous whitespace
    TemplateElement postParseCleanup(boolean stripWhitespacethrows ParseException {
        if ( != null) {
            for (int i = 0; i < .size(); i++) {
                TemplateElement te = (TemplateElement.get(i);
                te = te.postParseCleanup(stripWhitespace);
                .set(ite);
                te.parent = this;
            }
            if (stripWhitespace) {
                for (Iterator it = .iterator(); it.hasNext();) {
                    TemplateElement te = (TemplateElementit.next();
                    if (te.isIgnorable()) {
                        it.remove();
                    }
                }
            }
            if ( instanceof ArrayList) {
                ((ArrayList).trimToSize();
            }
        }
        if ( != null) {
             = .postParseCleanup(stripWhitespace);
            if (.isIgnorable()) {
                 = null;
            } else {
                . = this;
            }
        }
        return this;
    }
    boolean isIgnorable() {
        return false;
    }
// The following methods exist to support some fancier tree-walking 
// and were introduced to support the whitespace cleanup feature in 2.2
        TemplateElement prev = previousSibling();
        if (prev != null) {
            return prev.getLastLeaf();
        }
        else if ( != null) {
            return .prevTerminalNode();
        }
        return null;
    }
        TemplateElement next = nextSibling();
        if (next != null) {
            return next.getFirstLeaf();
        }
        else if ( != null) {
            return .nextTerminalNode();
        }
        return null;
    }
        if ( == null) {
            return null;
        }
        List siblings = .;
        if (siblings == null) {
            return null;
        }
        for (int i = siblings.size() - 1; i>=0; i--) {
            if (siblings.get(i) == this) {
                return(i >0) ? (TemplateElementsiblings.get(i-1) : null;
            }
        }
        return null;
    }
        if ( == null) {
            return null;
        }
        List siblings = .;
        if (siblings == null) {
            return null;
        }
        for (int i = 0; i < siblings.size(); i++) {
            if (siblings.get(i) == this) {
                return (i+1) < siblings.size() ? (TemplateElementsiblings.get(i+1) : null;
            }
        }
        return null;
    }
    private TemplateElement getFirstChild() {
        if ( != null) {
            return ;
        }
        if ( != null && .size() >0) {
            return(TemplateElement.get(0);
        }
        return null;
    }
    private TemplateElement getLastChild() {
        if ( != null) {
            return ;
        }
        if ( != null && .size() >0) {
            return(TemplateElement.get(.size() -1);
        }
        return null;
    }
    private TemplateElement getFirstLeaf() {
        TemplateElement te = this;
        while (!te.isLeaf() && !(te instanceof Macro) && !(te instanceof BlockAssignment)) {
             // A macro or macro invocation is treated as a leaf here for special reasons
            te = te.getFirstChild();
        }
        return te;
    }
    private TemplateElement getLastLeaf() {
        TemplateElement te = this;
        while (!te.isLeaf() && !(te instanceof Macro) && !(te instanceof BlockAssignment)) {
            // A macro or macro invocation is treated as a leaf here for special reasons
            te = te.getLastChild();
        }
        return te;
    }

    
determines whether this element's presence on a line indicates that we should not strip opening whitespace in the post-parse whitespace gobbling step.
    boolean heedsOpeningWhitespace() {
        return false;
    }

    
determines whether this element's presence on a line indicates that we should not strip trailing whitespace in the post-parse whitespace gobbling step.
    boolean heedsTrailingWhitespace() {
        return false;
    }
New to GrepCode? Check out our FAQ X