package com.google.common.primitives;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import java.io.Serializable;
import java.util.AbstractList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.RandomAccess;

@GwtCompatible
public final class Booleans
{
  public static List<Boolean> asList(boolean... paramVarArgs)
  {
    if (paramVarArgs.length == 0) {
      return Collections.emptyList();
    }
    return new a(paramVarArgs);
  }
  
  private static int c(boolean[] paramArrayOfBoolean, boolean paramBoolean, int paramInt1, int paramInt2)
  {
    while (paramInt1 < paramInt2)
    {
      if (paramArrayOfBoolean[paramInt1] == paramBoolean) {
        return paramInt1;
      }
      paramInt1 += 1;
    }
    return -1;
  }
  
  public static int compare(boolean paramBoolean1, boolean paramBoolean2)
  {
    if (paramBoolean1 == paramBoolean2) {
      return 0;
    }
    if (paramBoolean1) {
      return 1;
    }
    return -1;
  }
  
  public static boolean[] concat(boolean[]... paramVarArgs)
  {
    int k = paramVarArgs.length;
    int i = 0;
    int j = 0;
    while (i < k)
    {
      j += paramVarArgs[i].length;
      i += 1;
    }
    boolean[] arrayOfBoolean1 = new boolean[j];
    k = paramVarArgs.length;
    j = 0;
    i = 0;
    while (i < k)
    {
      boolean[] arrayOfBoolean2 = paramVarArgs[i];
      System.arraycopy(arrayOfBoolean2, 0, arrayOfBoolean1, j, arrayOfBoolean2.length);
      j += arrayOfBoolean2.length;
      i += 1;
    }
    return arrayOfBoolean1;
  }
  
  public static boolean contains(boolean[] paramArrayOfBoolean, boolean paramBoolean)
  {
    boolean bool2 = false;
    int j = paramArrayOfBoolean.length;
    int i = 0;
    for (;;)
    {
      boolean bool1 = bool2;
      if (i < j)
      {
        if (paramArrayOfBoolean[i] == paramBoolean) {
          bool1 = true;
        }
      }
      else {
        return bool1;
      }
      i += 1;
    }
  }
  
  @Beta
  public static int countTrue(boolean... paramVarArgs)
  {
    int j = 0;
    int m = paramVarArgs.length;
    int i = 0;
    while (i < m)
    {
      int k = j;
      if (paramVarArgs[i] != 0) {
        k = j + 1;
      }
      i += 1;
      j = k;
    }
    return j;
  }
  
  private static int d(boolean[] paramArrayOfBoolean, boolean paramBoolean, int paramInt1, int paramInt2)
  {
    paramInt2 -= 1;
    while (paramInt2 >= paramInt1)
    {
      if (paramArrayOfBoolean[paramInt2] == paramBoolean) {
        return paramInt2;
      }
      paramInt2 -= 1;
    }
    return -1;
  }
  
  public static boolean[] ensureCapacity(boolean[] paramArrayOfBoolean, int paramInt1, int paramInt2)
  {
    if (paramInt1 >= 0)
    {
      bool = true;
      Preconditions.checkArgument(bool, "Invalid minLength: %s", new Object[] { Integer.valueOf(paramInt1) });
      if (paramInt2 < 0) {
        break label86;
      }
    }
    label86:
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "Invalid padding: %s", new Object[] { Integer.valueOf(paramInt2) });
      boolean[] arrayOfBoolean = paramArrayOfBoolean;
      if (paramArrayOfBoolean.length < paramInt1)
      {
        paramInt1 += paramInt2;
        arrayOfBoolean = new boolean[paramInt1];
        System.arraycopy(paramArrayOfBoolean, 0, arrayOfBoolean, 0, Math.min(paramArrayOfBoolean.length, paramInt1));
      }
      return arrayOfBoolean;
      bool = false;
      break;
    }
  }
  
  public static int hashCode(boolean paramBoolean)
  {
    if (paramBoolean) {
      return 1231;
    }
    return 1237;
  }
  
  public static int indexOf(boolean[] paramArrayOfBoolean, boolean paramBoolean)
  {
    return c(paramArrayOfBoolean, paramBoolean, 0, paramArrayOfBoolean.length);
  }
  
  public static int indexOf(boolean[] paramArrayOfBoolean1, boolean[] paramArrayOfBoolean2)
  {
    Preconditions.checkNotNull(paramArrayOfBoolean1, "array");
    Preconditions.checkNotNull(paramArrayOfBoolean2, "target");
    if (paramArrayOfBoolean2.length == 0) {
      return 0;
    }
    int i = 0;
    while (i < paramArrayOfBoolean1.length - paramArrayOfBoolean2.length + 1)
    {
      int j = 0;
      while (j < paramArrayOfBoolean2.length)
      {
        if (paramArrayOfBoolean1[(i + j)] != paramArrayOfBoolean2[j]) {
          break label62;
        }
        j += 1;
      }
      return i;
      label62:
      i += 1;
    }
    return -1;
  }
  
  public static String join(String paramString, boolean... paramVarArgs)
  {
    Preconditions.checkNotNull(paramString);
    if (paramVarArgs.length == 0) {
      return "";
    }
    StringBuilder localStringBuilder = new StringBuilder(paramVarArgs.length * 7);
    localStringBuilder.append(paramVarArgs[0]);
    int i = 1;
    while (i < paramVarArgs.length)
    {
      localStringBuilder.append(paramString).append(paramVarArgs[i]);
      i += 1;
    }
    return localStringBuilder.toString();
  }
  
  public static int lastIndexOf(boolean[] paramArrayOfBoolean, boolean paramBoolean)
  {
    return d(paramArrayOfBoolean, paramBoolean, 0, paramArrayOfBoolean.length);
  }
  
  public static Comparator<boolean[]> lexicographicalComparator()
  {
    return b.a;
  }
  
  public static boolean[] toArray(Collection<Boolean> paramCollection)
  {
    int i = 0;
    if ((paramCollection instanceof a))
    {
      paramCollection = (a)paramCollection;
      i = paramCollection.size();
      arrayOfBoolean = new boolean[i];
      System.arraycopy(paramCollection.a, paramCollection.b, arrayOfBoolean, 0, i);
      return arrayOfBoolean;
    }
    paramCollection = paramCollection.toArray();
    int j = paramCollection.length;
    boolean[] arrayOfBoolean = new boolean[j];
    while (i < j)
    {
      arrayOfBoolean[i] = ((Boolean)Preconditions.checkNotNull(paramCollection[i])).booleanValue();
      i += 1;
    }
    return arrayOfBoolean;
  }
  
  @GwtCompatible
  static final class a
    extends AbstractList<Boolean>
    implements Serializable, RandomAccess
  {
    private static final long serialVersionUID = 0L;
    final boolean[] a;
    final int b;
    final int c;
    
    a(boolean[] paramArrayOfBoolean)
    {
      this(paramArrayOfBoolean, 0, paramArrayOfBoolean.length);
    }
    
    private a(boolean[] paramArrayOfBoolean, int paramInt1, int paramInt2)
    {
      this.a = paramArrayOfBoolean;
      this.b = paramInt1;
      this.c = paramInt2;
    }
    
    public final boolean contains(Object paramObject)
    {
      return ((paramObject instanceof Boolean)) && (Booleans.a(this.a, ((Boolean)paramObject).booleanValue(), this.b, this.c) != -1);
    }
    
    public final boolean equals(Object paramObject)
    {
      if (paramObject == this) {}
      for (;;)
      {
        return true;
        if (!(paramObject instanceof a)) {
          break;
        }
        paramObject = (a)paramObject;
        int j = size();
        if (((a)paramObject).size() != j) {
          return false;
        }
        int i = 0;
        while (i < j)
        {
          if (this.a[(this.b + i)] != paramObject.a[(paramObject.b + i)]) {
            return false;
          }
          i += 1;
        }
      }
      return super.equals(paramObject);
    }
    
    public final int hashCode()
    {
      int j = 1;
      int i = this.b;
      while (i < this.c)
      {
        j = j * 31 + Booleans.hashCode(this.a[i]);
        i += 1;
      }
      return j;
    }
    
    public final int indexOf(Object paramObject)
    {
      if ((paramObject instanceof Boolean))
      {
        int i = Booleans.a(this.a, ((Boolean)paramObject).booleanValue(), this.b, this.c);
        if (i >= 0) {
          return i - this.b;
        }
      }
      return -1;
    }
    
    public final boolean isEmpty()
    {
      return false;
    }
    
    public final int lastIndexOf(Object paramObject)
    {
      if ((paramObject instanceof Boolean))
      {
        int i = Booleans.b(this.a, ((Boolean)paramObject).booleanValue(), this.b, this.c);
        if (i >= 0) {
          return i - this.b;
        }
      }
      return -1;
    }
    
    public final int size()
    {
      return this.c - this.b;
    }
    
    public final List<Boolean> subList(int paramInt1, int paramInt2)
    {
      Preconditions.checkPositionIndexes(paramInt1, paramInt2, size());
      if (paramInt1 == paramInt2) {
        return Collections.emptyList();
      }
      return new a(this.a, this.b + paramInt1, this.b + paramInt2);
    }
    
    public final String toString()
    {
      StringBuilder localStringBuilder = new StringBuilder(size() * 7);
      int i;
      if (this.a[this.b] != 0)
      {
        str = "[true";
        localStringBuilder.append(str);
        i = this.b + 1;
        label43:
        if (i >= this.c) {
          break label88;
        }
        if (this.a[i] == 0) {
          break label82;
        }
      }
      label82:
      for (String str = ", true";; str = ", false")
      {
        localStringBuilder.append(str);
        i += 1;
        break label43;
        str = "[false";
        break;
      }
      label88:
      return ']';
    }
  }
  
  static enum b
    implements Comparator<boolean[]>
  {
    private b() {}
  }
}


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