Package org.apache.storm.utils

Class WritableUtils

java.lang.Object
org.apache.storm.utils.WritableUtils
public final class WritableUtils extends Object

  • Constructor Details

    • WritableUtils

      public WritableUtils()

  • Method Details

    • readCompressedByteArray

      public static byte[] readCompressedByteArray(DataInput in) throws IOException
      Throws:
      IOException

    • skipCompressedByteArray

      public static void skipCompressedByteArray(DataInput in) throws IOException
      Throws:
      IOException

    • writeCompressedByteArray

      public static int writeCompressedByteArray(DataOutput out, byte[] bytes) throws IOException
      Throws:
      IOException

    • readCompressedString

      public static String readCompressedString(DataInput in) throws IOException
      Ugly utility, maybe someone else can do this better.
      Throws:
      IOException

    • writeCompressedString

      public static int writeCompressedString(DataOutput out, String s) throws IOException
      Throws:
      IOException

    • writeString

      public static void writeString(DataOutput out, String s) throws IOException
      Write a String as a Network Int n, followed by n Bytes Alternative to 16 bit read/writeUTF. Encoding standard is... ?
      Throws:
      IOException

    • readString

      public static String readString(DataInput in) throws IOException
      Read a String as a Network Int n, followed by n Bytes Alternative to 16 bit read/writeUTF. Encoding standard is... ?
      Throws:
      IOException

    • writeStringArray

      public static void writeStringArray(DataOutput out, String[] s) throws IOException
      Write a String array as a Nework Int N, followed by Int N Byte Array Strings. Could be generalised using introspection.
      Throws:
      IOException

    • writeCompressedStringArray

      public static void writeCompressedStringArray(DataOutput out, String[] s) throws IOException
      Throws:
      IOException

    • readStringArray

      public static String[] readStringArray(DataInput in) throws IOException
      Write a String array as a Nework Int N, followed by Int N Byte Array Strings. Could be generalised using introspection. Actually this bit couldn't...
      Throws:
      IOException

    • readCompressedStringArray

      public static String[] readCompressedStringArray(DataInput in) throws IOException
      Write a String array as a Nework Int N, followed by Int N Byte Array Strings. Could be generalised using introspection. Handles null arrays and null values.
      Throws:
      IOException

    • displayByteArray

      public static void displayByteArray(byte[] record)
      Test Utility Method Display Byte Array.

    • writeVInt

      public static void writeVInt(DataOutput stream, int i) throws IOException
      Serializes an integer to a binary stream with zero-compressed encoding. For -120 <= i <= 127, only one byte is used with the actual value. For other values of i, the first byte value indicates whether the integer is positive or negative, and the number of bytes that follow. If the first byte value v is between -121 and -124, the following integer is positive, with number of bytes that follow are -(v+120). If the first byte value v is between -125 and -128, the following integer is negative, with number of bytes that follow are -(v+124). Bytes are stored in the high-non-zero-byte-first order.
      Parameters:
      stream - Binary output stream
      i - Integer to be serialized
      Throws:
      IOException

    • writeVLong

      public static void writeVLong(DataOutput stream, long i) throws IOException
      Serializes a long to a binary stream with zero-compressed encoding. For -112 <= i <= 127, only one byte is used with the actual value. For other values of i, the first byte value indicates whether the long is positive or negative, and the number of bytes that follow. If the first byte value v is between -113 and -120, the following long is positive, with number of bytes that follow are -(v+112). If the first byte value v is between -121 and -128, the following long is negative, with number of bytes that follow are -(v+120). Bytes are stored in the high-non-zero-byte-first order.
      Parameters:
      stream - Binary output stream
      i - Long to be serialized
      Throws:
      IOException

    • readVLong

      public static long readVLong(DataInput stream) throws IOException
      Reads a zero-compressed encoded long from input stream and returns it.
      Parameters:
      stream - Binary input stream
      Returns:
      deserialized long from stream.
      Throws:
      IOException

    • readVInt

      public static int readVInt(DataInput stream) throws IOException
      Reads a zero-compressed encoded integer from input stream and returns it.
      Parameters:
      stream - Binary input stream
      Returns:
      deserialized integer from stream.
      Throws:
      IOException

    • isNegativeVInt

      public static boolean isNegativeVInt(byte value)
      Given the first byte of a vint/vlong, determine the sign.
      Parameters:
      value - the first byte
      Returns:
      is the value negative

    • decodeVIntSize

      public static int decodeVIntSize(byte value)
      Parse the first byte of a vint/vlong to determine the number of bytes.
      Parameters:
      value - the first byte of the vint/vlong
      Returns:
      the total number of bytes (1 to 9)

    • getVIntSize

      public static int getVIntSize(long i)
      Get the encoded length if an integer is stored in a variable-length format.
      Returns:
      the encoded length

    • skipFully

      public static void skipFully(DataInput in, int len) throws IOException
      Skip len number of bytes in input streamin.
      Parameters:
      in - input stream
      len - number of bytes to skip
      Throws:
      IOException - when skipped less number of bytes