Split GenericKeyState into separate classes

They all still work on the same shared stated in GenerickeyState though,
but much more readable, maintainable and less repetition.

Also there seems to be a performance benefit invoking methods on Type
compared to switch on type in all those places,
e.g. read/write/compare etc.

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

@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) 2002-2018 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.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.index.schema;
+
+import java.time.LocalDate;
+import java.util.function.IntFunction;
+
+import org.neo4j.io.pagecache.PageCursor;
+import org.neo4j.values.storable.Value;
+import org.neo4j.values.storable.ValueGroup;
+import org.neo4j.values.storable.ValueWriter;
+import org.neo4j.values.storable.Values;
+
+import static java.lang.Integer.min;
+import static org.neo4j.kernel.impl.index.schema.GenericKeyState.BIGGEST_REASONABLE_ARRAY_LENGTH;
+import static org.neo4j.kernel.impl.index.schema.GenericKeyState.SIZE_ARRAY_LENGTH;
+import static org.neo4j.kernel.impl.index.schema.GenericKeyState.setCursorException;
+import static org.neo4j.kernel.impl.index.schema.GenericKeyState.toNonNegativeShortExact;
+
+/**
+ * Common ancestor of all array-types. Many of the methods are implemented by doing array looping and delegating array item operations
+ * to the non-array versions of the specific array type.
+ * @param <T> type of raw array items for this array type, e.g. {@link LocalDate} for {@link DateArrayType}.
+ */
+abstract class AbstractArrayType<T> extends Type
+{
+    private final ArrayElementComparator arrayElementComparator;
+    private final ArrayElementValueFactory<T> valueFactory;
+    final ArrayElementWriter arrayElementWriter;
+    private final ArrayElementReader arrayElementReader;
+    private final IntFunction<T[]> arrayCreator;
+    private final ValueWriter.ArrayType arrayType;
+
+    AbstractArrayType( ValueGroup valueGroup, byte typeId,
+            ArrayElementComparator arrayElementComparator,
+            ArrayElementValueFactory<T> valueFactory,
+            ArrayElementWriter arrayElementWriter,
+            ArrayElementReader arrayElementReader,
+            IntFunction<T[]> arrayCreator,
+            ValueWriter.ArrayType arrayType )
+    {
+        super( valueGroup, typeId,
+                // null intentionally as we're overriding how min/max gets applied for all array types
+                null, null );
+        this.arrayElementComparator = arrayElementComparator;
+        this.valueFactory = valueFactory;
+        this.arrayElementWriter = arrayElementWriter;
+        this.arrayElementReader = arrayElementReader;
+        this.arrayCreator = arrayCreator;
+        this.arrayType = arrayType;
+    }
+
+    @Override
+    final void copyValue( GenericKeyState to, GenericKeyState from )
+    {
+        copyValue( to, from, from.arrayLength );
+    }
+
+    abstract void copyValue( GenericKeyState to, GenericKeyState from, int arrayLength );
+
+    abstract void initializeArray( GenericKeyState key, int length, ValueWriter.ArrayType arrayType );
+
+    @Override
+    void minimalSplitter( GenericKeyState left, GenericKeyState right, GenericKeyState into )
+    {
+        int lastEqualIndex = -1;
+        if ( left.type == right.type )
+        {
+            int maxLength = min( left.arrayLength, right.arrayLength );
+            for ( int index = 0; index < maxLength; index++ )
+            {
+                if ( arrayElementComparator.compare( left, right, index ) != 0 )
+                {
+                    break;
+                }
+                lastEqualIndex++;
+            }
+        }
+        // Convert from last equal index to first index to differ +1
+        // Convert from index to length +1
+        // Total +2
+        int length = Math.min( right.arrayLength, lastEqualIndex + 2 );
+        copyValue( into, right, length );
+        into.arrayLength = length;
+    }
+
+    @Override
+    int compareValue( GenericKeyState left, GenericKeyState right )
+    {
+        if ( left.isHighestArray || right.isHighestArray )
+        {
+            return Boolean.compare( left.isHighestArray, right.isHighestArray );
+        }
+
+        int index = 0;
+        int compare = 0;
+        int length = min( left.arrayLength, right.arrayLength );
+
+        for ( ; compare == 0 && index < length; index++ )
+        {
+            compare = arrayElementComparator.compare( left, right, index );
+        }
+
+        return compare == 0 ? Integer.compare( left.arrayLength, right.arrayLength ) : compare;
+    }
+
+    @Override
+    Value asValue( GenericKeyState state )
+    {
+        T[] array = arrayCreator.apply( state.arrayLength );
+        for ( int i = 0; i < state.arrayLength; i++ )
+        {
+            array[i] = valueFactory.from( state, i );
+        }
+        return Values.of( array );
+    }
+
+    @Override
+    void putValue( PageCursor cursor, GenericKeyState state )
+    {
+        putArray( cursor, state, arrayElementWriter );
+    }
+
+    @Override
+    boolean readValue( PageCursor cursor, int size, GenericKeyState into )
+    {
+        return readArray( cursor, arrayType, arrayElementReader, into );
+    }
+
+    /**
+     * In the array case there's nothing lower than a zero-length array, so simply make sure that the key state is initialized
+     * with state reflecting that. No specific value required.
+     * @param state key state to initialize as lowest of this type.
+     */
+    @Override
+    void initializeAsLowest( GenericKeyState state )
+    {
+        state.initializeArrayMeta( 0 );
+        initializeArray( state, 0, arrayType );
+    }
+
+    @Override
+    void initializeAsHighest( GenericKeyState state )
+    {
+        state.initializeArrayMeta( 0 );
+        initializeArray( state, 0, arrayType );
+        state.isHighestArray = true;
+    }
+
+    int arrayKeySize( GenericKeyState key, int elementSize )
+    {
+        return SIZE_ARRAY_LENGTH + key.arrayLength * elementSize;
+    }
+
+    static void putArrayHeader( PageCursor cursor, short arrayLength )
+    {
+        cursor.putShort( arrayLength );
+    }
+
+    static void putArrayItems( PageCursor cursor, GenericKeyState key, ArrayElementWriter itemWriter )
+    {
+        for ( int i = 0; i < key.arrayLength; i++ )
+        {
+            itemWriter.write( cursor, key, i );
+        }
+    }
+
+    static void putArray( PageCursor cursor, GenericKeyState key, ArrayElementWriter writer )
+    {
+        putArrayHeader( cursor, toNonNegativeShortExact( key.arrayLength ) );
+        putArrayItems( cursor, key, writer );
+    }
+
+    static boolean readArray( PageCursor cursor, ValueWriter.ArrayType type, ArrayElementReader reader, GenericKeyState into )
+    {
+        if ( !setArrayLengthWhenReading( into, cursor, cursor.getShort() ) )
+        {
+            return false;
+        }
+        into.beginArray( into.arrayLength, type );
+        for ( int i = 0; i < into.arrayLength; i++ )
+        {
+            if ( !reader.readFrom( cursor, into ) )
+            {
+                return false;
+            }
+        }
+        into.endArray();
+        return true;
+    }
+
+    static boolean setArrayLengthWhenReading( GenericKeyState state, PageCursor cursor, short arrayLength )
+    {
+        state.arrayLength = arrayLength;
+        if ( state.arrayLength < 0 || state.arrayLength > BIGGEST_REASONABLE_ARRAY_LENGTH )
+        {
+            setCursorException( cursor, "non-valid array length, " + state.arrayLength );
+            return false;
+        }
+        return true;
+    }
+
+    @FunctionalInterface
+    interface ArrayElementComparator
+    {
+        int compare( GenericKeyState o1, GenericKeyState o2, int i );
+    }
+
+    @FunctionalInterface
+    interface ArrayElementReader
+    {
+        boolean readFrom( PageCursor cursor, GenericKeyState into );
+    }
+
+    @FunctionalInterface
+    interface ArrayElementWriter
+    {
+        void write( PageCursor cursor, GenericKeyState key, int i );
+    }
+
+    @FunctionalInterface
+    interface ArrayElementValueFactory<T>
+    {
+        T from( GenericKeyState key, int i );
+    }
+}

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

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2002-2018 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.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.index.schema;
+
+import org.neo4j.values.storable.Value;
+import org.neo4j.values.storable.ValueGroup;
+import org.neo4j.values.storable.ValueWriter;
+import org.neo4j.values.storable.Values;
+
+import static org.neo4j.kernel.impl.index.schema.GenericKeyState.FALSE;
+import static org.neo4j.kernel.impl.index.schema.GenericKeyState.TRUE;
+
+// <Boolean> as generic raw type is mostly for show, this class overrides default object:y behaviour to create primitive boolean[] array
+class BooleanArrayType extends AbstractArrayType<Boolean>
+{
+    // Affected key state:
+    // long0Array
+
+    BooleanArrayType( byte typeId )
+    {
+        super( ValueGroup.BOOLEAN_ARRAY, typeId, ( o1, o2, i ) -> BooleanType.compare(
+                        o1.long0Array[i],
+                        o2.long0Array[i] ),
+                null,
+                ( c, k, i ) -> BooleanType.put( c, k.long0Array[i] ),
+                BooleanType::read, null, ValueWriter.ArrayType.BOOLEAN );
+    }
+
+    @Override
+    int valueSize( GenericKeyState state )
+    {
+        return arrayKeySize( state, GenericKeyState.SIZE_BOOLEAN );
+    }
+
+    @Override
+    void copyValue( GenericKeyState to, GenericKeyState from, int length )
+    {
+        initializeArray( to, length, null );
+        System.arraycopy( from.long0Array, 0, to.long0Array, 0, length );
+    }
+
+    @Override
+    void initializeArray( GenericKeyState key, int length, ValueWriter.ArrayType arrayType )
+    {
+        key.long0Array = ensureBigEnough( key.long0Array, length );
+    }
+
+    @Override
+    Value asValue( GenericKeyState state )
+    {
+        boolean[] array = new boolean[state.arrayLength];
+        for ( int i = 0; i < state.arrayLength; i++ )
+        {
+            array[i] = BooleanType.asValueRaw( state.long0Array[i] );
+        }
+        return Values.of( array );
+    }
+
+    void write( GenericKeyState state, int offset, boolean value )
+    {
+        state.long0Array[offset] = value ? TRUE : FALSE;
+    }
+}