package okio;

import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import tu;
import ua;

public class ByteString
  implements Serializable, Comparable<ByteString>
{
  public static final ByteString EMPTY = of(new byte[0]);
  static final char[] a = { 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102 };
  private static final long serialVersionUID = 1L;
  final byte[] b;
  protected transient int c;
  transient String d;
  
  protected ByteString(byte[] paramArrayOfByte)
  {
    this.b = paramArrayOfByte;
  }
  
  private static int a(char paramChar)
  {
    if ((paramChar >= '0') && (paramChar <= '9')) {
      return paramChar - '0';
    }
    if ((paramChar >= 'a') && (paramChar <= 'f')) {
      return paramChar - 'a' + 10;
    }
    if ((paramChar >= 'A') && (paramChar <= 'F')) {
      return paramChar - 'A' + 10;
    }
    throw new IllegalArgumentException("Unexpected hex digit: " + paramChar);
  }
  
  private ByteString a(String paramString)
  {
    try
    {
      paramString = of(MessageDigest.getInstance(paramString).digest(this.b));
      return paramString;
    }
    catch (NoSuchAlgorithmException paramString)
    {
      throw new AssertionError(paramString);
    }
  }
  
  public static ByteString decodeBase64(String paramString)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("base64 == null");
    }
    paramString = tu.a(paramString);
    if (paramString != null) {
      return new ByteString(paramString);
    }
    return null;
  }
  
  public static ByteString decodeHex(String paramString)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("hex == null");
    }
    if (paramString.length() % 2 != 0) {
      throw new IllegalArgumentException("Unexpected hex string: " + paramString);
    }
    byte[] arrayOfByte = new byte[paramString.length() / 2];
    int i = 0;
    while (i < arrayOfByte.length)
    {
      arrayOfByte[i] = ((byte)((a(paramString.charAt(i * 2)) << 4) + a(paramString.charAt(i * 2 + 1))));
      i += 1;
    }
    return of(arrayOfByte);
  }
  
  public static ByteString encodeUtf8(String paramString)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("s == null");
    }
    ByteString localByteString = new ByteString(paramString.getBytes(ua.a));
    localByteString.d = paramString;
    return localByteString;
  }
  
  public static ByteString of(byte... paramVarArgs)
  {
    if (paramVarArgs == null) {
      throw new IllegalArgumentException("data == null");
    }
    return new ByteString((byte[])paramVarArgs.clone());
  }
  
  public static ByteString of(byte[] paramArrayOfByte, int paramInt1, int paramInt2)
  {
    if (paramArrayOfByte == null) {
      throw new IllegalArgumentException("data == null");
    }
    ua.a(paramArrayOfByte.length, paramInt1, paramInt2);
    byte[] arrayOfByte = new byte[paramInt2];
    System.arraycopy(paramArrayOfByte, paramInt1, arrayOfByte, 0, paramInt2);
    return new ByteString(arrayOfByte);
  }
  
  public static ByteString read(InputStream paramInputStream, int paramInt)
    throws IOException
  {
    if (paramInputStream == null) {
      throw new IllegalArgumentException("in == null");
    }
    if (paramInt < 0) {
      throw new IllegalArgumentException("byteCount < 0: " + paramInt);
    }
    byte[] arrayOfByte = new byte[paramInt];
    int i = 0;
    while (i < paramInt)
    {
      int j = paramInputStream.read(arrayOfByte, i, paramInt - i);
      if (j == -1) {
        throw new EOFException();
      }
      i += j;
    }
    return new ByteString(arrayOfByte);
  }
  
  private void readObject(ObjectInputStream paramObjectInputStream)
    throws IOException
  {
    paramObjectInputStream = read(paramObjectInputStream, paramObjectInputStream.readInt());
    try
    {
      Field localField = ByteString.class.getDeclaredField("b");
      localField.setAccessible(true);
      localField.set(this, paramObjectInputStream.b);
      return;
    }
    catch (NoSuchFieldException paramObjectInputStream)
    {
      throw new AssertionError();
    }
    catch (IllegalAccessException paramObjectInputStream)
    {
      throw new AssertionError();
    }
  }
  
  private void writeObject(ObjectOutputStream paramObjectOutputStream)
    throws IOException
  {
    paramObjectOutputStream.writeInt(this.b.length);
    paramObjectOutputStream.write(this.b);
  }
  
  protected void a(Buffer paramBuffer)
  {
    paramBuffer.write(this.b, 0, this.b.length);
  }
  
  public String base64()
  {
    return tu.a(this.b);
  }
  
  public String base64Url()
  {
    return tu.b(this.b);
  }
  
  public int compareTo(ByteString paramByteString)
  {
    int j = size();
    int k = paramByteString.size();
    int m = Math.min(j, k);
    int i = 0;
    if (i < m)
    {
      int n = getByte(i) & 0xFF;
      int i1 = paramByteString.getByte(i) & 0xFF;
      if (n != i1) {
        if (n >= i1) {}
      }
    }
    do
    {
      return -1;
      return 1;
      i += 1;
      break;
      if (j == k) {
        return 0;
      }
    } while (j < k);
    return 1;
  }
  
  public boolean equals(Object paramObject)
  {
    if (paramObject == this) {
      return true;
    }
    return ((paramObject instanceof ByteString)) && (((ByteString)paramObject).size() == this.b.length) && (((ByteString)paramObject).rangeEquals(0, this.b, 0, this.b.length));
  }
  
  public byte getByte(int paramInt)
  {
    return this.b[paramInt];
  }
  
  public int hashCode()
  {
    int i = this.c;
    if (i != 0) {
      return i;
    }
    i = Arrays.hashCode(this.b);
    this.c = i;
    return i;
  }
  
  public String hex()
  {
    int i = 0;
    char[] arrayOfChar = new char[this.b.length * 2];
    byte[] arrayOfByte = this.b;
    int k = arrayOfByte.length;
    int j = 0;
    while (i < k)
    {
      int m = arrayOfByte[i];
      int n = j + 1;
      arrayOfChar[j] = a[(m >> 4 & 0xF)];
      j = n + 1;
      arrayOfChar[n] = a[(m & 0xF)];
      i += 1;
    }
    return new String(arrayOfChar);
  }
  
  public ByteString md5()
  {
    return a("MD5");
  }
  
  public boolean rangeEquals(int paramInt1, ByteString paramByteString, int paramInt2, int paramInt3)
  {
    return paramByteString.rangeEquals(paramInt2, this.b, paramInt1, paramInt3);
  }
  
  public boolean rangeEquals(int paramInt1, byte[] paramArrayOfByte, int paramInt2, int paramInt3)
  {
    return (paramInt1 <= this.b.length - paramInt3) && (paramInt2 <= paramArrayOfByte.length - paramInt3) && (ua.a(this.b, paramInt1, paramArrayOfByte, paramInt2, paramInt3));
  }
  
  public ByteString sha256()
  {
    return a("SHA-256");
  }
  
  public int size()
  {
    return this.b.length;
  }
  
  public ByteString substring(int paramInt)
  {
    return substring(paramInt, this.b.length);
  }
  
  public ByteString substring(int paramInt1, int paramInt2)
  {
    if (paramInt1 < 0) {
      throw new IllegalArgumentException("beginIndex < 0");
    }
    if (paramInt2 > this.b.length) {
      throw new IllegalArgumentException("endIndex > length(" + this.b.length + ")");
    }
    int i = paramInt2 - paramInt1;
    if (i < 0) {
      throw new IllegalArgumentException("endIndex < beginIndex");
    }
    if ((paramInt1 == 0) && (paramInt2 == this.b.length)) {
      return this;
    }
    byte[] arrayOfByte = new byte[i];
    System.arraycopy(this.b, paramInt1, arrayOfByte, 0, i);
    return new ByteString(arrayOfByte);
  }
  
  public ByteString toAsciiLowercase()
  {
    int i = 0;
    for (;;)
    {
      Object localObject = this;
      if (i < this.b.length)
      {
        int j = this.b[i];
        if ((j >= 65) && (j <= 90))
        {
          localObject = (byte[])this.b.clone();
          localObject[i] = ((byte)(j + 32));
          i += 1;
          while (i < localObject.length)
          {
            j = localObject[i];
            if ((j >= 65) && (j <= 90)) {
              localObject[i] = ((byte)(j + 32));
            }
            i += 1;
          }
          localObject = new ByteString((byte[])localObject);
        }
      }
      else
      {
        return (ByteString)localObject;
      }
      i += 1;
    }
  }
  
  public ByteString toAsciiUppercase()
  {
    int i = 0;
    for (;;)
    {
      Object localObject = this;
      if (i < this.b.length)
      {
        int j = this.b[i];
        if ((j >= 97) && (j <= 122))
        {
          localObject = (byte[])this.b.clone();
          localObject[i] = ((byte)(j - 32));
          i += 1;
          while (i < localObject.length)
          {
            j = localObject[i];
            if ((j >= 97) && (j <= 122)) {
              localObject[i] = ((byte)(j - 32));
            }
            i += 1;
          }
          localObject = new ByteString((byte[])localObject);
        }
      }
      else
      {
        return (ByteString)localObject;
      }
      i += 1;
    }
  }
  
  public byte[] toByteArray()
  {
    return (byte[])this.b.clone();
  }
  
  public String toString()
  {
    if (this.b.length == 0) {
      return "ByteString[size=0]";
    }
    if (this.b.length <= 16) {
      return String.format("ByteString[size=%s data=%s]", new Object[] { Integer.valueOf(this.b.length), hex() });
    }
    return String.format("ByteString[size=%s md5=%s]", new Object[] { Integer.valueOf(this.b.length), md5().hex() });
  }
  
  public String utf8()
  {
    String str = this.d;
    if (str != null) {
      return str;
    }
    str = new String(this.b, ua.a);
    this.d = str;
    return str;
  }
  
  public void write(OutputStream paramOutputStream)
    throws IOException
  {
    if (paramOutputStream == null) {
      throw new IllegalArgumentException("out == null");
    }
    paramOutputStream.write(this.b);
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/okio/ByteString.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */