Package akka.routing

Class MurmurHash$

  • public class MurmurHash$
extends java.lang.Object
    An object designed to generate well-distributed non-cryptographic hashes. It is designed to hash a collection of integers; along with the integers to hash, it generates two magic streams of integers to increase the distribution of repetitive input sequences. Thus, three methods need to be called at each step (to start and to incorporate a new integer) to update the values. Only one method needs to be called to finalize the hash.

    • Field Summary

      Fields 
      Modifier and Type Field Description
      static MurmurHash$ MODULE$
      Static reference to the singleton instance of this Scala object.

    • Constructor Summary

      Constructors 
      Constructor Description
      MurmurHash$()  

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      <T> int arrayHash​(java.lang.Object a)
      Compute a high-quality hash of an array
      int extendHash​(int hash, int value, int magicA, int magicB)
      Incorporates a new value into an existing hash.
      int finalizeHash​(int hash)
      Once all hashes have been incorporated, this performs a final mixing
      int nextMagicA​(int magicA)
      Given a magic integer from the first stream, compute the next
      int nextMagicB​(int magicB)
      Given a magic integer from the second stream, compute the next
      int startHash​(int seed)
      Begin a new hash with a seed value.
      int startMagicA()
      The initial magic integers in the first stream.
      int startMagicB()
      The initial magic integer in the second stream.
      int stringHash​(java.lang.String s)
      Compute a high-quality hash of a string
      <T> int symmetricHash​(scala.collection.IterableOnce<T> xs, int seed)
      Compute a hash that is symmetric in its arguments--that is, where the order of appearance of elements does not matter.

      • Methods inherited from class java.lang.Object

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

    • Field Detail

      • MODULE$

        public static final MurmurHash$ MODULE$
        Static reference to the singleton instance of this Scala object.

    • Constructor Detail

      • MurmurHash$

        public MurmurHash$()

    • Method Detail

      • startHash

        public int startHash​(int seed)
        Begin a new hash with a seed value.

      • startMagicA

        public int startMagicA()
        The initial magic integers in the first stream.

      • startMagicB

        public int startMagicB()
        The initial magic integer in the second stream.

      • extendHash

        public int extendHash​(int hash,
                      int value,
                      int magicA,
                      int magicB)
        Incorporates a new value into an existing hash.

        Parameters:
        hash - the prior hash value
        value - the new value to incorporate
        magicA - a magic integer from the stream
        magicB - a magic integer from a different stream
        Returns:
        the updated hash value

      • nextMagicA

        public int nextMagicA​(int magicA)
        Given a magic integer from the first stream, compute the next

      • nextMagicB

        public int nextMagicB​(int magicB)
        Given a magic integer from the second stream, compute the next

      • finalizeHash

        public int finalizeHash​(int hash)
        Once all hashes have been incorporated, this performs a final mixing

      • arrayHash

        public <T> int arrayHash​(java.lang.Object a)
        Compute a high-quality hash of an array

      • stringHash

        public int stringHash​(java.lang.String s)
        Compute a high-quality hash of a string

      • symmetricHash

        public <T> int symmetricHash​(scala.collection.IterableOnce<T> xs,
                             int seed)
        Compute a hash that is symmetric in its arguments--that is, where the order of appearance of elements does not matter. This is useful for hashing sets, for example.