com.google.common.hash.FarmHashFingerprint64 java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 LocalDateTime l =new LocalDateTime()
LocalDateTime.now()
DateTimeFormatter formatter;String text;formatter.parseLocalDateTime(text)
Smart code suggestions by Tabnine
}

@Override
public HashCode hashBytes(byte[] input, int off, int len) {
 checkPositionIndexes(off, off + len, input.length);
 return HashCode.fromLong(fingerprint(input, off, len));
}

@VisibleForTesting
static long fingerprint(byte[] bytes, int offset, int length) {
 if (length <= 32) {
  if (length <= 16) {
   return hashLength0to16(bytes, offset, length);
  } else {
   return hashLength17to32(bytes, offset, length);
  }
 } else if (length <= 64) {
  return hashLength33To64(bytes, offset, length);
 } else {
  return hashLength65Plus(bytes, offset, length);
 }
}

@SuppressWarnings("ConstantOverflow")
long y = seed * K1 + 113;
long z = shiftMix(y * K2 + 113) * K2;
long[] v = new long[2];
long[] w = new long[2];
 y += v[0] + load64(bytes, offset + 40);
 z = rotateRight(z + w[0], 33) * K1;
 weakHashLength32WithSeeds(bytes, offset, v[1] * K1, x + w[0], v);
 weakHashLength32WithSeeds(bytes, offset + 32, z + w[1], y + load64(bytes, offset + 16), w);
 long tmp = x;
 x = z;
y += v[0] * 9 + load64(bytes, offset + 40);
z = rotateRight(z + w[0], 33) * mul;
weakHashLength32WithSeeds(bytes, offset, v[1] * mul, x + w[0], v);
weakHashLength32WithSeeds(bytes, offset + 32, z + w[1], y + load64(bytes, offset + 16), w);
return hashLength16(
  hashLength16(v[0], w[0], mul) + shiftMix(y) * K0 + x,
  hashLength16(v[1], w[1], mul) + z,
  mul);

private static long hashLength0to16(byte[] bytes, int offset, int length) {
 if (length >= 8) {
  long mul = K2 + length * 2;
  long a = load64(bytes, offset) + K2;
  long b = load64(bytes, offset + length - 8);
  long c = rotateRight(b, 37) * mul + a;
  long d = (rotateRight(a, 25) + b) * mul;
  return hashLength16(c, d, mul);
 }
 if (length >= 4) {
  long mul = K2 + length * 2;
  long a = load32(bytes, offset) & 0xFFFFFFFFL;
  return hashLength16(length + (a << 3), load32(bytes, offset + length - 4) & 0xFFFFFFFFL, mul);
 }
 if (length > 0) {
  byte a = bytes[offset];
  byte b = bytes[offset + (length >> 1)];
  byte c = bytes[offset + (length - 1)];
  int y = (a & 0xFF) + ((b & 0xFF) << 8);
  int z = length + ((c & 0xFF) << 2);
  return shiftMix(y * K2 ^ z * K0) * K2;
 }
 return K2;
}

private static long hashLength17to32(byte[] bytes, int offset, int length) {
 long mul = K2 + length * 2;
 long a = load64(bytes, offset) * K1;
 long b = load64(bytes, offset + 8);
 long c = load64(bytes, offset + length - 8) * mul;
 long d = load64(bytes, offset + length - 16) * K2;
 return hashLength16(
   rotateRight(a + b, 43) + rotateRight(c, 30) + d, a + rotateRight(b + K2, 18) + c, mul);
}

private static long hashLength0to16(byte[] bytes, int offset, int length) {
 if (length >= 8) {
  long mul = K2 + length * 2;
  long a = load64(bytes, offset) + K2;
  long b = load64(bytes, offset + length - 8);
  long c = rotateRight(b, 37) * mul + a;
  long d = (rotateRight(a, 25) + b) * mul;
  return hashLength16(c, d, mul);
 }
 if (length >= 4) {
  long mul = K2 + length * 2;
  long a = load32(bytes, offset) & 0xFFFFFFFFL;
  return hashLength16(length + (a << 3), load32(bytes, offset + length - 4) & 0xFFFFFFFFL, mul);
 }
 if (length > 0) {
  byte a = bytes[offset];
  byte b = bytes[offset + (length >> 1)];
  byte c = bytes[offset + (length - 1)];
  int y = (a & 0xFF) + ((b & 0xFF) << 8);
  int z = length + ((c & 0xFF) << 2);
  return shiftMix(y * K2 ^ z * K0) * K2;
 }
 return K2;
}

private static long hashLength33To64(byte[] bytes, int offset, int length) {
 long mul = K2 + length * 2;
 long a = load64(bytes, offset) * K2;
 long b = load64(bytes, offset + 8);
 long c = load64(bytes, offset + length - 8) * mul;
 long d = load64(bytes, offset + length - 16) * K2;
 long y = rotateRight(a + b, 43) + rotateRight(c, 30) + d;
 long z = hashLength16(y, a + rotateRight(b + K2, 18) + c, mul);
 long e = load64(bytes, offset + 16) * mul;
 long f = load64(bytes, offset + 24);
 long g = (y + load64(bytes, offset + length - 32)) * mul;
 long h = (z + load64(bytes, offset + length - 24)) * mul;
 return hashLength16(
   rotateRight(e + f, 43) + rotateRight(g, 30) + h, e + rotateRight(f + a, 18) + g, mul);
}

@VisibleForTesting
static long fingerprint(byte[] bytes, int offset, int length) {
 if (length <= 32) {
  if (length <= 16) {
   return hashLength0to16(bytes, offset, length);
  } else {
   return hashLength17to32(bytes, offset, length);
  }
 } else if (length <= 64) {
  return hashLength33To64(bytes, offset, length);
 } else {
  return hashLength65Plus(bytes, offset, length);
 }
}

@SuppressWarnings("ConstantOverflow")
long y = seed * K1 + 113;
long z = shiftMix(y * K2 + 113) * K2;
long[] v = new long[2];
long[] w = new long[2];
 y += v[0] + load64(bytes, offset + 40);
 z = rotateRight(z + w[0], 33) * K1;
 weakHashLength32WithSeeds(bytes, offset, v[1] * K1, x + w[0], v);
 weakHashLength32WithSeeds(bytes, offset + 32, z + w[1], y + load64(bytes, offset + 16), w);
 long tmp = x;
 x = z;
y += v[0] * 9 + load64(bytes, offset + 40);
z = rotateRight(z + w[0], 33) * mul;
weakHashLength32WithSeeds(bytes, offset, v[1] * mul, x + w[0], v);
weakHashLength32WithSeeds(bytes, offset + 32, z + w[1], y + load64(bytes, offset + 16), w);
return hashLength16(
  hashLength16(v[0], w[0], mul) + shiftMix(y) * K0 + x,
  hashLength16(v[1], w[1], mul) + z,
  mul);

private static long hashLength0to16(byte[] bytes, int offset, int length) {
 if (length >= 8) {
  long mul = K2 + length * 2;
  long a = load64(bytes, offset) + K2;
  long b = load64(bytes, offset + length - 8);
  long c = rotateRight(b, 37) * mul + a;
  long d = (rotateRight(a, 25) + b) * mul;
  return hashLength16(c, d, mul);
 }
 if (length >= 4) {
  long mul = K2 + length * 2;
  long a = load32(bytes, offset) & 0xFFFFFFFFL;
  return hashLength16(length + (a << 3), load32(bytes, offset + length - 4) & 0xFFFFFFFFL, mul);
 }
 if (length > 0) {
  byte a = bytes[offset];
  byte b = bytes[offset + (length >> 1)];
  byte c = bytes[offset + (length - 1)];
  int y = (a & 0xFF) + ((b & 0xFF) << 8);
  int z = length + ((c & 0xFF) << 2);
  return shiftMix(y * K2 ^ z * K0) * K2;
 }
 return K2;
}

private static long hashLength17to32(byte[] bytes, int offset, int length) {
 long mul = K2 + length * 2;
 long a = load64(bytes, offset) * K1;
 long b = load64(bytes, offset + 8);
 long c = load64(bytes, offset + length - 8) * mul;
 long d = load64(bytes, offset + length - 16) * K2;
 return hashLength16(
   rotateRight(a + b, 43) + rotateRight(c, 30) + d, a + rotateRight(b + K2, 18) + c, mul);
}

@Override
public HashCode hashBytes(byte[] input, int off, int len) {
 checkPositionIndexes(off, off + len, input.length);
 return HashCode.fromLong(fingerprint(input, off, len));
}

@VisibleForTesting
static long fingerprint(byte[] bytes, int offset, int length) {
 if (length <= 32) {
  if (length <= 16) {
   return hashLength0to16(bytes, offset, length);
  } else {
   return hashLength17to32(bytes, offset, length);
  }
 } else if (length <= 64) {
  return hashLength33To64(bytes, offset, length);
 } else {
  return hashLength65Plus(bytes, offset, length);
 }
}

@SuppressWarnings("ConstantOverflow")
long y = seed * K1 + 113;
long z = shiftMix(y * K2 + 113) * K2;
long[] v = new long[2];
long[] w = new long[2];
 y += v[0] + load64(bytes, offset + 40);
 z = rotateRight(z + w[0], 33) * K1;
 weakHashLength32WithSeeds(bytes, offset, v[1] * K1, x + w[0], v);
 weakHashLength32WithSeeds(bytes, offset + 32, z + w[1], y + load64(bytes, offset + 16), w);
 long tmp = x;
 x = z;
y += v[0] * 9 + load64(bytes, offset + 40);
z = rotateRight(z + w[0], 33) * mul;
weakHashLength32WithSeeds(bytes, offset, v[1] * mul, x + w[0], v);
weakHashLength32WithSeeds(bytes, offset + 32, z + w[1], y + load64(bytes, offset + 16), w);
return hashLength16(
  hashLength16(v[0], w[0], mul) + shiftMix(y) * K0 + x,
  hashLength16(v[1], w[1], mul) + z,
  mul);

private static long hashLength0to16(byte[] bytes, int offset, int length) {
 if (length >= 8) {
  long mul = K2 + length * 2;
  long a = load64(bytes, offset) + K2;
  long b = load64(bytes, offset + length - 8);
  long c = rotateRight(b, 37) * mul + a;
  long d = (rotateRight(a, 25) + b) * mul;
  return hashLength16(c, d, mul);
 }
 if (length >= 4) {
  long mul = K2 + length * 2;
  long a = load32(bytes, offset) & 0xFFFFFFFFL;
  return hashLength16(length + (a << 3), load32(bytes, offset + length - 4) & 0xFFFFFFFFL, mul);
 }
 if (length > 0) {
  byte a = bytes[offset];
  byte b = bytes[offset + (length >> 1)];
  byte c = bytes[offset + (length - 1)];
  int y = (a & 0xFF) + ((b & 0xFF) << 8);
  int z = length + ((c & 0xFF) << 2);
  return shiftMix(y * K2 ^ z * K0) * K2;
 }
 return K2;
}

private static long hashLength17to32(byte[] bytes, int offset, int length) {
 long mul = K2 + length * 2;
 long a = load64(bytes, offset) * K1;
 long b = load64(bytes, offset + 8);
 long c = load64(bytes, offset + length - 8) * mul;
 long d = load64(bytes, offset + length - 16) * K2;
 return hashLength16(
   rotateRight(a + b, 43) + rotateRight(c, 30) + d, a + rotateRight(b + K2, 18) + c, mul);
}

@Override
public HashCode hashBytes(byte[] input, int off, int len) {
 checkPositionIndexes(off, off + len, input.length);
 return HashCode.fromLong(fingerprint(input, off, len));
}

@VisibleForTesting
static long fingerprint(byte[] bytes, int offset, int length) {
 if (length <= 32) {
  if (length <= 16) {
   return hashLength0to16(bytes, offset, length);
  } else {
   return hashLength17to32(bytes, offset, length);
  }
 } else if (length <= 64) {
  return hashLength33To64(bytes, offset, length);
 } else {
  return hashLength65Plus(bytes, offset, length);
 }
}

@SuppressWarnings("ConstantOverflow")
long y = seed * K1 + 113;
long z = shiftMix(y * K2 + 113) * K2;
long[] v = new long[2];
long[] w = new long[2];
 y += v[0] + load64(bytes, offset + 40);
 z = rotateRight(z + w[0], 33) * K1;
 weakHashLength32WithSeeds(bytes, offset, v[1] * K1, x + w[0], v);
 weakHashLength32WithSeeds(bytes, offset + 32, z + w[1], y + load64(bytes, offset + 16), w);
 long tmp = x;
 x = z;
y += v[0] * 9 + load64(bytes, offset + 40);
z = rotateRight(z + w[0], 33) * mul;
weakHashLength32WithSeeds(bytes, offset, v[1] * mul, x + w[0], v);
weakHashLength32WithSeeds(bytes, offset + 32, z + w[1], y + load64(bytes, offset + 16), w);
return hashLength16(
  hashLength16(v[0], w[0], mul) + shiftMix(y) * K0 + x,
  hashLength16(v[1], w[1], mul) + z,
  mul);

private static long hashLength0to16(byte[] bytes, int offset, int length) {
 if (length >= 8) {
  long mul = K2 + length * 2;
  long a = load64(bytes, offset) + K2;
  long b = load64(bytes, offset + length - 8);
  long c = rotateRight(b, 37) * mul + a;
  long d = (rotateRight(a, 25) + b) * mul;
  return hashLength16(c, d, mul);
 }
 if (length >= 4) {
  long mul = K2 + length * 2;
  long a = load32(bytes, offset) & 0xFFFFFFFFL;
  return hashLength16(length + (a << 3), load32(bytes, offset + length - 4) & 0xFFFFFFFFL, mul);
 }
 if (length > 0) {
  byte a = bytes[offset];
  byte b = bytes[offset + (length >> 1)];
  byte c = bytes[offset + (length - 1)];
  int y = (a & 0xFF) + ((b & 0xFF) << 8);
  int z = length + ((c & 0xFF) << 2);
  return shiftMix(y * K2 ^ z * K0) * K2;
 }
 return K2;
}

Javadoc

Implementation of FarmHash Fingerprint64, an open-source fingerprinting algorithm for strings.

Its speed is comparable to CityHash64, and its quality of hashing is at least as good.

Note to maintainers: This implementation relies on signed arithmetic being bit-wise equivalent to unsigned arithmetic in all cases except:

comparisons (signed values can be negative)
division (avoided here)
shifting (right shift must be unsigned)

Most used methods

fingerprint
hashLength0to16
hashLength16
hashLength17to32
hashLength33To64
hashLength65Plus
shiftMix
weakHashLength32WithSeeds
Computes intermediate hash of 32 bytes of byte array from the given offset. Results are returned in

Popular in Java

Parsing JSON documents to java classes using gson
findViewById (Activity)
onRequestPermissionsResult (Fragment)
getContentResolver (Context)
PrintWriter (java.io)
Wraps either an existing OutputStream or an existing Writerand provides convenience methods for prin
Random (java.util)
This class provides methods that return pseudo-random values.It is dangerous to seed Random with the
BlockingQueue (java.util.concurrent)
A java.util.Queue that additionally supports operations that wait for the queue to become non-empty
Reference (javax.naming)
JFrame (javax.swing)
XPath (javax.xml.xpath)
XPath provides access to the XPath evaluation environment and expressions. Evaluation of XPath Expr
Sublime Text for Python

How to useFarmHashFingerprint64 in com.google.common.hash

Best Java code snippets using com.google.common.hash.FarmHashFingerprint64 (Showing top 20 results out of 315)

How to use
FarmHashFingerprint64
in
com.google.common.hash