package com.google.common.hash;

import com.google.common.base.Preconditions;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
import qs;

public abstract class AbstractStreamingHashFunction
  implements HashFunction
{
  public HashCode hashBytes(byte[] paramArrayOfByte)
  {
    return newHasher().putBytes(paramArrayOfByte).hash();
  }
  
  public HashCode hashBytes(byte[] paramArrayOfByte, int paramInt1, int paramInt2)
  {
    return newHasher().putBytes(paramArrayOfByte, paramInt1, paramInt2).hash();
  }
  
  public HashCode hashInt(int paramInt)
  {
    return newHasher().putInt(paramInt).hash();
  }
  
  public HashCode hashLong(long paramLong)
  {
    return newHasher().putLong(paramLong).hash();
  }
  
  public <T> HashCode hashObject(T paramT, Funnel<? super T> paramFunnel)
  {
    return newHasher().putObject(paramT, paramFunnel).hash();
  }
  
  public HashCode hashString(CharSequence paramCharSequence, Charset paramCharset)
  {
    return newHasher().putString(paramCharSequence, paramCharset).hash();
  }
  
  public HashCode hashUnencodedChars(CharSequence paramCharSequence)
  {
    return newHasher().putUnencodedChars(paramCharSequence).hash();
  }
  
  public Hasher newHasher(int paramInt)
  {
    if (paramInt >= 0) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool);
      return newHasher();
    }
  }
  
  public static abstract class AbstractStreamingHasher
    extends qs
  {
    private final ByteBuffer a;
    private final int b;
    private final int c;
    
    protected AbstractStreamingHasher(int paramInt)
    {
      this(paramInt, paramInt);
    }
    
    protected AbstractStreamingHasher(int paramInt1, int paramInt2)
    {
      if (paramInt2 % paramInt1 == 0) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool);
        this.a = ByteBuffer.allocate(paramInt2 + 7).order(ByteOrder.LITTLE_ENDIAN);
        this.b = paramInt2;
        this.c = paramInt1;
        return;
      }
    }
    
    private void b()
    {
      if (this.a.remaining() < 8) {
        c();
      }
    }
    
    private void c()
    {
      this.a.flip();
      while (this.a.remaining() >= this.c) {
        process(this.a);
      }
      this.a.compact();
    }
    
    public abstract HashCode a();
    
    public final HashCode hash()
    {
      c();
      this.a.flip();
      if (this.a.remaining() > 0) {
        processRemaining(this.a);
      }
      return a();
    }
    
    public abstract void process(ByteBuffer paramByteBuffer);
    
    public void processRemaining(ByteBuffer paramByteBuffer)
    {
      paramByteBuffer.position(paramByteBuffer.limit());
      paramByteBuffer.limit(this.c + 7);
      while (paramByteBuffer.position() < this.c) {
        paramByteBuffer.putLong(0L);
      }
      paramByteBuffer.limit(this.c);
      paramByteBuffer.flip();
      process(paramByteBuffer);
    }
    
    public final Hasher putByte(byte paramByte)
    {
      this.a.put(paramByte);
      b();
      return this;
    }
    
    public final Hasher putBytes(byte[] paramArrayOfByte)
    {
      return putBytes(paramArrayOfByte, 0, paramArrayOfByte.length);
    }
    
    public final Hasher putBytes(byte[] paramArrayOfByte, int paramInt1, int paramInt2)
    {
      paramArrayOfByte = ByteBuffer.wrap(paramArrayOfByte, paramInt1, paramInt2).order(ByteOrder.LITTLE_ENDIAN);
      if (paramArrayOfByte.remaining() <= this.a.remaining())
      {
        this.a.put(paramArrayOfByte);
        b();
        return this;
      }
      paramInt2 = this.b;
      int i = this.a.position();
      paramInt1 = 0;
      while (paramInt1 < paramInt2 - i)
      {
        this.a.put(paramArrayOfByte.get());
        paramInt1 += 1;
      }
      c();
      while (paramArrayOfByte.remaining() >= this.c) {
        process(paramArrayOfByte);
      }
      this.a.put(paramArrayOfByte);
      return this;
    }
    
    public final Hasher putChar(char paramChar)
    {
      this.a.putChar(paramChar);
      b();
      return this;
    }
    
    public final Hasher putInt(int paramInt)
    {
      this.a.putInt(paramInt);
      b();
      return this;
    }
    
    public final Hasher putLong(long paramLong)
    {
      this.a.putLong(paramLong);
      b();
      return this;
    }
    
    public final <T> Hasher putObject(T paramT, Funnel<? super T> paramFunnel)
    {
      paramFunnel.funnel(paramT, this);
      return this;
    }
    
    public final Hasher putShort(short paramShort)
    {
      this.a.putShort(paramShort);
      b();
      return this;
    }
    
    public final Hasher putUnencodedChars(CharSequence paramCharSequence)
    {
      int i = 0;
      while (i < paramCharSequence.length())
      {
        putChar(paramCharSequence.charAt(i));
        i += 1;
      }
      return this;
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/com/google/common/hash/AbstractStreamingHashFunction.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */