net.openhft.hashing

Class LongTupleHashFunction

java.lang.Object

net.openhft.hashing.LongTupleHashFunction

All Implemented Interfaces:

Serializable

@ParametersAreNonnullByDefault
public abstract class LongTupleHashFunction
extends Object
implements Serializable

Tuple hash function producing more than 64-bit hash code into a result array of type long[] from any byte sequences. See LongHashFunction for the definition of byte sequence semantics and ByteOrder requirements for implementations.

Every LongHashFunction hash method has two corresponding ones in this class for different allocation strategies:

• void hash(input..., long[] result)

  will store the hash results in array result[0 .. newResultArray().length-1], and throws exceptions when result == null or the length of the array is less than newResultArray().length. newResultArray() method should always be used to create resuable result arrays to avoid exceptions. See hashLong(long, long[]).

  Warning: A single allocation occurs only at the begining of some runtime scope, so it could be called Almost-Zero-Allocation-Hashing.

• long[] hash(input...)

  will allocate and return an array containing the results.

  Warning: Methods with this form always perform exactly one allocation for the result array in each invocation, that is One-Allocation-Hashing. So prefer the first form as much as possible.

Subclassing

To implement a specific hash function algorithm resulting more than 64 bits results, this class should be subclassed. Only methods with resued result array that accept single primitives, hashVoid(long[]) and hash(Object, Access, long, long, long[]) should be implemented; other have default implementations which in the end delegate to hash(Object, Access, long, long, long[]) abstract method.

The bitsLength() method should also be implemented, returning the actual number of bits in the result array. The bits length must be greater than 64, otherwise just use the LongHashFunction interface. And the length should also be a positive multiple of 8.

Also see LongHashFunction for additional information about subclassing andd access.

See Also:

LongHashFunction, Serialized Form

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	LongTupleHashFunction() Constructor for use in subclasses.

Method Summary

Modifier and Type	Method and Description
abstract int	bitsLength() Returns the actual number of bits in a result array; a positive multiple of 8.
<T> long[]	hash(T input, Access<T> access, long off, long len) The result array is allocated on the fly, and no exceptions will be thrown.
abstract <T> void	hash(T input, Access<T> access, long off, long len, long[] result) Computes the hash code for the given input object starting from the given offset, and store the results in the result array.
long[]	hashBoolean(boolean input) The result array is allocated on the fly, and no exceptions will be thrown.
void	hashBoolean(boolean input, long[] result) Shortcut for hashBooleans(new boolean[] {input}, result).
long[]	hashBooleans(boolean[] input) The result array is allocated on the fly, and no exceptions will be thrown.
long[]	hashBooleans(boolean[] input, int off, int len) The result array is allocated on the fly.
void	hashBooleans(boolean[] input, int off, int len, long[] result) Computes the hash code for the specified subsequence of the given boolean array, and store the results in the result array.
void	hashBooleans(boolean[] input, long[] result) Shortcut for hashBooleans(input, 0, input.length, result).
long[]	hashByte(byte input) The result array is allocated on the fly, and no exceptions will be thrown.
abstract void	hashByte(byte input, long[] result) Computes the hash code for the given byte value, and store the results in the result array; this method is consistent with LongTupleHashFunction methods that accept sequences of bytes, assuming the input value is the first and only byte.
long[]	hashBytes(byte[] input) The result array is allocated on the fly, and no exceptions will be thrown.
long[]	hashBytes(byte[] input, int off, int len) The result array is allocated on the fly.
void	hashBytes(byte[] input, int off, int len, long[] result) Computes the hash code for the specified subsequence of the given byte array, and store the results in the result array.
void	hashBytes(byte[] input, long[] result) Shortcut for hashBytes(input, 0, input.length, result).
long[]	hashBytes(ByteBuffer input) The result array is allocated on the fly, and no exceptions will be thrown.
long[]	hashBytes(ByteBuffer input, int off, int len) The result array is allocated on the fly.
void	hashBytes(ByteBuffer input, int off, int len, long[] result) Computes the hash code for the specified subsequence of the given ByteBuffer, and store the results in the result array.
void	hashBytes(ByteBuffer input, long[] result) Shortcut for hashBytes(input, input.position(), input.remaining(), result).
long[]	hashChar(char input) The result array is allocated on the fly, and no exceptions will be thrown.
abstract void	hashChar(char input, long[] result) Computes the hash code for the given char value, and store the results in the result array; this method is consistent with LongTupleHashFunction methods that accept sequences of bytes, assuming the input value is interpreted in native byte order.
long[]	hashChars(char[] input) The result array is allocated on the fly, and no exceptions will be thrown.
long[]	hashChars(char[] input, int off, int len) The result array is allocated on the fly.
void	hashChars(char[] input, int off, int len, long[] result) Computes the hash code for bytes, as they lay in memory, of the specified subsequence of the given char array.
void	hashChars(char[] input, long[] result) Shortcut for hashChars(input, 0, input.length, result).
long[]	hashChars(String input) The result array is allocated on the fly, and no exceptions will be thrown.
long[]	hashChars(String input, int off, int len) The result array is allocated on the fly.
void	hashChars(String input, int off, int len, long[] result) Computes the hash code for bytes of the specified subsequence of the given String's underlying char array or byte array.
void	hashChars(String input, long[] result) Shortcut for hashChars(input, 0, input.length(), result).
<T extends CharSequence> long[]	hashChars(T input) The result array is allocated on the fly, and no exceptions will be thrown.
<T extends CharSequence> long[]	hashChars(T input, int off, int len) The result array is allocated on the fly.
<T extends CharSequence> void	hashChars(T input, int off, int len, long[] result) Computes the hash code for bytes of the specified subsequence of the given CharSequence's underlying char array.
<T extends CharSequence> void	hashChars(T input, long[] result) Shortcut for hashChars(input, 0, input.length(), result).
long[]	hashInt(int input) The result array is allocated on the fly, and no exceptions will be thrown.
abstract void	hashInt(int input, long[] result) Computes the hash code for the given int value, and store the results in the result array; this method is consistent with LongTupleHashFunction methods that accept sequences of bytes, assuming the input value is interpreted in native byte order.
long[]	hashInts(int[] input) The result array is allocated on the fly, and no exceptions will be thrown.
long[]	hashInts(int[] input, int off, int len) The result array is allocated on the fly.
void	hashInts(int[] input, int off, int len, long[] result) Computes the hash code for bytes, as they lay in memory, of the specified subsequence of the given int array.
void	hashInts(int[] input, long[] result) Shortcut for hashInts(input, 0, input.length, result).
long[]	hashLong(long input) The result array is allocated on the fly, and no exceptions will be thrown.
abstract void	hashLong(long input, long[] result) Computes the hash code for the given long value, and store the results in the result array; this method is consistent with LongTupleHashFunction methods that accept sequences of bytes, assuming the input value is interpreted in native byte order.
long[]	hashLongs(long[] input) The result array is allocated on the fly, and no exceptions will be thrown.
long[]	hashLongs(long[] input, int off, int len) The result array is allocated on the fly.
void	hashLongs(long[] input, int off, int len, long[] result) Computes the hash code for bytes, as they lay in memory, of the specified subsequence of the given long array.
void	hashLongs(long[] input, long[] result) Shortcut for hashLongs(input, 0, input.length, result).
long[]	hashMemory(long address, long len) The result array is allocated on the fly, and no exceptions will be thrown.
void	hashMemory(long address, long len, long[] result) Computes the hash code of bytes of the wild memory from the given address.
long[]	hashShort(short input) The result array is allocated on the fly, and no exceptions will be thrown.
abstract void	hashShort(short input, long[] result) Computes the hash code for the given short value, and store the results in the result array; this method is consistent with LongTupleHashFunction methods that accept sequences of bytes, assuming the input value is interpreted in native byte order.
long[]	hashShorts(short[] input) The result array is allocated on the fly, and no exceptions will be thrown.
long[]	hashShorts(short[] input, int off, int len) The result array is allocated on the fly.
void	hashShorts(short[] input, int off, int len, long[] result) Computes the hash code for bytes, as they lay in memory, of the specified subsequence of the given short array.
void	hashShorts(short[] input, long[] result) Shortcut for hashShorts(input, 0, input.length, result).
long[]	hashVoid() The result array is allocated on the fly, and no exceptions will be thrown.
abstract void	hashVoid(long[] result) Computes the hash code for the empty (zero-length) bytes sequence, and store the results in the result array.
static LongTupleHashFunction	murmur_3() Returns a 128-bit hash function implementing MurmurHash3 algorithm without seed values.
static LongTupleHashFunction	murmur_3(long seed) Returns a 128-bit hash function implementing MurmurHash3 algorithm with the given seed value.
long[]	newResultArray() Returns a new-allocated result array.
static LongTupleHashFunction	xx128() Returns a 128-bit hash function implementing XXH3 128bit algorithm without seed values (0 is used as default seed value).
static LongTupleHashFunction	xx128(long seed) Returns a hash function implementing XXH3 128bit algorithm with the given seed value.

Methods inherited from class java.lang.Object

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

Constructor Detail

LongTupleHashFunction

protected LongTupleHashFunction()

Constructor for use in subclasses.

Method Detail

murmur_3

@NotNull
public static LongTupleHashFunction murmur_3()

Returns a 128-bit hash function implementing MurmurHash3 algorithm without seed values. This implementation produces equal results for equal input on platforms with different ByteOrder, but is slower on big-endian platforms than on little-endian.

See Also:

murmur_3(long)

murmur_3

@NotNull
public static LongTupleHashFunction murmur_3(long seed)

Returns a 128-bit hash function implementing MurmurHash3 algorithm with the given seed value. This implementation produces equal results for equal input on platforms with different ByteOrder, but is slower on big-endian platforms than on little-endian.

See Also:

murmur_3()

xx128

@NotNull
public static LongTupleHashFunction xx128()

Returns a 128-bit hash function implementing XXH3 128bit algorithm without seed values (0 is used as default seed value). This implementation produces equal results for equal input on platforms with different ByteOrder, but is slower on big-endian platforms than on little-endian.

See Also:

xx128(long)

xx128

@NotNull
public static LongTupleHashFunction xx128(long seed)

Returns a hash function implementing XXH3 128bit algorithm with the given seed value. This implementation produces equal results for equal input on platforms with different ByteOrder, but is slower on big-endian platforms than on little-endian.

See Also:

xx128()

bitsLength

public abstract int bitsLength()

Returns the actual number of bits in a result array; a positive multiple of 8.

newResultArray

@NotNull
public long[] newResultArray()

Returns a new-allocated result array. If bitsLength() returns non-multiple of 64, the implementation of this method should round-up the length to a multiple of 64 for allocating the long array.

hashLong

public abstract void hashLong(long input,
                              long[] result)

Computes the hash code for the given long value, and store the results in the result array; this method is consistent with LongTupleHashFunction methods that accept sequences of bytes, assuming the input value is interpreted in native byte order. For example, the result of hashLong(v, result) call is identical to the result of hashLongs(new long[] {v}, result) call for any long value.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

hashLong

@NotNull
public long[] hashLong(long input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashLong(long, long[])

hashInt

public abstract void hashInt(int input,
                             long[] result)

Computes the hash code for the given int value, and store the results in the result array; this method is consistent with LongTupleHashFunction methods that accept sequences of bytes, assuming the input value is interpreted in native byte order. For example, the result of hashInt(v, result) call is identical to the result of hashInts(new int[] {v}, result) call for any int value.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

hashInt

@NotNull
public long[] hashInt(int input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashInt(int, long[])

hashShort

public abstract void hashShort(short input,
                               long[] result)

Computes the hash code for the given short value, and store the results in the result array; this method is consistent with LongTupleHashFunction methods that accept sequences of bytes, assuming the input value is interpreted in native byte order. For example, the result of hashShort(v, result) call is identical to the result of hashShorts(new short[] {v}, result) call for any short value.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

hashShort

@NotNull
public long[] hashShort(short input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashShort(short, long[])

hashChar

public abstract void hashChar(char input,
                              long[] result)

Computes the hash code for the given char value, and store the results in the result array; this method is consistent with LongTupleHashFunction methods that accept sequences of bytes, assuming the input value is interpreted in native byte order. For example, the result of hashChar(v, result) call is identical to the result of hashChars(new char[] {v}, result) call for any char value.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

hashChar

@NotNull
public long[] hashChar(char input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashChar(char, long[])

hashByte

public abstract void hashByte(byte input,
                              long[] result)

Computes the hash code for the given byte value, and store the results in the result array; this method is consistent with LongTupleHashFunction methods that accept sequences of bytes, assuming the input value is the first and only byte. For example, the result of hashByte(v, result) call is identical to the result of hashBytes(new byte[] {v}, result) call for any byte value.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

hashByte

@NotNull
public long[] hashByte(byte input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashByte(byte, long[])

hashVoid

public abstract void hashVoid(long[] result)

Computes the hash code for the empty (zero-length) bytes sequence, and store the results in the result array. For example, the result of hashVoid(result) call is identical to the result of hashBytes(new byte[0], result) call.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

hashVoid

@NotNull
public long[] hashVoid()

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashVoid(long[])

hash

public abstract <T> void hash(@Nullable
                              T input,
                              Access<T> access,
                              long off,
                              long len,
                              long[] result)

Computes the hash code for the given input object starting from the given offset, and store the results in the result array. The abstraction of input as ordered byte sequence and "offset within the input" is defined by the given access strategy.

This method doesn't promise to throw a RuntimeException if [off, off + len - 1] subsequence exceeds the bounds of the bytes sequence, defined by access strategy for the given input, so use this method with caution.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Type Parameters:

T - the type of the input

Parameters:

input - the object to read bytes from

access - access which defines the abstraction of the given input as ordered byte sequence

off - offset to the first byte of the subsequence to hash

len - length of the subsequence to hash

result - the container array for storing the hash results, should be alloced by newResultArray()

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

hash

@NotNull
public <T> long[] hash(@Nullable
                                T input,
                                Access<T> access,
                                long off,
                                long len)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hash(Object, Access, long, long, long[])

hashBoolean

public void hashBoolean(boolean input,
                        long[] result)

Shortcut for hashBooleans(new boolean[] {input}, result). Note that this is not necessarily equal to hashByte(input ? (byte) 1 : (byte) 0, result), because booleans could be stored differently in this JVM.

hashBoolean

@NotNull
public long[] hashBoolean(boolean input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashBoolean(boolean, long[])

hashBooleans

public void hashBooleans(boolean[] input,
                         long[] result)

Shortcut for hashBooleans(input, 0, input.length, result).

hashBooleans

@NotNull
public long[] hashBooleans(boolean[] input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashBooleans(boolean[], long[])

hashBooleans

public void hashBooleans(boolean[] input,
                         int off,
                         int len,
                         long[] result)

Computes the hash code for the specified subsequence of the given boolean array, and store the results in the result array.

Default implementation delegates to hash(Object, Access, long, long, long[]) method using unsafe Access.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Parameters:

input - the array to read data from

off - index of the first boolean in the subsequence to hash

len - length of the subsequence to hash

result - the container array for storing the hash results, should be alloced by newResultArray()

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

IllegalArgumentException - if off < 0 or off + len > input.length or len < 0

hashBooleans

@NotNull
public long[] hashBooleans(boolean[] input,
                                    int off,
                                    int len)

The result array is allocated on the fly.

See Also:

hashBooleans(boolean[], int, int, long[])

hashBytes

public void hashBytes(byte[] input,
                      long[] result)

Shortcut for hashBytes(input, 0, input.length, result).

hashBytes

@NotNull
public long[] hashBytes(byte[] input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashBytes(byte[], long[])

hashBytes

public void hashBytes(byte[] input,
                      int off,
                      int len,
                      long[] result)

Computes the hash code for the specified subsequence of the given byte array, and store the results in the result array.

Default implementation delegates to hash(Object, Access, long, long, long[]) method using unsafe Access.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Parameters:

input - the array to read data from

off - index of the first byte in the subsequence to hash

len - length of the subsequence to hash

result - the container array for storing the hash results, should be alloced by newResultArray()

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

IllegalArgumentException - if off < 0 or off + len > input.length or len < 0

hashBytes

@NotNull
public long[] hashBytes(byte[] input,
                                 int off,
                                 int len)

The result array is allocated on the fly.

See Also:

hashBytes(byte[], int, int, long[])

hashBytes

public void hashBytes(ByteBuffer input,
                      long[] result)

Shortcut for hashBytes(input, input.position(), input.remaining(), result).

hashBytes

@NotNull
public long[] hashBytes(ByteBuffer input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashBytes(ByteBuffer, long[])

hashBytes

public void hashBytes(ByteBuffer input,
                      int off,
                      int len,
                      long[] result)

Computes the hash code for the specified subsequence of the given ByteBuffer, and store the results in the result array.

This method doesn't alter the state (mark, position, limit or order) of the given ByteBuffer.

Default implementation delegates to hash(Object, Access, long, long, long[]) method using unsafe Access.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Parameters:

input - the buffer to read bytes from

off - index of the first byte in the subsequence to hash

len - length of the subsequence to hash

result - the container array for storing the hash results, should be alloced by newResultArray()

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

IllegalArgumentException - if off < 0 or off + len > input.length or len < 0

hashBytes

@NotNull
public long[] hashBytes(ByteBuffer input,
                                 int off,
                                 int len)

The result array is allocated on the fly.

See Also:

hashBytes(ByteBuffer, int, int, long[])

hashMemory

public void hashMemory(long address,
                       long len,
                       long[] result)

Computes the hash code of bytes of the wild memory from the given address. Use with caution.

Default implementation delegates to hash(Object, Access, long, long, long[]) method using unsafe Access.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Parameters:

address - the address of the first byte to hash

len - length of the byte sequence to hash

result - the container array for storing the hash results, should be alloced by newResultArray()

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

IllegalArgumentException - if off < 0 or off + len > input.length or len < 0

hashMemory

@NotNull
public long[] hashMemory(long address,
                                  long len)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashMemory(long, long, long[])

hashChars

public void hashChars(char[] input,
                      long[] result)

Shortcut for hashChars(input, 0, input.length, result).

hashChars

@NotNull
public long[] hashChars(char[] input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashChars(char[], long[])

hashChars

public void hashChars(char[] input,
                      int off,
                      int len,
                      long[] result)

Computes the hash code for bytes, as they lay in memory, of the specified subsequence of the given char array.

Default implementation delegates to hash(Object, Access, long, long, long[]) method using unsafe Access.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Parameters:

input - the array to read data from

off - index of the first char in the subsequence to hash

len - length of the subsequence to hash, in chars (i.e. the length of the bytes sequence to hash is len * 2L)

result - the container array for storing the hash results, should be alloced by newResultArray()

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

IllegalArgumentException - if off < 0 or off + len > input.length or len < 0

hashChars

@NotNull
public long[] hashChars(char[] input,
                                 int off,
                                 int len)

The result array is allocated on the fly.

See Also:

hashChars(char[], int, int, long[])

hashChars

public void hashChars(String input,
                      long[] result)

Shortcut for hashChars(input, 0, input.length(), result).

hashChars

@NotNull
public long[] hashChars(String input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashChars(String, long[])

hashChars

public void hashChars(String input,
                      int off,
                      int len,
                      long[] result)

Computes the hash code for bytes of the specified subsequence of the given String's underlying char array or byte array.

Default implementation could either delegate to hash(Object, Access, long, long, long[]) using Access.toNativeCharSequence(), or to hashChars(char[], int, int, long[]).

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Parameters:

input - the string which bytes to hash

off - index of the first char in the subsequence to hash

len - length of the subsequence to hash, in chars (i.e. the length of the bytes sequence to hash is len * 2L)

result - the container array for storing the hash results, should be alloced by newResultArray()

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

IllegalArgumentException - if off < 0 or off + len > input.length or len < 0

hashChars

@NotNull
public long[] hashChars(String input,
                                 int off,
                                 int len)

The result array is allocated on the fly.

See Also:

hashChars(String, int, int, long[])

hashChars

public <T extends CharSequence> void hashChars(T input,
                                               long[] result)

Shortcut for hashChars(input, 0, input.length(), result).

hashChars

@NotNull
public <T extends CharSequence> long[] hashChars(T input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashChars(CharSequence, long[])

hashChars

public <T extends CharSequence> void hashChars(T input,
                                               int off,
                                               int len,
                                               long[] result)

Computes the hash code for bytes of the specified subsequence of the given CharSequence's underlying char array.

Default implementation delegates to hash(Object, Access, long, long, long[]) method using Access.toNativeCharSequence().

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Parameters:

input - the char sequence which bytes to hash

off - index of the first char in the subsequence to hash

len - length of the subsequence to hash, in chars (i.e. the length of the bytes sequence to hash is len * 2L)

result - the container array for storing the hash results, should be alloced by newResultArray()

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

IllegalArgumentException - if off < 0 or off + len > input.length or len < 0

hashChars

@NotNull
public <T extends CharSequence> long[] hashChars(T input,
                                                          int off,
                                                          int len)

The result array is allocated on the fly.

See Also:

hashChars(CharSequence, int, int, long[])

hashShorts

public void hashShorts(short[] input,
                       long[] result)

Shortcut for hashShorts(input, 0, input.length, result).

hashShorts

@NotNull
public long[] hashShorts(short[] input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashShorts(short[], long[])

hashShorts

public void hashShorts(short[] input,
                       int off,
                       int len,
                       long[] result)

Computes the hash code for bytes, as they lay in memory, of the specified subsequence of the given short array.

Default implementation delegates to hash(Object, Access, long, long, long[]) method using unsafe Access.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Parameters:

input - the array to read data from

off - index of the first short in the subsequence to hash

len - length of the subsequence to hash, in shorts (i.e. the length of the bytes sequence to hash is len * 2L)

result - the container array for storing the hash results, should be alloced by newResultArray()

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

IllegalArgumentException - if off < 0 or off + len > input.length or len < 0

hashShorts

@NotNull
public long[] hashShorts(short[] input,
                                  int off,
                                  int len)

The result array is allocated on the fly.

See Also:

hashShorts(short[], int, int, long[])

hashInts

public void hashInts(int[] input,
                     long[] result)

Shortcut for hashInts(input, 0, input.length, result).

hashInts

@NotNull
public long[] hashInts(int[] input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashInts(int[], long[])

hashInts

public void hashInts(int[] input,
                     int off,
                     int len,
                     long[] result)

Computes the hash code for bytes, as they lay in memory, of the specified subsequence of the given int array.

Default implementation delegates to hash(Object, Access, long, long, long[]) method using unsafe Access.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Parameters:

input - the array to read data from

off - index of the first int in the subsequence to hash

len - length of the subsequence to hash, in ints (i.e. the length of the bytes sequence to hash is len * 4L)

result - the container array for storing the hash results, should be alloced by newResultArray()

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

IllegalArgumentException - if off < 0 or off + len > input.length or len < 0

hashInts

@NotNull
public long[] hashInts(int[] input,
                                int off,
                                int len)

The result array is allocated on the fly.

See Also:

hashInts(int[], int, int, long[])

hashLongs

public void hashLongs(long[] input,
                      long[] result)

Shortcut for hashLongs(input, 0, input.length, result).

hashLongs

@NotNull
public long[] hashLongs(long[] input)

The result array is allocated on the fly, and no exceptions will be thrown.

See Also:

hashLongs(long[], long[])

hashLongs

public void hashLongs(long[] input,
                      int off,
                      int len,
                      long[] result)

Computes the hash code for bytes, as they lay in memory, of the specified subsequence of the given long array.

Default implementation delegates to hash(Object, Access, long, long, long[]) method using unsafe Access.

The result array should be always created by newResultArray() method. When storing, the result[0 .. newResultArray().length-1] will be accessed, the rest elements of the array will not be touched when result.length > newResultArray().length].

Parameters:

input - the array to read data from

off - index of the first long in the subsequence to hash

len - length of the subsequence to hash, in longs (i.e. the length of the bytes sequence to hash is len * 8L)

result - the container array for storing the hash results, should be alloced by newResultArray()

Throws:

NullPointerException - if result == null

IllegalArgumentException - if result.length < newResultArray().length

IllegalArgumentException - if off < 0 or off + len > input.length or len < 0

hashLongs

@NotNull
public long[] hashLongs(long[] input,
                                 int off,
                                 int len)

The result array is allocated on the fly.

See Also:

hashLongs(long[], int, int, long[])