Port for RegionedColumnSources

deephaven · Jan 31, 2023 · 3de7432 · 3de7432
1 parent d63044a
commit 3de7432
Show file tree

Hide file tree

Showing 26 changed files with 568 additions and 301 deletions.
diff --git a/...ain/java/io/deephaven/engine/table/impl/sources/regioned/RegionedColumnSourceBoolean.java b/...ain/java/io/deephaven/engine/table/impl/sources/regioned/RegionedColumnSourceBoolean.java
@@ -8,6 +8,7 @@
 import io.deephaven.engine.table.impl.ColumnSourceGetDefaults;
 import io.deephaven.chunk.*;
 import io.deephaven.engine.rowset.RowSequence;
+import org.jetbrains.annotations.NotNull;
 
 /**
  * Regioned column source implementation for columns of Booleans.
@@ -17,8 +18,11 @@ final class RegionedColumnSourceBoolean
         implements ColumnSourceGetDefaults.ForBoolean {
 
     public RegionedColumnSourceBoolean() {
-        super(ColumnRegionByte.createNull(PARAMETERS.regionMask), Boolean.class,
-                RegionedColumnSourceByte.NativeType.AsValues::new);
+        this(new RegionedColumnSourceByte.AsValues());
+    }
+
+    public RegionedColumnSourceBoolean(final @NotNull RegionedColumnSourceByte<Values> inner) {
+        super(ColumnRegionByte.createNull(PARAMETERS.regionMask), Boolean.class, inner);
     }
 
     @Override
@@ -39,6 +43,6 @@ public void convertRegion(WritableChunk<? super Values> destination,
     @Override
     public Boolean get(long rowKey) {
         return rowKey == RowSequence.NULL_ROW_KEY ? null :
-                BooleanUtils.byteAsBoolean(lookupRegion(rowKey).getReferencedRegion().getByte(rowKey));
+                BooleanUtils.byteAsBoolean(getNativeSource().lookupRegion(rowKey).getByte(rowKey));
     }
 }
diff --git a/...c/main/java/io/deephaven/engine/table/impl/sources/regioned/RegionedColumnSourceByte.java b/...c/main/java/io/deephaven/engine/table/impl/sources/regioned/RegionedColumnSourceByte.java
@@ -8,6 +8,8 @@
  */
 package io.deephaven.engine.table.impl.sources.regioned;
 
+import io.deephaven.engine.table.ColumnSource;
+
 import io.deephaven.engine.rowset.RowSequence;
 import io.deephaven.engine.table.ColumnDefinition;
 import io.deephaven.engine.table.impl.locations.ColumnLocation;
@@ -24,7 +26,7 @@
  */
 abstract class RegionedColumnSourceByte<ATTR extends Values>
         extends RegionedColumnSourceArray<Byte, ATTR, ColumnRegionByte<ATTR>>
-        implements ColumnSourceGetDefaults.ForByte {
+        implements ColumnSourceGetDefaults.ForByte /* MIXIN_INTERFACES */ {
 
     RegionedColumnSourceByte(@NotNull final ColumnRegionByte<ATTR> nullRegion,
                              @NotNull final MakeDeferred<ATTR, ColumnRegionByte<ATTR>> makeDeferred) {
@@ -48,35 +50,22 @@ default ColumnRegionByte<Values> makeRegion(@NotNull final ColumnDefinition<?> c
         }
     }
 
-    static final class AsValues extends RegionedColumnSourceByte<Values> implements MakeRegionDefault {
-        AsValues() {
-            super(ColumnRegionByte.createNull(PARAMETERS.regionMask), DeferredColumnRegionByte::new);
-        }
+    // region reinterpretation
+    @Override
+    public <ALTERNATE_DATA_TYPE> boolean allowsReinterpret(@NotNull Class<ALTERNATE_DATA_TYPE> alternateDataType) {
+        return alternateDataType == boolean.class || alternateDataType == Boolean.class || super.allowsReinterpret(alternateDataType);
     }
 
-    /**
-     * These are used by {@link RegionedColumnSourceReferencing} subclass who want a native byte type.  This class does
-     * <em>not</em> hold an array of regions, but rather derives from {@link RegionedColumnSourceBase}, accessing its
-     * regions by looking into the delegate instance's region array.
-     */
-    @SuppressWarnings("unused")
-    static abstract class NativeType<DATA_TYPE, ATTR extends Values>
-            extends RegionedColumnSourceReferencing.NativeColumnSource<DATA_TYPE, ATTR, Byte, ColumnRegionByte<ATTR>>
-            implements ColumnSourceGetDefaults.ForByte {
-
-        NativeType(@NotNull final RegionedColumnSourceBase<DATA_TYPE, ATTR, ColumnRegionReferencing<ATTR, ColumnRegionByte<ATTR>>> outerColumnSource) {
-            super(Byte.class, outerColumnSource);
-        }
-
-        @Override
-        public byte getByte(final long rowKey) {
-            return (rowKey == RowSequence.NULL_ROW_KEY ? getNullRegion() : lookupRegion(rowKey)).getByte(rowKey);
-        }
+    @Override
+    protected <ALTERNATE_DATA_TYPE> ColumnSource<ALTERNATE_DATA_TYPE> doReinterpret(@NotNull Class<ALTERNATE_DATA_TYPE> alternateDataType) {
+        //noinspection unchecked
+        return (ColumnSource<ALTERNATE_DATA_TYPE>) new RegionedColumnSourceBoolean((RegionedColumnSourceByte<Values>)this);
+    }
+    // endregion reinterpretation
 
-        static final class AsValues<DATA_TYPE> extends NativeType<DATA_TYPE, Values> implements MakeRegionDefault {
-            AsValues(@NotNull final RegionedColumnSourceBase<DATA_TYPE, Values, ColumnRegionReferencing<Values, ColumnRegionByte<Values>>> outerColumnSource) {
-                super(outerColumnSource);
-            }
+    static final class AsValues extends RegionedColumnSourceByte<Values> implements MakeRegionDefault {
+        AsValues() {
+            super(ColumnRegionByte.createNull(PARAMETERS.regionMask), DeferredColumnRegionByte::new);
         }
     }
 

diff --git a/...c/main/java/io/deephaven/engine/table/impl/sources/regioned/RegionedColumnSourceChar.java b/...c/main/java/io/deephaven/engine/table/impl/sources/regioned/RegionedColumnSourceChar.java
@@ -19,7 +19,7 @@
  */
 abstract class RegionedColumnSourceChar<ATTR extends Values>
         extends RegionedColumnSourceArray<Character, ATTR, ColumnRegionChar<ATTR>>
-        implements ColumnSourceGetDefaults.ForChar {
+        implements ColumnSourceGetDefaults.ForChar /* MIXIN_INTERFACES */ {
 
     RegionedColumnSourceChar(@NotNull final ColumnRegionChar<ATTR> nullRegion,
                              @NotNull final MakeDeferred<ATTR, ColumnRegionChar<ATTR>> makeDeferred) {
@@ -43,38 +43,15 @@ default ColumnRegionChar<Values> makeRegion(@NotNull final ColumnDefinition<?> c
         }
     }
 
+    // region reinterpretation
+    // endregion reinterpretation
+
     static final class AsValues extends RegionedColumnSourceChar<Values> implements MakeRegionDefault {
         AsValues() {
             super(ColumnRegionChar.createNull(PARAMETERS.regionMask), DeferredColumnRegionChar::new);
         }
     }
 
-    /**
-     * These are used by {@link RegionedColumnSourceReferencing} subclass who want a native char type.  This class does
-     * <em>not</em> hold an array of regions, but rather derives from {@link RegionedColumnSourceBase}, accessing its
-     * regions by looking into the delegate instance's region array.
-     */
-    @SuppressWarnings("unused")
-    static abstract class NativeType<DATA_TYPE, ATTR extends Values>
-            extends RegionedColumnSourceReferencing.NativeColumnSource<DATA_TYPE, ATTR, Character, ColumnRegionChar<ATTR>>
-            implements ColumnSourceGetDefaults.ForChar {
-
-        NativeType(@NotNull final RegionedColumnSourceBase<DATA_TYPE, ATTR, ColumnRegionReferencing<ATTR, ColumnRegionChar<ATTR>>> outerColumnSource) {
-            super(Character.class, outerColumnSource);
-        }
-
-        @Override
-        public char getChar(final long rowKey) {
-            return (rowKey == RowSequence.NULL_ROW_KEY ? getNullRegion() : lookupRegion(rowKey)).getChar(rowKey);
-        }
-
-        static final class AsValues<DATA_TYPE> extends NativeType<DATA_TYPE, Values> implements MakeRegionDefault {
-            AsValues(@NotNull final RegionedColumnSourceBase<DATA_TYPE, Values, ColumnRegionReferencing<Values, ColumnRegionChar<Values>>> outerColumnSource) {
-                super(outerColumnSource);
-            }
-        }
-    }
-
     static final class Partitioning extends RegionedColumnSourceChar<Values> {
 
         Partitioning() {

diff --git a/...in/java/io/deephaven/engine/table/impl/sources/regioned/RegionedColumnSourceDateTime.java b/...in/java/io/deephaven/engine/table/impl/sources/regioned/RegionedColumnSourceDateTime.java
@@ -4,23 +4,34 @@
 package io.deephaven.engine.table.impl.sources.regioned;
 
 import io.deephaven.chunk.attributes.Values;
+import io.deephaven.engine.table.ColumnSource;
+import io.deephaven.engine.table.impl.sources.ConvertableTimeSource;
 import io.deephaven.time.DateTime;
 import io.deephaven.time.DateTimeUtils;
 import io.deephaven.engine.table.impl.ColumnSourceGetDefaults;
 import io.deephaven.chunk.*;
 import io.deephaven.engine.rowset.RowSequence;
+import org.jetbrains.annotations.NotNull;
+
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
 
 /**
  * Regioned column source implementation for columns of {@link DateTime}s.
  */
 final class RegionedColumnSourceDateTime
-        extends
-        RegionedColumnSourceReferencing<DateTime, Values, Long, ColumnRegionLong<Values>>
-        implements ColumnSourceGetDefaults.ForObject<DateTime> {
+        extends RegionedColumnSourceReferencing<DateTime, Values, Long, ColumnRegionLong<Values>>
+        implements ColumnSourceGetDefaults.ForObject<DateTime>, ConvertableTimeSource {
 
     public RegionedColumnSourceDateTime() {
-        super(ColumnRegionLong.createNull(PARAMETERS.regionMask), DateTime.class,
-                RegionedColumnSourceLong.NativeType.AsValues::new);
+        this(new RegionedColumnSourceLong.AsValues());
+    }
+
+    public RegionedColumnSourceDateTime(@NotNull final RegionedColumnSourceLong<Values> inner) {
+        super(ColumnRegionLong.createNull(PARAMETERS.regionMask), DateTime.class, inner);
     }
 
     @Override
@@ -41,6 +52,43 @@ public void convertRegion(WritableChunk<? super Values> destination,
     @Override
     public DateTime get(long rowKey) {
         return rowKey == RowSequence.NULL_ROW_KEY ? null
-                : DateTimeUtils.nanosToTime(lookupRegion(rowKey).getReferencedRegion().getLong(rowKey));
+                : DateTimeUtils.nanosToTime(getNativeSource().lookupRegion(rowKey).getLong(rowKey));
+    }
+
+    @Override
+    public boolean supportsTimeConversion() {
+        return true;
+    }
+
+    @Override
+    public ColumnSource<Instant> toInstant() {
+        return new RegionedColumnSourceInstant((RegionedColumnSourceLong<Values>) getNativeSource());
+    }
+
+    @Override
+    public ColumnSource<ZonedDateTime> toZonedDateTime(@NotNull final ZoneId zone) {
+        return new RegionedColumnSourceZonedDateTime(zone, (RegionedColumnSourceLong<Values>) getNativeSource());
+    }
+
+    @Override
+    public ColumnSource<LocalDate> toLocalDate(@NotNull final ZoneId zone) {
+        return RegionedColumnSourceZonedDateTime.asLocalDate(zone,
+                (RegionedColumnSourceLong<Values>) getNativeSource());
+    }
+
+    @Override
+    public ColumnSource<LocalTime> toLocalTime(@NotNull final ZoneId zone) {
+        return RegionedColumnSourceZonedDateTime.asLocalTime(zone,
+                (RegionedColumnSourceLong<Values>) getNativeSource());
+    }
+
+    @Override
+    public ColumnSource<DateTime> toDateTime() {
+        return this;
+    }
+
+    @Override
+    public ColumnSource<Long> toEpochNano() {
+        return getNativeSource();
     }
 }
diff --git a/...main/java/io/deephaven/engine/table/impl/sources/regioned/RegionedColumnSourceDouble.java b/...main/java/io/deephaven/engine/table/impl/sources/regioned/RegionedColumnSourceDouble.java
@@ -24,7 +24,7 @@
  */
 abstract class RegionedColumnSourceDouble<ATTR extends Values>
         extends RegionedColumnSourceArray<Double, ATTR, ColumnRegionDouble<ATTR>>
-        implements ColumnSourceGetDefaults.ForDouble {
+        implements ColumnSourceGetDefaults.ForDouble /* MIXIN_INTERFACES */ {
 
     RegionedColumnSourceDouble(@NotNull final ColumnRegionDouble<ATTR> nullRegion,
                              @NotNull final MakeDeferred<ATTR, ColumnRegionDouble<ATTR>> makeDeferred) {
@@ -48,38 +48,15 @@ default ColumnRegionDouble<Values> makeRegion(@NotNull final ColumnDefinition<?>
         }
     }
 
+    // region reinterpretation
+    // endregion reinterpretation
+
     static final class AsValues extends RegionedColumnSourceDouble<Values> implements MakeRegionDefault {
         AsValues() {
             super(ColumnRegionDouble.createNull(PARAMETERS.regionMask), DeferredColumnRegionDouble::new);
         }
     }
 
-    /**
-     * These are used by {@link RegionedColumnSourceReferencing} subclass who want a native double type.  This class does
-     * <em>not</em> hold an array of regions, but rather derives from {@link RegionedColumnSourceBase}, accessing its
-     * regions by looking into the delegate instance's region array.
-     */
-    @SuppressWarnings("unused")
-    static abstract class NativeType<DATA_TYPE, ATTR extends Values>
-            extends RegionedColumnSourceReferencing.NativeColumnSource<DATA_TYPE, ATTR, Double, ColumnRegionDouble<ATTR>>
-            implements ColumnSourceGetDefaults.ForDouble {
-
-        NativeType(@NotNull final RegionedColumnSourceBase<DATA_TYPE, ATTR, ColumnRegionReferencing<ATTR, ColumnRegionDouble<ATTR>>> outerColumnSource) {
-            super(Double.class, outerColumnSource);
-        }
-
-        @Override
-        public double getDouble(final long rowKey) {
-            return (rowKey == RowSequence.NULL_ROW_KEY ? getNullRegion() : lookupRegion(rowKey)).getDouble(rowKey);
-        }
-
-        static final class AsValues<DATA_TYPE> extends NativeType<DATA_TYPE, Values> implements MakeRegionDefault {
-            AsValues(@NotNull final RegionedColumnSourceBase<DATA_TYPE, Values, ColumnRegionReferencing<Values, ColumnRegionDouble<Values>>> outerColumnSource) {
-                super(outerColumnSource);
-            }
-        }
-    }
-
     static final class Partitioning extends RegionedColumnSourceDouble<Values> {
 
         Partitioning() {

diff --git a/.../main/java/io/deephaven/engine/table/impl/sources/regioned/RegionedColumnSourceFloat.java b/.../main/java/io/deephaven/engine/table/impl/sources/regioned/RegionedColumnSourceFloat.java
@@ -24,7 +24,7 @@
  */
 abstract class RegionedColumnSourceFloat<ATTR extends Values>
         extends RegionedColumnSourceArray<Float, ATTR, ColumnRegionFloat<ATTR>>
-        implements ColumnSourceGetDefaults.ForFloat {
+        implements ColumnSourceGetDefaults.ForFloat /* MIXIN_INTERFACES */ {
 
     RegionedColumnSourceFloat(@NotNull final ColumnRegionFloat<ATTR> nullRegion,
                              @NotNull final MakeDeferred<ATTR, ColumnRegionFloat<ATTR>> makeDeferred) {
@@ -48,38 +48,15 @@ default ColumnRegionFloat<Values> makeRegion(@NotNull final ColumnDefinition<?>
         }
     }
 
+    // region reinterpretation
+    // endregion reinterpretation
+
     static final class AsValues extends RegionedColumnSourceFloat<Values> implements MakeRegionDefault {
         AsValues() {
             super(ColumnRegionFloat.createNull(PARAMETERS.regionMask), DeferredColumnRegionFloat::new);
         }
     }
 
-    /**
-     * These are used by {@link RegionedColumnSourceReferencing} subclass who want a native float type.  This class does
-     * <em>not</em> hold an array of regions, but rather derives from {@link RegionedColumnSourceBase}, accessing its
-     * regions by looking into the delegate instance's region array.
-     */
-    @SuppressWarnings("unused")
-    static abstract class NativeType<DATA_TYPE, ATTR extends Values>
-            extends RegionedColumnSourceReferencing.NativeColumnSource<DATA_TYPE, ATTR, Float, ColumnRegionFloat<ATTR>>
-            implements ColumnSourceGetDefaults.ForFloat {
-
-        NativeType(@NotNull final RegionedColumnSourceBase<DATA_TYPE, ATTR, ColumnRegionReferencing<ATTR, ColumnRegionFloat<ATTR>>> outerColumnSource) {
-            super(Float.class, outerColumnSource);
-        }
-
-        @Override
-        public float getFloat(final long rowKey) {
-            return (rowKey == RowSequence.NULL_ROW_KEY ? getNullRegion() : lookupRegion(rowKey)).getFloat(rowKey);
-        }
-
-        static final class AsValues<DATA_TYPE> extends NativeType<DATA_TYPE, Values> implements MakeRegionDefault {
-            AsValues(@NotNull final RegionedColumnSourceBase<DATA_TYPE, Values, ColumnRegionReferencing<Values, ColumnRegionFloat<Values>>> outerColumnSource) {
-                super(outerColumnSource);
-            }
-        }
-    }
-
     static final class Partitioning extends RegionedColumnSourceFloat<Values> {
 
         Partitioning() {