QPID-3801 : [Java] Move JMS Selector code into common

git-svn-id: https://svn.apache.org/repos/asf/qpid/trunk/qpid@1239643 13f79535-47bb-0310-9956-ffa450edef68

13 files changed, 2625 insertions, 1 deletions

diff --git a/java/common/build.xml b/java/common/build.xml
index f2f85fc634..fe96f384d5 100644
--- a/java/common/build.xml
+++ b/java/common/build.xml
@@ -32,6 +32,7 @@
   <property name="xml.spec.list" value='"${xml.spec.dir}/amqp.0-8.xml" "${xml.spec.dir}/amqp.0-9.xml" "${xml.spec.dir}/amqp0-9-1.stripped.xml"' />
   <property name="gentools.timestamp" location="${framing.generated.dir}/gentools.timestamp" />
   <property name="jython.timestamp" location="${framing.generated.dir}/jython.timestamp" />
+  <property name="selector.output.dir" value="${module.precompiled}/org/apache/qpid/filter/selector"/>
 
   <target name="check_jython_deps">
     <uptodate property="jython.notRequired" targetfile="${jython.timestamp}">
@@ -96,7 +97,14 @@ public class QpidBuildVersion
 
   </target>
 
-  <target name="precompile" depends="gentools,jython,create-version,build-version"/>
+  <target name="jms-selector">
+    <mkdir dir="${selector.output.dir}"/>
+    <javacc target="src/main/grammar/SelectorParser.jj"
+            outputdirectory="${selector.output.dir}"
+            javacchome="${project.root}/lib"/>
+  </target>
+
+  <target name="precompile" depends="gentools,jython,create-version,build-version,jms-selector"/>
 
   <target name="bundle" depends="bundle-tasks"/>
 </project>
diff --git a/java/common/src/main/grammar/SelectorParser.jj b/java/common/src/main/grammar/SelectorParser.jj
new file mode 100644
index 0000000000..32d8b61cc8
--- /dev/null
+++ b/java/common/src/main/grammar/SelectorParser.jj
@@ -0,0 +1,608 @@
+/*

+ *

+ * Licensed to the Apache Software Foundation (ASF) under one

+ * or more contributor license agreements.  See the NOTICE file

+ * distributed with this work for additional information

+ * regarding copyright ownership.  The ASF licenses this file

+ * to you under the Apache License, Version 2.0 (the

+ * "License"); you may not use this file except in compliance

+ * with the License.  You may obtain a copy of the License at

+ *

+ *   http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing,

+ * software distributed under the License is distributed on an

+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+ * KIND, either express or implied.  See the License for the

+ * specific language governing permissions and limitations

+ * under the License.

+ *

+ */

+

+ //

+ // Original File from r450141 of the Apache ActiveMQ project <http://www.activemq.org/site/home.html>

+ //

+

+// ----------------------------------------------------------------------------

+// OPTIONS

+// ----------------------------------------------------------------------------

+options {

+  STATIC = false;

+  UNICODE_INPUT = true;

+

+  // some performance optimizations

+  ERROR_REPORTING = false;

+}

+

+// ----------------------------------------------------------------------------

+// PARSER

+// ----------------------------------------------------------------------------

+

+PARSER_BEGIN(SelectorParser)

+/*

+ *

+ * Licensed to the Apache Software Foundation (ASF) under one

+ * or more contributor license agreements.  See the NOTICE file

+ * distributed with this work for additional information

+ * regarding copyright ownership.  The ASF licenses this file

+ * to you under the Apache License, Version 2.0 (the

+ * "License"); you may not use this file except in compliance

+ * with the License.  You may obtain a copy of the License at

+ *

+ *   http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing,

+ * software distributed under the License is distributed on an

+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+ * KIND, either express or implied.  See the License for the

+ * specific language governing permissions and limitations

+ * under the License.

+ *

+ */

+

+package org.apache.qpid.filter.selector;

+

+import java.io.StringReader;

+import java.util.ArrayList;

+

+import org.apache.qpid.filter.ArithmeticExpression;

+import org.apache.qpid.filter.BooleanExpression;

+import org.apache.qpid.filter.ComparisonExpression;

+import org.apache.qpid.filter.ConstantExpression;

+import org.apache.qpid.filter.Expression;

+import org.apache.qpid.filter.LogicExpression;

+import org.apache.qpid.filter.PropertyExpression;

+import org.apache.qpid.filter.UnaryExpression;

+

+/**

+ * JMS Selector Parser generated by JavaCC

+ *

+ * Do not edit this .java file directly - it is autogenerated from SelectorParser.jj

+ */

+public class SelectorParser

+{

+

+    public SelectorParser()

+    {

+        this(new StringReader(""));

+    }

+

+    public BooleanExpression parse(String sql) throws ParseException

+    {

+        this.ReInit(new StringReader(sql));

+

+        return this.JmsSelector();

+

+    }

+

+    private BooleanExpression asBooleanExpression(Expression value) throws ParseException

+    {

+        if (value instanceof BooleanExpression)

+        {

+            return (BooleanExpression) value;

+        }

+        if (value instanceof PropertyExpression)

+        {

+            return UnaryExpression.createBooleanCast( value );

+        }

+        throw new ParseException("Expression will not result in a boolean value: " + value);

+    }

+

+

+}

+

+PARSER_END(SelectorParser)

+

+// ----------------------------------------------------------------------------

+// Tokens

+// ----------------------------------------------------------------------------

+

+/* White Space */

+SPECIAL_TOKEN :

+{

+  " " | "\t" | "\n" | "\r" | "\f"

+}

+

+/* Comments */

+SKIP:

+{

+  <LINE_COMMENT: "--" (~["\n","\r"])* ("\n"|"\r"|"\r\n") >

+}

+

+SKIP:

+{

+  <BLOCK_COMMENT: "/*" (~["*"])* "*" ("*" | (~["*","/"] (~["*"])* "*"))* "/">

+}

+

+/* Reserved Words */

+TOKEN [IGNORE_CASE] :

+{

+    <  NOT     : "NOT">

+  | <  AND     : "AND">

+  | <  OR      : "OR">

+  | <  BETWEEN : "BETWEEN">

+  | <  LIKE    : "LIKE">

+  | <  ESCAPE  : "ESCAPE">

+  | <  IN      : "IN">

+  | <  IS      : "IS">

+  | <  TRUE    : "TRUE" >

+  | <  FALSE   : "FALSE" >

+  | <  NULL    : "NULL" >

+}

+

+/* Literals */

+TOKEN [IGNORE_CASE] :

+{

+

+    < DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* (["l","L"])? >

+  | < HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ >

+  | < OCTAL_LITERAL: "0" (["0"-"7"])* >

+  | < FLOATING_POINT_LITERAL:

+          (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? // matches: 5.5 or 5. or 5.5E10 or 5.E10

+        | "." (["0"-"9"])+ (<EXPONENT>)?              // matches: .5 or .5E10

+        | (["0"-"9"])+ <EXPONENT>                     // matches: 5E10

+    >

+  | < #EXPONENT: "E" (["+","-"])? (["0"-"9"])+ >

+  | < STRING_LITERAL: "'" ( ("''") | ~["'"] )*  "'" >

+}

+

+TOKEN [IGNORE_CASE] :

+{

+    < ID : ["a"-"z", "_", "$"] (["a"-"z","0"-"9","_", "$"])* >

+    | < QUOTED_ID : "\"" ( ("\"\"") | ~["\""] )*  "\""  >

+}

+

+// ----------------------------------------------------------------------------

+// Grammer

+// ----------------------------------------------------------------------------

+BooleanExpression JmsSelector() :

+{

+    Expression left=null;

+}

+{

+    (

+        left = orExpression()

+    )

+    {

+        return asBooleanExpression(left);

+    }

+

+}

+

+Expression orExpression() :

+{

+    Expression left;

+    Expression right;

+}

+{

+    (

+        left = andExpression()

+        (

+            <OR> right = andExpression()

+            {

+                left = LogicExpression.createOR(asBooleanExpression(left), asBooleanExpression(right));

+            }

+        )*

+    )

+    {

+        return left;

+    }

+

+}

+

+

+Expression andExpression() :

+{

+    Expression left;

+    Expression right;

+}

+{

+    (

+        left = equalityExpression()

+        (

+            <AND> right = equalityExpression()

+            {

+                left = LogicExpression.createAND(asBooleanExpression(left), asBooleanExpression(right));

+            }

+        )*

+    )

+    {

+        return left;

+    }

+}

+

+Expression equalityExpression() :

+{

+    Expression left;

+    Expression right;

+}

+{

+    (

+        left = comparisonExpression()

+        (

+

+            "=" right = comparisonExpression()

+            {

+                left = ComparisonExpression.createEqual(left, right);

+            }

+            |

+            "<>" right = comparisonExpression()

+            {

+                left = ComparisonExpression.createNotEqual(left, right);

+            }

+            |

+            LOOKAHEAD(2)

+            <IS> <NULL>

+            {

+                left = ComparisonExpression.createIsNull(left);

+            }

+            |

+            <IS> <NOT> <NULL>

+            {

+                left = ComparisonExpression.createIsNotNull(left);

+            }

+        )*

+    )

+    {

+        return left;

+    }

+}

+

+Expression comparisonExpression() :

+{

+    Expression left;

+    Expression right;

+    Expression low;

+    Expression high;

+    String t, u;

+	boolean not;

+	ArrayList list;

+}

+{

+    (

+        left = addExpression()

+        (

+

+                ">" right = addExpression()

+                {

+                    left = ComparisonExpression.createGreaterThan(left, right);

+                }

+            |

+                ">=" right = addExpression()

+                {

+                    left = ComparisonExpression.createGreaterThanEqual(left, right);

+                }

+            |

+                "<" right = addExpression()

+                {

+                    left = ComparisonExpression.createLessThan(left, right);

+                }

+            |

+                "<=" right = addExpression()

+                {

+                    left = ComparisonExpression.createLessThanEqual(left, right);

+                }

+           |

+				{

+					u=null;

+				}

+		        <LIKE> t = stringLiteral()

+		        	[ <ESCAPE> u = stringLiteral() ]

+		        {

+                    left = ComparisonExpression.createLike(left, t, u);

+		        }

+           |

+	        	LOOKAHEAD(2)

+				{

+					u=null;

+				}

+		        <NOT> <LIKE> t = stringLiteral() [ <ESCAPE> u = stringLiteral() ]

+		        {

+                    left = ComparisonExpression.createNotLike(left, t, u);

+		        }

+            |

+		        <BETWEEN> low = addExpression() <AND> high = addExpression()

+		        {

+					left = ComparisonExpression.createBetween(left, low, high);

+		        }

+	        |

+	        	LOOKAHEAD(2)

+		        <NOT> <BETWEEN> low = addExpression() <AND> high = addExpression()

+		        {

+					left = ComparisonExpression.createNotBetween(left, low, high);

+		        }

+            |

+				<IN>

+		        "("

+		            t = stringLiteral()

+		            {

+			            list = new ArrayList();

+			            list.add( t );

+		            }

+			        (

+			        	","

+			            t = stringLiteral()

+			            {

+				            list.add( t );

+			            }

+

+			        )*

+		        ")"

+		        {

+		           left = ComparisonExpression.createInFilter(left, list);

+		        }

+            |

+	        	LOOKAHEAD(2)

+	            <NOT> <IN>

+		        "("

+		            t = stringLiteral()

+		            {

+			            list = new ArrayList();

+			            list.add( t );

+		            }

+			        (

+			        	","

+			            t = stringLiteral()

+			            {

+				            list.add( t );

+			            }

+

+			        )*

+		        ")"

+		        {

+		           left = ComparisonExpression.createNotInFilter(left, list);

+		        }

+

+        )*

+    )

+    {

+        return left;

+    }

+}

+

+Expression addExpression() :

+{

+    Expression left;

+    Expression right;

+}

+{

+    left = multExpr()

+    (

+	    LOOKAHEAD( ("+"|"-") multExpr())

+	    (

+	        "+" right = multExpr()

+	        {

+	            left = ArithmeticExpression.createPlus(left, right);

+	        }

+	        |

+	        "-" right = multExpr()

+	        {

+	            left = ArithmeticExpression.createMinus(left, right);

+	        }

+        )

+

+    )*

+    {

+        return left;

+    }

+}

+

+Expression multExpr() :

+{

+    Expression left;

+    Expression right;

+}

+{

+    left = unaryExpr()

+    (

+        "*" right = unaryExpr()

+        {

+	        left = ArithmeticExpression.createMultiply(left, right);

+        }

+        |

+        "/" right = unaryExpr()

+        {

+	        left = ArithmeticExpression.createDivide(left, right);

+        }

+        |

+        "%" right = unaryExpr()

+        {

+	        left = ArithmeticExpression.createMod(left, right);

+        }

+

+    )*

+    {

+        return left;

+    }

+}

+

+

+Expression unaryExpr() :

+{

+    String s=null;

+    Expression left=null;

+}

+{

+	(

+		LOOKAHEAD( "+" unaryExpr() )

+	    "+" left=unaryExpr()

+	    |

+	    "-" left=unaryExpr()

+	    {

+	        left = UnaryExpression.createNegate(left);

+	    }

+	    |

+	    <NOT> left=unaryExpr()

+	    {

+		    left = UnaryExpression.createNOT( asBooleanExpression(left) );

+	    }

+	    |

+	    left = primaryExpr()

+    )

+    {

+        return left;

+    }

+

+}

+

+Expression primaryExpr() :

+{

+    Expression left=null;

+}

+{

+    (

+        left = literal()

+        |

+        left = variable()

+        |

+        "(" left = orExpression() ")"

+    )

+    {

+        return left;

+    }

+}

+

+

+

+ConstantExpression literal() :

+{

+    Token t;

+    String s;

+    ConstantExpression left=null;

+}

+{

+    (

+        (

+            s = stringLiteral()

+            {

+                left = new ConstantExpression(s);

+            }

+        )

+        |

+        (

+            t = <DECIMAL_LITERAL>

+            {

+            	left = ConstantExpression.createFromDecimal(t.image);

+            }

+        )

+        |

+        (

+            t = <HEX_LITERAL>

+            {

+            	left = ConstantExpression.createFromHex(t.image);

+            }

+        )

+        |

+        (

+            t = <OCTAL_LITERAL>

+            {

+            	left = ConstantExpression.createFromOctal(t.image);

+            }

+        )

+        |

+        (

+            t = <FLOATING_POINT_LITERAL>

+            {

+            	left = ConstantExpression.createFloat(t.image);

+            }

+        )

+        |

+        (

+            <TRUE>

+            {

+                left = ConstantExpression.TRUE;

+            }

+        )

+        |

+        (

+            <FALSE>

+            {

+                left = ConstantExpression.FALSE;

+            }

+        )

+        |

+        (

+            <NULL>

+            {

+                left = ConstantExpression.NULL;

+            }

+        )

+    )

+    {

+        return left;

+    }

+}

+

+String stringLiteral() :

+{

+    Token t;

+    StringBuffer rc = new StringBuffer();

+    boolean first=true;

+}

+{

+    t = <STRING_LITERAL>

+    {

+    	// Decode the sting value.

+    	String image = t.image;

+    	for( int i=1; i < image.length()-1; i++ ) {

+    		char c = image.charAt(i);

+    		if( c == '\'' )

+    			i++;

+   			rc.append(c);

+    	}

+	    return rc.toString();

+    }

+}

+

+PropertyExpression variable() :

+{

+    Token t;

+    StringBuffer rc = new StringBuffer();

+    PropertyExpression left=null;

+}

+{

+    (

+        t = <ID>

+        {

+            left = new PropertyExpression(t.image);

+        }

+        |

+        t = <QUOTED_ID>

+        {

+            // Decode the sting value.

+            String image = t.image;

+            for( int i=1; i < image.length()-1; i++ ) {

+                char c = image.charAt(i);

+                if( c == '"' )

+                    i++;

+                rc.append(c);

+            }

+            return new PropertyExpression(rc.toString());

+        }

+

+

+    )

+    {

+        return left;

+    }

+}

diff --git a/java/common/src/main/java/org/apache/qpid/filter/ArithmeticExpression.java b/java/common/src/main/java/org/apache/qpid/filter/ArithmeticExpression.java
new file mode 100644
index 0000000000..47d970cfbd
--- /dev/null
+++ b/java/common/src/main/java/org/apache/qpid/filter/ArithmeticExpression.java
@@ -0,0 +1,272 @@
+/**
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.qpid.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
+ */
+public abstract class ArithmeticExpression extends BinaryExpression
+{
+
+    protected static final int INTEGER = 1;
+    protected static final int LONG = 2;
+    protected static final int DOUBLE = 3;
+
+    /**
+     * @param left
+     * @param 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;
+                    }
+                    else if (lvalue instanceof Number)
+                    {
+                        return plus((Number) lvalue, asNumber(rvalue));
+                    }
+
+                    throw new SelectorParsingException("Cannot call plus operation on: " + lvalue + " and: " + rvalue);
+                }
+
+                public String getExpressionSymbol()
+                {
+                    return "+";
+                }
+            };
+    }
+
+    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 SelectorParsingException("Cannot call minus operation on: " + lvalue + " and: " + rvalue);
+                }
+
+                public String getExpressionSymbol()
+                {
+                    return "-";
+                }
+            };
+    }
+
+    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));
+                    }
+
+                    throw new SelectorParsingException("Cannot call multiply operation on: " + lvalue + " and: " + rvalue);
+                }
+
+                public String getExpressionSymbol()
+                {
+                    return "*";
+                }
+            };
+    }
+
+    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));
+                    }
+
+                    throw new SelectorParsingException("Cannot call divide operation on: " + lvalue + " and: " + rvalue);
+                }
+
+                public String getExpressionSymbol()
+                {
+                    return "/";
+                }
+            };
+    }
+
+    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));
+                    }
+
+                    throw new SelectorParsingException("Cannot call mod operation on: " + lvalue + " and: " + rvalue);
+                }
+
+                public String getExpressionSymbol()
+                {
+                    return "%";
+                }
+            };
+    }
+
+    protected Number plus(Number left, Number right)
+    {
+        switch (numberType(left, right))
+        {
+
+        case INTEGER:
+            return Integer.valueOf(left.intValue() + right.intValue());
+
+        case LONG:
+            return Long.valueOf(left.longValue() + right.longValue());
+
+        default:
+            return Double.valueOf(left.doubleValue() + right.doubleValue());
+        }
+    }
+
+    protected Number minus(Number left, Number right)
+    {
+        switch (numberType(left, right))
+        {
+
+        case INTEGER:
+            return Integer.valueOf(left.intValue() - right.intValue());
+
+        case LONG:
+            return Long.valueOf(left.longValue() - right.longValue());
+
+        default:
+            return Double.valueOf(left.doubleValue() - right.doubleValue());
+        }
+    }
+
+    protected Number multiply(Number left, Number right)
+    {
+        switch (numberType(left, right))
+        {
+
+        case INTEGER:
+            return Integer.valueOf(left.intValue() * right.intValue());
+
+        case LONG:
+            return Long.valueOf(left.longValue() * right.longValue());
+
+        default:
+            return Double.valueOf(left.doubleValue() * right.doubleValue());
+        }
+    }
+
+    protected Number divide(Number left, Number right)
+    {
+        return Double.valueOf(left.doubleValue() / right.doubleValue());
+    }
+
+    protected Number mod(Number left, Number right)
+    {
+        return Double.valueOf(left.doubleValue() % right.doubleValue());
+    }
+
+    private int numberType(Number left, Number right)
+    {
+        if (isDouble(left) || isDouble(right))
+        {
+            return DOUBLE;
+        }
+        else if ((left instanceof Long) || (right instanceof Long))
+        {
+            return LONG;
+        }
+        else
+        {
+            return INTEGER;
+        }
+    }
+
+    private boolean isDouble(Number n)
+    {
+        return (n instanceof Float) || (n instanceof Double);
+    }
+
+    protected Number asNumber(Object value)
+    {
+        if (value instanceof Number)
+        {
+            return (Number) value;
+        }
+        else
+        {
+            throw new SelectorParsingException("Cannot convert value: " + value + " into a number");
+        }
+    }
+
+    public Object evaluate(FilterableMessage message)
+    {
+        Object lvalue = getLeft().evaluate(message);
+        if (lvalue == null)
+        {
+            return null;
+        }
+
+        Object rvalue = getRight().evaluate(message);
+        if (rvalue == null)
+        {
+            return null;
+        }
+
+        return evaluate(lvalue, rvalue);
+    }
+
+    /**
+     * @param lvalue
+     * @param rvalue
+     * @return
+     */
+    protected abstract Object evaluate(Object lvalue, Object rvalue);
+
+}
diff --git a/java/common/src/main/java/org/apache/qpid/filter/BinaryExpression.java b/java/common/src/main/java/org/apache/qpid/filter/BinaryExpression.java
new file mode 100644
index 0000000000..6467bbbe1f
--- /dev/null
+++ b/java/common/src/main/java/org/apache/qpid/filter/BinaryExpression.java
@@ -0,0 +1,90 @@
+/**
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.qpid.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.
+ */
+public abstract class BinaryExpression implements Expression
+{
+    private final Expression left;
+    private final Expression right;
+
+    public BinaryExpression(Expression left, Expression right)
+    {
+        this.left = left;
+        this.right = right;
+    }
+
+    public Expression getLeft()
+    {
+        return left;
+    }
+
+    public Expression getRight()
+    {
+        return right;
+    }
+
+    /**
+     * @see java.lang.Object#toString()
+     */
+    public String toString()
+    {
+        return "(" + left.toString() + " " + getExpressionSymbol() + " " + right.toString() + ")";
+    }
+
+    /**
+     * TODO: more efficient hashCode()
+     *
+     * @see java.lang.Object#hashCode()
+     */
+    public int hashCode()
+    {
+        return toString().hashCode();
+    }
+
+    /**
+     * TODO: more efficient hashCode()
+     *
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
+    public boolean equals(Object o)
+    {
+
+        if ((o == null) || !this.getClass().equals(o.getClass()))
+        {
+            return false;
+        }
+
+        return toString().equals(o.toString());
+
+    }
+
+    /**
+     * Returns the symbol that represents this binary expression.  For example, addition is
+     * represented by "+"
+     *
+     * @return
+     */
+    public abstract String getExpressionSymbol();
+
+}
diff --git a/java/common/src/main/java/org/apache/qpid/filter/BooleanExpression.java b/java/common/src/main/java/org/apache/qpid/filter/BooleanExpression.java
new file mode 100644
index 0000000000..13e1604d5f
--- /dev/null
+++ b/java/common/src/main/java/org/apache/qpid/filter/BooleanExpression.java
@@ -0,0 +1,36 @@
+/**
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.qpid.filter;
+//
+// Based on like named file from r450141 of the Apache ActiveMQ project <http://www.activemq.org/site/home.html>
+//
+
+/**
+ * A BooleanExpression is an expression that always
+ * produces a Boolean result.
+ */
+public interface BooleanExpression extends Expression
+{
+
+    /**
+     * @param message
+     * @return true if the expression evaluates to Boolean.TRUE.
+     */
+    public boolean matches(FilterableMessage message);
+
+}
diff --git a/java/common/src/main/java/org/apache/qpid/filter/ComparisonExpression.java b/java/common/src/main/java/org/apache/qpid/filter/ComparisonExpression.java
new file mode 100644
index 0000000000..2cfb97dc6c
--- /dev/null
+++ b/java/common/src/main/java/org/apache/qpid/filter/ComparisonExpression.java
@@ -0,0 +1,596 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+package org.apache.qpid.filter;
+//
+// Based on like named file from r450141 of the Apache ActiveMQ project <http://www.activemq.org/site/home.html>
+//
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * A filter performing a comparison of two objects
+ */
+public abstract class ComparisonExpression extends BinaryExpression implements BooleanExpression
+{
+
+    public static BooleanExpression createBetween(Expression value, Expression left, Expression right)
+    {
+        return LogicExpression.createAND(createGreaterThanEqual(value, left), createLessThanEqual(value, right));
+    }
+
+    public static BooleanExpression createNotBetween(Expression value, Expression left, Expression right)
+    {
+        return LogicExpression.createOR(createLessThan(value, left), createGreaterThan(value, right));
+    }
+
+    private static final HashSet<Character> REGEXP_CONTROL_CHARS = new HashSet<Character>();
+
+    static
+    {
+        REGEXP_CONTROL_CHARS.add('.');
+        REGEXP_CONTROL_CHARS.add('\\');
+        REGEXP_CONTROL_CHARS.add('[');
+        REGEXP_CONTROL_CHARS.add(']');
+        REGEXP_CONTROL_CHARS.add('^');
+        REGEXP_CONTROL_CHARS.add('$');
+        REGEXP_CONTROL_CHARS.add('?');
+        REGEXP_CONTROL_CHARS.add('*');
+        REGEXP_CONTROL_CHARS.add('+');
+        REGEXP_CONTROL_CHARS.add('{');
+        REGEXP_CONTROL_CHARS.add('}');
+        REGEXP_CONTROL_CHARS.add('|');
+        REGEXP_CONTROL_CHARS.add('(');
+        REGEXP_CONTROL_CHARS.add(')');
+        REGEXP_CONTROL_CHARS.add(':');
+        REGEXP_CONTROL_CHARS.add('&');
+        REGEXP_CONTROL_CHARS.add('<');
+        REGEXP_CONTROL_CHARS.add('>');
+        REGEXP_CONTROL_CHARS.add('=');
+        REGEXP_CONTROL_CHARS.add('!');
+    }
+
+    static class LikeExpression extends UnaryExpression implements BooleanExpression
+    {
+
+        private Pattern likePattern;
+
+        /**
+         * @param right
+         */
+        public LikeExpression(Expression right, String like, int escape)
+        {
+            super(right);
+
+            StringBuffer regexp = new StringBuffer(like.length() * 2);
+            regexp.append("\\A"); // The beginning of the input
+            for (int i = 0; i < like.length(); i++)
+            {
+                char c = like.charAt(i);
+                if (escape == (0xFFFF & c))
+                {
+                    i++;
+                    if (i >= like.length())
+                    {
+                        // nothing left to escape...
+                        break;
+                    }
+
+                    char t = like.charAt(i);
+                    regexp.append("\\x");
+                    regexp.append(Integer.toHexString(0xFFFF & t));
+                }
+                else if (c == '%')
+                {
+                    regexp.append(".*?"); // Do a non-greedy match
+                }
+                else if (c == '_')
+                {
+                    regexp.append("."); // match one
+                }
+                else if (REGEXP_CONTROL_CHARS.contains(c))
+                {
+                    regexp.append("\\x");
+                    regexp.append(Integer.toHexString(0xFFFF & c));
+                }
+                else
+                {
+                    regexp.append(c);
+                }
+            }
+
+            regexp.append("\\z"); // The end of the input
+
+            likePattern = Pattern.compile(regexp.toString(), Pattern.DOTALL);
+        }
+
+        /**
+         *  org.apache.activemq.filter.UnaryExpression#getExpressionSymbol()
+         */
+        public String getExpressionSymbol()
+        {
+            return "LIKE";
+        }
+
+        /**
+         *  org.apache.activemq.filter.Expression#evaluate(MessageEvaluationContext)
+         */
+        public Object evaluate(FilterableMessage message)
+        {
+
+            Object rv = this.getRight().evaluate(message);
+
+            if (rv == null)
+            {
+                return null;
+            }
+
+            if (!(rv instanceof String))
+            {
+                return
+                    Boolean.FALSE;
+            }
+
+            return likePattern.matcher((String) rv).matches() ? Boolean.TRUE : Boolean.FALSE;
+        }
+
+        public boolean matches(FilterableMessage message)
+        {
+            Object object = evaluate(message);
+
+            return (object != null) && (object == Boolean.TRUE);
+        }
+    }
+
+    public static BooleanExpression createLike(Expression left, String right, String escape)
+    {
+        if ((escape != null) && (escape.length() != 1))
+        {
+            throw new SelectorParsingException(
+                "The ESCAPE string literal is invalid.  It can only be one character.  Litteral used: " + escape);
+        }
+
+        int c = -1;
+        if (escape != null)
+        {
+            c = 0xFFFF & escape.charAt(0);
+        }
+
+        return new LikeExpression(left, right, c);
+    }
+
+    public static BooleanExpression createNotLike(Expression left, String right, String escape)
+    {
+        return UnaryExpression.createNOT(createLike(left, right, escape));
+    }
+
+    public static BooleanExpression createInFilter(Expression left, List elements)
+    {
+
+        if (!(left instanceof PropertyExpression))
+        {
+            throw new SelectorParsingException("Expected a property for In expression, got: " + left);
+        }
+
+        return UnaryExpression.createInExpression((PropertyExpression) left, elements, false);
+
+    }
+
+    public static BooleanExpression createNotInFilter(Expression left, List elements)
+    {
+
+        if (!(left instanceof PropertyExpression))
+        {
+            throw new SelectorParsingException("Expected a property for In expression, got: " + left);
+        }
+
+        return UnaryExpression.createInExpression((PropertyExpression) left, elements, true);
+
+    }
+
+    public static BooleanExpression createIsNull(Expression left)
+    {
+        return doCreateEqual(left, ConstantExpression.NULL);
+    }
+
+    public static BooleanExpression createIsNotNull(Expression left)
+    {
+        return UnaryExpression.createNOT(doCreateEqual(left, ConstantExpression.NULL));
+    }
+
+    public static BooleanExpression createNotEqual(Expression left, Expression right)
+    {
+        return UnaryExpression.createNOT(createEqual(left, right));
+    }
+
+    public static BooleanExpression createEqual(Expression left, Expression right)
+    {
+        checkEqualOperand(left);
+        checkEqualOperand(right);
+        checkEqualOperandCompatability(left, right);
+
+        return doCreateEqual(left, right);
+    }
+
+    private static BooleanExpression doCreateEqual(Expression left, Expression right)
+    {
+        return new EqualExpression(left, right);
+    }
+
+    public static BooleanExpression createGreaterThan(final Expression left, final Expression right)
+    {
+        checkLessThanOperand(left);
+        checkLessThanOperand(right);
+
+        return new ComparisonExpression(left, right)
+            {
+                protected boolean asBoolean(int answer)
+                {
+                    return answer > 0;
+                }
+
+                public String getExpressionSymbol()
+                {
+                    return ">";
+                }
+            };
+    }
+
+    public static BooleanExpression createGreaterThanEqual(final Expression left, final Expression right)
+    {
+        checkLessThanOperand(left);
+        checkLessThanOperand(right);
+
+        return new ComparisonExpression(left, right)
+            {
+                protected boolean asBoolean(int answer)
+                {
+                    return answer >= 0;
+                }
+
+                public String getExpressionSymbol()
+                {
+                    return ">=";
+                }
+            };
+    }
+
+    public static BooleanExpression createLessThan(final Expression left, final Expression right)
+    {
+        checkLessThanOperand(left);
+        checkLessThanOperand(right);
+
+        return new ComparisonExpression(left, right)
+            {
+
+                protected boolean asBoolean(int answer)
+                {
+                    return answer < 0;
+                }
+
+                public String getExpressionSymbol()
+                {
+                    return "<";
+                }
+
+            };
+    }
+
+    public static BooleanExpression createLessThanEqual(final Expression left, final Expression right)
+    {
+        checkLessThanOperand(left);
+        checkLessThanOperand(right);
+
+        return new ComparisonExpression(left, right)
+            {
+
+                protected boolean asBoolean(int answer)
+                {
+                    return answer <= 0;
+                }
+
+                public String getExpressionSymbol()
+                {
+                    return "<=";
+                }
+            };
+    }
+
+    /**
+     * Only Numeric expressions can be used in >, >=, < or <= expressions.s
+     *
+     * @param expr
+     */
+    public static void checkLessThanOperand(Expression expr)
+    {
+        if (expr instanceof ConstantExpression)
+        {
+            Object value = ((ConstantExpression) expr).getValue();
+            if (value instanceof Number)
+            {
+                return;
+            }
+
+            // Else it's boolean or a String..
+            throw new SelectorParsingException("Value '" + expr + "' cannot be compared.");
+        }
+
+        if (expr instanceof BooleanExpression)
+        {
+            throw new SelectorParsingException("Value '" + expr + "' cannot be compared.");
+        }
+    }
+
+    /**
+     * Validates that the expression can be used in == or <> expression.
+     * Cannot not be NULL TRUE or FALSE literals.
+     *
+     * @param expr
+     */
+    public static void checkEqualOperand(Expression expr)
+    {
+        if (expr instanceof ConstantExpression)
+        {
+            Object value = ((ConstantExpression) expr).getValue();
+            if (value == null)
+            {
+                throw new SelectorParsingException("'" + expr + "' cannot be compared.");
+            }
+        }
+    }
+
+    /**
+     *
+     * @param left
+     * @param right
+     */
+    private static void checkEqualOperandCompatability(Expression left, Expression right)
+    {
+        if ((left instanceof ConstantExpression) && (right instanceof ConstantExpression))
+        {
+            if ((left instanceof BooleanExpression) && !(right instanceof BooleanExpression))
+            {
+                throw new SelectorParsingException("'" + left + "' cannot be compared with '" + right + "'");
+            }
+        }
+    }
+
+    /**
+     * @param left
+     * @param right
+     */
+    public ComparisonExpression(Expression left, Expression right)
+    {
+        super(left, right);
+    }
+
+    public Object evaluate(FilterableMessage message)
+    {
+        Comparable lv = (Comparable) getLeft().evaluate(message);
+        if (lv == null)
+        {
+            return null;
+        }
+
+        Comparable rv = (Comparable) getRight().evaluate(message);
+        if (rv == null)
+        {
+            return null;
+        }
+
+        return compare(lv, rv);
+    }
+
+    protected Boolean compare(Comparable lv, Comparable rv)
+    {
+        Class lc = lv.getClass();
+        Class rc = rv.getClass();
+        // If the the objects are not of the same type,
+        // try to convert up to allow the comparison.
+        if (lc != rc)
+        {
+            if (lc == Byte.class)
+            {
+                if (rc == Short.class)
+                {
+                    lv = ((Number) lv).shortValue();
+                }
+                else if (rc == Integer.class)
+                {
+                    lv = ((Number) lv).intValue();
+                }
+                else if (rc == Long.class)
+                {
+                    lv = ((Number) lv).longValue();
+                }
+                else if (rc == Float.class)
+                {
+                    lv = ((Number) lv).floatValue();
+                }
+                else if (rc == Double.class)
+                {
+                    lv = ((Number) lv).doubleValue();
+                }
+                else
+                {
+                    return Boolean.FALSE;
+                }
+            }
+            else if (lc == Short.class)
+            {
+                if (rc == Integer.class)
+                {
+                    lv = ((Number) lv).intValue();
+                }
+                else if (rc == Long.class)
+                {
+                    lv = ((Number) lv).longValue();
+                }
+                else if (rc == Float.class)
+                {
+                    lv = ((Number) lv).floatValue();
+                }
+                else if (rc == Double.class)
+                {
+                    lv = ((Number) lv).doubleValue();
+                }
+                else
+                {
+                    return Boolean.FALSE;
+                }
+            }
+            else if (lc == Integer.class)
+            {
+                if (rc == Long.class)
+                {
+                    lv = ((Number) lv).longValue();
+                }
+                else if (rc == Float.class)
+                {
+                    lv = ((Number) lv).floatValue();
+                }
+                else if (rc == Double.class)
+                {
+                    lv = ((Number) lv).doubleValue();
+                }
+                else
+                {
+                    return Boolean.FALSE;
+                }
+            }
+            else if (lc == Long.class)
+            {
+                if (rc == Integer.class)
+                {
+                    rv = ((Number) rv).longValue();
+                }
+                else if (rc == Float.class)
+                {
+                    lv = ((Number) lv).floatValue();
+                }
+                else if (rc == Double.class)
+                {
+                    lv = ((Number) lv).doubleValue();
+                }
+                else
+                {
+                    return Boolean.FALSE;
+                }
+            }
+            else if (lc == Float.class)
+            {
+                if (rc == Integer.class)
+                {
+                    rv = ((Number) rv).floatValue();
+                }
+                else if (rc == Long.class)
+                {
+                    rv = ((Number) rv).floatValue();
+                }
+                else if (rc == Double.class)
+                {
+                    lv = ((Number) lv).doubleValue();
+                }
+                else
+                {
+                    return Boolean.FALSE;
+                }
+            }
+            else if (lc == Double.class)
+            {
+                if (rc == Integer.class)
+                {
+                    rv = ((Number) rv).doubleValue();
+                }
+                else if (rc == Long.class)
+                {
+                    rv = ((Number) rv).doubleValue();
+                }
+                else if (rc == Float.class)
+                {
+                    rv = ((Number) rv).doubleValue();
+                }
+                else
+                {
+                    return Boolean.FALSE;
+                }
+            }
+            else
+            {
+                return Boolean.FALSE;
+            }
+        }
+
+        return asBoolean(lv.compareTo(rv)) ? Boolean.TRUE : Boolean.FALSE;
+    }
+
+    protected abstract boolean asBoolean(int answer);
+
+    public boolean matches(FilterableMessage message)
+    {
+        Object object = evaluate(message);
+
+        return (object != null) && (object == Boolean.TRUE);
+    }
+
+    private static class EqualExpression extends ComparisonExpression
+    {
+        public EqualExpression(final Expression left, final Expression right)
+        {
+            super(left, right);
+        }
+
+        public Object evaluate(FilterableMessage message)
+        {
+            Object lv = getLeft().evaluate(message);
+            Object rv = getRight().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;
+        }
+
+        protected boolean asBoolean(int answer)
+        {
+            return answer == 0;
+        }
+
+        public String getExpressionSymbol()
+        {
+            return "=";
+        }
+    }
+}
diff --git a/java/common/src/main/java/org/apache/qpid/filter/ConstantExpression.java b/java/common/src/main/java/org/apache/qpid/filter/ConstantExpression.java
new file mode 100644
index 0000000000..20c9f1438a
--- /dev/null
+++ b/java/common/src/main/java/org/apache/qpid/filter/ConstantExpression.java
@@ -0,0 +1,207 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+package org.apache.qpid.filter;
+//
+// Based on like named file from r450141 of the Apache ActiveMQ project <http://www.activemq.org/site/home.html>
+//
+
+import java.math.BigDecimal;
+
+/**
+ * Represents a constant expression
+ */
+public class ConstantExpression implements Expression
+{
+
+    static class BooleanConstantExpression extends ConstantExpression implements BooleanExpression
+    {
+        public BooleanConstantExpression(Object value)
+        {
+            super(value);
+        }
+
+        public boolean matches(FilterableMessage message)
+        {
+            Object object = evaluate(message);
+
+            return (object != null) && (object == Boolean.TRUE);
+        }
+    }
+
+    public static final BooleanConstantExpression NULL = new BooleanConstantExpression(null);
+    public static final BooleanConstantExpression TRUE = new BooleanConstantExpression(Boolean.TRUE);
+    public static final BooleanConstantExpression FALSE = new BooleanConstantExpression(Boolean.FALSE);
+
+    private Object value;
+
+    public static ConstantExpression createFromDecimal(String text)
+    {
+
+        // Strip off the 'l' or 'L' if needed.
+        if (text.endsWith("l") || text.endsWith("L"))
+        {
+            text = text.substring(0, text.length() - 1);
+        }
+
+        Number value;
+        try
+        {
+            value = new Long(text);
+        }
+        catch (NumberFormatException e)
+        {
+            // The number may be too big to fit in a long.
+            value = new BigDecimal(text);
+        }
+
+        long l = value.longValue();
+        if ((Integer.MIN_VALUE <= l) && (l <= Integer.MAX_VALUE))
+        {
+            value = value.intValue();
+        }
+
+        return new ConstantExpression(value);
+    }
+
+    public static ConstantExpression createFromHex(String text)
+    {
+        Number value = Long.parseLong(text.substring(2), 16);
+        long l = value.longValue();
+        if ((Integer.MIN_VALUE <= l) && (l <= Integer.MAX_VALUE))
+        {
+            value = value.intValue();
+        }
+
+        return new ConstantExpression(value);
+    }
+
+    public static ConstantExpression createFromOctal(String text)
+    {
+        Number value = Long.parseLong(text, 8);
+        long l = value.longValue();
+        if ((Integer.MIN_VALUE <= l) && (l <= Integer.MAX_VALUE))
+        {
+            value = value.intValue();
+        }
+
+        return new ConstantExpression(value);
+    }
+
+    public static ConstantExpression createFloat(String text)
+    {
+        Number value = new Double(text);
+
+        return new ConstantExpression(value);
+    }
+
+    public ConstantExpression(Object value)
+    {
+        this.value = value;
+    }
+
+    public Object evaluate(FilterableMessage message)
+    {
+        return value;
+    }
+
+    public Object getValue()
+    {
+        return value;
+    }
+
+    /**
+     * @see java.lang.Object#toString()
+     */
+    public String toString()
+    {
+        if (value == null)
+        {
+            return "NULL";
+        }
+
+        if (value instanceof Boolean)
+        {
+            return ((Boolean) value) ? "TRUE" : "FALSE";
+        }
+
+        if (value instanceof String)
+        {
+            return encodeString((String) value);
+        }
+
+        return value.toString();
+    }
+
+    /**
+     * TODO: more efficient hashCode()
+     *
+     * @see java.lang.Object#hashCode()
+     */
+    public int hashCode()
+    {
+        return toString().hashCode();
+    }
+
+    /**
+     * TODO: more efficient hashCode()
+     *
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
+    public boolean equals(Object o)
+    {
+
+        if ((o == null) || !this.getClass().equals(o.getClass()))
+        {
+            return false;
+        }
+
+        return toString().equals(o.toString());
+
+    }
+
+    /**
+     * Encodes the value of string so that it looks like it would look like
+     * when it was provided in a selector.
+     *
+     * @param s
+     * @return
+     */
+    public static String encodeString(String s)
+    {
+        StringBuffer b = new StringBuffer();
+        b.append('\'');
+        for (int i = 0; i < s.length(); i++)
+        {
+            char c = s.charAt(i);
+            if (c == '\'')
+            {
+                b.append(c);
+            }
+
+            b.append(c);
+        }
+
+        b.append('\'');
+
+        return b.toString();
+    }
+
+}
diff --git a/java/common/src/main/java/org/apache/qpid/filter/Expression.java b/java/common/src/main/java/org/apache/qpid/filter/Expression.java
new file mode 100644
index 0000000000..1030c7b588
--- /dev/null
+++ b/java/common/src/main/java/org/apache/qpid/filter/Expression.java
@@ -0,0 +1,34 @@
+/**
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.qpid.filter;
+//
+// Based on like named file from r450141 of the Apache ActiveMQ project <http://www.activemq.org/site/home.html>
+//
+
+/**
+ * Represents an expression
+ */
+public interface Expression
+{
+
+    /**
+     * @return the value of this expression
+     */
+    public Object evaluate(FilterableMessage message);
+
+}
diff --git a/java/common/src/main/java/org/apache/qpid/filter/FilterableMessage.java b/java/common/src/main/java/org/apache/qpid/filter/FilterableMessage.java
new file mode 100644
index 0000000000..b5b00ae70f
--- /dev/null
+++ b/java/common/src/main/java/org/apache/qpid/filter/FilterableMessage.java
@@ -0,0 +1,41 @@
+package org.apache.qpid.filter;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ * <p/>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p/>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+public interface FilterableMessage
+{
+
+    boolean isPersistent();
+
+    boolean isRedelivered();
+
+    Object getHeader(String name);
+
+    String getReplyTo();
+
+    String getType();
+
+    byte getPriority();
+
+    String getMessageId();
+
+    long getTimestamp();
+
+    String getCorrelationId();
+
+    long getExpiration();
+}
diff --git a/java/common/src/main/java/org/apache/qpid/filter/LogicExpression.java b/java/common/src/main/java/org/apache/qpid/filter/LogicExpression.java
new file mode 100644
index 0000000000..f8ec19d23b
--- /dev/null
+++ b/java/common/src/main/java/org/apache/qpid/filter/LogicExpression.java
@@ -0,0 +1,118 @@
+/**
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.qpid.filter;
+//
+// Based on like named file from r450141 of the Apache ActiveMQ project <http://www.activemq.org/site/home.html>
+//
+
+/**
+ * A filter performing a comparison of two objects
+ */
+public abstract class LogicExpression extends BinaryExpression implements BooleanExpression
+{
+
+    public static BooleanExpression createOR(BooleanExpression lvalue, BooleanExpression rvalue)
+    {
+        return new OrExpression(lvalue, rvalue);
+    }
+
+    public static BooleanExpression createAND(BooleanExpression lvalue, BooleanExpression rvalue)
+    {
+        return new AndExpression(lvalue, rvalue);
+    }
+
+    /**
+     * @param left
+     * @param right
+     */
+    public LogicExpression(BooleanExpression left, BooleanExpression right)
+    {
+        super(left, right);
+    }
+
+    public abstract Object evaluate(FilterableMessage message);
+
+    public boolean matches(FilterableMessage message)
+    {
+        Object object = evaluate(message);
+
+        return (object != null) && (object == Boolean.TRUE);
+    }
+
+    private static class OrExpression extends LogicExpression
+    {
+        public OrExpression(final BooleanExpression lvalue, final BooleanExpression rvalue)
+        {
+            super(lvalue, rvalue);
+        }
+
+        public Object evaluate(FilterableMessage message)
+        {
+
+            Boolean lv = (Boolean) getLeft().evaluate(message);
+            // Can we do an OR shortcut??
+            if ((lv != null) && lv.booleanValue())
+            {
+                return Boolean.TRUE;
+            }
+
+            Boolean rv = (Boolean) getRight().evaluate(message);
+
+            return (rv == null) ? null : rv;
+        }
+
+        public String getExpressionSymbol()
+        {
+            return "OR";
+        }
+    }
+
+    private static class AndExpression extends LogicExpression
+    {
+        public AndExpression(final BooleanExpression lvalue, final BooleanExpression rvalue)
+        {
+            super(lvalue, rvalue);
+        }
+
+        public Object evaluate(FilterableMessage message)
+        {
+
+            Boolean lv = (Boolean) getLeft().evaluate(message);
+
+            // Can we do an AND shortcut??
+            if (lv == null)
+            {
+                return null;
+            }
+
+            if (!lv.booleanValue())
+            {
+                return Boolean.FALSE;
+            }
+
+            Boolean rv = (Boolean) getRight().evaluate(message);
+
+            return (rv == null) ? null : rv;
+        }
+
+        public String getExpressionSymbol()
+        {
+            return "AND";
+        }
+    }
+}
diff --git a/java/common/src/main/java/org/apache/qpid/filter/PropertyExpression.java b/java/common/src/main/java/org/apache/qpid/filter/PropertyExpression.java
new file mode 100644
index 0000000000..4fb9c0e62f
--- /dev/null
+++ b/java/common/src/main/java/org/apache/qpid/filter/PropertyExpression.java
@@ -0,0 +1,234 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+package org.apache.qpid.filter;
+//
+// Based on like named file from r450141 of the Apache ActiveMQ project <http://www.activemq.org/site/home.html>
+//
+
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashMap;
+
+/**
+ * Represents a property  expression
+ */
+public class PropertyExpression implements Expression
+{
+    // Constants - defined the same as JMS
+    private static enum JMSDeliveryMode { NON_PERSISTENT, PERSISTENT }
+
+    private static final int DEFAULT_PRIORITY = 4;
+
+    private static final Logger _logger = LoggerFactory.getLogger(PropertyExpression.class);
+
+    private static final HashMap<String, Expression> JMS_PROPERTY_EXPRESSIONS = new HashMap<String, Expression>();
+
+    {
+        JMS_PROPERTY_EXPRESSIONS.put("JMSDestination", new Expression()
+                                     {
+                                         public Object evaluate(FilterableMessage message)
+                                         {
+                                             //TODO
+                                             return null;
+                                         }
+                                     });
+        JMS_PROPERTY_EXPRESSIONS.put("JMSReplyTo", new ReplyToExpression());
+
+        JMS_PROPERTY_EXPRESSIONS.put("JMSType", new TypeExpression());
+
+        JMS_PROPERTY_EXPRESSIONS.put("JMSDeliveryMode", new DeliveryModeExpression());
+
+        JMS_PROPERTY_EXPRESSIONS.put("JMSPriority", new PriorityExpression());
+
+        JMS_PROPERTY_EXPRESSIONS.put("JMSMessageID", new MessageIDExpression());
+
+        JMS_PROPERTY_EXPRESSIONS.put("AMQMessageID", new MessageIDExpression());
+
+        JMS_PROPERTY_EXPRESSIONS.put("JMSTimestamp", new TimestampExpression());
+
+        JMS_PROPERTY_EXPRESSIONS.put("JMSCorrelationID", new CorrelationIdExpression());
+
+        JMS_PROPERTY_EXPRESSIONS.put("JMSExpiration", new ExpirationExpression());
+
+        JMS_PROPERTY_EXPRESSIONS.put("JMSRedelivered", new Expression()
+                                     {
+                                         public Object evaluate(FilterableMessage message)
+                                         {
+                                             return message.isRedelivered();
+                                         }
+                                     });
+    }
+
+    private final String name;
+    private final Expression jmsPropertyExpression;
+
+    public boolean outerTest()
+    {
+        return false;
+    }
+
+    public PropertyExpression(String name)
+    {
+        this.name = name;
+
+        
+
+        jmsPropertyExpression = JMS_PROPERTY_EXPRESSIONS.get(name);
+    }
+
+    public Object evaluate(FilterableMessage message)
+    {
+
+        if (jmsPropertyExpression != null)
+        {
+            return jmsPropertyExpression.evaluate(message);
+        }
+        else
+        {
+            return message.getHeader(name);
+        }
+    }
+
+    public String getName()
+    {
+        return name;
+    }
+
+    /**
+     * @see java.lang.Object#toString()
+     */
+    public String toString()
+    {
+        return name;
+    }
+
+    /**
+     * @see java.lang.Object#hashCode()
+     */
+    public int hashCode()
+    {
+        return name.hashCode();
+    }
+
+    /**
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
+    public boolean equals(Object o)
+    {
+
+        if ((o == null) || !this.getClass().equals(o.getClass()))
+        {
+            return false;
+        }
+
+        return name.equals(((PropertyExpression) o).name);
+
+    }
+
+    private static class ReplyToExpression implements Expression
+    {
+        public Object evaluate(FilterableMessage message)
+        {
+            String replyTo = message.getReplyTo();
+            return replyTo;
+        }
+
+    }
+
+    private static class TypeExpression implements Expression
+    {
+        public Object evaluate(FilterableMessage message)
+        {
+
+                String type = message.getType();
+                return type;
+
+        }
+    }
+
+    private static class DeliveryModeExpression implements Expression
+    {
+        public Object evaluate(FilterableMessage message)
+        {
+                JMSDeliveryMode mode = message.isPersistent() ? JMSDeliveryMode.PERSISTENT :
+                                                                JMSDeliveryMode.NON_PERSISTENT;
+                if (_logger.isDebugEnabled())
+                {
+                    _logger.debug("JMSDeliveryMode is :" + mode);
+                }
+
+                return mode.toString();
+        }
+    }
+
+    private static class PriorityExpression implements Expression
+    {
+        public Object evaluate(FilterableMessage message)
+        {
+            byte priority = message.getPriority();
+            return (int) priority;
+        }
+    }
+
+    private static class MessageIDExpression implements Expression
+    {
+        public Object evaluate(FilterableMessage message)
+        {
+
+            String messageId = message.getMessageId();
+
+            return messageId;
+
+        }
+    }
+
+    private static class TimestampExpression implements Expression
+    {
+        public Object evaluate(FilterableMessage message)
+        {
+            long timestamp = message.getTimestamp();
+            return timestamp;
+        }
+    }
+
+    private static class CorrelationIdExpression implements Expression
+    {
+        public Object evaluate(FilterableMessage message)
+        {
+
+            String correlationId = message.getCorrelationId();
+
+            return correlationId;
+        }
+    }
+
+    private static class ExpirationExpression implements Expression
+    {
+        public Object evaluate(FilterableMessage message)
+        {
+            long expiration = message.getExpiration();
+            return expiration;
+
+        }
+    }
+}
diff --git a/java/common/src/main/java/org/apache/qpid/filter/SelectorParsingException.java b/java/common/src/main/java/org/apache/qpid/filter/SelectorParsingException.java
new file mode 100644
index 0000000000..47892edc33
--- /dev/null
+++ b/java/common/src/main/java/org/apache/qpid/filter/SelectorParsingException.java
@@ -0,0 +1,40 @@
+package org.apache.qpid.filter;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ * <p/>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p/>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+public class SelectorParsingException extends RuntimeException
+{
+    public SelectorParsingException(String s)
+    {
+        super(s);
+    }
+
+    public SelectorParsingException(String message, Throwable cause)
+    {
+        super(message, cause);
+    }
+
+    public SelectorParsingException(Throwable cause)
+    {
+        super(cause);
+    }
+
+    public SelectorParsingException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace)
+    {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+}
diff --git a/java/common/src/main/java/org/apache/qpid/filter/UnaryExpression.java b/java/common/src/main/java/org/apache/qpid/filter/UnaryExpression.java
new file mode 100644
index 0000000000..b80b89840c
--- /dev/null
+++ b/java/common/src/main/java/org/apache/qpid/filter/UnaryExpression.java
@@ -0,0 +1,340 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+package org.apache.qpid.filter;
+//
+// Based on like named file from r450141 of the Apache ActiveMQ project <http://www.activemq.org/site/home.html>
+//
+
+import java.math.BigDecimal;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+
+/**
+ * An expression which performs an operation on two expression values
+ */
+public abstract class UnaryExpression implements Expression
+{
+
+    private static final BigDecimal BD_LONG_MIN_VALUE = BigDecimal.valueOf(Long.MIN_VALUE);
+    private Expression right;
+
+    public static Expression createNegate(Expression left)
+    {
+        return new NegativeExpression(left);
+    }
+
+    public static BooleanExpression createInExpression(PropertyExpression right, List elements, final boolean not)
+    {
+
+        // Use a HashSet if there are many elements.
+        Collection t;
+        if (elements.size() == 0)
+        {
+            t = null;
+        }
+        else if (elements.size() < 5)
+        {
+            t = elements;
+        }
+        else
+        {
+            t = new HashSet(elements);
+        }
+
+        final Collection inList = t;
+
+        return new InExpression(right, inList, not);
+    }
+
+    abstract static class BooleanUnaryExpression extends UnaryExpression implements BooleanExpression
+    {
+        public BooleanUnaryExpression(Expression left)
+        {
+            super(left);
+        }
+
+        public boolean matches(FilterableMessage message)
+        {
+            Object object = evaluate(message);
+
+            return (object != null) && (object == Boolean.TRUE);
+        }
+    }
+
+    public static BooleanExpression createNOT(BooleanExpression left)
+    {
+        return new NotExpression(left);
+    }
+
+    public static BooleanExpression createBooleanCast(Expression left)
+    {
+        return new BooleanCastExpression(left);
+    }
+
+    private static Number negate(Number left)
+    {
+        Class clazz = left.getClass();
+        if (clazz == Integer.class)
+        {
+            return -left.intValue();
+        }
+        else if (clazz == Long.class)
+        {
+            return -left.longValue();
+        }
+        else if (clazz == Float.class)
+        {
+            return -left.floatValue();
+        }
+        else if (clazz == Double.class)
+        {
+            return -left.doubleValue();
+        }
+        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
+            // to a Long.
+            BigDecimal bd = (BigDecimal) left;
+            bd = bd.negate();
+
+            if (BD_LONG_MIN_VALUE.compareTo(bd) == 0)
+            {
+                return Long.MIN_VALUE;
+            }
+
+            return bd;
+        }
+        else
+        {
+            throw new SelectorParsingException("Don't know how to negate: " + left);
+        }
+    }
+
+    public UnaryExpression(Expression left)
+    {
+        this.right = left;
+    }
+
+    public Expression getRight()
+    {
+        return right;
+    }
+
+    /**
+     * @see java.lang.Object#toString()
+     */
+    public String toString()
+    {
+        return "(" + getExpressionSymbol() + " " + right.toString() + ")";
+    }
+
+    /**
+     * TODO: more efficient hashCode()
+     *
+     * @see java.lang.Object#hashCode()
+     */
+    public int hashCode()
+    {
+        return toString().hashCode();
+    }
+
+    /**
+     * TODO: more efficient hashCode()
+     *
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
+    public boolean equals(Object o)
+    {
+        return ((o != null) && this.getClass().equals(o.getClass())) && toString().equals(o.toString());
+    }
+
+    /**
+     * Returns the symbol that represents this binary expression.  For example, addition is
+     * represented by "+"
+     *
+     * @return symbol
+     */
+    public abstract String getExpressionSymbol();
+
+    private static class NegativeExpression extends UnaryExpression
+    {
+        public NegativeExpression(final Expression left)
+        {
+            super(left);
+        }
+
+        public Object evaluate(FilterableMessage message)
+        {
+            Object rvalue = getRight().evaluate(message);
+            if (rvalue == null)
+            {
+                return null;
+            }
+
+            if (rvalue instanceof Number)
+            {
+                return negate((Number) rvalue);
+            }
+
+            return null;
+        }
+
+        public String getExpressionSymbol()
+        {
+            return "-";
+        }
+    }
+
+    private static class InExpression extends BooleanUnaryExpression
+    {
+        private final Collection _inList;
+        private final boolean _not;
+
+        public InExpression(final PropertyExpression right, final Collection inList, final boolean not)
+        {
+            super(right);
+            _inList = inList;
+            _not = not;
+        }
+
+        public Object evaluate(FilterableMessage message)
+        {
+
+            Object rvalue = getRight().evaluate(message);
+            if (rvalue == null)
+            {
+                return null;
+            }
+
+            if (rvalue.getClass() != String.class)
+            {
+                return null;
+            }
+
+            if (((_inList != null) && _inList.contains(rvalue)) ^ _not)
+            {
+                return Boolean.TRUE;
+            }
+            else
+            {
+                return Boolean.FALSE;
+            }
+
+        }
+
+        public String toString()
+        {
+            StringBuilder answer = new StringBuilder(String.valueOf(getRight()));
+            answer.append(" ");
+            answer.append(getExpressionSymbol());
+            answer.append(" ( ");
+
+            int count = 0;
+            for (Object o : _inList)
+            {
+                if (count != 0)
+                {
+                    answer.append(", ");
+                }
+
+                answer.append(o);
+                count++;
+            }
+
+            answer.append(" )");
+
+            return answer.toString();
+        }
+
+        public String getExpressionSymbol()
+        {
+            if (_not)
+            {
+                return "NOT IN";
+            }
+            else
+            {
+                return "IN";
+            }
+        }
+    }
+
+    private static class NotExpression extends BooleanUnaryExpression
+    {
+        public NotExpression(final BooleanExpression left)
+        {
+            super(left);
+        }
+
+        public Object evaluate(FilterableMessage message)
+        {
+            Boolean lvalue = (Boolean) getRight().evaluate(message);
+            if (lvalue == null)
+            {
+                return null;
+            }
+
+            return lvalue ? Boolean.FALSE : Boolean.TRUE;
+        }
+
+        public String getExpressionSymbol()
+        {
+            return "NOT";
+        }
+    }
+
+    private static class BooleanCastExpression extends BooleanUnaryExpression
+    {
+        public BooleanCastExpression(final Expression left)
+        {
+            super(left);
+        }
+
+        public Object evaluate(FilterableMessage message)
+        {
+            Object rvalue = getRight().evaluate(message);
+            if (rvalue == null)
+            {
+                return null;
+            }
+
+            if (!rvalue.getClass().equals(Boolean.class))
+            {
+                return Boolean.FALSE;
+            }
+
+            return ((Boolean) rvalue) ? Boolean.TRUE : Boolean.FALSE;
+        }
+
+        public String toString()
+        {
+            return getRight().toString();
+        }
+
+        public String getExpressionSymbol()
+        {
+            return "";
+        }
+    }
+}