- further simplified bootstrapping Traverser's initial context

gkesler · andimarek · commit ad2f45b3c3f8 · 2018-03-17T21:14:04.000+11:00
* provided fluent api to add a bootstrap variable or a set of variables
diff --git a/src/main/java/graphql/analysis/QueryTraversal.java b/src/main/java/graphql/analysis/QueryTraversal.java
@@ -35,6 +35,8 @@
 
 import static graphql.Assert.assertNotNull;
 import static graphql.Assert.assertShouldNeverHappen;
+import java.util.Collections;
+import java.util.HashMap;
 
 @Internal
 public class QueryTraversal {
@@ -112,20 +114,10 @@ private void visitImpl(QueryVisitor visitor, SelectionSet selectionSet, GraphQLC
         // we always can obtain the root QueryTraversalContext,
         // we are subclassing here TraverserStack to set up a BARRIER
         // parent that stores root QueryTraversalContext
-        new Traverser<Selection>(createStack(context), this::childrenOf)
+        Traverser.depthFirst(this::childrenOf)
+            .rootVar(QueryTraversalContext.class, context)
             .traverse(selectionSet.getSelections(), null, delegate);
     }
-
-    private TraverserStack<Selection> createStack (QueryTraversalContext root) {
-        return new TraverserStack<Selection>() {
-            @Override
-            public void addAll(Collection<? extends Selection> col) {
-                TraverserContext<Selection> rootContext = newContext(null, null)
-                        .setVar(QueryTraversalContext.class, root);
-                addAll(col, rootContext);
-            }
-        };
-    }
     
     private class QueryTraversalDelegate extends NodeVisitorStub<TraverserContext<Selection>> {
         
diff --git a/src/main/java/graphql/util/RecursionState.java b/src/main/java/graphql/util/RecursionState.java
@@ -41,7 +41,7 @@ public void addAll(Collection<? extends T> col) {
         addAll(col, null);
     }
 
-    protected void addAll(Collection<? extends T> col, TraverserContext<T> root) {
+    public void addAll(Collection<? extends T> col, TraverserContext<T> root) {
         assertNotNull(col).stream().map((x) -> newContext(x, root)).collect(Collectors.toCollection(() -> delegate));
     }
     
@@ -54,7 +54,13 @@ public void clear() {
         visitedMap.clear();
     }
 
-    public TraverserContext<T> newContext(final T o, final TraverserContext<T> parent) {
+    public TraverserContext<T> newContext(T o, TraverserContext<T> parent) {
+        return newContext(o, parent, new ConcurrentHashMap<>());
+    }
+    
+    public TraverserContext<T> newContext(T o, TraverserContext<T> parent, Map<Class<?>, Object> vars) {
+        assertNotNull(vars);
+        
         return new TraverserContext<T>() {
             @Override
             public T thisNode() {
@@ -86,8 +92,6 @@ public <S> TraverserContext<T> setVar(Class<? super S> key, S value) {
                 vars.put(key, value);
                 return this;
             }
-
-            final Map<Class<?>, Object> vars = new HashMap<>();
         };
     }
 
diff --git a/src/main/java/graphql/util/Traverser.java b/src/main/java/graphql/util/Traverser.java
@@ -8,12 +8,15 @@
 import java.util.function.Function;
 
 import static graphql.Assert.assertNotNull;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 @Internal
 public class Traverser<T> {
 
     private final RecursionState<T> stack;
     private final Function<? super T, ? extends List<T>> getChildren;
+    private final Map<Class<?>, Object> rootVars = new ConcurrentHashMap<>();
 
     /**
      * Instantiates a depth-first Traverser object with a given method to extract
@@ -39,7 +42,32 @@ public Traverser(RecursionState<T> stack, Function<? super T, ? extends List<T>>
         this.stack = assertNotNull(stack);
         this.getChildren = assertNotNull(getChildren);
     }
-
+    
+    /**
+     * Bootstraps the very root (BARRIER) TraverserContext as a common parent for
+     * all traversal roots' contexts with the provided set of root variables
+     * 
+     * @param rootVars root variables
+     * @return this Traverser instance to allow chaining
+     */
+    public Traverser<T> rootVars (Map<Class<?>, Object> rootVars) {
+        rootVars.putAll(assertNotNull(rootVars));
+        return this;
+    }
+    
+    /**
+     * Bootstraps the very root (BARRIER) TraverserContext as a common parent for
+     * all traversal roots' contexts with the provided root variable
+     * 
+     * @param key key to store root variable
+     * @param value value of the root variable
+     * @return this Traverser instance to allow chaining
+     */
+    public Traverser<T> rootVar (Class<?> key, Object value) {
+        rootVars.put(key, value);
+        return this;
+    }
+    
     /**
      * Creates a standard Traverser suitable for depth-first traversal (both pre- and post- order)
      *
@@ -107,7 +135,7 @@ public <U> Object traverse(Collection<T> roots, U data, TraverserVisitor<? super
         assertNotNull(roots);
         assertNotNull(visitor);
 
-        stack.addAll(roots);
+        stack.addAll(roots, stack.newContext(null, null, rootVars));
 
         Object d = data;
         while (!(stack.isEmpty() || (d = traverseOne((TraverserVisitor<T, U>) visitor, (U) d)) == TraverserMarkers.QUIT))

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ public void addAll(Collection<? extends T> col) {`
`41`	`41`	`addAll(col, null);`
`42`	`42`	`}`
`43`	`43`
`44`		`- protected void addAll(Collection<? extends T> col, TraverserContext<T> root) {`
	`44`	`+ public void addAll(Collection<? extends T> col, TraverserContext<T> root) {`
`45`	`45`	`assertNotNull(col).stream().map((x) -> newContext(x, root)).collect(Collectors.toCollection(() -> delegate));`
`46`	`46`	`}`
`47`	`47`
`@@ -54,7 +54,13 @@ public void clear() {`
`54`	`54`	`visitedMap.clear();`
`55`	`55`	`}`
`56`	`56`
`57`		`- public TraverserContext<T> newContext(final T o, final TraverserContext<T> parent) {`
	`57`	`+ public TraverserContext<T> newContext(T o, TraverserContext<T> parent) {`
	`58`	`+ return newContext(o, parent, new ConcurrentHashMap<>());`
	`59`	`+ }`
	`60`	`+`
	`61`	`+ public TraverserContext<T> newContext(T o, TraverserContext<T> parent, Map<Class<?>, Object> vars) {`
	`62`	`+ assertNotNull(vars);`
	`63`	`+`
`58`	`64`	`return new TraverserContext<T>() {`
`59`	`65`	`@Override`
`60`	`66`	`public T thisNode() {`
`@@ -86,8 +92,6 @@ public <S> TraverserContext<T> setVar(Class<? super S> key, S value) {`
`86`	`92`	`vars.put(key, value);`
`87`	`93`	`return this;`
`88`	`94`	`}`
`89`		`-`
`90`		`- final Map<Class<?>, Object> vars = new HashMap<>();`
`91`	`95`	`};`
`92`	`96`	`}`
`93`	`97`