Package com.apple.foundationdb.tuple

Class ByteArrayUtil

  • public class ByteArrayUtil
extends java.lang.Object
    Utility functions for operating on byte arrays. Although built for the FoundationDB tuple layer, some functions may be useful otherwise, such as use of printable(byte[]) for debugging non-text keys and values.

    • Field Summary

      Fields 
      Modifier and Type Field Description
      static byte[] EMPTY_BYTES
      A zero-length byte array.

    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method Description
      static java.util.Comparator<byte[]> comparator()  
      static int compareTo​(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2, int length2)
      Lexicographically compare two byte arrays.
      static int compareUnsigned​(byte[] l, byte[] r)
      Compare byte arrays for equality and ordering purposes.
      static long decodeInt​(byte[] src)
      Decode a little-endian encoded long integer from an 8-byte array.
      static byte[] encodeInt​(long i)
      Encode an 64-bit integer (long) into a byte array.
      static byte[] interludeJoin​(byte[] interlude, byte[][] parts)
      Joins a set of byte arrays into a larger array.
      static byte[] join​(byte[]... parts)
      Joins a variable number of byte arrays into one larger array.
      static byte[] join​(byte[] interlude, java.util.List<byte[]> parts)
      Joins a set of byte arrays into a larger array.
      static byte[] keyAfter​(byte[] key)
      Computes the key that would sort immediately after key.
      static java.lang.String printable​(byte[] val)
      Gets a human readable version of a byte array.
      static byte[] replace​(byte[] src, byte[] pattern, byte[] replacement)
      Replaces occurrences of a pattern in a byte array.
      static byte[] replace​(byte[] src, int offset, int length, byte[] pattern, byte[] replacement)
      Replaces occurrences of a pattern in a byte array.
      static java.util.List<byte[]> split​(byte[] src, byte[] delimiter)
      Splits a byte array at each occurrence of a pattern.
      static java.util.List<byte[]> split​(byte[] src, int offset, int length, byte[] delimiter)
      Splits a byte array at each occurrence of a pattern.
      static boolean startsWith​(byte[] array, byte[] prefix)
      Check if a byte array starts with another byte array.
      static byte[] strinc​(byte[] key)
      Computes the first key that would sort outside the range prefixed by key.

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • Field Detail

      • EMPTY_BYTES

        public static final byte[] EMPTY_BYTES
        A zero-length byte array.

    • Method Detail

      • join

        public static byte[] join​(byte[] interlude,
                          java.util.List<byte[]> parts)
        Joins a set of byte arrays into a larger array. The interlude is placed between each of the elements, but not at the beginning or end. In the case that the list is empty or null, a zero-length byte array will be returned.
        Parameters:
        interlude - can be null or zero length. Placed internally between concatenated elements.
        parts - the pieces to be joined. May be null, but does not allow for elements in the list to be null.
        Returns:
        a newly created concatenation of the input

      • interludeJoin

        public static byte[] interludeJoin​(byte[] interlude,
                                   byte[][] parts)
        Joins a set of byte arrays into a larger array. The interlude is placed between each of the elements, but not at the beginning or end. In the case that the list is empty or null, a zero-length byte array will be returned.
        Parameters:
        interlude - can be null or zero length. Placed internally between concatenated elements.
        parts - the pieces to be joined. May be null, but does not allow for elements in the array to be null.
        Returns:
        a newly created concatenation of the input

      • join

        public static byte[] join​(byte[]... parts)
        Joins a variable number of byte arrays into one larger array.
        Parameters:
        parts - the elements to join. null elements are not allowed.
        Returns:
        a newly created concatenation of the input

      • replace

        public static byte[] replace​(byte[] src,
                             byte[] pattern,
                             byte[] replacement)
        Replaces occurrences of a pattern in a byte array. Does not mutate the contents of the parameter src.
        Parameters:
        src - the source to search for pattern
        pattern - the pattern for which to search
        replacement - the sequence of bytes to replace pattern with.
        Returns:
        a newly created array where pattern replaced with replacement

      • replace

        public static byte[] replace​(byte[] src,
                             int offset,
                             int length,
                             byte[] pattern,
                             byte[] replacement)
        Replaces occurrences of a pattern in a byte array. Does not mutate the contents of the parameter src.
        Parameters:
        src - the source to search for pattern
        offset - the location in src at which to start the operation
        length - the number of bytes past offset to search for pattern
        pattern - the pattern for which to search
        replacement - the sequence of bytes to replace pattern with.
        Returns:
        a newly created array where pattern replaced with replacement

      • split

        public static java.util.List<byte[]> split​(byte[] src,
                                           byte[] delimiter)
        Splits a byte array at each occurrence of a pattern. If the pattern is found at the beginning or end of the array the result will have a leading or trailing zero-length array. The delimiter is not included in the output array. Does not mutate the contents the source array.
        Parameters:
        src - the array to split
        delimiter - the byte pattern on which to split
        Returns:
        a list of byte arrays from src now not containing delimiter

      • split

        public static java.util.List<byte[]> split​(byte[] src,
                                           int offset,
                                           int length,
                                           byte[] delimiter)
        Splits a byte array at each occurrence of a pattern. If the pattern is found at the beginning or end of the array the result will have a leading or trailing zero-length array. The delimiter is not included in the output array. Does not mutate the contents the source array.
        Parameters:
        src - the array to split
        offset - the location in the array at which to start the operation
        length - the number of bytes to search, must not extend past the end of src
        delimiter - the byte pattern on which to split
        Returns:
        a list of byte arrays from src now not containing delimiter

      • compareUnsigned

        public static int compareUnsigned​(byte[] l,
                                  byte[] r)
        Compare byte arrays for equality and ordering purposes. Elements in the array are interpreted and compared as unsigned bytes. Neither parameter may be null.
        Parameters:
        l - byte array on the left-hand side of the inequality
        r - byte array on the right-hand side of the inequality
        Returns:
        return -1, 0, or 1 if l is less than, equal to, or greater than r.

      • comparator

        public static java.util.Comparator<byte[]> comparator()
        Returns:
        a Comparator instance which can be used for Java-level sorting of byte arrays.

      • startsWith

        public static boolean startsWith​(byte[] array,
                                 byte[] prefix)
        Check if a byte array starts with another byte array.
        Parameters:
        array - the source byte array
        prefix - the byte array that we are checking if src starts with.
        Returns:
        true if array starts with prefix

      • strinc

        public static byte[] strinc​(byte[] key)
        Computes the first key that would sort outside the range prefixed by key. key must be non-null, and contain at least some character this is not \xFF (255).
        Parameters:
        key - prefix key
        Returns:
        a newly created byte array

      • keyAfter

        public static byte[] keyAfter​(byte[] key)
        Computes the key that would sort immediately after key. key must be non-null.
        Parameters:
        key - byte array for which next key is to be computed
        Returns:
        a newly created byte array that would sort immediately after key

      • decodeInt

        public static long decodeInt​(byte[] src)
        Decode a little-endian encoded long integer from an 8-byte array.
        Parameters:
        src - the non-null, 8-element byte array from which to decode
        Returns:
        a decoded 64-bit integer

      • printable

        public static java.lang.String printable​(byte[] val)
        Gets a human readable version of a byte array. The bytes that correspond with ASCII printable characters [32-127) are passed through. Other bytes are replaced with \x followed by a two character zero-padded hex code for the byte.
        Parameters:
        val - the byte array for which to create a human readable form
        Returns:
        a modification of the byte array with unprintable characters replaced.

      • compareTo

        public static int compareTo​(byte[] buffer1,
                            int offset1,
                            int length1,
                            byte[] buffer2,
                            int offset2,
                            int length2)
        Lexicographically compare two byte arrays.
        Parameters:
        buffer1 - left operand, expected to not be null
        buffer2 - right operand, expected to not be null
        offset1 - Where to start comparing in the left buffer, expected to be >= 0
        offset2 - Where to start comparing in the right buffer, expected to be >= 0
        length1 - How much to compare from the left buffer, expected to be >= 0
        length2 - How much to compare from the right buffer, expected to be >= 0
        Returns:
        0 if equal, < 0 if left is less than right, etc.