From 5af0b7353c19fcf20f9ca803dc72854a2266e4a6 Mon Sep 17 00:00:00 2001
From: Lahiru Gunathilake <lahiru@apache.org>
Date: Wed, 8 Oct 2008 07:37:02 +0000
Subject: resolving jira 1329.

git-svn-id: https://svn.apache.org/repos/asf/incubator/qpid/trunk@702745 13f79535-47bb-0310-9956-ffa450edef68
---
 .../apache/qpid/server/filter/UnaryExpression.java | 227 +++++++++------------
 1 file changed, 97 insertions(+), 130 deletions(-)

(limited to 'qpid/java')

diff --git a/qpid/java/broker/src/main/java/org/apache/qpid/server/filter/UnaryExpression.java b/qpid/java/broker/src/main/java/org/apache/qpid/server/filter/UnaryExpression.java
index 799a38af5a..1681958a38 100644
--- a/qpid/java/broker/src/main/java/org/apache/qpid/server/filter/UnaryExpression.java
+++ b/qpid/java/broker/src/main/java/org/apache/qpid/server/filter/UnaryExpression.java
@@ -35,32 +35,24 @@ import org.apache.qpid.server.queue.Filterable;
 /**
  * An expression which performs an operation on two expression values
  */
-public abstract class UnaryExpression<E extends Exception> implements Expression<E>
-{
+public abstract class UnaryExpression<E extends Exception> implements Expression<E> {
 
     private static final BigDecimal BD_LONG_MIN_VALUE = BigDecimal.valueOf(Long.MIN_VALUE);
     protected Expression<E> right;
 
-    public static<E extends Exception> Expression<E> createNegate(Expression<E> left)
-    {
+    public static <E extends Exception> Expression<E> createNegate(Expression<E> left) {
         return new NegativeExpression(left);
     }
 
-    public static<E extends Exception> BooleanExpression createInExpression(PropertyExpression<E> right, List elements, final boolean not)
-    {
+    public static <E extends Exception> BooleanExpression createInExpression(PropertyExpression<E> right, List elements, final boolean not) {
 
         // Use a HashSet if there are many elements.
         Collection t;
-        if (elements.size() == 0)
-        {
+        if (elements.size() == 0) {
             t = null;
-        }
-        else if (elements.size() < 5)
-        {
+        } else if (elements.size() < 5) {
             t = elements;
-        }
-        else
-        {
+        } else {
             t = new HashSet(elements);
         }
 
@@ -69,63 +61,53 @@ public abstract class UnaryExpression<E extends Exception> implements Expression
         return new InExpression(right, inList, not);
     }
 
-    abstract static class BooleanUnaryExpression<E extends Exception> extends UnaryExpression<E> implements BooleanExpression<E>
-    {
-        public BooleanUnaryExpression(Expression<E> left)
-        {
+    abstract static class BooleanUnaryExpression<E extends Exception> extends UnaryExpression<E> implements BooleanExpression<E> {
+        public BooleanUnaryExpression(Expression<E> left) {
             super(left);
         }
 
-        public boolean matches(Filterable<E> message) throws E
-        {
-            Object object = evaluate(message);
+        public boolean matches(Filterable<E> message) throws E {
+            Object object = null;
+            try{
+                object = evaluate(message);
+            }catch(Exception ex)
+            {
+                ex.printStackTrace();
+            }
 
             return (object != null) && (object == Boolean.TRUE);
         }
     }
+
     ;
 
-    public static<E extends Exception> BooleanExpression<E> createNOT(BooleanExpression<E> left)
-    {
+    public static <E extends Exception> BooleanExpression<E> createNOT(BooleanExpression<E> left) {
         return new NotExpression(left);
     }
 
-    public static BooleanExpression createXPath(final String xpath)
-    {
+    public static BooleanExpression createXPath(final String xpath) {
         return new XPathExpression(xpath);
     }
 
-    public static BooleanExpression createXQuery(final String xpath)
-    {
+    public static BooleanExpression createXQuery(final String xpath) {
         return new XQueryExpression(xpath);
     }
 
-    public static<E extends Exception> BooleanExpression createBooleanCast(Expression<E> left)
-    {
+    public static <E extends Exception> BooleanExpression createBooleanCast(Expression<E> left) {
         return new BooleanCastExpression(left);
     }
 
-    private static Number negate(Number left)
-    {
+    private static Number negate(Number left) {
         Class clazz = left.getClass();
-        if (clazz == Integer.class)
-        {
+        if (clazz == Integer.class) {
             return new Integer(-left.intValue());
-        }
-        else if (clazz == Long.class)
-        {
+        } else if (clazz == Long.class) {
             return new Long(-left.longValue());
-        }
-        else if (clazz == Float.class)
-        {
+        } else if (clazz == Float.class) {
             return new Float(-left.floatValue());
-        }
-        else if (clazz == Double.class)
-        {
+        } else if (clazz == Double.class) {
             return new Double(-left.doubleValue());
-        }
-        else if (clazz == BigDecimal.class)
-        {
+        } else if (clazz == BigDecimal.class) {
             // We ussually get a big deciamal when we have Long.MIN_VALUE constant in the
             // Selector.  Long.MIN_VALUE is too big to store in a Long as a positive so we store it
             // as a Big decimal.  But it gets Negated right away.. to here we try to covert it back
@@ -133,39 +115,32 @@ public abstract class UnaryExpression<E extends Exception> implements Expression
             BigDecimal bd = (BigDecimal) left;
             bd = bd.negate();
 
-            if (BD_LONG_MIN_VALUE.compareTo(bd) == 0)
-            {
+            if (BD_LONG_MIN_VALUE.compareTo(bd) == 0) {
                 return new Long(Long.MIN_VALUE);
             }
 
             return bd;
-        }
-        else
-        {
+        } else {
             throw new RuntimeException("Don't know how to negate: " + left);
         }
     }
 
-    public UnaryExpression(Expression left)
-    {
+    public UnaryExpression(Expression left) {
         this.right = left;
     }
 
-    public Expression<E> getRight()
-    {
+    public Expression<E> getRight() {
         return right;
     }
 
-    public void setRight(Expression expression)
-    {
+    public void setRight(Expression expression) {
         right = expression;
     }
 
     /**
      * @see java.lang.Object#toString()
      */
-    public String toString()
-    {
+    public String toString() {
         return "(" + getExpressionSymbol() + " " + right.toString() + ")";
     }
 
@@ -174,8 +149,7 @@ public abstract class UnaryExpression<E extends Exception> implements Expression
      *
      * @see java.lang.Object#hashCode()
      */
-    public int hashCode()
-    {
+    public int hashCode() {
         return toString().hashCode();
     }
 
@@ -184,11 +158,9 @@ public abstract class UnaryExpression<E extends Exception> 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;
         }
 
@@ -204,74 +176,73 @@ public abstract class UnaryExpression<E extends Exception> implements Expression
      */
     public abstract String getExpressionSymbol();
 
-    private static class NegativeExpression<E extends Exception> extends UnaryExpression<E>
-    {
-        public NegativeExpression(final Expression<E> left)
-        {
+    private static class NegativeExpression<E extends Exception> extends UnaryExpression<E> {
+        public NegativeExpression(final Expression<E> left) {
             super(left);
         }
 
-        public Object evaluate(Filterable<E> message) throws E
-        {
-            Object rvalue = right.evaluate(message);
-            if (rvalue == null)
+        public Object evaluate(Filterable<E> message) throws E {
+            Object rvalue = null;
+            try{
+                rvalue = right.evaluate(message);
+            }catch(Exception ex)
             {
+                ex.printStackTrace();
+            }
+
+            if (rvalue == null) {
                 return null;
             }
 
-            if (rvalue instanceof Number)
-            {
+            if (rvalue instanceof Number) {
                 return negate((Number) rvalue);
             }
 
             return null;
         }
 
-        public String getExpressionSymbol()
-        {
+        public String getExpressionSymbol() {
             return "-";
         }
     }
 
-    private static class InExpression<E extends Exception> extends BooleanUnaryExpression<E>
-    {
+    private static class InExpression<E extends Exception> extends BooleanUnaryExpression<E> {
         private final Collection _inList;
         private final boolean _not;
 
-        public InExpression(final PropertyExpression<E> right, final Collection inList, final boolean not)
-        {
+        public InExpression(final PropertyExpression<E> right, final Collection inList, final boolean not) {
             super(right);
             _inList = inList;
             _not = not;
         }
 
-        public Object evaluate(Filterable<E> message) throws E
-        {
+        public Object evaluate(Filterable<E> message) throws E {
 
-            Object rvalue = right.evaluate(message);
-            if (rvalue == null)
+            Object rvalue = null;
+            try{
+                rvalue = right.evaluate(message);
+            }
+            catch(Exception ex)
             {
+                ex.printStackTrace();
+            }
+            if (rvalue == null) {
                 return null;
             }
 
-            if (rvalue.getClass() != String.class)
-            {
+            if (rvalue.getClass() != String.class) {
                 return null;
             }
 
-            if (((_inList != null) && _inList.contains(rvalue)) ^ _not)
-            {
+            if (((_inList != null) && _inList.contains(rvalue)) ^ _not) {
                 return Boolean.TRUE;
-            }
-            else
-            {
+            } else {
                 return Boolean.FALSE;
             }
 
         }
 
-        public String toString()
-        {
+        public String toString() {
             StringBuffer answer = new StringBuffer();
             answer.append(right);
             answer.append(" ");
@@ -279,11 +250,9 @@ public abstract class UnaryExpression<E extends Exception> implements Expression
             answer.append(" ( ");
 
             int count = 0;
-            for (Iterator i = _inList.iterator(); i.hasNext();)
-            {
+            for (Iterator i = _inList.iterator(); i.hasNext();) {
                 Object o = (Object) i.next();
-                if (count != 0)
-                {
+                if (count != 0) {
                     answer.append(", ");
                 }
 
@@ -296,73 +265,71 @@ public abstract class UnaryExpression<E extends Exception> implements Expression
             return answer.toString();
         }
 
-        public String getExpressionSymbol()
-        {
-            if (_not)
-            {
+        public String getExpressionSymbol() {
+            if (_not) {
                 return "NOT IN";
-            }
-            else
-            {
+            } else {
                 return "IN";
             }
         }
     }
 
-    private static class NotExpression<E extends Exception> extends BooleanUnaryExpression<E>
-    {
-        public NotExpression(final BooleanExpression<E> left)
-        {
+    private static class NotExpression<E extends Exception> extends BooleanUnaryExpression<E> {
+        public NotExpression(final BooleanExpression<E> left) {
             super(left);
         }
 
-        public Object evaluate(Filterable<E> message) throws E
-        {
-            Boolean lvalue = (Boolean) right.evaluate(message);
-            if (lvalue == null)
-            {
+        public Object evaluate(Filterable<E> message) throws E {
+            Boolean lvalue = null;
+            try {
+                lvalue = (Boolean) right.evaluate(message);
+            } catch (Exception ex) {
+                ex.printStackTrace();
+
+            }
+
+            if (lvalue == null) {
                 return null;
             }
 
             return lvalue.booleanValue() ? Boolean.FALSE : Boolean.TRUE;
+
         }
 
-        public String getExpressionSymbol()
-        {
+        public String getExpressionSymbol() {
             return "NOT";
         }
     }
 
-    private static class BooleanCastExpression<E extends Exception> extends BooleanUnaryExpression<E>
-    {
-        public BooleanCastExpression(final Expression<E> left)
-        {
+    private static class BooleanCastExpression<E extends Exception> extends BooleanUnaryExpression<E> {
+        public BooleanCastExpression(final Expression<E> left) {
             super(left);
         }
 
-        public Object evaluate(Filterable<E> message) throws E
-        {
-            Object rvalue = right.evaluate(message);
-            if (rvalue == null)
-            {
+        public Object evaluate(Filterable<E> message) throws E {
+            Object rvalue = null;
+            try {
+                rvalue = right.evaluate(message);
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+            if (rvalue == null) {
                 return null;
             }
 
-            if (!rvalue.getClass().equals(Boolean.class))
-            {
+            if (!rvalue.getClass().equals(Boolean.class)) {
                 return Boolean.FALSE;
             }
 
             return ((Boolean) rvalue).booleanValue() ? Boolean.TRUE : Boolean.FALSE;
+
         }
 
-        public String toString()
-        {
+        public String toString() {
             return right.toString();
         }
 
-        public String getExpressionSymbol()
-        {
+        public String getExpressionSymbol() {
             return "";
         }
     }
-- 
cgit v1.2.1