Class BufferUtils

    • Field Detail

      • DEFAULT_HEXDUMP_LEVEL

        public static final Level DEFAULT_HEXDUMP_LEVEL
      • DEFAULT_BUFFER_GROWTH_FACTOR

        public static final IntUnaryOperator DEFAULT_BUFFER_GROWTH_FACTOR
      • MAX_UINT32_VALUE

        public static final long MAX_UINT32_VALUE
        Maximum value of a uint32 field
        See Also:
        Constant Field Values
      • MAX_UINT8_VALUE

        public static final int MAX_UINT8_VALUE
        Maximum value of a uint8 field
        See Also:
        Constant Field Values
    • 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
      • getLong

        public static long getLong​(byte[] buf,
                                   int off,
                                   int len)
      • fromMPIntBytes

        public static BigInteger fromMPIntBytes​(byte[] mpInt)
      • 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
      • putLong

        public static int putLong​(long value,
                                  byte[] buf,
                                  int off,
                                  int len)
      • equals

        public static boolean equals​(byte[] a1,
                                     byte[] a2)
        Compares the contents of 2 arrays of bytes - Note: do not use it to execute security related comparisons (e.g. MACs) since the method leaks timing information. Use Mac#equals method instead.
        Parameters:
        a1 - 1st array
        a2 - 2nd array
        Returns:
        true if all bytes in the compared arrays are equal
      • equals

        public static boolean equals​(byte[] a1,
                                     int a1Offset,
                                     byte[] a2,
                                     int a2Offset,
                                     int length)
        Compares the contents of 2 arrays of bytes - Note: do not use it to execute security related comparisons (e.g. MACs) since the method leaks timing information. Use Mac#equals method instead.
        Parameters:
        a1 - 1st array
        a1Offset - Offset to start comparing in 1st array
        a2 - 2nd array
        a2Offset - Offset to start comparing in 2nd array
        length - Number of bytes to compare
        Returns:
        true if all bytes in the compared arrays are equal when compared from the specified offsets and up to specified 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)