Remove done() from Node*Client

Instead, progressor.next() will be used directly as
an indicator if client is done or not.

This means NodeValueClientFilter now sits in the
middle between NodeValueClient and IndexProgressor
and passes calls between them.

community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/NativeSchemaNumberIndexReader.java

@@ -210,19 +210,19 @@ public boolean hasFullNumberPrecision( IndexQuery... predicates )
         return true;
     }
 
-    private void startSeekForInitializedRange( IndexProgressor.NodeValueClient cursor, KEY treeKeyFrom, KEY treeKeyTo )
+    private void startSeekForInitializedRange( IndexProgressor.NodeValueClient client, KEY treeKeyFrom, KEY treeKeyTo )
     {
         if ( layout.compare( treeKeyFrom, treeKeyTo ) > 0 )
         {
-            cursor.initialize( IndexProgressor.EMPTY, propertyKeys );
+            client.initialize( IndexProgressor.EMPTY, propertyKeys );
             return;
         }
         try
         {
             RawCursor<Hit<KEY,VALUE>,IOException> seeker = tree.seek( treeKeyFrom, treeKeyTo );
             openSeekers.add( seeker );
-            IndexProgressor hitProgressor = new NumberHitIndexCursorProgressor<>( seeker, cursor, openSeekers );
-            cursor.initialize( hitProgressor, propertyKeys );
+            IndexProgressor hitProgressor = new NumberHitIndexCursorProgressor<>( seeker, client, openSeekers );
+            client.initialize( hitProgressor, propertyKeys );
         }
         catch ( IOException e )
         {

community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/NodeValueIterator.java

@@ -21,15 +21,17 @@
 
 import org.neo4j.collection.primitive.PrimitiveLongCollections;
 import org.neo4j.collection.primitive.PrimitiveLongIterator;
+import org.neo4j.graphdb.Resource;
 import org.neo4j.storageengine.api.schema.IndexProgressor;
 import org.neo4j.values.storable.Value;
 
 /**
  * A {@link IndexProgressor} + {@link IndexProgressor.NodeValueClient} combo presented as a {@link PrimitiveLongIterator}.
  */
-public class NodeValueIterator extends PrimitiveLongCollections.PrimitiveLongBaseIterator implements IndexProgressor.NodeValueClient
+public class NodeValueIterator extends PrimitiveLongCollections.PrimitiveLongBaseIterator
+        implements IndexProgressor.NodeValueClient, Resource
 {
-    private boolean closed;
+    private volatile boolean closed;
     private IndexProgressor progressor;
 
     @Override
@@ -39,7 +41,7 @@ protected boolean fetchNext()
         // and feed result into this with node( long reference, Value... values )
         if ( closed || !progressor.next() )
         {
-            done();
+            close();
             return false;
         }
         return true;
@@ -58,12 +60,12 @@ public boolean acceptNode( long reference, Value... values )
     }
 
     @Override
-    public void done()
+    public void close()
     {
         if ( !closed )
         {
-            progressor.close();
             closed = true;
+            progressor.close();
         }
     }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/NumberHitIndexCursorProgressor.java

@@ -30,15 +30,15 @@
 public class NumberHitIndexCursorProgressor<KEY extends SchemaNumberKey, VALUE extends SchemaNumberValue> implements IndexProgressor
 {
     private final RawCursor<Hit<KEY,VALUE>,IOException> seeker;
-    private final NodeValueClient cursor;
+    private final NodeValueClient client;
     private final Collection<RawCursor<Hit<KEY,VALUE>,IOException>> toRemoveFromOnClose;
     private boolean closed;
 
-    NumberHitIndexCursorProgressor( RawCursor<Hit<KEY,VALUE>,IOException> seeker, NodeValueClient cursor,
+    NumberHitIndexCursorProgressor( RawCursor<Hit<KEY,VALUE>,IOException> seeker, NodeValueClient client,
             Collection<RawCursor<Hit<KEY,VALUE>,IOException>> toRemoveFromOnClose )
     {
         this.seeker = seeker;
-        this.cursor = cursor;
+        this.client = client;
         this.toRemoveFromOnClose = toRemoveFromOnClose;
     }
 
@@ -50,7 +50,7 @@ public boolean next()
             if ( seeker.next() )
             {
                 KEY key = seeker.get().key();
-                cursor.acceptNode( key.entityId, key.asValue() );
+                client.acceptNode( key.entityId, key.asValue() );
                 return true;
             }
             return false;

community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/fusion/FusionIndexReader.java

@@ -132,7 +132,7 @@ public void query( IndexProgressor.NodeValueClient cursor, IndexOrder indexOrder
         // todo: There will be no ordering of the node ids here. Is this a problem?
         if ( predicates[0] instanceof ExistsPredicate )
         {
-            MultiProgressorNodeValueCursor multiProgressor = new MultiProgressorNodeValueCursor( cursor, propertyKeys );
+            BridgingIndexProgressor multiProgressor = new BridgingIndexProgressor( cursor, propertyKeys );
             cursor.initialize( multiProgressor, propertyKeys );
             nativeReader.query( multiProgressor, indexOrder, predicates[0] );
             luceneReader.query( multiProgressor, indexOrder, predicates[0] );
@@ -161,16 +161,19 @@ public boolean hasFullNumberPrecision( IndexQuery... predicates )
         return predicates[0] instanceof NumberRangePredicate && nativeReader.hasFullNumberPrecision( predicates );
     }
 
-    private class MultiProgressorNodeValueCursor implements IndexProgressor.NodeValueClient, IndexProgressor
+    /**
+     * Combine multiple progressor to act like one single logical progressor seen from clients perspective.
+     */
+    private class BridgingIndexProgressor implements IndexProgressor.NodeValueClient, IndexProgressor
     {
-        private final NodeValueClient cursor;
+        private final NodeValueClient client;
         private final int[] keys;
         private final Queue<IndexProgressor> progressors;
         private IndexProgressor current;
 
-        MultiProgressorNodeValueCursor( NodeValueClient cursor, int[] keys )
+        BridgingIndexProgressor( NodeValueClient client, int[] keys )
         {
-            this.cursor = cursor;
+            this.client = client;
             this.keys = keys;
             progressors = new ArrayDeque<>();
         }
@@ -190,6 +193,7 @@ public boolean next()
                 }
                 else
                 {
+                    current.close();
                     current = progressors.poll();
                 }
             }
@@ -223,13 +227,7 @@ private void assertKeysAlign( int[] keys )
         @Override
         public boolean acceptNode( long reference, Value[] values )
         {
-            return cursor.acceptNode( reference, values );
-        }
-
-        @Override
-        public void done()
-        {
-            cursor.done();
+            return client.acceptNode( reference, values );
         }
     }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/IndexCursor.java

@@ -30,11 +30,6 @@ final void initialize( IndexProgressor progressor )
         this.progressor = progressor;
     }
 
-    public final void done()
-    {
-        close();
-    }
-
     public final boolean next()
     {
         return progressor != null && progressor.next();

community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/NodeValueClientFilter.java

@@ -24,23 +24,58 @@
 
 import org.neo4j.internal.kernel.api.IndexQuery;
 import org.neo4j.storageengine.api.schema.IndexProgressor;
+import org.neo4j.storageengine.api.schema.IndexProgressor.NodeValueClient;
 import org.neo4j.values.storable.Value;
 
 /**
  * This class filters acceptNode() calls from an index progressor, to assert that exact entries returned from the
  * progressor really match the exact property values. See also org.neo4j.kernel.impl.api.LookupFilter.
+ *
+ * It works by acting as a man-in-the-middle between outer {@link NodeValueClient client} and inner {@link IndexProgressor}.
+ * Interaction goes like:
+ *
+ * Initialize:
+ * <pre><code>
+ * client
+ *      -- query( client ) ->      filter = new filter(client)
+ *                                 filter -- query( filter ) ->        progressor
+ *                                 filter <- initialize(progressor) -- progressor
+ * client <- initialize(filter) -- filter
+ * </code></pre>
+ *
+ * Progress:
+ * <pre><code>
+ * client -- next() ->       filter
+ *                           filter -- next() ->          progressor
+ *                                     <- acceptNode() --
+ *                                  -- :false ->
+ *                                     <- acceptNode() --
+ *                                  -- :false ->
+ *                           filter    <- acceptNode() --
+ * client <- acceptNode() -- filter
+ *        -- :true ->        filter -- :true ->           progressor
+ * client <----------------------------------------------
+ * </code></pre>
+ *
+ * Close:
+ * <pre><code>
+ * client -- close() -> filter
+ *                      filter -- close() -> progressor
+ * client <---------------------------------
+ * </code></pre>
  */
-class NodeValueClientFilter implements IndexProgressor.NodeValueClient
+class NodeValueClientFilter implements NodeValueClient, IndexProgressor
 {
     private static final Comparator<IndexQuery> ASCENDING_BY_KEY = Comparator.comparingInt( IndexQuery::propertyKeyId );
-    private final IndexProgressor.NodeValueClient target;
+    private final NodeValueClient target;
     private final NodeCursor node;
     private final PropertyCursor property;
     private final IndexQuery[] filters;
     private int[] keys;
+    private IndexProgressor progressor;
 
     NodeValueClientFilter(
-            IndexProgressor.NodeValueClient target,
+            NodeValueClient target,
             NodeCursor node, PropertyCursor property, IndexQuery... filters )
     {
         this.target = target;
@@ -53,16 +88,9 @@ class NodeValueClientFilter implements IndexProgressor.NodeValueClient
     @Override
     public void initialize( IndexProgressor progressor, int[] propertyIds )
     {
+        this.progressor = progressor;
         this.keys = propertyIds;
-        target.initialize( progressor, propertyIds );
-    }
-
-    @Override
-    public void done()
-    {
-        node.close();
-        property.close();
-        target.done();
+        target.initialize( this, propertyIds );
     }
 
     @Override
@@ -88,6 +116,20 @@ public boolean acceptNode( long reference, Value[] values )
         }
     }
 
+    @Override
+    public boolean next()
+    {
+        return progressor.next();
+    }
+
+    @Override
+    public void close()
+    {
+        node.close();
+        property.close();
+        progressor.close();
+    }
+
     private boolean filterByIndexValues( long reference, Value[] values )
     {
         FILTERS:

community/kernel/src/main/java/org/neo4j/storageengine/api/schema/IndexProgressor.java

@@ -82,11 +82,6 @@ interface NodeValueClient
          * @return true if the entry is accepted, false otherwise
          */
         boolean acceptNode( long reference, Value... values );
-
-        /**
-         * Called by progressor so signal that there are no more entries.
-         */
-        void done();
     }
 
     /**
@@ -109,11 +104,6 @@ interface NodeLabelClient
          * @return true if the entry is accepted, false otherwise
          */
         boolean acceptNode( long reference, LabelSet labels );
-
-        /**
-         * Called by progressor so signal that there are no more entries.
-         */
-        void done();
     }
 
     /**
@@ -135,11 +125,6 @@ interface ExplicitClient
          * @return true if the entry is accepted, false otherwise
          */
         boolean acceptEntity( long reference, float score );
-
-        /**
-         * Called by progressor so signal that there are no more entries.
-         */
-        void done();
     }
 
     IndexProgressor EMPTY = new IndexProgressor()