io.deephaven.engine.table.impl.sources.immutable.ImmutableLongArraySource Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of deephaven-engine-table Show documentation
Show all versions of deephaven-engine-table Show documentation
Engine Table: Implementation and closely-coupled utilities
/**
* Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending
*/
/*
* ---------------------------------------------------------------------------------------------------------------------
* AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit ImmutableCharArraySource and regenerate
* ---------------------------------------------------------------------------------------------------------------------
*/
package io.deephaven.engine.table.impl.sources.immutable;
import java.util.function.LongFunction;
import java.util.function.ToLongFunction;
import java.time.Instant;
import java.time.ZonedDateTime;
import java.time.LocalDate;
import java.time.LocalTime;
import io.deephaven.base.verify.Require;
import java.time.ZoneId;
import io.deephaven.engine.table.ColumnSource;
import io.deephaven.chunk.*;
import io.deephaven.chunk.attributes.Values;
import io.deephaven.engine.rowset.RowSequence;
import io.deephaven.engine.rowset.RowSet;
import io.deephaven.engine.rowset.chunkattributes.RowKeys;
import io.deephaven.engine.table.WritableColumnSource;
import io.deephaven.engine.table.WritableSourceWithPrepareForParallelPopulation;
import io.deephaven.engine.table.impl.DefaultGetContext;
import io.deephaven.engine.table.impl.ImmutableColumnSourceGetDefaults;
import io.deephaven.engine.table.impl.sources.*;
import org.apache.commons.lang3.mutable.MutableInt;
import org.jetbrains.annotations.NotNull;
import java.util.Arrays;
// region boxing imports
import static io.deephaven.util.QueryConstants.NULL_LONG;
// endregion boxing imports
/**
* Simple flat array source that supports fillFromChunk for initial creation.
*
* No previous value tracking is permitted, so this column source is only useful as a flat static source.
*
* A single array backs the result, so getChunk calls with contiguous ranges should always be able to return a
* reference to the backing store without an array copy. The immediate consequence is that you may not create
* sources that have a capacity larger than the maximum capacity of an array.
*
* If your size is greater than the maximum capacity of an array, prefer {@link Immutable2DLongArraySource}.
*/
public class ImmutableLongArraySource extends AbstractDeferredGroupingColumnSource
implements ImmutableColumnSourceGetDefaults.ForLong, WritableColumnSource, FillUnordered,
InMemoryColumnSource, ChunkedBackingStoreExposedWritableSource, WritableSourceWithPrepareForParallelPopulation
, ConvertibleTimeSource {
private long[] data;
// region constructor
public ImmutableLongArraySource() {
super(long.class);
}
// endregion constructor
// region array constructor
public ImmutableLongArraySource(long [] data) {
super(long.class);
this.data = data;
}
// endregion array constructor
// region allocateArray
void allocateArray(long capacity, boolean nullFilled) {
final int intCapacity = Math.toIntExact(capacity);
this.data = new long[intCapacity];
if (nullFilled) {
Arrays.fill(this.data, 0, intCapacity, NULL_LONG);
}
}
// endregion allocateArray
@Override
public final long getLong(long rowKey) {
if (rowKey < 0 || rowKey >= data.length) {
return NULL_LONG;
}
return getUnsafe(rowKey);
}
public final long getUnsafe(long rowKey) {
return data[(int)rowKey];
}
public final long getAndSetUnsafe(long rowKey, long newValue) {
long oldValue = data[(int)rowKey];
data[(int)rowKey] = newValue;
return oldValue;
}
@Override
public final void setNull(long key) {
data[(int)key] = NULL_LONG;
}
@Override
public final void set(long key, long value) {
data[(int)key] = value;
}
@Override
public void ensureCapacity(long capacity, boolean nullFilled) {
if (data == null) {
allocateArray(capacity, nullFilled);
}
if (capacity > data.length) {
throw new UnsupportedOperationException();
}
}
@Override
public void fillChunk(@NotNull FillContext context, @NotNull WritableChunk destination, @NotNull RowSequence rowSequence) {
if (rowSequence.getAverageRunLengthEstimate() >= ArrayBackedColumnSource.USE_RANGES_AVERAGE_RUN_LENGTH) {
fillChunkByRanges(destination, rowSequence);
} else {
fillChunkByKeys(destination, rowSequence);
}
}
// region fillChunkByRanges
/* TYPE_MIXIN */ void fillChunkByRanges(
@NotNull final WritableChunk destination,
@NotNull final RowSequence rowSequence
/* CONVERTER */) {
// region chunkDecl
final WritableLongChunk chunk = destination.asWritableLongChunk();
// endregion chunkDecl
final MutableInt destPosition = new MutableInt(0);
rowSequence.forAllRowKeyRanges((long start, long end) -> {
final int length = (int)(end - start + 1);
// region copyFromTypedArrayImmutable
chunk.copyFromTypedArray(data, (int)start, destPosition.getAndAdd(length), length);
// endregion copyFromTypedArrayImmutable
});
chunk.setSize(destPosition.intValue());
}
void fillChunkByRanges(
@NotNull final WritableChunk destination,
@NotNull final RowSequence rowSequence
, LongFunction converter) {
// region chunkDecl
final WritableObjectChunk chunk = destination.asWritableObjectChunk();
// endregion chunkDecl
final MutableInt destPosition = new MutableInt(0);
rowSequence.forAllRowKeyRanges((long start, long end) -> {
final int length = (int)(end - start + 1);
// region copyFromTypedArrayImmutable
final int offset = destPosition.getAndAdd(length);
for (int ii = 0; ii < length; ii++) {
chunk.set(offset + ii, converter.apply(data[(int)start + ii]));
}
// endregion copyFromTypedArrayImmutable
});
chunk.setSize(destPosition.intValue());
}
// endregion fillChunkByRanges
// region fillChunkByKeys
/* TYPE_MIXIN */ void fillChunkByKeys(
@NotNull final WritableChunk destination,
@NotNull final RowSequence rowSequence
/* CONVERTER */) {
// region chunkDecl
final WritableLongChunk chunk = destination.asWritableLongChunk();
// endregion chunkDecl
final MutableInt destPosition = new MutableInt(0);
rowSequence.forAllRowKeys((long key) -> {
// region conversion
chunk.set(destPosition.getAndIncrement(), getUnsafe(key));
// endregion conversion
});
chunk.setSize(destPosition.intValue());
}
void fillChunkByKeys(
@NotNull final WritableChunk destination,
@NotNull final RowSequence rowSequence
, LongFunction converter) {
// region chunkDecl
final WritableObjectChunk chunk = destination.asWritableObjectChunk();
// endregion chunkDecl
final MutableInt destPosition = new MutableInt(0);
rowSequence.forAllRowKeys((long key) -> {
// region conversion
chunk.set(destPosition.getAndIncrement(),converter.apply( getUnsafe(key)));
// endregion conversion
});
chunk.setSize(destPosition.intValue());
}
// endregion fillChunkByKeys
@Override
public Chunk getChunk(@NotNull GetContext context, @NotNull RowSequence rowSequence) {
if (rowSequence.isEmpty()) {
return LongChunk.getEmptyChunk();
}
if (rowSequence.isContiguous()) {
return getChunk(context, rowSequence.firstRowKey(), rowSequence.lastRowKey());
}
return super.getChunk(context, rowSequence);
}
@Override
public long resetWritableChunkToBackingStore(@NotNull ResettableWritableChunk chunk, long position) {
chunk.asResettableWritableLongChunk().resetFromTypedArray(data, 0, data.length);
return 0;
}
@Override
public long resetWritableChunkToBackingStoreSlice(@NotNull ResettableWritableChunk chunk, long position) {
final int capacity = (int)(data.length - position);
ResettableWritableLongChunk resettableWritableLongChunk = chunk.asResettableWritableLongChunk();
resettableWritableLongChunk.resetFromTypedArray(data, (int)position, capacity);
return capacity;
}
@Override
public Chunk getChunk(@NotNull GetContext context, long firstKey, long lastKey) {
final int len = (int)(lastKey - firstKey + 1);
//noinspection unchecked
DefaultGetContext context1 = (DefaultGetContext) context;
return context1.getResettableChunk().resetFromArray(data, (int)firstKey, len);
}
@Override
public void fillFromChunk(@NotNull FillFromContext context, @NotNull Chunk src, @NotNull RowSequence rowSequence) {
if (rowSequence.getAverageRunLengthEstimate() >= ArrayBackedColumnSource.USE_RANGES_AVERAGE_RUN_LENGTH) {
fillFromChunkByRanges(src, rowSequence);
} else {
fillFromChunkByKeys(src, rowSequence);
}
}
// region fillFromChunkByKeys
/* TYPE_MIXIN */ void fillFromChunkByKeys(
@NotNull final Chunk src,
@NotNull final RowSequence rowSequence
/* CONVERTER */) {
// region chunkDecl
final LongChunk chunk = src.asLongChunk();
// endregion chunkDecl
final MutableInt srcPos = new MutableInt(0);
rowSequence.forAllRowKeys((long key) -> {
// region conversion
set(key, chunk.get(srcPos.getAndIncrement()));
// endregion conversion
});
}
void fillFromChunkByKeys(
@NotNull final Chunk src,
@NotNull final RowSequence rowSequence
, ToLongFunction converter) {
// region chunkDecl
final ObjectChunk chunk = src.asObjectChunk();
// endregion chunkDecl
final MutableInt srcPos = new MutableInt(0);
rowSequence.forAllRowKeys((long key) -> {
// region conversion
set(key,converter.applyAsLong( chunk.get(srcPos.getAndIncrement())));
// endregion conversion
});
}
// endregion fillFromChunkByKeys
// region fillFromChunkByRanges
/* TYPE_MIXIN */ void fillFromChunkByRanges(
@NotNull final Chunk src,
@NotNull final RowSequence rowSequence
/* CONVERTER */) {
// region chunkDecl
final LongChunk chunk = src.asLongChunk();
// endregion chunkDecl
final MutableInt srcPos = new MutableInt(0);
rowSequence.forAllRowKeyRanges((long start, long end) -> {
final int length = (int)(end - start + 1);
// region copyToTypedArrayImmutable
chunk.copyToTypedArray(srcPos.getAndAdd(length), data, (int)start, length);
// endregion copyToTypedArrayImmutable
});
}
void fillFromChunkByRanges(
@NotNull final Chunk src,
@NotNull final RowSequence rowSequence
, ToLongFunction converter) {
// region chunkDecl
final ObjectChunk chunk = src.asObjectChunk();
// endregion chunkDecl
final MutableInt srcPos = new MutableInt(0);
rowSequence.forAllRowKeyRanges((long start, long end) -> {
final int length = (int)(end - start + 1);
// region copyToTypedArrayImmutable
final int offset = srcPos.getAndAdd(length);
for (int jj = 0; jj < length; jj++) {
data[(int)start + jj] = converter.applyAsLong(chunk.get(offset + jj));
}
// endregion copyToTypedArrayImmutable
});
}
// endregion fillFromChunkByRanges
// region fillFromChunkUnordered
@Override
public /* TYPE_MIXIN */ void fillFromChunkUnordered(
@NotNull final FillFromContext context,
@NotNull final Chunk src,
@NotNull final LongChunk keys
/* CONVERTER */) {
// region chunkDecl
final LongChunk chunk = src.asLongChunk();
// endregion chunkDecl
for (int ii = 0; ii < keys.size(); ++ii) {
// region conversion
set(keys.get(ii), chunk.get(ii));
// endregion conversion
}
}
public void fillFromChunkUnordered(
@NotNull final FillFromContext context,
@NotNull final Chunk src,
@NotNull final LongChunk keys
, ToLongFunction converter) {
// region chunkDecl
final ObjectChunk chunk = src.asObjectChunk();
// endregion chunkDecl
for (int ii = 0; ii < keys.size(); ++ii) {
// region conversion
set(keys.get(ii),converter.applyAsLong( chunk.get(ii)));
// endregion conversion
}
}
// endregion fillFromChunkUnordered
// region fillChunkUnordered
@Override
public /* TYPE_MIXIN */ void fillChunkUnordered(
@NotNull final FillContext context,
@NotNull final WritableChunk dest,
@NotNull final LongChunk keys
/* CONVERTER */) {
// region chunkDecl
final WritableLongChunk chunk = dest.asWritableLongChunk();
// endregion chunkDecl
for (int ii = 0; ii < keys.size(); ++ii) {
final long longKey = keys.get(ii);
if (longKey == RowSet.NULL_ROW_KEY) {
chunk.set(ii, NULL_LONG);
} else {
final int key = (int)longKey;
// region conversion
chunk.set(ii, getUnsafe(key));
// endregion conversion
}
}
}
public void fillChunkUnordered(
@NotNull final FillContext context,
@NotNull final WritableChunk dest,
@NotNull final LongChunk keys
, LongFunction converter) {
// region chunkDecl
final WritableObjectChunk chunk = dest.asWritableObjectChunk();
// endregion chunkDecl
for (int ii = 0; ii < keys.size(); ++ii) {
final long longKey = keys.get(ii);
if (longKey == RowSet.NULL_ROW_KEY) {
chunk.set(ii, null);
} else {
final int key = (int)longKey;
// region conversion
chunk.set(ii,converter.apply( getUnsafe(key)));
// endregion conversion
}
}
}
// endregion fillChunkUnordered
@Override
public void fillPrevChunkUnordered(@NotNull FillContext context, @NotNull WritableChunk dest, @NotNull LongChunk keys) {
fillChunkUnordered(context, dest, keys);
}
@Override
public void fillPrevChunk(@NotNull FillContext context, @NotNull WritableChunk destination, @NotNull RowSequence rowSequence) {
fillChunk(context, destination, rowSequence);
}
@Override
public Chunk getPrevChunk(@NotNull GetContext context, @NotNull RowSequence rowSequence) {
return getChunk(context, rowSequence);
}
@Override
public Chunk getPrevChunk(@NotNull GetContext context, long firstKey, long lastKey) {
return getChunk(context, firstKey, lastKey);
}
@Override
public boolean providesFillUnordered() {
return true;
}
@Override
public void prepareForParallelPopulation(@NotNull final RowSequence rowSequence) {
// We don't track previous values, but we do need to ensure we can accept the expected rows.
ensureCapacity(rowSequence.lastRowKey() + 1, false);
}
// region getArray
public long [] getArray() {
return data;
}
// endregion getArray
// region setArray
public void setArray(long [] array) {
data = array;
}
// endregion setArray
// region reinterpretation
@Override
public boolean allowsReinterpret(@NotNull final Class alternateDataType) {
return alternateDataType == long.class || alternateDataType == Instant.class;
}
@SuppressWarnings("unchecked")
@Override
protected ColumnSource doReinterpret(@NotNull Class alternateDataType) {
if (alternateDataType == this.getType()) {
return (ColumnSource) this;
} else if (alternateDataType == Instant.class) {
return (ColumnSource) toInstant();
}
throw new IllegalArgumentException("Cannot reinterpret `" + getType().getName() + "` to `" + alternateDataType.getName() + "`");
}
@Override
public boolean supportsTimeConversion() {
return true;
}
@Override
public ColumnSource toZonedDateTime(@NotNull final ZoneId zone) {
return new ImmutableZonedDateTimeArraySource(Require.neqNull(zone, "zone"), this);
}
@Override
public ColumnSource toLocalDate(@NotNull final ZoneId zone) {
return new LongAsLocalDateColumnSource(this, zone);
}
@Override
public ColumnSource toLocalTime(@NotNull final ZoneId zone) {
return new LongAsLocalTimeColumnSource(this, zone);
}
@Override
public ColumnSource toInstant() {
return new ImmutableInstantArraySource(this);
}
@Override
public ColumnSource toEpochNano() {
return this;
}
// endregion reinterpretation
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy