package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import java.io.Serializable;
import java.util.AbstractCollection;
import java.util.Collection;
import java.util.Iterator;
import javax.annotation.Nullable;
import nj;
import ph;

@GwtCompatible(emulated=true)
public abstract class ImmutableCollection<E>
  extends AbstractCollection<E>
  implements Serializable
{
  private transient ImmutableList<E> a;
  
  protected int a(Object[] paramArrayOfObject, int paramInt)
  {
    Iterator localIterator = iterator();
    while (localIterator.hasNext())
    {
      paramArrayOfObject[paramInt] = localIterator.next();
      paramInt += 1;
    }
    return paramInt;
  }
  
  public abstract boolean a();
  
  @Deprecated
  public final boolean add(E paramE)
  {
    throw new UnsupportedOperationException();
  }
  
  @Deprecated
  public final boolean addAll(Collection<? extends E> paramCollection)
  {
    throw new UnsupportedOperationException();
  }
  
  public ImmutableList<E> asList()
  {
    ImmutableList localImmutableList2 = this.a;
    ImmutableList localImmutableList1 = localImmutableList2;
    if (localImmutableList2 == null)
    {
      localImmutableList1 = c();
      this.a = localImmutableList1;
    }
    return localImmutableList1;
  }
  
  public ImmutableList<E> c()
  {
    switch (size())
    {
    default: 
      return new ph(this, toArray());
    case 0: 
      return ImmutableList.of();
    }
    return ImmutableList.of(iterator().next());
  }
  
  @Deprecated
  public final void clear()
  {
    throw new UnsupportedOperationException();
  }
  
  public boolean contains(@Nullable Object paramObject)
  {
    return (paramObject != null) && (super.contains(paramObject));
  }
  
  public abstract UnmodifiableIterator<E> iterator();
  
  @Deprecated
  public final boolean remove(Object paramObject)
  {
    throw new UnsupportedOperationException();
  }
  
  @Deprecated
  public final boolean removeAll(Collection<?> paramCollection)
  {
    throw new UnsupportedOperationException();
  }
  
  @Deprecated
  public final boolean retainAll(Collection<?> paramCollection)
  {
    throw new UnsupportedOperationException();
  }
  
  public final Object[] toArray()
  {
    int i = size();
    if (i == 0) {
      return ObjectArrays.a;
    }
    Object[] arrayOfObject = new Object[i];
    a(arrayOfObject, 0);
    return arrayOfObject;
  }
  
  public final <T> T[] toArray(T[] paramArrayOfT)
  {
    Preconditions.checkNotNull(paramArrayOfT);
    int i = size();
    Object localObject;
    if (paramArrayOfT.length < i) {
      localObject = ObjectArrays.newArray(paramArrayOfT, i);
    }
    for (;;)
    {
      a((Object[])localObject, 0);
      return (T[])localObject;
      localObject = paramArrayOfT;
      if (paramArrayOfT.length > i)
      {
        paramArrayOfT[i] = null;
        localObject = paramArrayOfT;
      }
    }
  }
  
  public Object writeReplace()
  {
    return new ImmutableList.b(toArray());
  }
  
  public static abstract class Builder<E>
  {
    static int a(int paramInt1, int paramInt2)
    {
      if (paramInt2 < 0) {
        throw new AssertionError("cannot store more than MAX_VALUE elements");
      }
      int i = (paramInt1 >> 1) + paramInt1 + 1;
      paramInt1 = i;
      if (i < paramInt2) {
        paramInt1 = Integer.highestOneBit(paramInt2 - 1) << 1;
      }
      paramInt2 = paramInt1;
      if (paramInt1 < 0) {
        paramInt2 = Integer.MAX_VALUE;
      }
      return paramInt2;
    }
    
    public abstract Builder<E> add(E paramE);
    
    public Builder<E> add(E... paramVarArgs)
    {
      int j = paramVarArgs.length;
      int i = 0;
      while (i < j)
      {
        add(paramVarArgs[i]);
        i += 1;
      }
      return this;
    }
    
    public Builder<E> addAll(Iterable<? extends E> paramIterable)
    {
      paramIterable = paramIterable.iterator();
      while (paramIterable.hasNext()) {
        add(paramIterable.next());
      }
      return this;
    }
    
    public Builder<E> addAll(Iterator<? extends E> paramIterator)
    {
      while (paramIterator.hasNext()) {
        add(paramIterator.next());
      }
      return this;
    }
    
    public abstract ImmutableCollection<E> build();
  }
  
  static abstract class a<E>
    extends ImmutableCollection.Builder<E>
  {
    Object[] a;
    int b;
    
    a(int paramInt)
    {
      nj.a(paramInt, "initialCapacity");
      this.a = new Object[paramInt];
      this.b = 0;
    }
    
    private void a(int paramInt)
    {
      if (this.a.length < paramInt) {
        this.a = ObjectArrays.a(this.a, a(this.a.length, paramInt));
      }
    }
    
    public ImmutableCollection.Builder<E> add(E... paramVarArgs)
    {
      ObjectArrays.a(paramVarArgs);
      a(this.b + paramVarArgs.length);
      System.arraycopy(paramVarArgs, 0, this.a, this.b, paramVarArgs.length);
      this.b += paramVarArgs.length;
      return this;
    }
    
    public a<E> add(E paramE)
    {
      Preconditions.checkNotNull(paramE);
      a(this.b + 1);
      Object[] arrayOfObject = this.a;
      int i = this.b;
      this.b = (i + 1);
      arrayOfObject[i] = paramE;
      return this;
    }
    
    public ImmutableCollection.Builder<E> addAll(Iterable<? extends E> paramIterable)
    {
      if ((paramIterable instanceof Collection))
      {
        Collection localCollection = (Collection)paramIterable;
        int i = this.b;
        a(localCollection.size() + i);
      }
      super.addAll(paramIterable);
      return this;
    }
  }
}


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