Class BufferUtils

    • Method Detail

      • dumpHex

        public static void dumpHex​(SimplifiedLog logger,
                                   Level level,
                                   String prefix,
                                   char sep,
                                   int chunkSize,
                                   byte... data)
      • dumpHex

        public static void dumpHex​(SimplifiedLog logger,
                                   Level level,
                                   String prefix,
                                   char sep,
                                   int chunkSize,
                                   byte[] data,
                                   int offset,
                                   int len)
      • toHex

        public static String toHex​(byte... array)
      • toHex

        public static String toHex​(char sep,
                                   byte... array)
      • toHex

        public static String toHex​(byte[] array,
                                   int offset,
                                   int len)
      • toHex

        public static String toHex​(byte[] array,
                                   int offset,
                                   int len,
                                   char sep)
      • appendHex

        public static <A extends Appendable> A appendHex​(A sb,
                                                         byte[] array,
                                                         int offset,
                                                         int len,
                                                         char sep)
                                                  throws IOException
        Throws:
        IOException
      • decodeHex

        public static byte[] decodeHex​(char separator,
                                       CharSequence csq,
                                       int start,
                                       int end)
        Parameters:
        separator - The separator between the HEX values - may be EMPTY_HEX_SEPARATOR
        csq - The CharSequence containing the HEX encoded bytes
        start - Start offset of the HEX sequence (inclusive)
        end - End offset of the HEX sequence (exclusive)
        Returns:
        The decoded bytes
        Throws:
        IllegalArgumentException - If invalid HEX sequence length
        NumberFormatException - If invalid HEX characters found
      • readInt

        public static int readInt​(InputStream input,
                                  byte[] buf,
                                  int offset,
                                  int len)
                           throws IOException
        Read a 32-bit value in network order
        Parameters:
        input - The InputStream
        buf - Work buffer to use
        offset - Offset in buffer to us
        len - Available length - must have at least 4 bytes available
        Returns:
        The read 32-bit value
        Throws:
        IOException - If failed to read 4 bytes or not enough room in work buffer
        See Also:
        readUInt(InputStream, byte[], int, int)
      • readUInt

        public static long readUInt​(InputStream input,
                                    byte[] buf,
                                    int offset,
                                    int len)
                             throws IOException
        Read a 32-bit value in network order
        Parameters:
        input - The InputStream
        buf - Work buffer to use
        offset - Offset in buffer to us
        len - Available length - must have at least 4 bytes available
        Returns:
        The read 32-bit value
        Throws:
        IOException - If failed to read 4 bytes or not enough room in work buffer
        See Also:
        getUInt(byte[], int, int)
      • getUInt

        public static long getUInt​(byte... buf)
        Parameters:
        buf - A buffer holding a 32-bit unsigned integer in big endian format. Note: if more than 4 bytes are available, then only the first 4 bytes in the buffer will be used
        Returns:
        The result as a long whose 32 high-order bits are zero
        See Also:
        getUInt(byte[], int, int)
      • getUInt

        public static long getUInt​(byte[] buf,
                                   int off,
                                   int len)
        Parameters:
        buf - A buffer holding a 32-bit unsigned integer in big endian format.
        off - The offset of the data in the buffer
        len - The available data length. Note: if more than 4 bytes are available, then only the first 4 bytes in the buffer will be used (starting at the specified offset)
        Returns:
        The result as a long whose 32 high-order bits are zero
      • writeInt

        public static void writeInt​(OutputStream output,
                                    int value,
                                    byte[] buf,
                                    int off,
                                    int len)
                             throws IOException
        Writes a 32-bit value in network order (i.e., MSB 1st)
        Parameters:
        output - The OutputStream to write the value
        value - The 32-bit value
        buf - A work buffer to use - must have enough space to contain 4 bytes
        off - The offset to write the value
        len - The available space
        Throws:
        IOException - If failed to write the value or work buffer too small
        See Also:
        writeUInt(OutputStream, long, byte[], int, int)
      • writeUInt

        public static void writeUInt​(OutputStream output,
                                     long value,
                                     byte[] buf,
                                     int off,
                                     int len)
                              throws IOException
        Writes a 32-bit value in network order (i.e., MSB 1st)
        Parameters:
        output - The OutputStream to write the value
        value - The 32-bit value
        buf - A work buffer to use - must have enough space to contain 4 bytes
        off - The offset to write the value
        len - The available space
        Throws:
        IOException - If failed to write the value or work buffer to small
        See Also:
        putUInt(long, byte[], int, int)
      • putUInt

        public static int putUInt​(long value,
                                  byte[] buf)
        Writes a 32-bit value in network order (i.e., MSB 1st)
        Parameters:
        value - The 32-bit value
        buf - The buffer
        Returns:
        The number of bytes used in the buffer
        Throws:
        IllegalArgumentException - if not enough space available
        See Also:
        putUInt(long, byte[], int, int)
      • putUInt

        public static int putUInt​(long value,
                                  byte[] buf,
                                  int off,
                                  int len)
        Writes a 32-bit value in network order (i.e., MSB 1st)
        Parameters:
        value - The 32-bit value
        buf - The buffer
        off - The offset to write the value
        len - The available space
        Returns:
        The number of bytes used in the buffer
        Throws:
        IllegalArgumentException - if not enough space available
      • equals

        public static boolean equals​(byte[] a1,
                                     byte[] a2)
      • equals

        public static boolean equals​(byte[] a1,
                                     int a1Offset,
                                     byte[] a2,
                                     int a2Offset,
                                     int length)
      • getNextPowerOf2

        public static int getNextPowerOf2​(int value)
      • updateLengthPlaceholder

        public static int updateLengthPlaceholder​(Buffer buffer,
                                                  int lenPos)
        Used for encodings where we don't know the data length before adding it to the buffer. The idea is to place a 32-bit "placeholder", encode the data and then return back to the placeholder and update the length. The method calculates the encoded data length, moves the write position to the specified placeholder position, updates the length value and then moves the write position it back to its original value.
        Parameters:
        buffer - The Buffer
        lenPos - The offset in the buffer where the length placeholder is to be update - Note: assumption is that the encoded data starts immediately after the placeholder
        Returns:
        The amount of data that has been encoded
      • updateLengthPlaceholder

        public static void updateLengthPlaceholder​(Buffer buffer,
                                                   int lenPos,
                                                   int dataLength)
        Updates a 32-bit "placeholder" location for data length - moves the write position to the specified placeholder position, updates the length value and then moves the write position it back to its original value.
        Parameters:
        buffer - The Buffer
        lenPos - The offset in the buffer where the length placeholder is to be update - Note: assumption is that the encoded data starts immediately after the placeholder
        dataLength - The length to update
      • clear

        public static <B extends Buffer> B clear​(B buffer)
        Type Parameters:
        B - The generic buffer type
        Parameters:
        buffer - A Buffer instance - ignored if null
        Returns:
        The same as the input instance
      • validateInt32Value

        public static long validateInt32Value​(long value,
                                              String message)
      • validateInt32Value

        public static long validateInt32Value​(long value,
                                              String format,
                                              Object arg)
      • validateInt32Value

        public static long validateInt32Value​(long value,
                                              String format,
                                              Object... args)
      • isValidInt32Value

        public static boolean isValidInt32Value​(long value)
      • validateUint32Value

        public static long validateUint32Value​(long value,
                                               String message)
      • validateUint32Value

        public static long validateUint32Value​(long value,
                                               String format,
                                               Object arg)
      • validateUint32Value

        public static long validateUint32Value​(long value,
                                               String format,
                                               Object... args)
      • isValidUint32Value

        public static boolean isValidUint32Value​(long value)