QPID-394. Removed revision tags.

git-svn-id: https://svn.apache.org/repos/asf/incubator/qpid/branches/M2@531437 13f79535-47bb-0310-9956-ffa450edef68

6 files changed, 316 insertions, 241 deletions

diff --git a/java/broker/src/main/java/org/apache/qpid/server/filter/ArithmeticExpression.java b/java/broker/src/main/java/org/apache/qpid/server/filter/ArithmeticExpression.java
index 1b3b116fd0..138d4155b1 100644
--- a/java/broker/src/main/java/org/apache/qpid/server/filter/ArithmeticExpression.java
+++ b/java/broker/src/main/java/org/apache/qpid/server/filter/ArithmeticExpression.java
@@ -1,3 +1,4 @@
+/* Copyright Rupert Smith, 2005 to 2006, all rights reserved. */
 /**
  *
  * Licensed to the Apache Software Foundation (ASF) under one or more
@@ -20,16 +21,14 @@ package org.apache.qpid.server.filter;
 // Based on like named file from r450141 of the Apache ActiveMQ project <http://www.activemq.org/site/home.html>
 //
 
-
 import org.apache.qpid.AMQException;
 import org.apache.qpid.server.queue.AMQMessage;
 
 /**
  * An expression which performs an operation on two expression values
- * 
- * @version $Revision$
  */
-public abstract class ArithmeticExpression extends BinaryExpression {
+public abstract class ArithmeticExpression extends BinaryExpression
+{
 
     protected static final int INTEGER = 1;
     protected static final int LONG = 2;
@@ -39,156 +38,213 @@ public abstract class ArithmeticExpression extends BinaryExpression {
      * @param left
      * @param right
      */
-    public ArithmeticExpression(Expression left, Expression right) {
+    public ArithmeticExpression(Expression left, Expression right)
+    {
         super(left, right);
     }
 
-    public static Expression createPlus(Expression left, Expression right) {
-        return new ArithmeticExpression(left, right) {
-            protected Object evaluate(Object lvalue, Object rvalue) {
-                if (lvalue instanceof String) {
-                    String text = (String) lvalue;
-                    String answer = text + rvalue;
-                    return answer;
+    public static Expression createPlus(Expression left, Expression right)
+    {
+        return new ArithmeticExpression(left, right)
+            {
+                protected Object evaluate(Object lvalue, Object rvalue)
+                {
+                    if (lvalue instanceof String)
+                    {
+                        String text = (String) lvalue;
+                        String answer = text + rvalue;
+
+                        return answer;
+                    }
+                    else if (lvalue instanceof Number)
+                    {
+                        return plus((Number) lvalue, asNumber(rvalue));
+                    }
+
+                    throw new RuntimeException("Cannot call plus operation on: " + lvalue + " and: " + rvalue);
                 }
-                else if (lvalue instanceof Number) {
-                    return plus((Number) lvalue, asNumber(rvalue));
+
+                public String getExpressionSymbol()
+                {
+                    return "+";
                 }
-                throw new RuntimeException("Cannot call plus operation on: " + lvalue + " and: " + rvalue);
-            }
+            };
+    }
 
-            public String getExpressionSymbol()
+    public static Expression createMinus(Expression left, Expression right)
+    {
+        return new ArithmeticExpression(left, right)
             {
-                return "+";
-            }
-        };
-    }
+                protected Object evaluate(Object lvalue, Object rvalue)
+                {
+                    if (lvalue instanceof Number)
+                    {
+                        return minus((Number) lvalue, asNumber(rvalue));
+                    }
 
-    public static Expression createMinus(Expression left, Expression right) {
-        return new ArithmeticExpression(left, right) {
-            protected Object evaluate(Object lvalue, Object rvalue) {
-                if (lvalue instanceof Number) {
-                    return minus((Number) lvalue, asNumber(rvalue));
+                    throw new RuntimeException("Cannot call minus operation on: " + lvalue + " and: " + rvalue);
                 }
-                throw new RuntimeException("Cannot call minus operation on: " + lvalue + " and: " + rvalue);
-            }
 
-            public String getExpressionSymbol() {
-                return "-";
-            }
-        };
+                public String getExpressionSymbol()
+                {
+                    return "-";
+                }
+            };
     }
 
-    public static Expression createMultiply(Expression left, Expression right) {
-        return new ArithmeticExpression(left, right) {
+    public static Expression createMultiply(Expression left, Expression right)
+    {
+        return new ArithmeticExpression(left, right)
+            {
+
+                protected Object evaluate(Object lvalue, Object rvalue)
+                {
+                    if (lvalue instanceof Number)
+                    {
+                        return multiply((Number) lvalue, asNumber(rvalue));
+                    }
 
-            protected Object evaluate(Object lvalue, Object rvalue) {
-                if (lvalue instanceof Number) {
-                    return multiply((Number) lvalue, asNumber(rvalue));
+                    throw new RuntimeException("Cannot call multiply operation on: " + lvalue + " and: " + rvalue);
                 }
-                throw new RuntimeException("Cannot call multiply operation on: " + lvalue + " and: " + rvalue);
-            }
 
-            public String getExpressionSymbol() {
-                return "*";
-            }
-        };
+                public String getExpressionSymbol()
+                {
+                    return "*";
+                }
+            };
     }
 
-    public static Expression createDivide(Expression left, Expression right) {
-        return new ArithmeticExpression(left, right) {
+    public static Expression createDivide(Expression left, Expression right)
+    {
+        return new ArithmeticExpression(left, right)
+            {
 
-            protected Object evaluate(Object lvalue, Object rvalue) {
-                if (lvalue instanceof Number) {
-                    return divide((Number) lvalue, asNumber(rvalue));
+                protected Object evaluate(Object lvalue, Object rvalue)
+                {
+                    if (lvalue instanceof Number)
+                    {
+                        return divide((Number) lvalue, asNumber(rvalue));
+                    }
+
+                    throw new RuntimeException("Cannot call divide operation on: " + lvalue + " and: " + rvalue);
                 }
-                throw new RuntimeException("Cannot call divide operation on: " + lvalue + " and: " + rvalue);
-            }
 
-            public String getExpressionSymbol() {
-                return "/";
-            }
-        };
+                public String getExpressionSymbol()
+                {
+                    return "/";
+                }
+            };
     }
 
-    public static Expression createMod(Expression left, Expression right) {
-        return new ArithmeticExpression(left, right) {
+    public static Expression createMod(Expression left, Expression right)
+    {
+        return new ArithmeticExpression(left, right)
+            {
+
+                protected Object evaluate(Object lvalue, Object rvalue)
+                {
+                    if (lvalue instanceof Number)
+                    {
+                        return mod((Number) lvalue, asNumber(rvalue));
+                    }
 
-            protected Object evaluate(Object lvalue, Object rvalue) {
-                if (lvalue instanceof Number) {
-                    return mod((Number) lvalue, asNumber(rvalue));
+                    throw new RuntimeException("Cannot call mod operation on: " + lvalue + " and: " + rvalue);
                 }
-                throw new RuntimeException("Cannot call mod operation on: " + lvalue + " and: " + rvalue);
-            }
 
-            public String getExpressionSymbol() {
-                return "%";
-            }
-        };
+                public String getExpressionSymbol()
+                {
+                    return "%";
+                }
+            };
     }
 
-    protected Number plus(Number left, Number right) {
-        switch (numberType(left, right)) {
-            case INTEGER:
-                return new Integer(left.intValue() + right.intValue());
-            case LONG:
-                return new Long(left.longValue() + right.longValue());
-            default:
-                return new Double(left.doubleValue() + right.doubleValue());
+    protected Number plus(Number left, Number right)
+    {
+        switch (numberType(left, right))
+        {
+
+        case INTEGER:
+            return new Integer(left.intValue() + right.intValue());
+
+        case LONG:
+            return new Long(left.longValue() + right.longValue());
+
+        default:
+            return new Double(left.doubleValue() + right.doubleValue());
         }
     }
 
-    protected Number minus(Number left, Number right) {
-        switch (numberType(left, right)) {
-            case INTEGER:
-                return new Integer(left.intValue() - right.intValue());
-            case LONG:
-                return new Long(left.longValue() - right.longValue());
-            default:
-                return new Double(left.doubleValue() - right.doubleValue());
+    protected Number minus(Number left, Number right)
+    {
+        switch (numberType(left, right))
+        {
+
+        case INTEGER:
+            return new Integer(left.intValue() - right.intValue());
+
+        case LONG:
+            return new Long(left.longValue() - right.longValue());
+
+        default:
+            return new Double(left.doubleValue() - right.doubleValue());
         }
     }
 
-    protected Number multiply(Number left, Number right) {
-        switch (numberType(left, right)) {
-            case INTEGER:
-                return new Integer(left.intValue() * right.intValue());
-            case LONG:
-                return new Long(left.longValue() * right.longValue());
-            default:
-                return new Double(left.doubleValue() * right.doubleValue());
+    protected Number multiply(Number left, Number right)
+    {
+        switch (numberType(left, right))
+        {
+
+        case INTEGER:
+            return new Integer(left.intValue() * right.intValue());
+
+        case LONG:
+            return new Long(left.longValue() * right.longValue());
+
+        default:
+            return new Double(left.doubleValue() * right.doubleValue());
         }
     }
 
-    protected Number divide(Number left, Number right) {
+    protected Number divide(Number left, Number right)
+    {
         return new Double(left.doubleValue() / right.doubleValue());
     }
 
-    protected Number mod(Number left, Number right) {
+    protected Number mod(Number left, Number right)
+    {
         return new Double(left.doubleValue() % right.doubleValue());
     }
 
-    private int numberType(Number left, Number right) {
-        if (isDouble(left) || isDouble(right)) {
+    private int numberType(Number left, Number right)
+    {
+        if (isDouble(left) || isDouble(right))
+        {
             return DOUBLE;
         }
-        else if (left instanceof Long || right instanceof Long) {
+        else if ((left instanceof Long) || (right instanceof Long))
+        {
             return LONG;
         }
-        else {
+        else
+        {
             return INTEGER;
         }
     }
 
-    private boolean isDouble(Number n) {
-        return n instanceof Float || n instanceof Double;
+    private boolean isDouble(Number n)
+    {
+        return (n instanceof Float) || (n instanceof Double);
     }
 
-    protected Number asNumber(Object value) {
-        if (value instanceof Number) {
+    protected Number asNumber(Object value)
+    {
+        if (value instanceof Number)
+        {
             return (Number) value;
         }
-        else {
+        else
+        {
             throw new RuntimeException("Cannot convert value: " + value + " into a number");
         }
     }
@@ -196,22 +252,25 @@ public abstract class ArithmeticExpression extends BinaryExpression {
     public Object evaluate(AMQMessage message) throws AMQException
     {
         Object lvalue = left.evaluate(message);
-        if (lvalue == null) {
+        if (lvalue == null)
+        {
             return null;
         }
+
         Object rvalue = right.evaluate(message);
-        if (rvalue == null) {
+        if (rvalue == null)
+        {
             return null;
         }
+
         return evaluate(lvalue, rvalue);
     }
 
-
     /**
      * @param lvalue
      * @param rvalue
      * @return
      */
-    abstract protected Object evaluate(Object lvalue, Object rvalue);
+    protected abstract Object evaluate(Object lvalue, Object rvalue);
 
 }
diff --git a/java/broker/src/main/java/org/apache/qpid/server/filter/BinaryExpression.java b/java/broker/src/main/java/org/apache/qpid/server/filter/BinaryExpression.java
index 4256ab9189..1a1024bd2b 100644
--- a/java/broker/src/main/java/org/apache/qpid/server/filter/BinaryExpression.java
+++ b/java/broker/src/main/java/org/apache/qpid/server/filter/BinaryExpression.java
@@ -1,3 +1,4 @@
+/* Copyright Rupert Smith, 2005 to 2006, all rights reserved. */
 /**
  *
  * Licensed to the Apache Software Foundation (ASF) under one or more
@@ -20,35 +21,35 @@ package org.apache.qpid.server.filter;
 // Based on like named file from r450141 of the Apache ActiveMQ project <http://www.activemq.org/site/home.html>
 //
 
-
-
 /**
  * An expression which performs an operation on two expression values.
- * 
- * @version $Revision$
  */
-abstract public class BinaryExpression implements Expression {
+public abstract class BinaryExpression implements Expression
+{
     protected Expression left;
     protected Expression right;
 
-    public BinaryExpression(Expression left, Expression right) {
+    public BinaryExpression(Expression left, Expression right)
+    {
         this.left = left;
         this.right = right;
     }
 
-    public Expression getLeft() {
+    public Expression getLeft()
+    {
         return left;
     }
 
-    public Expression getRight() {
+    public Expression getRight()
+    {
         return right;
     }
 
-
     /**
      * @see java.lang.Object#toString()
      */
-    public String toString() {
+    public String toString()
+    {
         return "(" + left.toString() + " " + getExpressionSymbol() + " " + right.toString() + ")";
     }
 
@@ -57,7 +58,8 @@ abstract public class BinaryExpression implements Expression {
      *
      * @see java.lang.Object#hashCode()
      */
-    public int hashCode() {
+    public int hashCode()
+    {
         return toString().hashCode();
     }
 
@@ -66,11 +68,14 @@ abstract public class BinaryExpression implements Expression {
      *
      * @see java.lang.Object#equals(java.lang.Object)
      */
-    public boolean equals(Object o) {
+    public boolean equals(Object o)
+    {
 
-        if (o == null || !this.getClass().equals(o.getClass())) {
+        if ((o == null) || !this.getClass().equals(o.getClass()))
+        {
             return false;
         }
+
         return toString().equals(o.toString());
 
     }
@@ -81,20 +86,22 @@ abstract public class BinaryExpression implements Expression {
      *
      * @return
      */
-    abstract public String getExpressionSymbol();
+    public abstract String getExpressionSymbol();
 
     /**
      * @param expression
      */
-    public void setRight(Expression expression) {
+    public void setRight(Expression expression)
+    {
         right = expression;
     }
 
     /**
      * @param expression
      */
-    public void setLeft(Expression expression) {
+    public void setLeft(Expression expression)
+    {
         left = expression;
     }
-    
+
 }
diff --git a/java/broker/src/main/java/org/apache/qpid/server/filter/BooleanExpression.java b/java/broker/src/main/java/org/apache/qpid/server/filter/BooleanExpression.java
index 122527d4f3..0d5c5009f7 100644
--- a/java/broker/src/main/java/org/apache/qpid/server/filter/BooleanExpression.java
+++ b/java/broker/src/main/java/org/apache/qpid/server/filter/BooleanExpression.java
@@ -1,3 +1,4 @@
+/* Copyright Rupert Smith, 2005 to 2006, all rights reserved. */
 /**
  *
  * Licensed to the Apache Software Foundation (ASF) under one or more
@@ -20,18 +21,12 @@ package org.apache.qpid.server.filter;
 // Based on like named file from r450141 of the Apache ActiveMQ project <http://www.activemq.org/site/home.html>
 //
 
-
 import org.apache.qpid.AMQException;
 import org.apache.qpid.server.queue.AMQMessage;
 
-
-
-
 /**
  * A BooleanExpression is an expression that always
  * produces a Boolean result.
- *
- * @version $Revision$
  */
 public interface BooleanExpression extends Expression
 {
diff --git a/java/broker/src/main/java/org/apache/qpid/server/filter/ComparisonExpression.java b/java/broker/src/main/java/org/apache/qpid/server/filter/ComparisonExpression.java
index cedb8d7ca8..606a59e0fa 100644
--- a/java/broker/src/main/java/org/apache/qpid/server/filter/ComparisonExpression.java
+++ b/java/broker/src/main/java/org/apache/qpid/server/filter/ComparisonExpression.java
@@ -1,3 +1,4 @@
+/* Copyright Rupert Smith, 2005 to 2006, all rights reserved. */
 /*
  *
  * Licensed to the Apache Software Foundation (ASF) under one
@@ -32,8 +33,6 @@ import org.apache.qpid.server.queue.AMQMessage;
 
 /**
  * A filter performing a comparison of two objects
- *
- * @version $Revision$
  */
 public abstract class ComparisonExpression extends BinaryExpression implements BooleanExpression
 {
@@ -153,7 +152,7 @@ public abstract class ComparisonExpression extends BinaryExpression implements B
             {
                 return
                     Boolean.FALSE;
-                    //throw new RuntimeException("LIKE can only operate on String identifiers.  LIKE attemped on: '" + rv.getClass());
+                    // throw new RuntimeException("LIKE can only operate on String identifiers.  LIKE attemped on: '" + rv.getClass());
             }
 
             return likePattern.matcher((String) rv).matches() ? Boolean.TRUE : Boolean.FALSE;
@@ -240,42 +239,42 @@ public abstract class ComparisonExpression extends BinaryExpression implements B
     private static BooleanExpression doCreateEqual(Expression left, Expression right)
     {
         return new ComparisonExpression(left, right)
-        {
-
-            public Object evaluate(AMQMessage message) throws AMQException
             {
-                Object lv = left.evaluate(message);
-                Object rv = right.evaluate(message);
 
-                // Iff one of the values is null
-                if ((lv == null) ^ (rv == null))
+                public Object evaluate(AMQMessage message) throws AMQException
                 {
+                    Object lv = left.evaluate(message);
+                    Object rv = right.evaluate(message);
+
+                    // Iff one of the values is null
+                    if ((lv == null) ^ (rv == null))
+                    {
+                        return Boolean.FALSE;
+                    }
+
+                    if ((lv == rv) || lv.equals(rv))
+                    {
+                        return Boolean.TRUE;
+                    }
+
+                    if ((lv instanceof Comparable) && (rv instanceof Comparable))
+                    {
+                        return compare((Comparable) lv, (Comparable) rv);
+                    }
+
                     return Boolean.FALSE;
                 }
 
-                if ((lv == rv) || lv.equals(rv))
+                protected boolean asBoolean(int answer)
                 {
-                    return Boolean.TRUE;
+                    return answer == 0;
                 }
 
-                if ((lv instanceof Comparable) && (rv instanceof Comparable))
+                public String getExpressionSymbol()
                 {
-                    return compare((Comparable) lv, (Comparable) rv);
+                    return "=";
                 }
-
-                return Boolean.FALSE;
-            }
-
-            protected boolean asBoolean(int answer)
-            {
-                return answer == 0;
-            }
-
-            public String getExpressionSymbol()
-            {
-                return "=";
-            }
-        };
+            };
     }
 
     public static BooleanExpression createGreaterThan(final Expression left, final Expression right)
@@ -284,17 +283,17 @@ public abstract class ComparisonExpression extends BinaryExpression implements B
         checkLessThanOperand(right);
 
         return new ComparisonExpression(left, right)
-        {
-            protected boolean asBoolean(int answer)
             {
-                return answer > 0;
-            }
+                protected boolean asBoolean(int answer)
+                {
+                    return answer > 0;
+                }
 
-            public String getExpressionSymbol()
-            {
-                return ">";
-            }
-        };
+                public String getExpressionSymbol()
+                {
+                    return ">";
+                }
+            };
     }
 
     public static BooleanExpression createGreaterThanEqual(final Expression left, final Expression right)
@@ -303,17 +302,17 @@ public abstract class ComparisonExpression extends BinaryExpression implements B
         checkLessThanOperand(right);
 
         return new ComparisonExpression(left, right)
-        {
-            protected boolean asBoolean(int answer)
             {
-                return answer >= 0;
-            }
+                protected boolean asBoolean(int answer)
+                {
+                    return answer >= 0;
+                }
 
-            public String getExpressionSymbol()
-            {
-                return ">=";
-            }
-        };
+                public String getExpressionSymbol()
+                {
+                    return ">=";
+                }
+            };
     }
 
     public static BooleanExpression createLessThan(final Expression left, final Expression right)
@@ -322,19 +321,19 @@ public abstract class ComparisonExpression extends BinaryExpression implements B
         checkLessThanOperand(right);
 
         return new ComparisonExpression(left, right)
-        {
-
-            protected boolean asBoolean(int answer)
             {
-                return answer < 0;
-            }
 
-            public String getExpressionSymbol()
-            {
-                return "<";
-            }
+                protected boolean asBoolean(int answer)
+                {
+                    return answer < 0;
+                }
+
+                public String getExpressionSymbol()
+                {
+                    return "<";
+                }
 
-        };
+            };
     }
 
     public static BooleanExpression createLessThanEqual(final Expression left, final Expression right)
@@ -343,18 +342,18 @@ public abstract class ComparisonExpression extends BinaryExpression implements B
         checkLessThanOperand(right);
 
         return new ComparisonExpression(left, right)
-        {
-
-            protected boolean asBoolean(int answer)
             {
-                return answer <= 0;
-            }
 
-            public String getExpressionSymbol()
-            {
-                return "<=";
-            }
-        };
+                protected boolean asBoolean(int answer)
+                {
+                    return answer <= 0;
+                }
+
+                public String getExpressionSymbol()
+                {
+                    return "<=";
+                }
+            };
     }
 
     /**
diff --git a/java/broker/src/main/java/org/apache/qpid/server/filter/Expression.java b/java/broker/src/main/java/org/apache/qpid/server/filter/Expression.java
index 4a2130e767..cb40a32290 100644
--- a/java/broker/src/main/java/org/apache/qpid/server/filter/Expression.java
+++ b/java/broker/src/main/java/org/apache/qpid/server/filter/Expression.java
@@ -1,3 +1,4 @@
+/* Copyright Rupert Smith, 2005 to 2006, all rights reserved. */
 /**
  *
  * Licensed to the Apache Software Foundation (ASF) under one or more
@@ -15,7 +16,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package org.apache.qpid.server.filter;
 //
 // Based on like named file from r450141 of the Apache ActiveMQ project <http://www.activemq.org/site/home.html>
@@ -24,11 +24,8 @@ package org.apache.qpid.server.filter;
 import org.apache.qpid.AMQException;
 import org.apache.qpid.server.queue.AMQMessage;
 
-
 /**
  * Represents an expression
- * 
- * @version $Revision$
  */
 public interface Expression
 {
@@ -37,5 +34,5 @@ public interface Expression
      * @return the value of this expression
      */
     public Object evaluate(AMQMessage message) throws AMQException;
-    
+
 }
diff --git a/java/broker/src/main/java/org/apache/qpid/server/filter/LogicExpression.java b/java/broker/src/main/java/org/apache/qpid/server/filter/LogicExpression.java
index dea6092b8a..a90775a186 100644
--- a/java/broker/src/main/java/org/apache/qpid/server/filter/LogicExpression.java
+++ b/java/broker/src/main/java/org/apache/qpid/server/filter/LogicExpression.java
@@ -1,3 +1,4 @@
+/* Copyright Rupert Smith, 2005 to 2006, all rights reserved. */
 /**
  *
  * Licensed to the Apache Software Foundation (ASF) under one or more
@@ -25,69 +26,86 @@ import org.apache.qpid.server.queue.AMQMessage;
 
 /**
  * A filter performing a comparison of two objects
- * 
- * @version $Revision$
  */
-public abstract class LogicExpression extends BinaryExpression implements BooleanExpression {
-
-    public static BooleanExpression createOR(BooleanExpression lvalue, BooleanExpression rvalue) {
-        return new LogicExpression(lvalue, rvalue) {
-        	
-            public Object evaluate(AMQMessage message) throws AMQException {
-                
-            	Boolean lv = (Boolean) left.evaluate(message);
-                // Can we do an OR shortcut??
-            	if (lv !=null && lv.booleanValue()) {
-                    return Boolean.TRUE;
+public abstract class LogicExpression extends BinaryExpression implements BooleanExpression
+{
+
+    public static BooleanExpression createOR(BooleanExpression lvalue, BooleanExpression rvalue)
+    {
+        return new LogicExpression(lvalue, rvalue)
+            {
+
+                public Object evaluate(AMQMessage message) throws AMQException
+                {
+
+                    Boolean lv = (Boolean) left.evaluate(message);
+                    // Can we do an OR shortcut??
+                    if ((lv != null) && lv.booleanValue())
+                    {
+                        return Boolean.TRUE;
+                    }
+
+                    Boolean rv = (Boolean) right.evaluate(message);
+
+                    return (rv == null) ? null : rv;
+                }
+
+                public String getExpressionSymbol()
+                {
+                    return "OR";
                 }
-            	
-                Boolean rv = (Boolean) right.evaluate(message);
-                return rv==null ? null : rv;
-            }
-
-            public String getExpressionSymbol() {
-                return "OR";
-            }
-        };
+            };
     }
 
-    public static BooleanExpression createAND(BooleanExpression lvalue, BooleanExpression rvalue) {
-        return new LogicExpression(lvalue, rvalue) {
+    public static BooleanExpression createAND(BooleanExpression lvalue, BooleanExpression rvalue)
+    {
+        return new LogicExpression(lvalue, rvalue)
+            {
 
-            public Object evaluate(AMQMessage message) throws AMQException {
+                public Object evaluate(AMQMessage message) throws AMQException
+                {
 
-                Boolean lv = (Boolean) left.evaluate(message);
+                    Boolean lv = (Boolean) left.evaluate(message);
 
-                // Can we do an AND shortcut??
-                if (lv == null)
-                    return null;
-                if (!lv.booleanValue()) {
-                    return Boolean.FALSE;
-                }
+                    // Can we do an AND shortcut??
+                    if (lv == null)
+                    {
+                        return null;
+                    }
+
+                    if (!lv.booleanValue())
+                    {
+                        return Boolean.FALSE;
+                    }
+
+                    Boolean rv = (Boolean) right.evaluate(message);
 
-                Boolean rv = (Boolean) right.evaluate(message);
-                return rv == null ? null : rv;
-            }
+                    return (rv == null) ? null : rv;
+                }
 
-            public String getExpressionSymbol() {
-                return "AND";
-            }
-        };
+                public String getExpressionSymbol()
+                {
+                    return "AND";
+                }
+            };
     }
 
     /**
      * @param left
      * @param right
      */
-    public LogicExpression(BooleanExpression left, BooleanExpression right) {
+    public LogicExpression(BooleanExpression left, BooleanExpression right)
+    {
         super(left, right);
     }
 
-    abstract public Object evaluate(AMQMessage message) throws AMQException;
+    public abstract Object evaluate(AMQMessage message) throws AMQException;
 
-    public boolean matches(AMQMessage message) throws AMQException {
+    public boolean matches(AMQMessage message) throws AMQException
+    {
         Object object = evaluate(message);
-        return object!=null && object==Boolean.TRUE;            
+
+        return (object != null) && (object == Boolean.TRUE);
     }
 
 }