co.cask.common
Class Bytes

java.lang.Object
  co.cask.common.Bytes

public class Bytes
extends Object

Utility class that handles byte arrays, conversions to/from other types, comparisons, hash code generation, manufacturing keys for HashMaps or HashSets, etc.

Nested Class Summary

static class

Bytes.ByteArrayComparator Byte array comparator class.

Field Summary

static Comparator<byte[]>	BYTES_COMPARATOR Pass this to TreeMaps where byte [] are keys.
static byte[]	EMPTY_BYTE_ARRAY Byte array of size zero.
static int	SIZEOF_BOOLEAN Size of boolean in bytes.
static int	SIZEOF_BYTE Size of byte in bytes.
static int	SIZEOF_CHAR Size of char in bytes.
static int	SIZEOF_DOUBLE Size of double in bytes.
static int	SIZEOF_FLOAT Size of float in bytes.
static int	SIZEOF_INT Size of int in bytes.
static int	SIZEOF_LONG Size of long in bytes.
static int	SIZEOF_SHORT Size of short in bytes.
static String	UTF8_ENCODING When we encode strings, we always specify UTF8 encoding.

Constructor Summary

Bytes()

Method Summary

static byte[]	add(byte[] a, byte[] b) Concatenate two byte arrays.
static byte[]	add(byte[] a, byte[] b, byte[] c) Concatenate three byte arrays.
static int	compareTo(byte[] left, byte[] right) Lexicographically compare two arrays.
static int	compareTo(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2, int length2) Lexicographically compare two arrays.
static byte[]	concat(byte[]... arrays) Returns the values from each provided array combined into a single array.
static boolean	equals(byte[] left, byte[] right) Checks two byte arrays for equality.
static boolean	equals(byte[] left, int leftOffset, int leftLen, byte[] right, int rightOffset, int rightLen) Checks segments of two byte arrays for equality.
static byte[]	getBytes(ByteBuffer buf) This method will get a sequence of bytes from pos -> limit, but will restore pos after.
static int	hashBytes(byte[] bytes, int length) Compute hash for binary data.
static int	hashBytes(byte[] bytes, int offset, int length) Compute hash for binary data.
static int	hashCode(byte[] b) Compute hash for binary data.
static int	hashCode(byte[] b, int length) Compute hash for binary data.
static int	hashCode(byte[] bytes, int offset, int length)
static byte[]	head(byte[] a, int length) Returns first length bytes from byte array.
static <T> NavigableMap<byte[],T>	immutableSortedMapOf(byte[] key, T value) Creates immutable sorted map with one entry with given key and value.
static <T> NavigableMap<byte[],T>	immutableSortedMapOf(byte[] key1, T value1, byte[] key2, T value2) Creates immutable sorted map with two entries with given keys and values.
static byte[]	incrementBytes(byte[] value, long amount) Bytewise binary increment/deincrement of long contained in byte array on given amount.
static Iterable<byte[]>	iterateOnSplits(byte[] a, byte[] b, boolean inclusive, int num) Iterate over keys within the passed range.
static Iterable<byte[]>	iterateOnSplits(byte[] a, byte[] b, int num) Iterate over keys within the passed range, splitting at an [a,b) boundary.
static Integer	mapKey(byte[] b) Returns a hash of a byte array as an Integer that can be used as key in Maps.
static Integer	mapKey(byte[] b, int length) Returns a hash of a byte array segment as an Integer that can be used as key in Maps.
static byte[]	padHead(byte[] a, int length) Return a byte array with value in a plus length prepended 0 bytes.
static byte[]	padTail(byte[] a, int length) Return a byte array with value in a plus length appended 0 bytes.
static int	putBigDecimal(byte[] bytes, int offset, BigDecimal val) Put a BigDecimal value out to the specified byte array position.
static int	putByte(byte[] bytes, int offset, byte b) Write a single byte out to the specified byte array position.
static int	putBytes(byte[] tgtBytes, int tgtOffset, byte[] srcBytes, int srcOffset, int srcLength) Put bytes at the specified byte array position.
static int	putDouble(byte[] bytes, int offset, double d) Put a double value out to the specified byte array position.
static int	putFloat(byte[] bytes, int offset, float f) Put a float value out to the specified byte array position.
static int	putInt(byte[] bytes, int offset, int val) Put an int value out to the specified byte array position.
static int	putLong(byte[] bytes, int offset, long val) Put a long value out to the specified byte array position.
static int	putShort(byte[] bytes, int offset, short val) Put a short value out to the specified byte array position.
static byte[][]	split(byte[] a, byte[] b, boolean inclusive, int num) Split passed range.
static byte[][]	split(byte[] a, byte[] b, int num) Split passed range.
static boolean	startsWith(byte[] bytes, byte[] prefix) Return true if the byte array on the right is a prefix of the byte array on the left.
static byte[]	stopKeyForPrefix(byte[] prefix) Returns the given prefix, incremented by one, in the form that will be suitable for prefix matching.
static byte[]	tail(byte[] a, int length) Returns last length bytes from byte array.
static BigDecimal	toBigDecimal(byte[] bytes) Converts a byte array to a BigDecimal.
static BigDecimal	toBigDecimal(byte[] bytes, int offset, int length) Converts a byte array to a BigDecimal value.
static byte	toBinaryFromHex(byte ch) Takes a ASCII digit in the range A-F0-9 and returns the corresponding integer/ordinal value.
static boolean	toBoolean(byte[] b) Reverses toBytes(boolean).
static byte[][]	toByteArrays(byte[] column) Returns an array of byte arrays where first and only entry is.
static byte[][]	toByteArrays(String column) Returns an array of byte arrays where first and only entry is.
static byte[][]	toByteArrays(String[] t) Returns an array of byte arrays made from passed array of Text.
static byte[]	toBytes(BigDecimal val) Convert a BigDecimal value to a byte array.
static byte[]	toBytes(boolean b) Convert a boolean to a byte array.
static byte[]	toBytes(ByteBuffer bb) Returns a new byte array, copied from the passed ByteBuffer.
static byte[]	toBytes(double d) Serialize a double as the IEEE 754 double format output.
static byte[]	toBytes(float f)
static byte[]	toBytes(int val) Convert an int value to a byte array.
static byte[]	toBytes(long val) Convert a long value to a byte array using big-endian.
static byte[]	toBytes(short val) Convert a short value to a byte array of SIZEOF_SHORT bytes long.
static byte[]	toBytes(String s) Converts a string to a UTF-8 byte array.
static byte[]	toBytesBinary(String in)
static double	toDouble(byte[] bytes) Return double made from passed bytes.
static double	toDouble(byte[] bytes, int offset) Return double made from passed bytes.
static float	toFloat(byte[] bytes) Presumes float encoded as IEEE 754 floating-point "single format".
static float	toFloat(byte[] bytes, int offset) Presumes float encoded as IEEE 754 floating-point "single format".
static String	toHexString(byte[] bytes) Returns a string containing each byte, in order, as a two-digit unsigned hexadecimal number in lower case.
static int	toInt(byte[] bytes) Converts a byte array to an int value.
static int	toInt(byte[] bytes, int offset) Converts a byte array to an int value.
static int	toInt(byte[] bytes, int offset, int length) Converts a byte array to an int value.
static long	toLong(byte[] bytes) Converts a byte array to a long value.
static long	toLong(byte[] bytes, int offset) Converts a byte array to a long value.
static long	toLong(byte[] bytes, int offset, int length) Converts a byte array to a long value.
static short	toShort(byte[] bytes) Converts a byte array to a short value.
static short	toShort(byte[] bytes, int offset) Converts a byte array to a short value.
static short	toShort(byte[] bytes, int offset, int length) Converts a byte array to a short value.
static String	toString(byte[] b) This method will convert utf8 encoded bytes into a string.
static String	toString(byte[] b, int off, int len) This method will convert utf8 encoded bytes into a string.
static String	toString(byte[] b1, String sep, byte[] b2) Joins two byte arrays together using a separator.
static String	toString(ByteBuffer buf) This method will convert the remaining bytes of a UTF8 encoded byte buffer into a string.
static String	toStringBinary(byte[] b) Write a printable representation of a byte array.
static String	toStringBinary(byte[] b, int off, int len) Write a printable representation of a byte array.
static String	toStringBinary(ByteBuffer buf) Converts the given byte buffer, from its array offset to its limit, to a string.
static void	writeStringFixedSize(DataOutput out, String s, int size) Writes a string as a fixed-size field, padded with zeros.

Methods inherited from class java.lang.Object

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

Field Detail

SIZEOF_BOOLEAN

public static final int SIZEOF_BOOLEAN

Size of boolean in bytes.

See Also:

Constant Field Values

SIZEOF_BYTE

public static final int SIZEOF_BYTE

Size of byte in bytes.

See Also:

Constant Field Values

SIZEOF_CHAR

public static final int SIZEOF_CHAR

Size of char in bytes.

See Also:

Constant Field Values

SIZEOF_DOUBLE

public static final int SIZEOF_DOUBLE

Size of double in bytes.

See Also:

Constant Field Values

SIZEOF_FLOAT

public static final int SIZEOF_FLOAT

Size of float in bytes.

See Also:

Constant Field Values

SIZEOF_INT

public static final int SIZEOF_INT

Size of int in bytes.

See Also:

Constant Field Values

SIZEOF_LONG

public static final int SIZEOF_LONG

Size of long in bytes.

See Also:

Constant Field Values

SIZEOF_SHORT

public static final int SIZEOF_SHORT

Size of short in bytes.

See Also:

Constant Field Values

BYTES_COMPARATOR

public static final Comparator<byte[]> BYTES_COMPARATOR

Pass this to TreeMaps where byte [] are keys.

UTF8_ENCODING

public static final String UTF8_ENCODING

When we encode strings, we always specify UTF8 encoding.

See Also:

Constant Field Values

EMPTY_BYTE_ARRAY

public static final byte[] EMPTY_BYTE_ARRAY

Byte array of size zero.

Constructor Detail

Bytes

public Bytes()

Method Detail

putBytes

public static int putBytes(byte[] tgtBytes,
                           int tgtOffset,
                           byte[] srcBytes,
                           int srcOffset,
                           int srcLength)

Put bytes at the specified byte array position.

Parameters:

tgtBytes - the byte array

tgtOffset - position in the array

srcBytes - array to write out

srcOffset - source offset

srcLength - source length

Returns:

incremented offset

putByte

public static int putByte(byte[] bytes,
                          int offset,
                          byte b)

Write a single byte out to the specified byte array position.

Parameters:

bytes - the byte array

offset - position in the array

b - byte to write out

Returns:

incremented offset

toBytes

public static byte[] toBytes(ByteBuffer bb)

Returns a new byte array, copied from the passed ByteBuffer.

Parameters:

bb - A ByteBuffer

Returns:

the byte array

toString

public static String toString(byte[] b)

This method will convert utf8 encoded bytes into a string. If an UnsupportedEncodingException occurs, this method will eat it and return null instead.

Parameters:

b - Presumed UTF-8 encoded byte array.

Returns:

String made from b

toString

public static String toString(byte[] b1,
                              String sep,
                              byte[] b2)

Joins two byte arrays together using a separator.

Parameters:

b1 - The first byte array.

sep - The separator to use.

b2 - The second byte array.

toString

public static String toString(byte[] b,
                              int off,
                              int len)

This method will convert utf8 encoded bytes into a string. If an UnsupportedEncodingException occurs, this method will eat it and return null instead.

Parameters:

b - Presumed UTF-8 encoded byte array.

off - offset into array

len - length of utf-8 sequence

Returns:

String made from b or null

toString

public static String toString(ByteBuffer buf)

This method will convert the remaining bytes of a UTF8 encoded byte buffer into a string.

Parameters:

buf - Presumed UTF-8 encoded byte buffer.

Returns:

String made from buf or null

toStringBinary

public static String toStringBinary(byte[] b)

Write a printable representation of a byte array.

Parameters:

b - byte array

Returns:

string

See Also:

toStringBinary(byte[], int, int)

toHexString

public static String toHexString(byte[] bytes)

Returns a string containing each byte, in order, as a two-digit unsigned hexadecimal number in lower case.

toStringBinary

public static String toStringBinary(ByteBuffer buf)

Converts the given byte buffer, from its array offset to its limit, to a string. The position and the mark are ignored.

Parameters:

buf - a byte buffer

Returns:

a string representation of the buffer's binary contents

toStringBinary

public static String toStringBinary(byte[] b,
                                    int off,
                                    int len)

Write a printable representation of a byte array. Non-printable characters are hex escaped in the format \\x%02X, eg: \x00 \x05 etc

Parameters:

b - array to write out

off - offset to start at

len - length to write

Returns:

string output

toBinaryFromHex

public static byte toBinaryFromHex(byte ch)

Takes a ASCII digit in the range A-F0-9 and returns the corresponding integer/ordinal value.

Parameters:

ch - The hex digit.

Returns:

The converted hex value as a byte.

toBytesBinary

public static byte[] toBytesBinary(String in)

toBytes

public static byte[] toBytes(String s)

Converts a string to a UTF-8 byte array.

Parameters:

s - string

Returns:

the byte array

toBytes

public static byte[] toBytes(boolean b)

Convert a boolean to a byte array. True becomes -1 and false becomes 0.

Parameters:

b - value

Returns:

b encoded in a byte array.

toBoolean

public static boolean toBoolean(byte[] b)

Reverses toBytes(boolean).

Parameters:

b - array

Returns:

True or false.

toBytes

public static byte[] toBytes(long val)

Convert a long value to a byte array using big-endian.

Parameters:

val - value to convert

Returns:

the byte array

toLong

public static long toLong(byte[] bytes)

Converts a byte array to a long value. Reverses toBytes(long)

Parameters:

bytes - array

Returns:

the long value

toLong

public static long toLong(byte[] bytes,
                          int offset)

Converts a byte array to a long value. Assumes there will be SIZEOF_LONG bytes available.

Parameters:

bytes - bytes

offset - offset

Returns:

the long value

toLong

public static long toLong(byte[] bytes,
                          int offset,
                          int length)

Converts a byte array to a long value.

Parameters:

bytes - array of bytes

offset - offset into array

length - length of data (must be SIZEOF_LONG)

Returns:

the long value

Throws:

IllegalArgumentException - if length is not SIZEOF_LONG or if there's not enough room in the array at the offset indicated.

putLong

public static int putLong(byte[] bytes,
                          int offset,
                          long val)

Put a long value out to the specified byte array position.

Parameters:

bytes - the byte array

offset - position in the array

val - long to write out

Returns:

incremented offset

Throws:

IllegalArgumentException - if the byte array given doesn't have enough room at the offset specified.

toFloat

public static float toFloat(byte[] bytes)

Presumes float encoded as IEEE 754 floating-point "single format".

Parameters:

bytes - byte array

Returns:

Float made from passed byte array.

toFloat

public static float toFloat(byte[] bytes,
                            int offset)

Presumes float encoded as IEEE 754 floating-point "single format".

Parameters:

bytes - array to convert

offset - offset into array

Returns:

Float made from passed byte array.

putFloat

public static int putFloat(byte[] bytes,
                           int offset,
                           float f)

Put a float value out to the specified byte array position.

Parameters:

bytes - byte array

offset - offset to write to

f - float value

Returns:

New offset in bytes

toBytes

public static byte[] toBytes(float f)

Parameters:

f - float value

Returns:

the float represented as byte []

toDouble

public static double toDouble(byte[] bytes)

Return double made from passed bytes.

Parameters:

bytes - byte array

Returns:

Return double made from passed bytes.

toDouble

public static double toDouble(byte[] bytes,
                              int offset)

Return double made from passed bytes.

Parameters:

bytes - byte array

offset - offset where double is

Returns:

Return double made from passed bytes.

putDouble

public static int putDouble(byte[] bytes,
                            int offset,
                            double d)

Put a double value out to the specified byte array position.

Parameters:

bytes - byte array

offset - offset to write to

d - value

Returns:

New offset into array bytes

toBytes

public static byte[] toBytes(double d)

Serialize a double as the IEEE 754 double format output. The resultant array will be 8 bytes long.

Parameters:

d - value

Returns:

the double represented as byte []

toBytes

public static byte[] toBytes(int val)

Convert an int value to a byte array.

Parameters:

val - value

Returns:

the byte array

toInt

public static int toInt(byte[] bytes)

Converts a byte array to an int value.

Parameters:

bytes - byte array

Returns:

the int value

toInt

public static int toInt(byte[] bytes,
                        int offset)

Converts a byte array to an int value.

Parameters:

bytes - byte array

offset - offset into array

Returns:

the int value

toInt

public static int toInt(byte[] bytes,
                        int offset,
                        int length)

Converts a byte array to an int value.

Parameters:

bytes - byte array

offset - offset into array

length - length of int (has to be SIZEOF_INT)

Returns:

the int value

Throws:

IllegalArgumentException - if length is not SIZEOF_INT or if there's not enough room in the array at the offset indicated.

putInt

public static int putInt(byte[] bytes,
                         int offset,
                         int val)

Put an int value out to the specified byte array position.

Parameters:

bytes - the byte array

offset - position in the array

val - int to write out

Returns:

incremented offset

Throws:

IllegalArgumentException - if the byte array given doesn't have enough room at the offset specified.

toBytes

public static byte[] toBytes(short val)

Convert a short value to a byte array of SIZEOF_SHORT bytes long.

Parameters:

val - value

Returns:

the byte array

toShort

public static short toShort(byte[] bytes)

Converts a byte array to a short value.

Parameters:

bytes - byte array

Returns:

the short value

toShort

public static short toShort(byte[] bytes,
                            int offset)

Converts a byte array to a short value.

Parameters:

bytes - byte array

offset - offset into array

Returns:

the short value

toShort

public static short toShort(byte[] bytes,
                            int offset,
                            int length)

Converts a byte array to a short value.

Parameters:

bytes - byte array

offset - offset into array

length - length, has to be SIZEOF_SHORT

Returns:

the short value

Throws:

IllegalArgumentException - if length is not SIZEOF_SHORT or if there's not enough room in the array at the offset indicated.

getBytes

public static byte[] getBytes(ByteBuffer buf)

This method will get a sequence of bytes from pos -> limit, but will restore pos after.

Parameters:

buf -

Returns:

byte array

putShort

public static int putShort(byte[] bytes,
                           int offset,
                           short val)

Put a short value out to the specified byte array position.

Parameters:

bytes - the byte array

offset - position in the array

val - short to write out

Returns:

incremented offset

Throws:

IllegalArgumentException - if the byte array given doesn't have enough room at the offset specified.

toBytes

public static byte[] toBytes(BigDecimal val)

Convert a BigDecimal value to a byte array.

Parameters:

val -

Returns:

the byte array

toBigDecimal

public static BigDecimal toBigDecimal(byte[] bytes)

Converts a byte array to a BigDecimal.

Parameters:

bytes -

Returns:

the char value

toBigDecimal

public static BigDecimal toBigDecimal(byte[] bytes,
                                      int offset,
                                      int length)

Converts a byte array to a BigDecimal value.

Parameters:

bytes -

offset -

length -

Returns:

the char value

putBigDecimal

public static int putBigDecimal(byte[] bytes,
                                int offset,
                                BigDecimal val)

Put a BigDecimal value out to the specified byte array position.

Parameters:

bytes - the byte array

offset - position in the array

val - BigDecimal to write out

Returns:

incremented offset

compareTo

public static int compareTo(byte[] left,
                            byte[] right)

Lexicographically compare two arrays.

Parameters:

left - left operand

right - right operand

Returns:

0 if equal, < 0 if left is less than right, etc.

compareTo

public static int compareTo(byte[] buffer1,
                            int offset1,
                            int length1,
                            byte[] buffer2,
                            int offset2,
                            int length2)

Lexicographically compare two arrays.

Parameters:

buffer1 - left operand

buffer2 - right operand

offset1 - Where to start comparing in the left buffer

offset2 - Where to start comparing in the right buffer

length1 - How much to compare from the left buffer

length2 - How much to compare from the right buffer

Returns:

0 if equal, < 0 if left is less than right, etc.

equals

public static boolean equals(byte[] left,
                             byte[] right)

Checks two byte arrays for equality.

Parameters:

left - left operand

right - right operand

Returns:

True if equal

equals

public static boolean equals(byte[] left,
                             int leftOffset,
                             int leftLen,
                             byte[] right,
                             int rightOffset,
                             int rightLen)

Checks segments of two byte arrays for equality.

Parameters:

left - left operand

leftOffset - offset from which to start comparison

leftLen - length of left segment

right - right operand

rightOffset - offset from which to start comparison

rightLen - length of right segment

Returns:

True if two segments are equal

startsWith

public static boolean startsWith(byte[] bytes,
                                 byte[] prefix)

Return true if the byte array on the right is a prefix of the byte array on the left.

hashCode

public static int hashCode(byte[] b)

Compute hash for binary data.

Parameters:

b - bytes to hash

Returns:

Runs hashBytes(byte[], int) on the passed in array.

hashCode

public static int hashCode(byte[] b,
                           int length)

Compute hash for binary data.

Parameters:

b - value

length - length of the value

Returns:

Runs hashBytes(byte[], int) on the passed in array.

hashBytes

public static int hashBytes(byte[] bytes,
                            int offset,
                            int length)

Compute hash for binary data.

hashBytes

public static int hashBytes(byte[] bytes,
                            int length)

Compute hash for binary data.

mapKey

public static Integer mapKey(byte[] b)

Returns a hash of a byte array as an Integer that can be used as key in Maps.

Parameters:

b - bytes to hash

Returns:

A hash of b as an Integer that can be used as key in Maps.

mapKey

public static Integer mapKey(byte[] b,
                             int length)

Returns a hash of a byte array segment as an Integer that can be used as key in Maps.

Parameters:

b - bytes to hash

length - length to hash

Returns:

A hash of b as an Integer that can be used as key in Maps.

add

public static byte[] add(byte[] a,
                         byte[] b)

Concatenate two byte arrays.

Parameters:

a - lower half

b - upper half

Returns:

New array that has a in lower half and b in upper half.

add

public static byte[] add(byte[] a,
                         byte[] b,
                         byte[] c)

Concatenate three byte arrays.

Parameters:

a - first third

b - second third

c - third third

Returns:

New array made from a, b and c

concat

public static byte[] concat(byte[]... arrays)

Returns the values from each provided array combined into a single array. For example, concat(new byte[] {a, b}, new byte[] {}, new byte[] {c} returns the array {a, b, c}. This method is copied from google guava library.

Parameters:

arrays - zero or more byte arrays

Returns:

a single array containing all the values from the source arrays, in order

head

public static byte[] head(byte[] a,
                          int length)

Returns first length bytes from byte array.

Parameters:

a - array

length - amount of bytes to grab

Returns:

First length bytes from a

tail

public static byte[] tail(byte[] a,
                          int length)

Returns last length bytes from byte array.

Parameters:

a - array

length - amount of bytes to snarf

Returns:

Last length bytes from a

padHead

public static byte[] padHead(byte[] a,
                             int length)

Return a byte array with value in a plus length prepended 0 bytes.

Parameters:

a - array

length - new array size

Returns:

Value in a plus length prepended 0 bytes

padTail

public static byte[] padTail(byte[] a,
                             int length)

Return a byte array with value in a plus length appended 0 bytes.

Parameters:

a - array

length - new array size

Returns:

Value in a plus length appended 0 bytes

split

public static byte[][] split(byte[] a,
                             byte[] b,
                             int num)

Split passed range. Expensive operation relatively. Uses BigInteger math. Useful splitting ranges for MapReduce jobs.

Parameters:

a - Beginning of range

b - End of range

num - Number of times to split range. Pass 1 if you want to split the range in two; i.e. one split.

Returns:

Array of dividing values

split

public static byte[][] split(byte[] a,
                             byte[] b,
                             boolean inclusive,
                             int num)

Split passed range. Expensive operation relatively. Uses BigInteger math. Useful splitting ranges for MapReduce jobs.

Parameters:

a - Beginning of range

b - End of range

inclusive - Whether the end of range is prefix-inclusive or is considered an exclusive boundary. Automatic splits are generally exclusive and manual splits with an explicit range utilize an inclusive end of range.

num - Number of times to split range. Pass 1 if you want to split the range in two; i.e. one split.

Returns:

Array of dividing values

iterateOnSplits

public static Iterable<byte[]> iterateOnSplits(byte[] a,
                                               byte[] b,
                                               int num)

Iterate over keys within the passed range, splitting at an [a,b) boundary.

iterateOnSplits

public static Iterable<byte[]> iterateOnSplits(byte[] a,
                                               byte[] b,
                                               boolean inclusive,
                                               int num)

Iterate over keys within the passed range.

hashCode

public static int hashCode(byte[] bytes,
                           int offset,
                           int length)

Parameters:

bytes - array to hash

offset - offset to start from

length - length to hash

toByteArrays

public static byte[][] toByteArrays(String[] t)

Returns an array of byte arrays made from passed array of Text.

Parameters:

t - operands

Returns:

Array of byte arrays made from passed array of Text

toByteArrays

public static byte[][] toByteArrays(String column)

Returns an array of byte arrays where first and only entry is. column

Parameters:

column - operand

Returns:

An array of byte arrays where first and only entry is column

toByteArrays

public static byte[][] toByteArrays(byte[] column)

Returns an array of byte arrays where first and only entry is. column

Parameters:

column - operand

Returns:

An array of byte arrays where first and only entry is column

incrementBytes

public static byte[] incrementBytes(byte[] value,
                                    long amount)

Bytewise binary increment/deincrement of long contained in byte array on given amount.

Parameters:

value - - array of bytes containing long (length <= SIZEOF_LONG)

amount - value will be incremented on (deincremented if negative)

Returns:

array of bytes containing incremented long (length == SIZEOF_LONG)

writeStringFixedSize

public static void writeStringFixedSize(DataOutput out,
                                        String s,
                                        int size)
                                 throws IOException

Writes a string as a fixed-size field, padded with zeros.

Throws:

IOException

stopKeyForPrefix

@Nullable
public static byte[] stopKeyForPrefix(byte[] prefix)

Returns the given prefix, incremented by one, in the form that will be suitable for prefix matching.

Parameters:

prefix - the prefix to increment for the stop key

Returns:

the stop key to use (may be null if the prefix cannot be incremented)

immutableSortedMapOf

public static <T> NavigableMap<byte[],T> immutableSortedMapOf(byte[] key,
                                                              T value)

Creates immutable sorted map with one entry with given key and value.

Parameters:

key - key of the entry

value - value of the entry

Returns:

instance of NavigableMap

immutableSortedMapOf

public static <T> NavigableMap<byte[],T> immutableSortedMapOf(byte[] key1,
                                                              T value1,
                                                              byte[] key2,
                                                              T value2)

Creates immutable sorted map with two entries with given keys and values.

Parameters:

key1 - key of the first entry

value1 - value of the first entry

key2 - key of the second entry

value2 - value of the second entry

Returns:

instance of NavigableMap