View Javadoc

1   package org.apache.velocity.runtime.parser.node;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.    
20   */
21  
22  /**
23   * Handles number addition of nodes.<br><br>
24   *
25   * Please look at the Parser.jjt file which is
26   * what controls the generation of this class.
27   *
28   * @author <a href="mailto:wglass@forio.com">Will Glass-Husain</a>
29   * @author <a href="mailto:pero@antaramusic.de">Peter Romianowski</a>
30   * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
31   * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
32   * @version $Id: ASTAddNode.java 517553 2007-03-13 06:09:58Z wglass $
33   */
34  import org.apache.velocity.context.InternalContextAdapter;
35  import org.apache.velocity.exception.MethodInvocationException;
36  import org.apache.velocity.runtime.parser.Parser;
37  import org.apache.velocity.util.TemplateNumber;
38  
39  /**
40   *
41   */
42  public class ASTAddNode extends SimpleNode
43  {
44      /**
45       * @param id
46       */
47      public ASTAddNode(int id)
48      {
49          super(id);
50      }
51  
52      /**
53       * @param p
54       * @param id
55       */
56      public ASTAddNode(Parser p, int id)
57      {
58          super(p, id);
59      }
60  
61      /**
62       * @see org.apache.velocity.runtime.parser.node.SimpleNode#jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object)
63       */
64      public Object jjtAccept(ParserVisitor visitor, Object data)
65      {
66          return visitor.visit(this, data);
67      }
68  
69      /**
70       *  computes the sum of the two nodes.
71       * @param context
72       *  @return result or null
73       * @throws MethodInvocationException
74       */
75      public Object value( InternalContextAdapter context)
76          throws MethodInvocationException
77      {
78          /*
79           *  get the two addends
80           */
81  
82          Object left = jjtGetChild(0).value(context);
83          Object right = jjtGetChild(1).value(context);
84  
85          /*
86           *  if either is null, lets log and bail
87           */
88  
89          if (left == null || right == null)
90          {
91              log.error((left == null ? "Left" : "Right")
92                             + " side ("
93                             + jjtGetChild( (left == null? 0 : 1) ).literal()
94                             + ") of addition operation has null value."
95                             + " Operation not possible. "
96                             + context.getCurrentTemplateName() + " [line " + getLine()
97                             + ", column " + getColumn() + "]");
98              return null;
99          }
100 
101         /*
102          *  convert to Number if applicable
103          */
104         if (left instanceof TemplateNumber)
105         {
106            left = ( (TemplateNumber) left).getAsNumber();
107         }
108         if (right instanceof TemplateNumber)
109         {
110            right = ( (TemplateNumber) right).getAsNumber();
111         }
112 
113         /*
114          * Arithmetic operation.
115          */
116         if (left instanceof Number && right instanceof Number)
117         {
118             return MathUtils.add((Number)left, (Number)right);
119         }
120 
121         /*
122          * shall we try for strings?
123          */
124         if (left instanceof String || right instanceof String)
125         {
126             return left.toString().concat(right.toString());
127         }
128         /*
129          *  if not a Number or Strings, not much we can do right now
130          */
131         log.error((!(left instanceof Number || left instanceof String) ? "Left" : "Right")
132                        + " side of addition operation is not a valid type. "
133                        + "Currently only Strings, numbers (1,2,3...) and Number type are supported. "
134                        + context.getCurrentTemplateName() + " [line " + getLine()
135                        + ", column " + getColumn() + "]");
136 
137         return null;
138     }
139 }
140 
141 
142 
143