View Javadoc

1   /*** 
2    * 
3    * Copyright 2004 Protique Ltd
4    * Copyright 2004 Hiram Chirino
5    * 
6    * Licensed under the Apache License, Version 2.0 (the "License"); 
7    * you may not use this file except in compliance with the License. 
8    * You may obtain a copy of the License at 
9    * 
10   * http://www.apache.org/licenses/LICENSE-2.0
11   * 
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS, 
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15   * See the License for the specific language governing permissions and 
16   * limitations under the License. 
17   * 
18   **/
19  package org.codehaus.activemq.filter;
20  
21  import javax.jms.JMSException;
22  import javax.jms.Message;
23  
24  /***
25   * An expression which performs an operation on two expression values
26   * 
27   * @version $Revision: 1.1 $
28   */
29  public abstract class ArithmeticExpression extends BinaryExpression {
30  
31      protected static final int INTEGER = 1;
32      protected static final int LONG = 2;
33      protected static final int DOUBLE = 3;
34  
35      /***
36       * @param left
37       * @param right
38       */
39      public ArithmeticExpression(Expression left, Expression right) {
40          super(left, right);
41      }
42  
43      public static Expression createPlus(Expression left, Expression right) {
44          return new ArithmeticExpression(left, right) {
45              protected Object evaluate(Object lvalue, Object rvalue) {
46                  if (lvalue instanceof String) {
47                      String text = (String) lvalue;
48                      String answer = text + rvalue;
49                      System.out.println("lvalue: " + lvalue + " rvalue: " + rvalue + " result: " + answer);
50                      return answer;
51                  }
52                  else if (lvalue instanceof Number) {
53                      return plus((Number) lvalue, asNumber(rvalue));
54                  }
55                  throw new RuntimeException("Cannot call plus operation on: " + lvalue + " and: " + rvalue);
56              }
57  
58              public String getExpressionSymbol() {
59                  return "+";
60              }
61          };
62      }
63  
64      public static Expression createMinus(Expression left, Expression right) {
65          return new ArithmeticExpression(left, right) {
66              protected Object evaluate(Object lvalue, Object rvalue) {
67                  if (lvalue instanceof Number) {
68                      return minus((Number) lvalue, asNumber(rvalue));
69                  }
70                  throw new RuntimeException("Cannot call minus operation on: " + lvalue + " and: " + rvalue);
71              }
72  
73              public String getExpressionSymbol() {
74                  return "-";
75              }
76          };
77      }
78  
79      public static Expression createMultiply(Expression left, Expression right) {
80          return new ArithmeticExpression(left, right) {
81  
82              protected Object evaluate(Object lvalue, Object rvalue) {
83                  if (lvalue instanceof Number) {
84                      return multiply((Number) lvalue, asNumber(rvalue));
85                  }
86                  throw new RuntimeException("Cannot call multiply operation on: " + lvalue + " and: " + rvalue);
87              }
88  
89              public String getExpressionSymbol() {
90                  return "*";
91              }
92          };
93      }
94  
95      public static Expression createDivide(Expression left, Expression right) {
96          return new ArithmeticExpression(left, right) {
97  
98              protected Object evaluate(Object lvalue, Object rvalue) {
99                  if (lvalue instanceof Number) {
100                     return divide((Number) lvalue, asNumber(rvalue));
101                 }
102                 throw new RuntimeException("Cannot call divide operation on: " + lvalue + " and: " + rvalue);
103             }
104 
105             public String getExpressionSymbol() {
106                 return "/";
107             }
108         };
109     }
110 
111     public static Expression createMod(Expression left, Expression right) {
112         return new ArithmeticExpression(left, right) {
113 
114             protected Object evaluate(Object lvalue, Object rvalue) {
115                 if (lvalue instanceof Number) {
116                     return mod((Number) lvalue, asNumber(rvalue));
117                 }
118                 throw new RuntimeException("Cannot call mod operation on: " + lvalue + " and: " + rvalue);
119             }
120 
121             public String getExpressionSymbol() {
122                 return "%";
123             }
124         };
125     }
126 
127     protected Number plus(Number left, Number right) {
128         switch (numberType(left, right)) {
129             case INTEGER:
130                 return new Integer(left.intValue() + right.intValue());
131             case LONG:
132                 return new Long(left.longValue() + right.longValue());
133             default:
134                 return new Double(left.doubleValue() + right.doubleValue());
135         }
136     }
137 
138     protected Number minus(Number left, Number right) {
139         switch (numberType(left, right)) {
140             case INTEGER:
141                 return new Integer(left.intValue() - right.intValue());
142             case LONG:
143                 return new Long(left.longValue() - right.longValue());
144             default:
145                 return new Double(left.doubleValue() - right.doubleValue());
146         }
147     }
148 
149     protected Number multiply(Number left, Number right) {
150         switch (numberType(left, right)) {
151             case INTEGER:
152                 return new Integer(left.intValue() * right.intValue());
153             case LONG:
154                 return new Long(left.longValue() * right.longValue());
155             default:
156                 return new Double(left.doubleValue() * right.doubleValue());
157         }
158     }
159 
160     protected Number divide(Number left, Number right) {
161         return new Double(left.doubleValue() / right.doubleValue());
162     }
163 
164     protected Number mod(Number left, Number right) {
165         return new Double(left.doubleValue() % right.doubleValue());
166     }
167 
168     private int numberType(Number left, Number right) {
169         if (isDouble(left) || isDouble(right)) {
170             return DOUBLE;
171         }
172         else if (left instanceof Long || right instanceof Long) {
173             return LONG;
174         }
175         else {
176             return INTEGER;
177         }
178     }
179 
180     private boolean isDouble(Number n) {
181         return n instanceof Float || n instanceof Double;
182     }
183 
184     protected Number asNumber(Object value) {
185         if (value instanceof Number) {
186             return (Number) value;
187         }
188         else {
189             throw new RuntimeException("Cannot convert value: " + value + " into a number");
190         }
191     }
192 
193     public Object evaluate(Message message) throws JMSException {
194         Object lvalue = left.evaluate(message);
195         if (lvalue == null) {
196             return null;
197         }
198         Object rvalue = right.evaluate(message);
199         if (rvalue == null) {
200             return null;
201         }
202         return evaluate(lvalue, rvalue);
203     }
204 
205 
206     /***
207      * @param lvalue
208      * @param rvalue
209      * @return
210      */
211     abstract protected Object evaluate(Object lvalue, Object rvalue);
212 
213 }