Class FarmHashFingerprint64

  • All Implemented Interfaces:
    HashFunction

    final class FarmHashFingerprint64
    extends AbstractNonStreamingHashFunction
    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)
    • Constructor Detail

      • FarmHashFingerprint64

        FarmHashFingerprint64()
    • Method Detail

      • hashBytes

        public HashCode hashBytes​(byte[] input,
                                  int off,
                                  int len)
        Description copied from interface: HashFunction
        Shortcut for newHasher().putBytes(input, off, len).hash(). The implementation might perform better than its longhand equivalent, but should not perform worse.
      • bits

        public int bits()
        Description copied from interface: HashFunction
        Returns the number of bits (a multiple of 32) that each hash code produced by this hash function has.
      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object
      • fingerprint

        static long fingerprint​(byte[] bytes,
                                int offset,
                                int length)
      • shiftMix

        private static long shiftMix​(long val)
      • hashLength16

        private static long hashLength16​(long u,
                                         long v,
                                         long mul)
      • weakHashLength32WithSeeds

        private static void weakHashLength32WithSeeds​(byte[] bytes,
                                                      int offset,
                                                      long seedA,
                                                      long seedB,
                                                      long[] output)
        Computes intermediate hash of 32 bytes of byte array from the given offset. Results are returned in the output array because when we last measured, this was 12% faster than allocating new arrays every time.
      • hashLength0to16

        private static long hashLength0to16​(byte[] bytes,
                                            int offset,
                                            int length)
      • hashLength17to32

        private static long hashLength17to32​(byte[] bytes,
                                             int offset,
                                             int length)
      • hashLength33To64

        private static long hashLength33To64​(byte[] bytes,
                                             int offset,
                                             int length)
      • hashLength65Plus

        private static long hashLength65Plus​(byte[] bytes,
                                             int offset,
                                             int length)