001 /**
002 *
003 * Copyright 2004 Protique Ltd
004 * Copyright 2004 Hiram Chirino
005 *
006 * Licensed under the Apache License, Version 2.0 (the "License");
007 * you may not use this file except in compliance with the License.
008 * You may obtain a copy of the License at
009 *
010 * http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 *
018 **/
019 package org.activemq.filter;
020
021 import javax.jms.JMSException;
022 import javax.jms.Message;
023
024 /**
025 * An expression which performs an operation on two expression values
026 *
027 * @version $Revision: 1.1.1.1 $
028 */
029 public abstract class ArithmeticExpression extends BinaryExpression {
030
031 protected static final int INTEGER = 1;
032 protected static final int LONG = 2;
033 protected static final int DOUBLE = 3;
034
035 /**
036 * @param left
037 * @param right
038 */
039 public ArithmeticExpression(Expression left, Expression right) {
040 super(left, right);
041 }
042
043 public static Expression createPlus(Expression left, Expression right) {
044 return new ArithmeticExpression(left, right) {
045 protected Object evaluate(Object lvalue, Object rvalue) {
046 if (lvalue instanceof String) {
047 String text = (String) lvalue;
048 String answer = text + rvalue;
049 System.out.println("lvalue: " + lvalue + " rvalue: " + rvalue + " result: " + answer);
050 return answer;
051 }
052 else if (lvalue instanceof Number) {
053 return plus((Number) lvalue, asNumber(rvalue));
054 }
055 throw new RuntimeException("Cannot call plus operation on: " + lvalue + " and: " + rvalue);
056 }
057
058 public String getExpressionSymbol() {
059 return "+";
060 }
061 };
062 }
063
064 public static Expression createMinus(Expression left, Expression right) {
065 return new ArithmeticExpression(left, right) {
066 protected Object evaluate(Object lvalue, Object rvalue) {
067 if (lvalue instanceof Number) {
068 return minus((Number) lvalue, asNumber(rvalue));
069 }
070 throw new RuntimeException("Cannot call minus operation on: " + lvalue + " and: " + rvalue);
071 }
072
073 public String getExpressionSymbol() {
074 return "-";
075 }
076 };
077 }
078
079 public static Expression createMultiply(Expression left, Expression right) {
080 return new ArithmeticExpression(left, right) {
081
082 protected Object evaluate(Object lvalue, Object rvalue) {
083 if (lvalue instanceof Number) {
084 return multiply((Number) lvalue, asNumber(rvalue));
085 }
086 throw new RuntimeException("Cannot call multiply operation on: " + lvalue + " and: " + rvalue);
087 }
088
089 public String getExpressionSymbol() {
090 return "*";
091 }
092 };
093 }
094
095 public static Expression createDivide(Expression left, Expression right) {
096 return new ArithmeticExpression(left, right) {
097
098 protected Object evaluate(Object lvalue, Object rvalue) {
099 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 }