Package org.apache.cassandra.utils.bytecomparable

Class ByteSourceInverse

java.lang.Object
org.apache.cassandra.utils.bytecomparable.ByteSourceInverse
public final class ByteSourceInverse extends Object
Contains inverse transformation utilities for ByteSources. See ByteComparable.md for details about the encoding scheme.

  • Constructor Details

    • ByteSourceInverse

      public ByteSourceInverse()

  • Method Details

    • getUnsignedFixedLengthAsLong

      public static long getUnsignedFixedLengthAsLong(ByteSource byteSource, int length)
      Consume the given number of bytes and produce a long from them, effectively treating the bytes as a big-endian unsigned encoding of the number.

    • getSignedFixedLength

      public static <V> V getSignedFixedLength(ValueAccessor<V> accessor, ByteSource byteSource, int length)
      Produce the bytes for an encoded signed fixed-length number. The first byte has its sign bit inverted, and the rest are passed unchanged.

    • getOptionalSignedFixedLength

      public static <V> V getOptionalSignedFixedLength(ValueAccessor<V> accessor, ByteSource byteSource, int length)
      Produce the bytes for an encoded signed fixed-length number, also translating null to empty buffer. The first byte has its sign bit inverted, and the rest are passed unchanged.

    • getSignedFixedLengthFloat

      public static <V> V getSignedFixedLengthFloat(ValueAccessor<V> accessor, ByteSource byteSource, int length)
      Produce the bytes for an encoded signed fixed-length floating-point number. If sign bit is on, returns negated bytes. If not, clears the sign bit and passes the rest of the bytes unchanged.

    • getOptionalSignedFixedLengthFloat

      public static <V> V getOptionalSignedFixedLengthFloat(ValueAccessor<V> accessor, ByteSource byteSource, int length)
      Produce the bytes for an encoded signed fixed-length floating-point number, also translating null to an empty buffer. If sign bit is on, returns negated bytes. If not, clears the sign bit and passes the rest of the bytes unchanged.

    • getFixedLength

      public static <V> V getFixedLength(ValueAccessor<V> accessor, ByteSource byteSource, int length)
      Consume the next length bytes from the source unchanged.

    • getOptionalFixedLength

      public static <V> V getOptionalFixedLength(ValueAccessor<V> accessor, ByteSource byteSource, int length)
      Consume the next length bytes from the source unchanged, also translating null to an empty buffer.

    • getSignedInt

      public static int getSignedInt(ByteSource byteSource)
      Consume the next int from the current position of the given ByteSource. The source position is modified accordingly (moved 4 bytes forward).

      The source is not strictly required to represent just the encoding of an int value, so theoretically this API could be used for reading data in 4-byte strides. Nevertheless its usage is fairly limited because:

      1. ...it presupposes signed fixed-length encoding for the encoding of the original value
      2. ...it decodes the data returned on each stride as an int (i.e. it inverts its leading bit)
      3. ...it doesn't provide any meaningful guarantees (with regard to throwing) in case there are not enough bytes to read, in case a special escape value was not interpreted as such, etc.

      Parameters:
      byteSource - A non-null byte source, containing at least 4 bytes.

    • getSignedLong

      public static long getSignedLong(ByteSource byteSource)
      Consume the next long from the current position of the given ByteSource. The source position is modified accordingly (moved 8 bytes forward).

      The source is not strictly required to represent just the encoding of a long value, so theoretically this API could be used for reading data in 8-byte strides. Nevertheless its usage is fairly limited because:

      1. ...it presupposes signed fixed-length encoding for the encoding of the original value
      2. ...it decodes the data returned on each stride as a long (i.e. it inverts its leading bit)
      3. ...it doesn't provide any meaningful guarantees (with regard to throwing) in case there are not enough bytes to read, in case a special escape value was not interpreted as such, etc.

      Parameters:
      byteSource - A non-null byte source, containing at least 8 bytes.

    • getSignedByte

      public static byte getSignedByte(ByteSource byteSource)
      Converts the given ByteSource to a byte.
      Parameters:
      byteSource - A non-null byte source, containing at least 1 byte.

    • getSignedShort

      public static short getSignedShort(ByteSource byteSource)
      Converts the given ByteSource to a short. All terms and conditions valid for getSignedInt(ByteSource) and getSignedLong(ByteSource) translate to this as well.
      Parameters:
      byteSource - A non-null byte source, containing at least 2 bytes.
      See Also:

    • getVariableLengthInteger

      public static long getVariableLengthInteger(ByteSource byteSource)
      Decode a variable-length signed integer.

    • getVariableLengthUnsignedIntegerXoring

      public static long getVariableLengthUnsignedIntegerXoring(ByteSource byteSource, int xorWith)
      Decode a variable-length unsigned integer, passing all bytes read through XOR with the given xorWith parameter. Used in BigInteger encoding to read number length, where negative numbers have their length negated (i.e. xorWith = 0xFF) to ensure correct ordering.

    • getUnescapedBytes

      public static byte[] getUnescapedBytes(ByteSource.Peekable byteSource)
      Reads a single variable-length byte sequence (blob, string, ...) encoded according to the scheme described in ByteComparable.md, decoding it back to its original, unescaped form.
      Parameters:
      byteSource - The source of the variable-length bytes sequence.
      Returns:
      A byte array containing the original, unescaped bytes of the given source. Unescaped here means not including any of the escape sequences of the encoding scheme used for variable-length byte sequences.

    • unescape

      public static ByteSource unescape(ByteSource.Peekable byteSource)
      As above, but converts the result to a ByteSource.

    • readBytes

      public static byte[] readBytes(ByteSource byteSource, int initialBufferCapacity)
      Reads the bytes of the given source into a byte array. Doesn't do any transformation on the bytes, just reads them until it reads an ByteSource.END_OF_STREAM byte, after which it returns an array of all the read bytes, excluding the ByteSource.END_OF_STREAM.

      This method sizes a tentative internal buffer array at initialBufferCapacity. However, if byteSource exceeds this size, the buffer array is recreated with doubled capacity as many times as necessary. If, after byteSource is fully exhausted, the number of bytes read from it does not exactly match the current size of the tentative buffer array, then it is copied into another array sized to fit the number of bytes read; otherwise, it is returned without that final copy step.

      Parameters:
      byteSource - The source which bytes we're interested in.
      initialBufferCapacity - The initial size of the internal buffer.
      Returns:
      A byte array containing exactly all the read bytes. In case of a null source, the returned byte array will be empty.

    • readBytes

      public static byte[] readBytes(ByteSource byteSource)
      Reads the bytes of the given source into a byte array. Doesn't do any transformation on the bytes, just reads them until it reads an ByteSource.END_OF_STREAM byte, after which it returns an array of all the read bytes, excluding the ByteSource.END_OF_STREAM.

      This is equivalent to readBytes(ByteSource, int) where the second actual parameter is INITIAL_BUFFER_CAPACITY (32).

      Parameters:
      byteSource - The source which bytes we're interested in.
      Returns:
      A byte array containing exactly all the read bytes. In case of a null source, the returned byte array will be empty.

    • copyBytes

      public static void copyBytes(ByteSource byteSource, byte[] bytes)

    • getString

      public static String getString(ByteSource.Peekable byteSource)
      Converts the given ByteSource to a UTF-8 String.
      Parameters:
      byteSource - The source we're interested in.
      Returns:
      A UTF-8 string corresponding to the given source.

    • nextComponentSource

      public static ByteSource.Peekable nextComponentSource(ByteSource.Peekable source)
      A utility for consuming components from a peekable multi-component sequence. It uses the component separators, so the given sequence needs to have its last component fully consumed, in order for the next consumable byte to be a separator. Identifying the end of the component that will then be consumed is the responsibility of the consumer (the user of this method).
      Parameters:
      source - A peekable multi-component sequence, which next byte is a component separator.
      Returns:
      the given multi-component sequence if its next component is not null, or null if it is.

    • nextComponentSource

      public static ByteSource.Peekable nextComponentSource(ByteSource.Peekable source, int separator)
      A utility for consuming components from a peekable multi-component sequence, very similar to nextComponentSource(ByteSource.Peekable) - the difference being that here the separator can be passed in case it had to be consumed beforehand.

    • nextComponentNull

      public static boolean nextComponentNull(int separator)