View Javadoc

1   /*** 
2    * 
3    * Copyright 2004 Hiram Chirino
4    * 
5    * Licensed under the Apache License, Version 2.0 (the "License"); 
6    * you may not use this file except in compliance with the License. 
7    * You may obtain a copy of the License at 
8    * 
9    * http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS, 
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
14   * See the License for the specific language governing permissions and 
15   * limitations under the License. 
16   * 
17   **/
18  package org.codehaus.activemq.filter;
19  
20  import javax.jms.JMSException;
21  import javax.jms.Message;
22  
23  /***
24   * An expression which performs an operation on two expression values
25   * 
26   * @version $Revision: 1.1 $
27   */
28  public abstract class UnaryExpression implements Expression {
29  
30      protected Expression right;
31  
32      public static Expression createNegate(Expression left) {
33          return new UnaryExpression(left) {
34              public Object evaluate(Message message) throws JMSException {
35                  Object lvalue = right.evaluate(message);
36                  if (lvalue == null) {
37                      return null;
38                  }
39                  if (lvalue instanceof Number) {
40                      return negate((Number) lvalue);
41                  }
42                  throw new RuntimeException("Cannot call negate operation on: " + lvalue);
43              }
44  
45              public String getExpressionSymbol() {
46                  return "-";
47              }
48          };
49      }
50  
51      abstract static class BooleanUnaryExpression extends UnaryExpression implements BooleanExpression {
52          public BooleanUnaryExpression(Expression left) {
53              super(left);
54          }
55      };
56      
57      public static BooleanExpression createNOT(BooleanExpression left) {
58          return new BooleanUnaryExpression(left) {
59              public Object evaluate(Message message) throws JMSException {
60                  Boolean lvalue = (Boolean) right.evaluate(message);
61                  if (lvalue == null) {
62                      return null;
63                  }
64                  return lvalue.booleanValue() ? Boolean.FALSE : Boolean.TRUE;
65              }
66  
67              public String getExpressionSymbol() {
68                  return "NOT";
69              }
70          };
71      }
72  
73      private static Number negate(Number left) {
74          if (left instanceof Integer) {
75              return new Integer(-left.intValue());
76          }
77          else if (left instanceof Long) {
78              return new Long(-left.longValue());
79          }
80          else {
81              return new Double(-left.doubleValue());
82          }
83      }
84  
85      public UnaryExpression(Expression left) {
86          this.right = left;
87      }
88  
89      public Expression getRight() {
90          return right;
91      }
92  
93      public void setRight(Expression expression) {
94          right = expression;
95      }
96  
97      /***
98       * @see java.lang.Object#toString()
99       */
100     public String toString() {
101         return "(" + getExpressionSymbol() + " " + right.toString() + ")";
102     }
103 
104     /***
105      * TODO: more efficient hashCode()
106      *
107      * @see java.lang.Object#hashCode()
108      */
109     public int hashCode() {
110         return toString().hashCode();
111     }
112 
113     /***
114      * TODO: more efficient hashCode()
115      *
116      * @see java.lang.Object#equals(java.lang.Object)
117      */
118     public boolean equals(Object o) {
119 
120         if (o == null || !this.getClass().equals(o.getClass())) {
121             return false;
122         }
123         return toString().equals(o.toString());
124 
125     }
126 
127     /***
128      * Returns the symbol that represents this binary expression.  For example, addition is
129      * represented by "+"
130      *
131      * @return
132      */
133     abstract public String getExpressionSymbol();
134 
135 }