@ParametersAreNonnullByDefault public abstract class LongTupleHashFunction extends Object implements Serializable
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.
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.
LongHashFunction,
Serialized Form| Modifier | Constructor and Description |
|---|---|
protected |
LongTupleHashFunction()
Constructor for use in subclasses.
|
| 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)
|
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> |
hashChars(T input)
The result array is allocated on the fly, and no exceptions will be thrown.
|
<T extends CharSequence> |
hashChars(T input,
int off,
int len)
The result array is allocated on the fly.
|
<T extends CharSequence> |
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> |
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.
|
protected LongTupleHashFunction()
@NotNull public static LongTupleHashFunction murmur_3()
ByteOrder, but is slower on big-endian platforms than on
little-endian.murmur_3(long)@NotNull public static LongTupleHashFunction murmur_3(long seed)
ByteOrder, but is slower on big-endian platforms
than on little-endian.murmur_3()@NotNull public static LongTupleHashFunction xx128()
ByteOrder, but is slower on big-endian platforms than on
little-endian.xx128(long)@NotNull public static LongTupleHashFunction xx128(long seed)
ByteOrder, but is slower on big-endian platforms than on little-endian.xx128()public abstract int bitsLength()
@NotNull public long[] newResultArray()
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.public abstract void hashLong(long input,
long[] result)
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].
NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().length@NotNull public long[] hashLong(long input)
hashLong(long, long[])public abstract void hashInt(int input,
long[] result)
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].
NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().length@NotNull public long[] hashInt(int input)
hashInt(int, long[])public abstract void hashShort(short input,
long[] result)
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].
NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().length@NotNull public long[] hashShort(short input)
hashShort(short, long[])public abstract void hashChar(char input,
long[] result)
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].
NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().length@NotNull public long[] hashChar(char input)
hashChar(char, long[])public abstract void hashByte(byte input,
long[] result)
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].
NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().length@NotNull public long[] hashByte(byte input)
hashByte(byte, long[])public abstract void hashVoid(long[] result)
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].
NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().length@NotNull public long[] hashVoid()
hashVoid(long[])public abstract <T> void hash(@Nullable
T input,
Access<T> access,
long off,
long len,
long[] result)
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].
T - the type of the inputinput - the object to read bytes fromaccess - access which defines the abstraction of the given input
as ordered byte sequenceoff - offset to the first byte of the subsequence to hashlen - length of the subsequence to hashresult - the container array for storing the hash results,
should be alloced by newResultArray()NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().length@NotNull
public <T> long[] hash(@Nullable
T input,
Access<T> access,
long off,
long len)
hash(Object, Access, long, long, long[])public void hashBoolean(boolean input,
long[] result)
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.@NotNull public long[] hashBoolean(boolean input)
hashBoolean(boolean, long[])public void hashBooleans(boolean[] input,
long[] result)
hashBooleans(input, 0, input.length, result).@NotNull public long[] hashBooleans(boolean[] input)
hashBooleans(boolean[], long[])public void hashBooleans(boolean[] input,
int off,
int len,
long[] result)
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].
input - the array to read data fromoff - index of the first boolean in the subsequence to hashlen - length of the subsequence to hashresult - the container array for storing the hash results,
should be alloced by newResultArray()NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().lengthIllegalArgumentException - if off < 0 or off + len > input.length
or len < 0@NotNull
public long[] hashBooleans(boolean[] input,
int off,
int len)
public void hashBytes(byte[] input,
long[] result)
hashBytes(input, 0, input.length, result).@NotNull public long[] hashBytes(byte[] input)
hashBytes(byte[], long[])public void hashBytes(byte[] input,
int off,
int len,
long[] result)
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].
input - the array to read data fromoff - index of the first byte in the subsequence to hashlen - length of the subsequence to hashresult - the container array for storing the hash results,
should be alloced by newResultArray()NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().lengthIllegalArgumentException - if off < 0 or off + len > input.length
or len < 0@NotNull
public long[] hashBytes(byte[] input,
int off,
int len)
hashBytes(byte[], int, int, long[])public void hashBytes(ByteBuffer input, long[] result)
@NotNull public long[] hashBytes(ByteBuffer input)
hashBytes(ByteBuffer, long[])public void hashBytes(ByteBuffer input, int off, int len, long[] result)
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].
input - the buffer to read bytes fromoff - index of the first byte in the subsequence to hashlen - length of the subsequence to hashresult - the container array for storing the hash results,
should be alloced by newResultArray()NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().lengthIllegalArgumentException - if off < 0 or off + len > input.length
or len < 0@NotNull public long[] hashBytes(ByteBuffer input, int off, int len)
hashBytes(ByteBuffer, int, int, long[])public void hashMemory(long address,
long len,
long[] result)
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].
address - the address of the first byte to hashlen - length of the byte sequence to hashresult - the container array for storing the hash results,
should be alloced by newResultArray()NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().lengthIllegalArgumentException - if off < 0 or off + len > input.length
or len < 0@NotNull
public long[] hashMemory(long address,
long len)
hashMemory(long, long, long[])public void hashChars(char[] input,
long[] result)
hashChars(input, 0, input.length, result).@NotNull public long[] hashChars(char[] input)
hashChars(char[], long[])public void hashChars(char[] input,
int off,
int len,
long[] result)
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].
input - the array to read data fromoff - index of the first char in the subsequence to hashlen - 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()NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().lengthIllegalArgumentException - if off < 0 or off + len > input.length
or len < 0@NotNull
public long[] hashChars(char[] input,
int off,
int len)
hashChars(char[], int, int, long[])public void hashChars(String input, long[] result)
hashChars(input, 0, input.length(), result).@NotNull public long[] hashChars(String input)
hashChars(String, long[])public void hashChars(String input, int off, int len, long[] result)
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].
input - the string which bytes to hashoff - index of the first char in the subsequence to hashlen - 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()NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().lengthIllegalArgumentException - if off < 0 or off + len > input.length
or len < 0@NotNull public long[] hashChars(String input, int off, int len)
hashChars(String, int, int, long[])public <T extends CharSequence> void hashChars(T input, long[] result)
hashChars(input, 0, input.length(), result).@NotNull public <T extends CharSequence> long[] hashChars(T input)
hashChars(CharSequence, long[])public <T extends CharSequence> void hashChars(T input, int off, int len, long[] result)
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].
input - the char sequence which bytes to hashoff - index of the first char in the subsequence to hashlen - 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()NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().lengthIllegalArgumentException - if off < 0 or off + len > input.length
or len < 0@NotNull public <T extends CharSequence> long[] hashChars(T input, int off, int len)
public void hashShorts(short[] input,
long[] result)
hashShorts(input, 0, input.length, result).@NotNull public long[] hashShorts(short[] input)
hashShorts(short[], long[])public void hashShorts(short[] input,
int off,
int len,
long[] result)
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].
input - the array to read data fromoff - index of the first short in the subsequence to hashlen - 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()NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().lengthIllegalArgumentException - if off < 0 or off + len > input.length
or len < 0@NotNull
public long[] hashShorts(short[] input,
int off,
int len)
hashShorts(short[], int, int, long[])public void hashInts(int[] input,
long[] result)
hashInts(input, 0, input.length, result).@NotNull public long[] hashInts(int[] input)
hashInts(int[], long[])public void hashInts(int[] input,
int off,
int len,
long[] result)
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].
input - the array to read data fromoff - index of the first int in the subsequence to hashlen - 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()NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().lengthIllegalArgumentException - if off < 0 or off + len > input.length
or len < 0@NotNull
public long[] hashInts(int[] input,
int off,
int len)
hashInts(int[], int, int, long[])public void hashLongs(long[] input,
long[] result)
hashLongs(input, 0, input.length, result).@NotNull public long[] hashLongs(long[] input)
hashLongs(long[], long[])public void hashLongs(long[] input,
int off,
int len,
long[] result)
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].
input - the array to read data fromoff - index of the first long in the subsequence to hashlen - 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()NullPointerException - if result == nullIllegalArgumentException - if result.length < newResultArray().lengthIllegalArgumentException - if off < 0 or off + len > input.length
or len < 0@NotNull
public long[] hashLongs(long[] input,
int off,
int len)
hashLongs(long[], int, int, long[])Copyright © 2014–2022. All rights reserved.