node parameter added to creators

Author: nRo

src/main/java/de/alexgruen/query/DefaultCreator.java

@@ -32,6 +32,19 @@ public abstract class DefaultCreator<T> {
 
     /**
      * Query creator for != operator
+     *
+     * @param queryNode current query node
+     * @param field input field
+     * @param value input value
+     * @return created query object
+     */
+    public T ne(QueryNode queryNode, Field field, Value value) {
+        return ne(field, value);
+    }
+
+    /**
+     * Query creator for != operator
+     *
      * @param field input field
      * @param value input value
      * @return created query object
@@ -42,6 +55,7 @@ public T ne(Field field, Value value) {
 
     /**
      * Query creator for == operator
+     *
      * @param field input field
      * @param value input value
      * @return created query object
@@ -50,8 +64,34 @@ public T eq(Field field, Value value) {
         throw new QueryCompilerException("'eq' operator is not allowed");
     }
 
+
+    /**
+     * Query creator for == operator
+     *
+     * @param queryNode current query node
+     * @param field input field
+     * @param value input value
+     * @return created query object
+     */
+    public T eq(QueryNode queryNode, Field field, Value value) {
+        return eq(field, value);
+    }
+
     /**
      * Query creator for >= operator
+     *
+     * @param queryNode current query node
+     * @param field input field
+     * @param value input value
+     * @return created query object
+     */
+    public T ge(QueryNode queryNode, Field field, Value value) {
+        return ge(field, value);
+    }
+
+    /**
+     * Query creator for >= operator
+     *
      * @param field input field
      * @param value input value
      * @return created query object
@@ -62,6 +102,19 @@ public T ge(Field field, Value value) {
 
     /**
      * Query creator for > operator
+     *
+     * @param queryNode current query node
+     * @param field input field
+     * @param value input value
+     * @return created query object
+     */
+    public T gt(QueryNode queryNode, Field field, Value value) {
+        return gt(field, value);
+    }
+
+    /**
+     * Query creator for > operator
+     *
      * @param field input field
      * @param value input value
      * @return created query object
@@ -72,6 +125,19 @@ public T gt(Field field, Value value) {
 
     /**
      * Query creator for < operator
+     *
+     * @param queryNode current query node
+     * @param field input field
+     * @param value input value
+     * @return created query object
+     */
+    public T lt(QueryNode queryNode, Field field, Value value) {
+        return lt(field, value);
+    }
+
+    /**
+     * Query creator for < operator
+     *
      * @param field input field
      * @param value input value
      * @return created query object
@@ -82,6 +148,20 @@ public T lt(Field field, Value value) {
 
     /**
      * Query creator for <= operator
+     *
+     * @param queryNode current query node
+     * @param field input field
+     * @param value input value
+     * @return created query object
+     */
+    public T le(QueryNode queryNode, Field field, Value value) {
+        return le(field, value);
+    }
+
+
+    /**
+     * Query creator for <= operator
+     *
      * @param field input field
      * @param value input value
      * @return created query object
@@ -92,6 +172,20 @@ public T le(Field field, Value value) {
 
     /**
      * Query creator for the regex operator
+     *
+     * @param queryNode current query node
+     * @param field input field
+     * @param value input value
+     * @return created query object
+     */
+    public T regex(QueryNode queryNode, Field field, Value value) {
+        return regex(field, value);
+    }
+
+
+    /**
+     * Query creator for the regex operator
+     *
      * @param field input field
      * @param value input value
      * @return created query object
@@ -102,6 +196,19 @@ public T regex(Field field, Value value) {
 
     /**
      * Query creator for the text operator
+     *
+     * @param queryNode current query node
+     * @param field input field
+     * @param value input value
+     * @return created query object
+     */
+    public T text(QueryNode queryNode, Field field, Value value) {
+        return text(field, value);
+    }
+
+    /**
+     * Query creator for the text operator
+     *
      * @param field input field
      * @param value input value
      * @return created query object
@@ -112,6 +219,18 @@ public T text(Field field, Value value) {
 
     /**
      * Logic creator for the negation of a query
+     *
+     * @param queryNode current query node
+     * @param v input query
+     * @return created query object
+     */
+    public T not(QueryNode queryNode, T v) {
+        return not(v);
+    }
+
+    /**
+     * Logic creator for the negation of a query
+     *
      * @param v input query
      * @return created query object
      */
@@ -121,6 +240,18 @@ public T not(T v) {
 
     /**
      * Logic creator for the AND concatenation of queries
+     *
+     * @param queryNode current query node
+     * @param v input queries
+     * @return created query object
+     */
+    public T and(QueryNode queryNode, T... v) {
+        return and(v);
+    }
+
+    /**
+     * Logic creator for the AND concatenation of queries
+     *
      * @param v input queries
      * @return created query object
      */
@@ -130,6 +261,18 @@ public T and(T... v) {
 
     /**
      * Logic creator for the OR concatenation of queries
+     *
+     * @param queryNode current query node
+     * @param v input queries
+     * @return created query object
+     */
+    public T or(QueryNode queryNode, T... v) {
+        return or(v);
+    }
+
+    /**
+     * Logic creator for the OR concatenation of queries
+     *
      * @param v input queries
      * @return created query object
      */
@@ -139,6 +282,18 @@ public T or(T... v) {
 
     /**
      * Logic creator for the XOR concatenation of queries
+     *
+     * @param queryNode current query node
+     * @param v input queries
+     * @return created query object
+     */
+    public T xor(QueryNode queryNode, T... v) {
+        return xor(v);
+    }
+
+    /**
+     * Logic creator for the XOR concatenation of queries
+     *
      * @param v input queries
      * @return created query object
      */
@@ -148,6 +303,18 @@ public T xor(T... v) {
 
     /**
      * Logic creator for the NOR concatenation of queries
+     *
+     * @param queryNode current query node
+     * @param v input queries
+     * @return created query object
+     */
+    public T nor(QueryNode queryNode, T... v) {
+        return nor(v);
+    }
+
+    /**
+     * Logic creator for the NOR concatenation of queries
+     *
      * @param v input queries
      * @return created query object
      */
@@ -157,6 +324,7 @@ public T nor(T... v) {
 
     /**
      * Term creator for fulltext search queries
+     *
      * @param value input value
      * @return created query object
      */
@@ -166,6 +334,7 @@ public T fullSearch(Value value) {
 
     /**
      * Term creator for empty queries (match all)
+     *
      * @return created query object
      */
     public T empty() {

src/main/java/de/alexgruen/query/QueryNode.java

@@ -26,16 +26,14 @@
 
 import de.alexgruen.query.term.Term;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
+import java.util.*;
 
 public class QueryNode {
     private boolean negate;
     private LogicalOperator operator;
     private Term term;
     private List<QueryNode> children = new ArrayList<>();
-
+    private Map<String, Object> attributes = new HashMap<>();
 
     public QueryNode() {
     }
@@ -71,6 +69,36 @@ public QueryNode(LogicalOperator operator, QueryNode... children) {
         this(false, operator, null, Arrays.asList(children));
     }
 
+    /**
+     * Returns the attributes map
+     * @return attributes map
+     */
+    public Map<String, Object> getAttributes() {
+        return attributes;
+    }
+
+    /**
+     * Returns an attribute value or null if no attribute with the specified name is found.
+     * @param name attribute name
+     * @return value
+     */
+    public Object getAttribute(String name){
+        return attributes.get(name);
+    }
+
+    /**
+     * Sets the value of an attribute. Returns the previously set value or null
+     * @param name attribute name
+     * @param value attribute value
+     * @return previous value or null
+     */
+    public Object setAttribute(String name, Object value){
+        return attributes.put(name,value);
+    }
+    /**
+     * Creates a new leaf node from a term
+     * @param term term
+     */
 
     /**
      * Returns <tt>true</tt> if this node is negated

src/main/java/de/alexgruen/query/compiler/QueryCompiler.java

@@ -124,14 +124,14 @@ private T compileTreeRec(QueryNode node) {
             if(context.getEmptyCreator() == null){
                 throw new QueryCompilerException("no empty creator defined");
             }
-            return context.getEmptyCreator().create(null,null);
+            return context.getEmptyCreator().create(node,null,null);
         }
         //return if node contains term
         if (node.getTerm() != null) {
-            T t = createTerm(node.getTerm());
+            T t = createTerm(node, node.getTerm());
             //negate term if required
             if (node.isNegate()) {
-                t = negate(t);
+                t = negate(node, t);
             }
             return t;
         }
@@ -146,9 +146,9 @@ private T compileTreeRec(QueryNode node) {
 
         //Create new term using child terms and logical operation
         LogicCreator<T> logicCreator = context.getLogicCreator(node.getOperator());
-        T t = logicCreator.create(terms);
+        T t = logicCreator.create(node, terms);
         if (node.isNegate()) {
-            t = negate(t);
+            t = negate(node, t);
         }
         return t;
     }
@@ -158,20 +158,20 @@ private T compileTreeRec(QueryNode node) {
      * @param t input object
      * @return negated object
      */
-    private T negate(T t) {
+    private T negate(QueryNode node, T t) {
         T[] a = CompilerUtil.createArray(context.getCl(), 1);
         a[0] = t;
-        return context.getLogicCreator(LogicalOperators.NOT).create(a);
+        return context.getLogicCreator(LogicalOperators.NOT).create(node, a);
     }
 
     /**
      * Create object of target class for a term using the creator ({@link TermCreator}) specified in the {@link QueryContext}
      * @param term input term
      * @return object of target class
      */
-    private T createTerm(Term term) {
+    private T createTerm(QueryNode node, Term term) {
         TermCreator<T> creator = context.getTermCreator(term.getOperator());
-        return creator.create(term.getField(), term.getValue());
+        return creator.create(node, term.getField(), term.getValue());
     }
 
     /**