Introduce IndexMeta

as container for:
- IndexDescriptor
- SchemaIndexProvider.Descriptor
- IndexCapability

Those three where passed to IndexProxy
instances individually even though they together
describe an index completely. Now they are contained
in one IndexMeta class instead for simplicity.

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/AbstractSwallowingIndexProxy.java

@@ -34,19 +34,12 @@
 
 public abstract class AbstractSwallowingIndexProxy implements IndexProxy
 {
-    private final IndexDescriptor descriptor;
-    private final IndexCapability indexCapability;
-    private final SchemaIndexProvider.Descriptor providerDescriptor;
+    private final IndexMeta indexMeta;
     private final IndexPopulationFailure populationFailure;
 
-    AbstractSwallowingIndexProxy( IndexDescriptor descriptor,
-            SchemaIndexProvider.Descriptor providerDescriptor,
-            IndexCapability indexCapability,
-            IndexPopulationFailure populationFailure )
+    AbstractSwallowingIndexProxy( IndexMeta indexMeta, IndexPopulationFailure populationFailure )
     {
-        this.descriptor = descriptor;
-        this.providerDescriptor = providerDescriptor;
-        this.indexCapability = indexCapability;
+        this.indexMeta = indexMeta;
         this.populationFailure = populationFailure;
     }
 
@@ -83,25 +76,25 @@ public void force()
     @Override
     public IndexCapability getIndexCapability()
     {
-        return indexCapability;
+        return indexMeta.indexCapability();
     }
 
     @Override
     public IndexDescriptor getDescriptor()
     {
-        return descriptor;
+        return indexMeta.indexDescriptor();
     }
 
     @Override
     public LabelSchemaDescriptor schema()
     {
-        return descriptor.schema();
+        return indexMeta.indexDescriptor().schema();
     }
 
     @Override
     public SchemaIndexProvider.Descriptor getProviderDescriptor()
     {
-        return providerDescriptor;
+        return indexMeta.providerDescriptor();
     }
 
     @Override

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/FailedIndexProxy.java

@@ -24,12 +24,9 @@
 import java.util.concurrent.Future;
 
 import org.neo4j.graphdb.ResourceIterator;
-import org.neo4j.internal.kernel.api.IndexCapability;
 import org.neo4j.kernel.api.exceptions.index.IndexPopulationFailedKernelException;
 import org.neo4j.kernel.api.index.IndexPopulator;
 import org.neo4j.kernel.api.index.InternalIndexState;
-import org.neo4j.kernel.api.index.SchemaIndexProvider;
-import org.neo4j.kernel.api.schema.index.IndexDescriptor;
 import org.neo4j.logging.Log;
 import org.neo4j.logging.LogProvider;
 
@@ -43,16 +40,14 @@ public class FailedIndexProxy extends AbstractSwallowingIndexProxy
     private final IndexCountsRemover indexCountsRemover;
     private final Log log;
 
-    FailedIndexProxy( IndexDescriptor descriptor,
-            SchemaIndexProvider.Descriptor providerDescriptor,
-            IndexCapability indexCapability,
+    FailedIndexProxy( IndexMeta indexMeta,
             String indexUserDescription,
             IndexPopulator populator,
             IndexPopulationFailure populationFailure,
             IndexCountsRemover indexCountsRemover,
             LogProvider logProvider )
     {
-        super( descriptor, providerDescriptor, indexCapability, populationFailure );
+        super( indexMeta, populationFailure );
         this.populator = populator;
         this.indexUserDescription = indexUserDescription;
         this.indexCountsRemover = indexCountsRemover;

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/FailedPopulatingIndexProxyFactory.java

@@ -19,35 +19,26 @@
  */
 package org.neo4j.kernel.impl.api.index;
 
-import org.neo4j.internal.kernel.api.IndexCapability;
 import org.neo4j.kernel.api.index.IndexPopulator;
-import org.neo4j.kernel.api.index.SchemaIndexProvider;
-import org.neo4j.kernel.api.schema.index.IndexDescriptor;
 import org.neo4j.logging.LogProvider;
 
 import static org.neo4j.kernel.impl.api.index.IndexPopulationFailure.failure;
 
 public class FailedPopulatingIndexProxyFactory implements FailedIndexProxyFactory
 {
-    private final IndexDescriptor descriptor;
-    private final SchemaIndexProvider.Descriptor providerDescriptor;
-    private final IndexCapability indexCapability;
+    private final IndexMeta indexMeta;
     private final IndexPopulator populator;
     private final String indexUserDescription;
     private final IndexCountsRemover indexCountsRemover;
     private final LogProvider logProvider;
 
-    FailedPopulatingIndexProxyFactory( IndexDescriptor descriptor,
-                                       SchemaIndexProvider.Descriptor providerDescriptor,
-                                       IndexCapability indexCapability,
-                                       IndexPopulator populator,
-                                       String indexUserDescription,
-                                       IndexCountsRemover indexCountsRemover,
-                                       LogProvider logProvider )
+    FailedPopulatingIndexProxyFactory( IndexMeta indexMeta,
+            IndexPopulator populator,
+            String indexUserDescription,
+            IndexCountsRemover indexCountsRemover,
+            LogProvider logProvider )
     {
-        this.descriptor = descriptor;
-        this.providerDescriptor = providerDescriptor;
-        this.indexCapability = indexCapability;
+        this.indexMeta = indexMeta;
         this.populator = populator;
         this.indexUserDescription = indexUserDescription;
         this.indexCountsRemover = indexCountsRemover;
@@ -57,7 +48,7 @@ public class FailedPopulatingIndexProxyFactory implements FailedIndexProxyFactor
     @Override
     public IndexProxy create( Throwable failure )
     {
-        return new FailedIndexProxy( descriptor, providerDescriptor, indexCapability, indexUserDescription, populator, failure( failure ),
+        return new FailedIndexProxy( indexMeta, indexUserDescription, populator, failure( failure ),
                 indexCountsRemover, logProvider );
     }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/FlippableIndexProxy.java

@@ -382,7 +382,7 @@ public PopulationProgress getIndexPopulationProgress()
         }
     }
 
-    public void setFlipTarget( IndexProxyFactory flipTarget )
+    void setFlipTarget( IndexProxyFactory flipTarget )
     {
         lock.writeLock().lock();
         try
@@ -395,7 +395,7 @@ public void setFlipTarget( IndexProxyFactory flipTarget )
         }
     }
 
-    public void flipTo( IndexProxy targetDelegate )
+    void flipTo( IndexProxy targetDelegate )
     {
         lock.writeLock().lock();
         try

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/IndexMeta.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.kernel.impl.api.index;
+
+import org.neo4j.internal.kernel.api.IndexCapability;
+import org.neo4j.kernel.api.index.SchemaIndexProvider;
+import org.neo4j.kernel.api.schema.index.IndexDescriptor;
+
+public class IndexMeta
+{
+    private final IndexDescriptor indexDescriptor;
+    private final SchemaIndexProvider.Descriptor providerDescriptor;
+    private final IndexCapability indexCapability;
+
+    public IndexMeta( IndexDescriptor indexDescriptor, SchemaIndexProvider.Descriptor providerDescriptor, IndexCapability indexCapability )
+    {
+        this.indexDescriptor = indexDescriptor;
+        this.providerDescriptor = providerDescriptor;
+        this.indexCapability = indexCapability;
+    }
+
+    public IndexDescriptor indexDescriptor()
+    {
+        return indexDescriptor;
+    }
+
+    public SchemaIndexProvider.Descriptor providerDescriptor()
+    {
+        return providerDescriptor;
+    }
+
+    public IndexCapability indexCapability()
+    {
+        return indexCapability;
+    }
+}

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/IndexPopulationJob.java

@@ -23,12 +23,9 @@
 import java.util.concurrent.Future;
 
 import org.neo4j.function.Suppliers;
-import org.neo4j.internal.kernel.api.IndexCapability;
 import org.neo4j.kernel.api.exceptions.index.IndexPopulationFailedKernelException;
 import org.neo4j.kernel.api.index.IndexEntryUpdate;
 import org.neo4j.kernel.api.index.IndexPopulator;
-import org.neo4j.kernel.api.index.SchemaIndexProvider;
-import org.neo4j.kernel.api.schema.index.IndexDescriptor;
 import org.neo4j.kernel.impl.api.SchemaState;
 import org.neo4j.storageengine.api.schema.PopulationProgress;
 
@@ -38,8 +35,7 @@
 /**
  * A background job for initially populating one or more index over existing data in the database.
  * Use provided store view to scan store. Participating {@link IndexPopulator} are added with
- * {@link #addPopulator(IndexPopulator, long, IndexDescriptor, SchemaIndexProvider.Descriptor, IndexCapability, String,
- * FlippableIndexProxy, FailedIndexProxyFactory)}
+ * {@link #addPopulator(IndexPopulator, long, IndexMeta, String, FlippableIndexProxy, FailedIndexProxyFactory)}
  * before {@link #run() running} this job.
  */
 public class IndexPopulationJob implements Runnable
@@ -64,25 +60,21 @@ public IndexPopulationJob( MultipleIndexPopulator multiPopulator, IndexingServic
      * be added before calling {@link #run()}.
      *
      * @param populator {@link IndexPopulator} to participate.
-     * @param descriptor {@link IndexDescriptor} describing the index.
-     * @param providerDescriptor provider of this index.
-     * @param indexCapability capability of this index.
+     * @param indexId id of index.
+     * @param indexMeta {@link IndexMeta} meta information about index.
      * @param indexUserDescription user description of this index.
      * @param flipper {@link FlippableIndexProxy} to call after a successful population.
      * @param failedIndexProxyFactory {@link FailedIndexProxyFactory} to use after an unsuccessful population.
      */
     void addPopulator( IndexPopulator populator,
             long indexId,
-            IndexDescriptor descriptor,
-            SchemaIndexProvider.Descriptor providerDescriptor,
-            IndexCapability indexCapability,
+            IndexMeta indexMeta,
             String indexUserDescription,
             FlippableIndexProxy flipper,
             FailedIndexProxyFactory failedIndexProxyFactory )
     {
         assert storeScan == null : "Population have already started, too late to add populators at this point";
-        this.multiPopulator.addPopulator( populator, indexId, descriptor, providerDescriptor, indexCapability,
-                flipper, failedIndexProxyFactory, indexUserDescription );
+        this.multiPopulator.addPopulator( populator, indexId, indexMeta, flipper, failedIndexProxyFactory, indexUserDescription );
     }
 
     /**

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/IndexProxyCreator.java

@@ -68,22 +68,18 @@ IndexProxy createPopulatingIndexProxy( final long ruleId,
         // TODO: This is here because there is a circular dependency from PopulatingIndexProxy to FlippableIndexProxy
         final String indexUserDescription = indexUserDescription( descriptor, providerDescriptor );
         IndexPopulator populator = populatorFromProvider( providerDescriptor, ruleId, descriptor, samplingConfig );
-        IndexCapability indexCapability = indexCapabilityFromProvider( providerDescriptor, descriptor );
+        IndexMeta indexMeta = indexMetaFromProvider( providerDescriptor, descriptor );
 
         FailedIndexProxyFactory failureDelegateFactory = new FailedPopulatingIndexProxyFactory(
-                descriptor,
-                providerDescriptor,
-                indexCapability,
+                indexMeta,
                 populator,
                 indexUserDescription,
                 new IndexCountsRemover( storeView, ruleId ),
                 logProvider );
 
-        PopulatingIndexProxy populatingIndex =
-                new PopulatingIndexProxy( descriptor, providerDescriptor, indexCapability, populationJob );
+        PopulatingIndexProxy populatingIndex = new PopulatingIndexProxy( indexMeta, populationJob );
 
-        populationJob.addPopulator( populator, ruleId, descriptor, providerDescriptor, indexCapability,
-                indexUserDescription, flipper, failureDelegateFactory );
+        populationJob.addPopulator( populator, ruleId, indexMeta, indexUserDescription, flipper, failureDelegateFactory );
 
         flipper.flipTo( populatingIndex );
 
@@ -94,9 +90,7 @@ IndexProxy createPopulatingIndexProxy( final long ruleId,
             OnlineIndexProxy onlineProxy =
                     new OnlineIndexProxy(
                             ruleId,
-                            descriptor,
-                            providerDescriptor,
-                            indexCapabilityFromProvider( providerDescriptor, descriptor ),
+                            indexMeta,
                             onlineAccessorFromProvider( providerDescriptor, ruleId, descriptor, samplingConfig ),
                             storeView,
                             true );
@@ -113,8 +107,8 @@ IndexProxy createPopulatingIndexProxy( final long ruleId,
     IndexProxy createRecoveringIndexProxy( IndexDescriptor descriptor,
             SchemaIndexProvider.Descriptor providerDescriptor )
     {
-        IndexCapability indexCapability = indexCapabilityFromProvider( providerDescriptor, descriptor );
-        IndexProxy proxy = new RecoveringIndexProxy( descriptor, providerDescriptor, indexCapability );
+        IndexMeta indexMeta = indexMetaFromProvider( providerDescriptor, descriptor );
+        IndexProxy proxy = new RecoveringIndexProxy( indexMeta );
         return new ContractCheckingIndexProxy( proxy, true );
     }
 
@@ -127,9 +121,9 @@ IndexProxy createOnlineIndexProxy( long ruleId,
         {
             IndexAccessor onlineAccessor =
                     onlineAccessorFromProvider( providerDescriptor, ruleId, descriptor, samplingConfig );
-            IndexCapability indexCapability = indexCapabilityFromProvider( providerDescriptor, descriptor );
+            IndexMeta indexMeta = indexMetaFromProvider( providerDescriptor, descriptor );
             IndexProxy proxy;
-            proxy = new OnlineIndexProxy( ruleId, descriptor, providerDescriptor, indexCapability, onlineAccessor, storeView, false );
+            proxy = new OnlineIndexProxy( ruleId, indexMeta, onlineAccessor, storeView, false );
             proxy = new ContractCheckingIndexProxy( proxy, true );
             return proxy;
         }
@@ -148,12 +142,11 @@ IndexProxy createFailedIndexProxy( long ruleId,
             IndexPopulationFailure populationFailure )
     {
         IndexPopulator indexPopulator = populatorFromProvider( providerDescriptor, ruleId, descriptor, samplingConfig );
-        IndexCapability indexCapability = indexCapabilityFromProvider( providerDescriptor, descriptor );
+        IndexMeta indexMeta = indexMetaFromProvider( providerDescriptor, descriptor );
         String indexUserDescription = indexUserDescription( descriptor, providerDescriptor );
         IndexProxy proxy;
         proxy = new FailedIndexProxy(
-                descriptor,
-                providerDescriptor, indexCapability,
+                indexMeta,
                 indexUserDescription,
                 indexPopulator,
                 populationFailure,
@@ -185,9 +178,9 @@ private IndexAccessor onlineAccessorFromProvider( SchemaIndexProvider.Descriptor
         return indexProvider.getOnlineAccessor( ruleId, descriptor, samplingConfig );
     }
 
-    private IndexCapability indexCapabilityFromProvider( SchemaIndexProvider.Descriptor providerDescriptor,
-            IndexDescriptor indexDescriptor )
+    private IndexMeta indexMetaFromProvider( SchemaIndexProvider.Descriptor providerDescriptor, IndexDescriptor indexDescriptor )
     {
-        return providerMap.apply( providerDescriptor ).getCapability( indexDescriptor );
+        IndexCapability indexCapability = providerMap.apply( providerDescriptor ).getCapability( indexDescriptor );
+        return new IndexMeta( indexDescriptor, providerDescriptor, indexCapability );
     }
 }