package com.google.common.collect;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.base.Preconditions;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import ns;
import ob;
import oz;
import po;
import pp;

@Beta
@GwtIncompatible("hasn't been tested yet")
public abstract class ImmutableSortedMultiset<E>
  extends oz<E>
  implements SortedMultiset<E>
{
  private static final Comparator<Comparable> b = ;
  private static final ImmutableSortedMultiset<Comparable> c = new ob(b);
  transient ImmutableSortedMultiset<E> a;
  
  protected static <E> ImmutableSortedMultiset<E> a(Comparator<? super E> paramComparator)
  {
    if (b.equals(paramComparator)) {
      return c;
    }
    return new ob(paramComparator);
  }
  
  private static <E> ImmutableSortedMultiset<E> a(Comparator<? super E> paramComparator, Collection<Multiset.Entry<E>> paramCollection)
  {
    if (paramCollection.isEmpty()) {
      return a(paramComparator);
    }
    ImmutableList.Builder localBuilder = new ImmutableList.Builder(paramCollection.size());
    int[] arrayOfInt = new int[paramCollection.size()];
    long[] arrayOfLong = new long[paramCollection.size() + 1];
    Iterator localIterator = paramCollection.iterator();
    int i = 0;
    while (localIterator.hasNext())
    {
      Multiset.Entry localEntry = (Multiset.Entry)localIterator.next();
      localBuilder.add(localEntry.getElement());
      arrayOfInt[i] = localEntry.getCount();
      arrayOfLong[(i + 1)] = (arrayOfLong[i] + arrayOfInt[i]);
      i += 1;
    }
    return new po(new pp(localBuilder.build(), paramComparator), arrayOfInt, arrayOfLong, 0, paramCollection.size());
  }
  
  public static <E> ImmutableSortedMultiset<E> copyOf(Iterable<? extends E> paramIterable)
  {
    return copyOf(Ordering.natural(), paramIterable);
  }
  
  public static <E> ImmutableSortedMultiset<E> copyOf(Comparator<? super E> paramComparator, Iterable<? extends E> paramIterable)
  {
    if ((paramIterable instanceof ImmutableSortedMultiset))
    {
      localObject = (ImmutableSortedMultiset)paramIterable;
      if (paramComparator.equals(((ImmutableSortedMultiset)localObject).comparator()))
      {
        paramIterable = (Iterable<? extends E>)localObject;
        if (((ImmutableSortedMultiset)localObject).a()) {
          paramIterable = a(paramComparator, ((ImmutableSortedMultiset)localObject).entrySet().asList());
        }
        return paramIterable;
      }
    }
    paramIterable = Lists.newArrayList(paramIterable);
    Object localObject = TreeMultiset.create((Comparator)Preconditions.checkNotNull(paramComparator));
    Iterables.addAll((Collection)localObject, paramIterable);
    return a(paramComparator, ((TreeMultiset)localObject).entrySet());
  }
  
  public static <E> ImmutableSortedMultiset<E> copyOf(Comparator<? super E> paramComparator, Iterator<? extends E> paramIterator)
  {
    Preconditions.checkNotNull(paramComparator);
    return new Builder(paramComparator).addAll(paramIterator).build();
  }
  
  public static <E> ImmutableSortedMultiset<E> copyOf(Iterator<? extends E> paramIterator)
  {
    return copyOf(Ordering.natural(), paramIterator);
  }
  
  public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> copyOf(E[] paramArrayOfE)
  {
    return copyOf(Ordering.natural(), Arrays.asList(paramArrayOfE));
  }
  
  public static <E> ImmutableSortedMultiset<E> copyOfSorted(SortedMultiset<E> paramSortedMultiset)
  {
    return a(paramSortedMultiset.comparator(), Lists.newArrayList(paramSortedMultiset.entrySet()));
  }
  
  public static <E extends Comparable<E>> Builder<E> naturalOrder()
  {
    return new Builder(Ordering.natural());
  }
  
  public static <E> ImmutableSortedMultiset<E> of()
  {
    return c;
  }
  
  public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E paramE)
  {
    return new po((pp)ImmutableSortedSet.of(paramE), new int[] { 1 }, new long[] { 0L, 1L }, 0, 1);
  }
  
  public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E paramE1, E paramE2)
  {
    return copyOf(Ordering.natural(), Arrays.asList(new Comparable[] { paramE1, paramE2 }));
  }
  
  public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E paramE1, E paramE2, E paramE3)
  {
    return copyOf(Ordering.natural(), Arrays.asList(new Comparable[] { paramE1, paramE2, paramE3 }));
  }
  
  public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E paramE1, E paramE2, E paramE3, E paramE4)
  {
    return copyOf(Ordering.natural(), Arrays.asList(new Comparable[] { paramE1, paramE2, paramE3, paramE4 }));
  }
  
  public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E paramE1, E paramE2, E paramE3, E paramE4, E paramE5)
  {
    return copyOf(Ordering.natural(), Arrays.asList(new Comparable[] { paramE1, paramE2, paramE3, paramE4, paramE5 }));
  }
  
  public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E paramE1, E paramE2, E paramE3, E paramE4, E paramE5, E paramE6, E... paramVarArgs)
  {
    ArrayList localArrayList = Lists.newArrayListWithCapacity(paramVarArgs.length + 6);
    Collections.addAll(localArrayList, new Comparable[] { paramE1, paramE2, paramE3, paramE4, paramE5, paramE6 });
    Collections.addAll(localArrayList, paramVarArgs);
    return copyOf(Ordering.natural(), localArrayList);
  }
  
  public static <E> Builder<E> orderedBy(Comparator<E> paramComparator)
  {
    return new Builder(paramComparator);
  }
  
  public static <E extends Comparable<E>> Builder<E> reverseOrder()
  {
    return new Builder(Ordering.natural().reverse());
  }
  
  public final Comparator<? super E> comparator()
  {
    return elementSet().comparator();
  }
  
  public ImmutableSortedMultiset<E> descendingMultiset()
  {
    ImmutableSortedMultiset localImmutableSortedMultiset = this.a;
    Object localObject = localImmutableSortedMultiset;
    if (localImmutableSortedMultiset == null)
    {
      localObject = new ns(this);
      this.a = ((ImmutableSortedMultiset)localObject);
    }
    return (ImmutableSortedMultiset<E>)localObject;
  }
  
  public abstract ImmutableSortedSet<E> elementSet();
  
  public abstract ImmutableSortedMultiset<E> headMultiset(E paramE, BoundType paramBoundType);
  
  @Deprecated
  public final Multiset.Entry<E> pollFirstEntry()
  {
    throw new UnsupportedOperationException();
  }
  
  @Deprecated
  public final Multiset.Entry<E> pollLastEntry()
  {
    throw new UnsupportedOperationException();
  }
  
  public ImmutableSortedMultiset<E> subMultiset(E paramE1, BoundType paramBoundType1, E paramE2, BoundType paramBoundType2)
  {
    if (comparator().compare(paramE1, paramE2) <= 0) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "Expected lowerBound <= upperBound but %s > %s", new Object[] { paramE1, paramE2 });
      return tailMultiset(paramE1, paramBoundType1).headMultiset(paramE2, paramBoundType2);
    }
  }
  
  public abstract ImmutableSortedMultiset<E> tailMultiset(E paramE, BoundType paramBoundType);
  
  Object writeReplace()
  {
    return new a(this);
  }
  
  public static class Builder<E>
    extends ImmutableMultiset.Builder<E>
  {
    public Builder(Comparator<? super E> paramComparator)
    {
      super();
    }
    
    public Builder<E> add(E paramE)
    {
      super.add(paramE);
      return this;
    }
    
    public Builder<E> add(E... paramVarArgs)
    {
      super.add(paramVarArgs);
      return this;
    }
    
    public Builder<E> addAll(Iterable<? extends E> paramIterable)
    {
      super.addAll(paramIterable);
      return this;
    }
    
    public Builder<E> addAll(Iterator<? extends E> paramIterator)
    {
      super.addAll(paramIterator);
      return this;
    }
    
    public Builder<E> addCopies(E paramE, int paramInt)
    {
      super.addCopies(paramE, paramInt);
      return this;
    }
    
    public ImmutableSortedMultiset<E> build()
    {
      return ImmutableSortedMultiset.copyOfSorted((SortedMultiset)this.a);
    }
    
    public Builder<E> setCount(E paramE, int paramInt)
    {
      super.setCount(paramE, paramInt);
      return this;
    }
  }
  
  static final class a<E>
    implements Serializable
  {
    Comparator<? super E> a;
    E[] b;
    int[] c;
    
    a(SortedMultiset<E> paramSortedMultiset)
    {
      this.a = paramSortedMultiset.comparator();
      int i = paramSortedMultiset.entrySet().size();
      this.b = ((Object[])new Object[i]);
      this.c = new int[i];
      paramSortedMultiset = paramSortedMultiset.entrySet().iterator();
      i = 0;
      while (paramSortedMultiset.hasNext())
      {
        Multiset.Entry localEntry = (Multiset.Entry)paramSortedMultiset.next();
        this.b[i] = localEntry.getElement();
        this.c[i] = localEntry.getCount();
        i += 1;
      }
    }
    
    final Object readResolve()
    {
      int j = this.b.length;
      ImmutableSortedMultiset.Builder localBuilder = new ImmutableSortedMultiset.Builder(this.a);
      int i = 0;
      while (i < j)
      {
        localBuilder.addCopies(this.b[i], this.c[i]);
        i += 1;
      }
      return localBuilder.build();
    }
  }
}


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