package com.google.common.collect;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.base.Preconditions;
import com.google.common.primitives.Ints;
import java.io.Serializable;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Set;
import javax.annotation.Nullable;
import na;
import nq;
import pp;

@Beta
public final class ImmutableRangeSet<C extends Comparable>
  extends na<C>
  implements Serializable
{
  private static final ImmutableRangeSet<Comparable<?>> a = new ImmutableRangeSet(ImmutableList.of());
  private static final ImmutableRangeSet<Comparable<?>> b = new ImmutableRangeSet(ImmutableList.of(Range.all()));
  private final transient ImmutableList<Range<C>> c;
  private transient ImmutableRangeSet<C> d;
  
  ImmutableRangeSet(ImmutableList<Range<C>> paramImmutableList)
  {
    this.c = paramImmutableList;
  }
  
  private ImmutableRangeSet(ImmutableList<Range<C>> paramImmutableList, ImmutableRangeSet<C> paramImmutableRangeSet)
  {
    this.c = paramImmutableList;
    this.d = paramImmutableRangeSet;
  }
  
  static <C extends Comparable> ImmutableRangeSet<C> a()
  {
    return b;
  }
  
  public static <C extends Comparable<?>> Builder<C> builder()
  {
    return new Builder();
  }
  
  public static <C extends Comparable> ImmutableRangeSet<C> copyOf(RangeSet<C> paramRangeSet)
  {
    Preconditions.checkNotNull(paramRangeSet);
    Object localObject;
    if (paramRangeSet.isEmpty()) {
      localObject = of();
    }
    ImmutableRangeSet localImmutableRangeSet;
    do
    {
      return (ImmutableRangeSet<C>)localObject;
      if (paramRangeSet.encloses(Range.all())) {
        return b;
      }
      if (!(paramRangeSet instanceof ImmutableRangeSet)) {
        break;
      }
      localImmutableRangeSet = (ImmutableRangeSet)paramRangeSet;
      localObject = localImmutableRangeSet;
    } while (!localImmutableRangeSet.c.a());
    return new ImmutableRangeSet(ImmutableList.copyOf(paramRangeSet.asRanges()));
  }
  
  public static <C extends Comparable> ImmutableRangeSet<C> of()
  {
    return a;
  }
  
  public static <C extends Comparable> ImmutableRangeSet<C> of(Range<C> paramRange)
  {
    Preconditions.checkNotNull(paramRange);
    if (paramRange.isEmpty()) {
      return of();
    }
    if (paramRange.equals(Range.all())) {
      return b;
    }
    return new ImmutableRangeSet(ImmutableList.of(paramRange));
  }
  
  public final void add(Range<C> paramRange)
  {
    throw new UnsupportedOperationException();
  }
  
  public final void addAll(RangeSet<C> paramRangeSet)
  {
    throw new UnsupportedOperationException();
  }
  
  public final ImmutableSet<Range<C>> asRanges()
  {
    if (this.c.isEmpty()) {
      return ImmutableSet.of();
    }
    return new pp(this.c, Range.a);
  }
  
  public final ImmutableSortedSet<C> asSet(DiscreteDomain<C> paramDiscreteDomain)
  {
    Preconditions.checkNotNull(paramDiscreteDomain);
    if (isEmpty()) {
      return ImmutableSortedSet.of();
    }
    Range localRange = span().canonical(paramDiscreteDomain);
    if (!localRange.hasLowerBound()) {
      throw new IllegalArgumentException("Neither the DiscreteDomain nor this range set are bounded below");
    }
    if (!localRange.hasUpperBound()) {}
    try
    {
      paramDiscreteDomain.maxValue();
      return new a(paramDiscreteDomain);
    }
    catch (NoSuchElementException paramDiscreteDomain)
    {
      throw new IllegalArgumentException("Neither the DiscreteDomain nor this range set are bounded above");
    }
  }
  
  public final ImmutableRangeSet<C> complement()
  {
    ImmutableRangeSet localImmutableRangeSet = this.d;
    if (localImmutableRangeSet != null) {
      return localImmutableRangeSet;
    }
    if (this.c.isEmpty())
    {
      localImmutableRangeSet = b;
      this.d = localImmutableRangeSet;
      return localImmutableRangeSet;
    }
    if ((this.c.size() == 1) && (((Range)this.c.get(0)).equals(Range.all())))
    {
      localImmutableRangeSet = of();
      this.d = localImmutableRangeSet;
      return localImmutableRangeSet;
    }
    localImmutableRangeSet = new ImmutableRangeSet(new c(), this);
    this.d = localImmutableRangeSet;
    return localImmutableRangeSet;
  }
  
  public final boolean encloses(Range<C> paramRange)
  {
    int i = SortedLists.a(this.c, Range.a(), paramRange.b, Ordering.natural(), SortedLists.KeyPresentBehavior.ANY_PRESENT, SortedLists.KeyAbsentBehavior.NEXT_LOWER);
    return (i != -1) && (((Range)this.c.get(i)).encloses(paramRange));
  }
  
  public final boolean isEmpty()
  {
    return this.c.isEmpty();
  }
  
  public final Range<C> rangeContaining(C paramC)
  {
    int i = SortedLists.a(this.c, Range.a(), nq.b(paramC), Ordering.natural(), SortedLists.KeyPresentBehavior.ANY_PRESENT, SortedLists.KeyAbsentBehavior.NEXT_LOWER);
    if (i != -1)
    {
      Range localRange = (Range)this.c.get(i);
      if (localRange.contains(paramC)) {
        return localRange;
      }
      return null;
    }
    return null;
  }
  
  public final void remove(Range<C> paramRange)
  {
    throw new UnsupportedOperationException();
  }
  
  public final void removeAll(RangeSet<C> paramRangeSet)
  {
    throw new UnsupportedOperationException();
  }
  
  public final Range<C> span()
  {
    if (this.c.isEmpty()) {
      throw new NoSuchElementException();
    }
    return Range.a(((Range)this.c.get(0)).b, ((Range)this.c.get(this.c.size() - 1)).c);
  }
  
  public final ImmutableRangeSet<C> subRangeSet(final Range<C> paramRange)
  {
    if (!isEmpty())
    {
      Range localRange = span();
      if (paramRange.encloses(localRange)) {
        return this;
      }
      if (paramRange.isConnected(localRange))
      {
        if ((this.c.isEmpty()) || (paramRange.isEmpty())) {
          paramRange = ImmutableList.of();
        }
        for (;;)
        {
          return new ImmutableRangeSet(paramRange);
          if (paramRange.encloses(span()))
          {
            paramRange = this.c;
          }
          else
          {
            final int i;
            if (paramRange.hasLowerBound())
            {
              i = SortedLists.a(this.c, Range.b(), paramRange.b, SortedLists.KeyPresentBehavior.FIRST_AFTER, SortedLists.KeyAbsentBehavior.NEXT_HIGHER);
              label110:
              if (!paramRange.hasUpperBound()) {
                break label158;
              }
            }
            label158:
            for (final int j = SortedLists.a(this.c, Range.a(), paramRange.c, SortedLists.KeyPresentBehavior.FIRST_PRESENT, SortedLists.KeyAbsentBehavior.NEXT_HIGHER);; j = this.c.size())
            {
              j -= i;
              if (j != 0) {
                break label169;
              }
              paramRange = ImmutableList.of();
              break;
              i = 0;
              break label110;
            }
            label169:
            paramRange = new ImmutableList()
            {
              final boolean a()
              {
                return true;
              }
              
              public final int size()
              {
                return j;
              }
            };
          }
        }
      }
    }
    return of();
  }
  
  final Object writeReplace()
  {
    return new d(this.c);
  }
  
  public static class Builder<C extends Comparable<?>>
  {
    private final RangeSet<C> a = TreeRangeSet.create();
    
    public Builder<C> add(Range<C> paramRange)
    {
      if (paramRange.isEmpty())
      {
        paramRange = String.valueOf(String.valueOf(paramRange));
        throw new IllegalArgumentException(paramRange.length() + 33 + "range must not be empty, but was " + paramRange);
      }
      if (!this.a.complement().encloses(paramRange))
      {
        Iterator localIterator = this.a.asRanges().iterator();
        if (localIterator.hasNext())
        {
          Range localRange = (Range)localIterator.next();
          if ((!localRange.isConnected(paramRange)) || (localRange.intersection(paramRange).isEmpty())) {}
          for (boolean bool = true;; bool = false)
          {
            Preconditions.checkArgument(bool, "Ranges may not overlap, but received %s and %s", new Object[] { localRange, paramRange });
            break;
          }
        }
        throw new AssertionError("should have thrown an IAE above");
      }
      this.a.add(paramRange);
      return this;
    }
    
    public Builder<C> addAll(RangeSet<C> paramRangeSet)
    {
      paramRangeSet = paramRangeSet.asRanges().iterator();
      while (paramRangeSet.hasNext()) {
        add((Range)paramRangeSet.next());
      }
      return this;
    }
    
    public ImmutableRangeSet<C> build()
    {
      return ImmutableRangeSet.copyOf(this.a);
    }
  }
  
  final class a
    extends ImmutableSortedSet<C>
  {
    private final DiscreteDomain<C> d;
    private transient Integer e;
    
    a()
    {
      super();
      DiscreteDomain localDiscreteDomain;
      this.d = localDiscreteDomain;
    }
    
    private ImmutableSortedSet<C> a(Range<C> paramRange)
    {
      return ImmutableRangeSet.this.subRangeSet(paramRange).asSet(this.d);
    }
    
    final int a(Object paramObject)
    {
      if (contains(paramObject))
      {
        paramObject = (Comparable)paramObject;
        Iterator localIterator = ImmutableRangeSet.a(ImmutableRangeSet.this).iterator();
        Range localRange;
        for (long l = 0L; localIterator.hasNext(); l = ContiguousSet.create(localRange, this.d).size() + l)
        {
          localRange = (Range)localIterator.next();
          if (localRange.contains((Comparable)paramObject)) {
            return Ints.saturatedCast(ContiguousSet.create(localRange, this.d).a(paramObject) + l);
          }
        }
        throw new AssertionError("impossible");
      }
      return -1;
    }
    
    final boolean a()
    {
      return ImmutableRangeSet.a(ImmutableRangeSet.this).a();
    }
    
    public final boolean contains(@Nullable Object paramObject)
    {
      if (paramObject == null) {
        return false;
      }
      try
      {
        paramObject = (Comparable)paramObject;
        boolean bool = ImmutableRangeSet.this.contains((Comparable)paramObject);
        return bool;
      }
      catch (ClassCastException paramObject) {}
      return false;
    }
    
    @GwtIncompatible("NavigableSet")
    public final UnmodifiableIterator<C> descendingIterator()
    {
      new AbstractIterator()
      {
        final Iterator<Range<C>> a = ImmutableRangeSet.a(ImmutableRangeSet.this).reverse().iterator();
        Iterator<C> b = Iterators.emptyIterator();
      };
    }
    
    public final UnmodifiableIterator<C> iterator()
    {
      new AbstractIterator()
      {
        final Iterator<Range<C>> a = ImmutableRangeSet.a(ImmutableRangeSet.this).iterator();
        Iterator<C> b = Iterators.emptyIterator();
      };
    }
    
    public final int size()
    {
      Integer localInteger = this.e;
      Object localObject = localInteger;
      long l;
      if (localInteger == null)
      {
        localObject = ImmutableRangeSet.a(ImmutableRangeSet.this).iterator();
        l = 0L;
        if (!((Iterator)localObject).hasNext()) {
          break label88;
        }
        l = ContiguousSet.create((Range)((Iterator)localObject).next(), this.d).size() + l;
        if (l < 2147483647L) {
          break label85;
        }
      }
      label85:
      label88:
      for (;;)
      {
        localObject = Integer.valueOf(Ints.saturatedCast(l));
        this.e = ((Integer)localObject);
        return ((Integer)localObject).intValue();
        break;
      }
    }
    
    public final String toString()
    {
      return ImmutableRangeSet.a(ImmutableRangeSet.this).toString();
    }
    
    final Object writeReplace()
    {
      return new ImmutableRangeSet.b(ImmutableRangeSet.a(ImmutableRangeSet.this), this.d);
    }
  }
  
  static final class b<C extends Comparable>
    implements Serializable
  {
    private final ImmutableList<Range<C>> a;
    private final DiscreteDomain<C> b;
    
    b(ImmutableList<Range<C>> paramImmutableList, DiscreteDomain<C> paramDiscreteDomain)
    {
      this.a = paramImmutableList;
      this.b = paramDiscreteDomain;
    }
    
    final Object readResolve()
    {
      return new ImmutableRangeSet(this.a).asSet(this.b);
    }
  }
  
  final class c
    extends ImmutableList<Range<C>>
  {
    private final boolean b = ((Range)ImmutableRangeSet.a(ImmutableRangeSet.this).get(0)).hasLowerBound();
    private final boolean c = ((Range)Iterables.getLast(ImmutableRangeSet.a(ImmutableRangeSet.this))).hasUpperBound();
    private final int d;
    
    c()
    {
      int j = ImmutableRangeSet.a(ImmutableRangeSet.this).size() - 1;
      int i = j;
      if (this.b) {
        i = j + 1;
      }
      j = i;
      if (this.c) {
        j = i + 1;
      }
      this.d = j;
    }
    
    final boolean a()
    {
      return true;
    }
    
    public final int size()
    {
      return this.d;
    }
  }
  
  static final class d<C extends Comparable>
    implements Serializable
  {
    private final ImmutableList<Range<C>> a;
    
    d(ImmutableList<Range<C>> paramImmutableList)
    {
      this.a = paramImmutableList;
    }
    
    final Object readResolve()
    {
      if (this.a.isEmpty()) {
        return ImmutableRangeSet.of();
      }
      if (this.a.equals(ImmutableList.of(Range.all()))) {
        return ImmutableRangeSet.a();
      }
      return new ImmutableRangeSet(this.a);
    }
  }
}


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