Class MurmurHash3.IncrementalHash32x86

  • Direct Known Subclasses:
    MurmurHash3.IncrementalHash32
    Enclosing class:
    MurmurHash3

    public static class MurmurHash3.IncrementalHash32x86
    extends java.lang.Object
    Generates 32-bit hash from input bytes. Bytes can be added incrementally and the new hash computed.

    This is an implementation of the 32-bit hash function MurmurHash3_x86_32 from from Austin Applyby's original MurmurHash3 c++ code in SMHasher.

    Since:
    1.14
    • Field Summary

      Fields 
      Modifier and Type Field Description
      private static int BLOCK_SIZE
      The size of byte blocks that are processed together.
      private int hash
      The current running hash.
      private int totalLen
      The total number of input bytes added since the start.
      private byte[] unprocessed
      Up to 3 unprocessed bytes from input data.
      private int unprocessedLength
      The number of unprocessed bytes in the tail data.
    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void add​(byte[] data, int offset, int length)
      Adds the byte array to the current incremental hash.
      int end()
      Generate the 32-bit hash value.
      (package private) int finalise​(int hash, int unprocessedLength, byte[] unprocessed, int totalLen)
      Finalize the running hash to the output 32-bit hash by processing remaining bytes and performing final mixing.
      private static int orBytes​(byte b1, byte b2, byte b3, byte b4)
      Combines the bytes using an Or operation (| in a little-endian representation of a 32-bit integer; byte 1 will be the least significant byte, byte 4 the most significant.
      void start​(int seed)
      Starts a new incremental hash.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • BLOCK_SIZE

        private static final int BLOCK_SIZE
        The size of byte blocks that are processed together.
        See Also:
        Constant Field Values
      • unprocessed

        private final byte[] unprocessed
        Up to 3 unprocessed bytes from input data.
      • unprocessedLength

        private int unprocessedLength
        The number of unprocessed bytes in the tail data.
      • totalLen

        private int totalLen
        The total number of input bytes added since the start.
      • hash

        private int hash
        The current running hash. This must be finalised to generate the 32-bit hash value.
    • Constructor Detail

      • IncrementalHash32x86

        public IncrementalHash32x86()
    • Method Detail

      • start

        public final void start​(int seed)
        Starts a new incremental hash.
        Parameters:
        seed - The initial seed value
      • add

        public final void add​(byte[] data,
                              int offset,
                              int length)
        Adds the byte array to the current incremental hash.
        Parameters:
        data - The input byte array
        offset - The offset of data
        length - The length of array
      • end

        public final int end()
        Generate the 32-bit hash value. Repeat calls to this method with no additional data will generate the same hash value.
        Returns:
        The 32-bit hash
      • finalise

        int finalise​(int hash,
                     int unprocessedLength,
                     byte[] unprocessed,
                     int totalLen)
        Finalize the running hash to the output 32-bit hash by processing remaining bytes and performing final mixing.
        Parameters:
        hash - The running hash
        unprocessedLength - The number of unprocessed bytes in the tail data.
        unprocessed - Up to 3 unprocessed bytes from input data.
        totalLen - The total number of input bytes added since the start.
        Returns:
        The 32-bit hash
      • orBytes

        private static int orBytes​(byte b1,
                                   byte b2,
                                   byte b3,
                                   byte b4)
        Combines the bytes using an Or operation (| in a little-endian representation of a 32-bit integer; byte 1 will be the least significant byte, byte 4 the most significant.
        Parameters:
        b1 - The first byte
        b2 - The second byte
        b3 - The third byte
        b4 - The fourth byte
        Returns:
        The 32-bit integer