Small ring chunk source cleanup (#5502)

This was originally explored as a fix for #5498; ultimately, it was an upstream data issue that was solved in #5503. Along the way though, it was noted that ring chunk sources were 1) using reflection in places they didn't need to, and 2) using specifically typed arrays for generic types as opposed to other object chunks which use `Object[]` at the top layer. In the latest iteration of this, the construction reflection was removed (there is a new getLength check); but I'm apt to keep the more specifically typed arrays unless we know they are causing other issues. At a minimum, the specifically typed arrays helped us notice and fix #5503.

engine/table/src/main/java/io/deephaven/engine/table/impl/sources/ring/AbstractRingChunkSource.java

@@ -21,6 +21,7 @@
 
 import java.io.Closeable;
 import java.lang.reflect.Array;
+import java.util.Objects;
 import java.util.function.LongConsumer;
 
 import static io.deephaven.engine.table.impl.AbstractColumnSource.USE_RANGES_AVERAGE_RUN_LENGTH;
@@ -67,13 +68,12 @@ abstract class AbstractRingChunkSource<T, ARRAY, SELF extends AbstractRingChunkS
     protected final int capacity;
     long nextRingIx;
 
-    public AbstractRingChunkSource(@NotNull Class<T> type, int capacity) {
+    public AbstractRingChunkSource(ARRAY ring) {
+        this.ring = Objects.requireNonNull(ring);
+        this.capacity = Array.getLength(ring);
         if (capacity <= 0) {
             throw new IllegalArgumentException("Capacity must be positive");
         }
-        this.capacity = capacity;
-        // noinspection unchecked
-        ring = (ARRAY) Array.newInstance(type, capacity);
     }
 
     /**

engine/table/src/main/java/io/deephaven/engine/table/impl/sources/ring/ByteRingChunkSource.java

@@ -25,7 +25,7 @@ public static RingColumnSource<Byte> columnSource(int n) {
     }
 
     public ByteRingChunkSource(int capacity) {
-        super(byte.class, capacity);
+        super(new byte[capacity]);
     }
 
     @Override

engine/table/src/main/java/io/deephaven/engine/table/impl/sources/ring/CharacterRingChunkSource.java

@@ -21,7 +21,7 @@ public static RingColumnSource<Character> columnSource(int n) {
     }
 
     public CharacterRingChunkSource(int capacity) {
-        super(char.class, capacity);
+        super(new char[capacity]);
     }
 
     @Override

engine/table/src/main/java/io/deephaven/engine/table/impl/sources/ring/DoubleRingChunkSource.java

@@ -25,7 +25,7 @@ public static RingColumnSource<Double> columnSource(int n) {
     }
 
     public DoubleRingChunkSource(int capacity) {
-        super(double.class, capacity);
+        super(new double[capacity]);
     }
 
     @Override

engine/table/src/main/java/io/deephaven/engine/table/impl/sources/ring/FloatRingChunkSource.java

@@ -25,7 +25,7 @@ public static RingColumnSource<Float> columnSource(int n) {
     }
 
     public FloatRingChunkSource(int capacity) {
-        super(float.class, capacity);
+        super(new float[capacity]);
     }
 
     @Override

engine/table/src/main/java/io/deephaven/engine/table/impl/sources/ring/IntegerRingChunkSource.java

@@ -25,7 +25,7 @@ public static RingColumnSource<Integer> columnSource(int n) {
     }
 
     public IntegerRingChunkSource(int capacity) {
-        super(int.class, capacity);
+        super(new int[capacity]);
     }
 
     @Override

engine/table/src/main/java/io/deephaven/engine/table/impl/sources/ring/LongRingChunkSource.java

@@ -25,7 +25,7 @@ public static RingColumnSource<Long> columnSource(int n) {
     }
 
     public LongRingChunkSource(int capacity) {
-        super(long.class, capacity);
+        super(new long[capacity]);
     }
 
     @Override

engine/table/src/main/java/io/deephaven/engine/table/impl/sources/ring/ObjectRingChunkSource.java

@@ -10,22 +10,33 @@
 import io.deephaven.engine.rowset.RowSet;
 import org.jetbrains.annotations.NotNull;
 
+import java.lang.reflect.Array;
 import java.util.Objects;
 
 // Note: this is not being auto-generated ATM
-final class ObjectRingChunkSource<T> extends AbstractRingChunkSource<T, Object[], ObjectRingChunkSource<T>> {
+final class ObjectRingChunkSource<T> extends AbstractRingChunkSource<T, T[], ObjectRingChunkSource<T>> {
     public static <T> RingColumnSource<T> columnSource(Class<T> type, int capacity) {
+        if (type.isPrimitive()) {
+            throw new IllegalArgumentException();
+        }
         return new RingColumnSource<>(type, new ObjectRingChunkSource<>(type, capacity),
                 new ObjectRingChunkSource<>(type, capacity));
     }
 
     public static <T> RingColumnSource<T> columnSource(Class<T> type, Class<?> componentType, int capacity) {
+        if (type.isPrimitive()) {
+            throw new IllegalArgumentException();
+        }
         return new RingColumnSource<>(type, componentType, new ObjectRingChunkSource<>(type, capacity),
                 new ObjectRingChunkSource<>(type, capacity));
     }
 
-    public ObjectRingChunkSource(Class<T> type, int capacity) {
-        super(type, capacity);
+    private ObjectRingChunkSource(Class<T> type, int capacity) {
+        // In the general case, we can't know that Array.newInstance(Class<T>, ...) will result in T[]; for example,
+        // type=int.class (T=Integer) => int[] (not Integer[]). That said, we know that type is generic, and thus we
+        // know resulting array type is T[].
+        // noinspection unchecked
+        super((T[]) Array.newInstance(type, capacity));
     }
 
     @Override
@@ -42,8 +53,7 @@ T get(long key) {
             throw new IllegalArgumentException(
                     String.format("Invalid key %d. available=[%d, %d]", key, firstKey(), lastKey()));
         }
-        // noinspection unchecked
-        return (T) ring[keyToRingIndex(key)];
+        return ring[keyToRingIndex(key)];
     }
 
     @Override
@@ -60,14 +70,12 @@ private class FillerImpl extends Filler {
 
         @Override
         protected void copyFromRing(int srcRingIx, int destOffset) {
-            // noinspection unchecked
-            dest.set(destOffset, (T) ring[srcRingIx]);
+            dest.set(destOffset, ring[srcRingIx]);
         }
 
         @Override
         protected void copyFromRing(int srcRingIx, int destOffset, int size) {
-            // noinspection unchecked
-            dest.copyFromTypedArray((T[]) ring, srcRingIx, destOffset, size);
+            dest.copyFromTypedArray(ring, srcRingIx, destOffset, size);
         }
 
         @Override

engine/table/src/main/java/io/deephaven/engine/table/impl/sources/ring/ShortRingChunkSource.java

@@ -25,7 +25,7 @@ public static RingColumnSource<Short> columnSource(int n) {
     }
 
     public ShortRingChunkSource(int capacity) {
-        super(short.class, capacity);
+        super(new short[capacity]);
     }
 
     @Override

engine/table/src/main/java/io/deephaven/engine/table/impl/util/ColumnHolder.java

@@ -15,6 +15,7 @@
 import io.deephaven.chunk.ObjectChunk;
 import io.deephaven.chunk.ShortChunk;
 import io.deephaven.chunk.attributes.Values;
+import io.deephaven.engine.rowset.RowSequence;
 import io.deephaven.engine.rowset.RowSequenceFactory;
 import io.deephaven.engine.table.ChunkSink;
 import io.deephaven.engine.table.WritableColumnSource;
@@ -291,8 +292,10 @@ public ColumnSource<?> getColumnSource() {
 
         final WritableColumnSource<?> cs = ArrayBackedColumnSource.getMemoryColumnSource(
                 chunkData.size(), dataType, componentType);
-        try (final ChunkSink.FillFromContext ffc = cs.makeFillFromContext(chunkData.size())) {
-            cs.fillFromChunk(ffc, chunkData, RowSequenceFactory.forRange(0, chunkData.size() - 1));
+        try (
+                final ChunkSink.FillFromContext ffc = cs.makeFillFromContext(chunkData.size());
+                final RowSequence rs = RowSequenceFactory.forRange(0, chunkData.size() - 1)) {
+            cs.fillFromChunk(ffc, chunkData, rs);
         }
         return cs;
     }

engine/table/src/test/java/io/deephaven/engine/table/impl/sources/ring/RingTableToolsTest.java

@@ -3,6 +3,7 @@
 //
 package io.deephaven.engine.table.impl.sources.ring;
 
+import io.deephaven.chunk.ObjectChunk;
 import io.deephaven.engine.context.ExecutionContext;
 import io.deephaven.engine.rowset.RowSet;
 import io.deephaven.engine.rowset.RowSetFactory;
@@ -70,6 +71,19 @@ public void blinkTableToRing() {
         coprime(14, 25);
     }
 
+    @Test
+    public void doubleArrayChunk() {
+        final Object[] objectArray = {
+                null,
+                new double[] {},
+                new double[] {42.42, 43.43}
+        };
+        final Table table = TableTools.newTable(TstUtils.columnHolderForChunk(
+                "DoubleArray", double[].class, double.class, ObjectChunk.chunkWrap(objectArray)));
+        final Table ring = RingTableTools.of(table, 32, true);
+        checkEquals(table, ring);
+    }
+
     private static void coprime(int a, int b) {
         if (!BigInteger.valueOf(a).gcd(BigInteger.valueOf(b)).equals(BigInteger.ONE)) {
             throw new IllegalArgumentException("not coprime: " + a + ", " + b);