Package io.deephaven.chunk

Class WritableShortChunk<ATTR extends Any>

java.lang.Object
io.deephaven.chunk.ChunkBase<ATTR>
io.deephaven.chunk.ShortChunk<ATTR>
io.deephaven.chunk.WritableShortChunk<ATTR>
All Implemented Interfaces:
Chunk<ATTR>, PoolableChunk<ATTR>, WritableChunk<ATTR>, SafeCloseable, AutoCloseable
Direct Known Subclasses:
ResettableWritableShortChunk
public class WritableShortChunk<ATTR extends Any> extends ShortChunk<ATTR> implements WritableChunk<ATTR>
WritableChunk implementation for short data.

  • Constructor Details

    • WritableShortChunk

      protected WritableShortChunk(short[] data, int offset, int capacity)

  • Method Details

    • makeWritableChunk

      public static <ATTR extends Any> WritableShortChunk<ATTR> makeWritableChunk(int size)
      Get a WritableShortChunk with ChunkBase.size() of size for use by the caller until it is closed.
      Parameters:
      size - The ChunkBase.size() and minimum capacity of the returned chunk
      Returns:
      The chunk

    • writableChunkWrap

      public static <ATTR extends Any> WritableShortChunk<ATTR> writableChunkWrap(short[] data)

    • writableChunkWrap

      public static <ATTR extends Any> WritableShortChunk<ATTR> writableChunkWrap(short[] data, int offset, int size)

    • set

      public final void set(int index, short value)

    • add

      public final void add(short value)

    • slice

      public WritableShortChunk<ATTR> slice(int offset, int capacity)
      Description copied from interface: Chunk
      Make a new Chunk that represents either exactly the same view on the underlying data as this Chunk, or a subrange of that view. The view is defined as [0..size) (in the coordinate space of this Chunk).
      Specified by:
      slice in interface Chunk<ATTR extends Any>
      Specified by:
      slice in interface WritableChunk<ATTR extends Any>
      Overrides:
      slice in class ShortChunk<ATTR extends Any>
      Parameters:
      offset - Offset of the new Chunk, relative to this Chunk. 0 ≤ offset ≤ this.size
      capacity - Capacity and initial size of the new Chunk. 0 ≤ capacity ≤ this.size - offset.
      Returns:
      The new Chunk. A new Chunk will always be returned, even if the Chunks represent the same view.

    • array

      public final short[] array()
      Get the data array backing this WritableShortChunk. The first element of this chunk corresponds to array()[arrayOffset()].

      This WritableShortChunk must never be closed while the array may be in use externally, because it must not be returned to any pool for re-use until that re-use is guaranteed to be exclusive.

      Returns:
      The backing data array

    • arrayOffset

      public final int arrayOffset()
      Get this WritableShortChunk's offset into the backing data array. The first element of this chunk corresponds to array()[arrayOffset()].
      Returns:
      The offset into the backing data array

    • fillWithNullValue

      public final void fillWithNullValue(int offset, int length)
      Description copied from interface: WritableChunk
      Fill a sub-range of this writable chunk with the appropriate Deephaven null value for the type.
      Specified by:
      fillWithNullValue in interface WritableChunk<ATTR extends Any>
      Parameters:
      offset - Starting offset
      length - Number of values to fill

    • fillWithBoxedValue

      public final void fillWithBoxedValue(int offset, int size, Object value)
      Description copied from interface: WritableChunk
      Fill a sub-range of this writable chunk with the given value, unboxing it as appropriate.
      Specified by:
      fillWithBoxedValue in interface WritableChunk<ATTR extends Any>
      Parameters:
      offset - Starting offset
      size - Number of values to fill

    • fillWithValue

      public final void fillWithValue(int offset, int length, short value)

    • appendTypedChunk

      public final void appendTypedChunk(ShortChunk<? extends ATTR> src, int srcOffset, int length)

    • copyFromChunk

      public final void copyFromChunk(Chunk<? extends ATTR> src, int srcOffset, int destOffset, int length)
      Specified by:
      copyFromChunk in interface WritableChunk<ATTR extends Any>

    • copyFromTypedChunk

      public final void copyFromTypedChunk(ShortChunk<? extends ATTR> src, int srcOffset, int destOffset, int length)

    • copyFromArray

      public final void copyFromArray(Object srcArray, int srcOffset, int destOffset, int length)
      Specified by:
      copyFromArray in interface WritableChunk<ATTR extends Any>

    • copyFromTypedArray

      public final void copyFromTypedArray(short[] src, int srcOffset, int destOffset, int length)

    • copyFromBuffer

      public final void copyFromBuffer(@NotNull @NotNull Buffer srcBuffer, int srcOffset, int destOffset, int length)
      Description copied from interface: WritableChunk

      Fill a sub-range of this writable chunk with values from a Buffer. This is an optional method, as some chunk types do not have a corresponding buffer type.

      Implementations are free to copy data as efficiently as they may, and will use absolute rather than positional access where possible. To facilitate this pattern, srcOffset is an absolute offset from position 0, rather than a relative offset from srcBuffer.position().

      It is required that srcBuffer.limit() is at least srcOffset + length.

      srcBuffer's position may be modified, but will always be restored to its initial value upon successful return.

      Specified by:
      copyFromBuffer in interface WritableChunk<ATTR extends Any>
      Parameters:
      srcBuffer - The source buffer, which will be cast to the appropriate type for this chunk
      srcOffset - The offset into srcBuffer (from position 0, not srcBuffer.position()) to start copying from
      destOffset - The offset into this chunk to start copying to
      length - The number of elements to copy

    • copyFromTypedBuffer

      public final void copyFromTypedBuffer(@NotNull @NotNull ShortBuffer srcBuffer, int srcOffset, int destOffset, int length)

      Fill a sub-range of this WritableShortChunk with values from a ShortBuffer.

      See copyFromBuffer(Buffer, int, int, int) for general documentation.

      Parameters:
      srcBuffer - The source ShortBuffer
      srcOffset - The absolute offset into srcBuffer to start copying from
      destOffset - The offset into this chunk to start copying to
      length - The number of elements to copy

    • sort

      public final void sort()
      Description copied from interface: WritableChunk
      Sort this chunk in-place using Java's primitive defined ordering.

      Of note is that nulls or NaNs are not sorted according to Deephaven ordering rules.

      Specified by:
      sort in interface WritableChunk<ATTR extends Any>

    • sort

      public final void sort(int start, int length)
      Description copied from interface: WritableChunk
      Sort this chunk in-place using Java's primitive defined ordering.

      Of note is that nulls or NaNs are not sorted according to Deephaven ordering rules.

      Specified by:
      sort in interface WritableChunk<ATTR extends Any>

    • close

      public void close()
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface SafeCloseable

    • upcast

      public static <ATTR extends Any, ATTR_DERIV extends ATTR> WritableShortChunk<ATTR> upcast(WritableShortChunk<ATTR_DERIV> self)