Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2012 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
   * in compliance with the License. You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
 
 /*
  * SipHash-c-d was designed by Jean-Philippe Aumasson and Daniel J. Bernstein and is described in
  * "SipHash: a fast short-input PRF" (available at https://131002.net/siphash/siphash.pdf).
  */
 
 package com.google.common.hash;
 
 import static com.google.common.base.Preconditions.checkArgument;
 
 
 import  javax.annotation.Nullable;

HashFunction implementation of SipHash-c-d.

Author(s):
Kurt Alfred Kluever
Jean-Philippe Aumasson
Daniel J. Bernstein
 
 final class SipHashFunction extends AbstractStreamingHashFunction implements Serializable {
 
   // The number of compression rounds.
   private final int c;
   // The number of finalization rounds.
   private final int d;
   // Two 64-bit keys (represent a single 128-bit key).
   private final long k0;
   private final long k1;

  

Parameters:
c the number of compression rounds (must be positive)
d the number of finalization rounds (must be positive)
k0 the first half of the key
k1 the second half of the key
 
   SipHashFunction(int cint dlong k0long k1) {
     checkArgument(c > 0,
         "The number of SipRound iterations (c=%s) during Compression must be positive."c);
     checkArgument(d > 0,
         "The number of SipRound iterations (d=%s) during Finalization must be positive."d);
     this. = c;
     this. = d;
     this. = k0;
     this. = k1;
   }
 
   @Override public int bits() {
     return 64;
   }
 
   @Override public Hasher newHasher() {
     return new SipHasher();
   }
 
   // TODO(user): Implement and benchmark the hashFoo() shortcuts.
 
   @Override public String toString() {
     return "Hashing.sipHash" +  + "" +  + "(" +  + ", " +  + ")";
   }
 
   @Override
   public boolean equals(@Nullable Object object) {
     if (object instanceof SipHashFunction) {
       SipHashFunction other = (SipHashFunctionobject;
       return ( == other.c)
           && ( == other.d)
           && ( == other.k0)
           && ( == other.k1);
     }
     return false;
   }
 
   @Override
   public int hashCode() {
     return (int) (getClass().hashCode() ^  ^  ^  ^ );
   }
 
   private static final class SipHasher extends AbstractStreamingHasher {
     private static final int CHUNK_SIZE = 8;
 
     // The number of compression rounds.
     private final int c;
     // The number of finalization rounds.
    private final int d;
    // Four 64-bit words of internal state.
    // The initial state corresponds to the ASCII string "somepseudorandomlygeneratedbytes",
    // big-endian encoded. There is nothing special about this value; the only requirement
    // was some asymmetry so that the initial v0 and v1 differ from v2 and v3.
    private long v0 = 0x736f6d6570736575L;
    private long v1 = 0x646f72616e646f6dL;
    private long v2 = 0x6c7967656e657261L;
    private long v3 = 0x7465646279746573L;
    // The number of bytes in the input.
    private long b = 0;
    // The final 64-bit chunk includes the last 0 through 7 bytes of m followed by null bytes
    // and ending with a byte encoding the positive integer b mod 256.
    private long finalM = 0;
    SipHasher(int cint dlong k0long k1) {
      super();
      this. = c;
      this. = d;
      this. ^= k0;
      this. ^= k1;
      this. ^= k0;
      this. ^= k1;
    }
    @Override protected void process(ByteBuffer buffer) {
       += ;
      processM(buffer.getLong());
    }
    @Override protected void processRemaining(ByteBuffer buffer) {
       += buffer.remaining();
      for (int i = 0; buffer.hasRemaining(); i += 8) {
         ^= (buffer.get() & 0xFFL) << i;
      }
    }
    @Override public HashCode makeHash() {
      // End with a byte encoding the positive integer b mod 256.
       ^=  << 56;
      processM();
      // Finalization
       ^= 0xFFL;
      sipRound();
      return HashCode.fromLong( ^  ^  ^ );
    }
    private void processM(long m) {
       ^= m;
      sipRound();
       ^= m;
    }
    private void sipRound(int iterations) {
      for (int i = 0; i < iterationsi++) {
         += ;
         += ;
         = Long.rotateLeft(, 13);
         = Long.rotateLeft(, 16);
         ^= ;
         ^= ;
         = Long.rotateLeft(, 32);
         += ;
         += ;
         = Long.rotateLeft(, 17);
         = Long.rotateLeft(, 21);
         ^= ;
         ^= ;
         = Long.rotateLeft(, 32);
      }
    }
  }
  private static final long serialVersionUID = 0L;
New to GrepCode? Check out our FAQ X