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.*;

An operator for the + operator. Note that this is treated separately from the other 4 arithmetic operators, since + is overloaded to mean string concatenation.

Author(s):
Jonathan Revusky
 
 final class AddConcatExpression extends Expression {
 
     private final Expression left;
     private final Expression right;
 
     AddConcatExpression(Expression leftExpression right) {
         this. = left;
         this. = right;
     }
 
             throws TemplateException
     {
         TemplateModel leftModel = .getAsTemplateModel(env);
         TemplateModel rightModel = .getAsTemplateModel(env);
         if (leftModel instanceof TemplateNumberModel && rightModel instanceof TemplateNumberModel)
         {
             Number first = EvaluationUtil.getNumber((TemplateNumberModelleftModelenv);
             Number second = EvaluationUtil.getNumber((TemplateNumberModelrightModelenv);
             ArithmeticEngine ae =
                 env != null
                     ? env.getArithmeticEngine()
                     : getTemplate().getArithmeticEngine();
             return new SimpleNumber(ae.add(firstsecond));
         }
         else if(leftModel instanceof TemplateSequenceModel && rightModel instanceof TemplateSequenceModel)
         {
             return new ConcatenatedSequence((TemplateSequenceModel)leftModel, (TemplateSequenceModel)rightModel);
         }
         else
         {
             try {
                 String s1 = getStringValue(leftModelenv);
                 if(s1 == nulls1 = "null";
                 String s2 = getStringValue(rightModelenv);
                 if(s2 == nulls2 = "null";
                return new SimpleScalar(s1.concat(s2));
            } catch (NonStringException e) {
                if (leftModel instanceof TemplateHashModel && rightModel instanceof TemplateHashModel) {
                    if (leftModel instanceof TemplateHashModelEx && rightModel instanceof TemplateHashModelEx) {
                        TemplateHashModelEx leftModelEx = (TemplateHashModelEx)leftModel;
                        TemplateHashModelEx rightModelEx = (TemplateHashModelEx)rightModel;
                        if (leftModelEx.size() == 0) {
                            return rightModelEx;
                        } else if (rightModelEx.size() == 0) {
                            return leftModelEx;
                        } else {
                            return new ConcatenatedHashEx(leftModelExrightModelEx);
                        }
                    } else {
                        return new ConcatenatedHash((TemplateHashModel)leftModel,
                                                    (TemplateHashModel)rightModel);
                    }
                } else {
                    throw e;
                }
            }
        }
    }
    boolean isLiteral() {
        return  != null || (.isLiteral() && .isLiteral());
    }
    Expression _deepClone(String nameExpression subst) {
    	return new AddConcatExpression(.deepClone(namesubst), .deepClone(namesubst));
    }
    public String getCanonicalForm() {
        return .getCanonicalForm() + " + " + .getCanonicalForm();
    }
    private static final class ConcatenatedSequence
    implements
        TemplateSequenceModel
    {
        private final TemplateSequenceModel left;
        private final TemplateSequenceModel right;
        {
            this. = left;
            this. = right;
        }
        public int size()
        throws
            TemplateModelException
        {
            return .size() + .size();
        }
        public TemplateModel get(int i)
        throws
            TemplateModelException
        {
            int ls = .size();
            return i < ls ? .get(i) : .get(i - ls);
        }
    }
    private static class ConcatenatedHash
    implements TemplateHashModel
    {
        protected final TemplateHashModel left;
        protected final TemplateHashModel right;
        {
            this. = left;
            this. = right;
        }
        
        public TemplateModel get(String key)
        throws TemplateModelException
        {
            TemplateModel model = .get(key);
            return (model != null) ? model : .get(key);
        }
        public boolean isEmpty()
        throws TemplateModelException
        {
            return .isEmpty() && .isEmpty();
        }
    }
    private static final class ConcatenatedHashEx
    extends ConcatenatedHash
    implements TemplateHashModelEx
    {
        private CollectionAndSequence keys;
        private CollectionAndSequence values;
        private int size;
        {
            super(leftright);
        }
        
        public int size() throws TemplateModelException
        {
            initKeys();
            return ;
        }
        public TemplateCollectionModel keys()
        throws TemplateModelException
        {
            initKeys();
            return ;
        }
        public TemplateCollectionModel values()
        throws TemplateModelException
        {
            initValues();
            return ;
        }
        private void initKeys()
        throws TemplateModelException
        {
            if ( == null) {
                HashSet keySet = new HashSet();
                SimpleSequence keySeq = new SimpleSequence(32);
                addKeys(keySetkeySeq, (TemplateHashModelEx)this.);
                addKeys(keySetkeySeq, (TemplateHashModelEx)this.);
                 = keySet.size();
                 = new CollectionAndSequence(keySeq);
            }
        }
        private static void addKeys(Set setSimpleSequence keySeqTemplateHashModelEx hash)
        throws TemplateModelException
        {
            TemplateModelIterator it = hash.keys().iterator();
            while (it.hasNext()) {
                TemplateScalarModel tsm = (TemplateScalarModel)it.next();
                if (set.add(tsm.getAsString())) {
                    // The first occurence of the key decides the index;
                    // this is consisten with stuff like java.util.LinkedHashSet.
                    keySeq.add(tsm);
                }
            }
        }        
        private void initValues()
        throws TemplateModelException
        {
            if ( == null) {
                SimpleSequence seq = new SimpleSequence(size());
                // Note: size() invokes initKeys() if needed.
            
                int ln = .size();
                for (int i  = 0; i < lni++) {
                    seq.add(get(((TemplateScalarModel).get(i)).getAsString()));
                }
                 = new CollectionAndSequence(seq);
            }
        }
    }
New to GrepCode? Check out our FAQ X