UnaryExpression xref

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 }