package com.google.common.collect;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.NavigableMap;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import javax.annotation.Nullable;
import mz;
import na;
import nq;

@Beta
@GwtIncompatible("uses NavigableMap")
public class TreeRangeSet<C extends Comparable<?>>
  extends na<C>
{
  @VisibleForTesting
  final NavigableMap<nq<C>, Range<C>> a;
  private transient Set<Range<C>> b;
  private transient RangeSet<C> c;
  
  private TreeRangeSet(NavigableMap<nq<C>, Range<C>> paramNavigableMap)
  {
    this.a = paramNavigableMap;
  }
  
  private void a(Range<C> paramRange)
  {
    if (paramRange.isEmpty())
    {
      this.a.remove(paramRange.b);
      return;
    }
    this.a.put(paramRange.b, paramRange);
  }
  
  public static <C extends Comparable<?>> TreeRangeSet<C> create()
  {
    return new TreeRangeSet(new TreeMap());
  }
  
  public static <C extends Comparable<?>> TreeRangeSet<C> create(RangeSet<C> paramRangeSet)
  {
    TreeRangeSet localTreeRangeSet = create();
    localTreeRangeSet.addAll(paramRangeSet);
    return localTreeRangeSet;
  }
  
  public void add(Range<C> paramRange)
  {
    Preconditions.checkNotNull(paramRange);
    if (paramRange.isEmpty()) {
      return;
    }
    Object localObject2 = paramRange.b;
    Object localObject1 = paramRange.c;
    paramRange = this.a.lowerEntry(localObject2);
    Object localObject3;
    if (paramRange != null)
    {
      localObject3 = (Range)paramRange.getValue();
      if (((Range)localObject3).c.a((nq)localObject2) >= 0)
      {
        paramRange = (Range<C>)localObject1;
        if (((Range)localObject3).c.a((nq)localObject1) >= 0) {
          paramRange = ((Range)localObject3).c;
        }
      }
    }
    for (localObject1 = ((Range)localObject3).b;; localObject1 = localObject2)
    {
      localObject3 = this.a.floorEntry(paramRange);
      localObject2 = paramRange;
      if (localObject3 != null)
      {
        localObject3 = (Range)((Map.Entry)localObject3).getValue();
        localObject2 = paramRange;
        if (((Range)localObject3).c.a(paramRange) >= 0) {
          localObject2 = ((Range)localObject3).c;
        }
      }
      this.a.subMap(localObject1, localObject2).clear();
      a(Range.a((nq)localObject1, (nq)localObject2));
      return;
      paramRange = (Range<C>)localObject1;
    }
  }
  
  public Set<Range<C>> asRanges()
  {
    Set localSet = this.b;
    Object localObject = localSet;
    if (localSet == null)
    {
      localObject = new a();
      this.b = ((Set)localObject);
    }
    return (Set<Range<C>>)localObject;
  }
  
  public RangeSet<C> complement()
  {
    RangeSet localRangeSet = this.c;
    Object localObject = localRangeSet;
    if (localRangeSet == null)
    {
      localObject = new b();
      this.c = ((RangeSet)localObject);
    }
    return (RangeSet<C>)localObject;
  }
  
  public boolean encloses(Range<C> paramRange)
  {
    Preconditions.checkNotNull(paramRange);
    Map.Entry localEntry = this.a.floorEntry(paramRange.b);
    return (localEntry != null) && (((Range)localEntry.getValue()).encloses(paramRange));
  }
  
  @Nullable
  public Range<C> rangeContaining(C paramC)
  {
    Preconditions.checkNotNull(paramC);
    Map.Entry localEntry = this.a.floorEntry(nq.b(paramC));
    if ((localEntry != null) && (((Range)localEntry.getValue()).contains(paramC))) {
      return (Range)localEntry.getValue();
    }
    return null;
  }
  
  public void remove(Range<C> paramRange)
  {
    Preconditions.checkNotNull(paramRange);
    if (paramRange.isEmpty()) {
      return;
    }
    Object localObject = this.a.lowerEntry(paramRange.b);
    if (localObject != null)
    {
      localObject = (Range)((Map.Entry)localObject).getValue();
      if (((Range)localObject).c.a(paramRange.b) >= 0)
      {
        if ((paramRange.hasUpperBound()) && (((Range)localObject).c.a(paramRange.c) >= 0)) {
          a(Range.a(paramRange.c, ((Range)localObject).c));
        }
        a(Range.a(((Range)localObject).b, paramRange.b));
      }
    }
    localObject = this.a.floorEntry(paramRange.c);
    if (localObject != null)
    {
      localObject = (Range)((Map.Entry)localObject).getValue();
      if ((paramRange.hasUpperBound()) && (((Range)localObject).c.a(paramRange.c) >= 0)) {
        a(Range.a(paramRange.c, ((Range)localObject).c));
      }
    }
    this.a.subMap(paramRange.b, paramRange.c).clear();
  }
  
  public Range<C> span()
  {
    Map.Entry localEntry1 = this.a.firstEntry();
    Map.Entry localEntry2 = this.a.lastEntry();
    if (localEntry1 == null) {
      throw new NoSuchElementException();
    }
    return Range.a(((Range)localEntry1.getValue()).b, ((Range)localEntry2.getValue()).c);
  }
  
  public RangeSet<C> subRangeSet(Range<C> paramRange)
  {
    if (paramRange.equals(Range.all())) {
      return this;
    }
    return new e(paramRange);
  }
  
  final class a
    extends ForwardingCollection<Range<C>>
    implements Set<Range<C>>
  {
    a() {}
    
    protected final Collection<Range<C>> delegate()
    {
      return TreeRangeSet.this.a.values();
    }
    
    public final boolean equals(@Nullable Object paramObject)
    {
      return Sets.a(this, paramObject);
    }
    
    public final int hashCode()
    {
      return Sets.a(this);
    }
  }
  
  final class b
    extends TreeRangeSet<C>
  {
    b()
    {
      super((byte)0);
    }
    
    public final void add(Range<C> paramRange)
    {
      TreeRangeSet.this.remove(paramRange);
    }
    
    public final RangeSet<C> complement()
    {
      return TreeRangeSet.this;
    }
    
    public final boolean contains(C paramC)
    {
      return !TreeRangeSet.this.contains(paramC);
    }
    
    public final void remove(Range<C> paramRange)
    {
      TreeRangeSet.this.add(paramRange);
    }
  }
  
  static final class c<C extends Comparable<?>>
    extends mz<nq<C>, Range<C>>
  {
    private final NavigableMap<nq<C>, Range<C>> a;
    private final NavigableMap<nq<C>, Range<C>> b;
    private final Range<nq<C>> c;
    
    c(NavigableMap<nq<C>, Range<C>> paramNavigableMap)
    {
      this(paramNavigableMap, Range.all());
    }
    
    private c(NavigableMap<nq<C>, Range<C>> paramNavigableMap, Range<nq<C>> paramRange)
    {
      this.a = paramNavigableMap;
      this.b = new TreeRangeSet.d(paramNavigableMap);
      this.c = paramRange;
    }
    
    @Nullable
    private Range<C> a(Object paramObject)
    {
      if ((paramObject instanceof nq)) {
        try
        {
          paramObject = (nq)paramObject;
          Map.Entry localEntry = a((nq)paramObject, true).firstEntry();
          if ((localEntry != null) && (((nq)localEntry.getKey()).equals(paramObject)))
          {
            paramObject = (Range)localEntry.getValue();
            return (Range<C>)paramObject;
          }
        }
        catch (ClassCastException paramObject)
        {
          return null;
        }
      }
      return null;
    }
    
    private NavigableMap<nq<C>, Range<C>> a(Range<nq<C>> paramRange)
    {
      if (!this.c.isConnected(paramRange)) {
        return ImmutableSortedMap.of();
      }
      paramRange = paramRange.intersection(this.c);
      return new c(this.a, paramRange);
    }
    
    private NavigableMap<nq<C>, Range<C>> a(nq<C> paramnq, boolean paramBoolean)
    {
      return a(Range.downTo(paramnq, BoundType.a(paramBoolean)));
    }
    
    final Iterator<Map.Entry<nq<C>, Range<C>>> a()
    {
      final Object localObject2;
      boolean bool;
      if (this.c.hasLowerBound())
      {
        localObject1 = this.b;
        localObject2 = this.c.lowerEndpoint();
        if (this.c.lowerBoundType() == BoundType.CLOSED)
        {
          bool = true;
          localObject1 = ((NavigableMap)localObject1).tailMap(localObject2, bool).values();
          label52:
          localObject2 = Iterators.peekingIterator(((Collection)localObject1).iterator());
          if ((!this.c.contains(nq.d())) || ((((PeekingIterator)localObject2).hasNext()) && (((Range)((PeekingIterator)localObject2).peek()).b == nq.d()))) {
            break label135;
          }
        }
      }
      for (final Object localObject1 = nq.d();; localObject1 = ((Range)((PeekingIterator)localObject2).next()).c)
      {
        new AbstractIterator()
        {
          nq<C> a = localObject1;
        };
        bool = false;
        break;
        localObject1 = this.b.values();
        break label52;
        label135:
        if (!((PeekingIterator)localObject2).hasNext()) {
          break label160;
        }
      }
      label160:
      return Iterators.emptyIterator();
    }
    
    final Iterator<Map.Entry<nq<C>, Range<C>>> b()
    {
      nq localnq;
      boolean bool;
      label46:
      final PeekingIterator localPeekingIterator;
      if (this.c.hasUpperBound())
      {
        localnq = (nq)this.c.upperEndpoint();
        if ((!this.c.hasUpperBound()) || (this.c.upperBoundType() != BoundType.CLOSED)) {
          break label143;
        }
        bool = true;
        localPeekingIterator = Iterators.peekingIterator(this.b.headMap(localnq, bool).descendingMap().values().iterator());
        if (!localPeekingIterator.hasNext()) {
          break label176;
        }
        if (((Range)localPeekingIterator.peek()).c != nq.e()) {
          break label148;
        }
        localnq = ((Range)localPeekingIterator.next()).b;
      }
      for (;;)
      {
        new AbstractIterator()
        {
          nq<C> a = this.b;
        };
        localnq = nq.e();
        break;
        label143:
        bool = false;
        break label46;
        label148:
        localnq = (nq)this.a.higherKey(((Range)localPeekingIterator.peek()).c);
        continue;
        label176:
        if ((!this.c.contains(nq.d())) || (this.a.containsKey(nq.d()))) {
          return Iterators.emptyIterator();
        }
        localnq = (nq)this.a.higherKey(nq.d());
      }
    }
    
    public final Comparator<? super nq<C>> comparator()
    {
      return Ordering.natural();
    }
    
    public final boolean containsKey(Object paramObject)
    {
      return a(paramObject) != null;
    }
    
    public final int size()
    {
      return Iterators.size(a());
    }
  }
  
  @VisibleForTesting
  static final class d<C extends Comparable<?>>
    extends mz<nq<C>, Range<C>>
  {
    private final NavigableMap<nq<C>, Range<C>> a;
    private final Range<nq<C>> b;
    
    d(NavigableMap<nq<C>, Range<C>> paramNavigableMap)
    {
      this.a = paramNavigableMap;
      this.b = Range.all();
    }
    
    private d(NavigableMap<nq<C>, Range<C>> paramNavigableMap, Range<nq<C>> paramRange)
    {
      this.a = paramNavigableMap;
      this.b = paramRange;
    }
    
    private Range<C> a(@Nullable Object paramObject)
    {
      if ((paramObject instanceof nq)) {
        try
        {
          paramObject = (nq)paramObject;
          if (!this.b.contains((Comparable)paramObject)) {
            return null;
          }
          Map.Entry localEntry = this.a.lowerEntry(paramObject);
          if ((localEntry != null) && (((Range)localEntry.getValue()).c.equals(paramObject)))
          {
            paramObject = (Range)localEntry.getValue();
            return (Range<C>)paramObject;
          }
        }
        catch (ClassCastException paramObject)
        {
          return null;
        }
      }
      return null;
    }
    
    private NavigableMap<nq<C>, Range<C>> a(Range<nq<C>> paramRange)
    {
      if (paramRange.isConnected(this.b)) {
        return new d(this.a, paramRange.intersection(this.b));
      }
      return ImmutableSortedMap.of();
    }
    
    final Iterator<Map.Entry<nq<C>, Range<C>>> a()
    {
      final Object localObject;
      if (!this.b.hasLowerBound()) {
        localObject = this.a.values().iterator();
      }
      for (;;)
      {
        new AbstractIterator() {};
        localObject = this.a.lowerEntry(this.b.lowerEndpoint());
        if (localObject == null) {
          localObject = this.a.values().iterator();
        } else if (this.b.b.a(((Range)((Map.Entry)localObject).getValue()).c)) {
          localObject = this.a.tailMap(((Map.Entry)localObject).getKey(), true).values().iterator();
        } else {
          localObject = this.a.tailMap(this.b.lowerEndpoint(), true).values().iterator();
        }
      }
    }
    
    final Iterator<Map.Entry<nq<C>, Range<C>>> b()
    {
      if (this.b.hasUpperBound()) {}
      for (final Object localObject = this.a.headMap(this.b.upperEndpoint(), false).descendingMap().values();; localObject = this.a.descendingMap().values())
      {
        localObject = Iterators.peekingIterator(((Collection)localObject).iterator());
        if ((((PeekingIterator)localObject).hasNext()) && (this.b.c.a(((Range)((PeekingIterator)localObject).peek()).c))) {
          ((PeekingIterator)localObject).next();
        }
        new AbstractIterator() {};
      }
    }
    
    public final Comparator<? super nq<C>> comparator()
    {
      return Ordering.natural();
    }
    
    public final boolean containsKey(@Nullable Object paramObject)
    {
      return a(paramObject) != null;
    }
    
    public final boolean isEmpty()
    {
      if (this.b.equals(Range.all())) {
        return this.a.isEmpty();
      }
      return !a().hasNext();
    }
    
    public final int size()
    {
      if (this.b.equals(Range.all())) {
        return this.a.size();
      }
      return Iterators.size(a());
    }
  }
  
  final class e
    extends TreeRangeSet<C>
  {
    private final Range<C> c;
    
    e()
    {
      super((byte)0);
      this.c = localRange;
    }
    
    public final void add(Range<C> paramRange)
    {
      Preconditions.checkArgument(this.c.encloses(paramRange), "Cannot add range %s to subRangeSet(%s)", new Object[] { paramRange, this.c });
      super.add(paramRange);
    }
    
    public final void clear()
    {
      TreeRangeSet.this.remove(this.c);
    }
    
    public final boolean contains(C paramC)
    {
      return (this.c.contains(paramC)) && (TreeRangeSet.this.contains(paramC));
    }
    
    public final boolean encloses(Range<C> paramRange)
    {
      if ((!this.c.isEmpty()) && (this.c.encloses(paramRange)))
      {
        Object localObject = TreeRangeSet.this;
        Preconditions.checkNotNull(paramRange);
        localObject = ((TreeRangeSet)localObject).a.floorEntry(paramRange.b);
        if ((localObject != null) && (((Range)((Map.Entry)localObject).getValue()).encloses(paramRange))) {}
        for (paramRange = (Range)((Map.Entry)localObject).getValue(); (paramRange != null) && (!paramRange.intersection(this.c).isEmpty()); paramRange = null) {
          return true;
        }
        return false;
      }
      return false;
    }
    
    @Nullable
    public final Range<C> rangeContaining(C paramC)
    {
      if (!this.c.contains(paramC)) {}
      do
      {
        return null;
        paramC = TreeRangeSet.this.rangeContaining(paramC);
      } while (paramC == null);
      return paramC.intersection(this.c);
    }
    
    public final void remove(Range<C> paramRange)
    {
      if (paramRange.isConnected(this.c)) {
        TreeRangeSet.this.remove(paramRange.intersection(this.c));
      }
    }
    
    public final RangeSet<C> subRangeSet(Range<C> paramRange)
    {
      if (paramRange.encloses(this.c)) {
        return this;
      }
      if (paramRange.isConnected(this.c)) {
        return new e(this, this.c.intersection(paramRange));
      }
      return ImmutableRangeSet.of();
    }
  }
  
  static final class f<C extends Comparable<?>>
    extends mz<nq<C>, Range<C>>
  {
    private final Range<nq<C>> a;
    private final Range<C> b;
    private final NavigableMap<nq<C>, Range<C>> c;
    private final NavigableMap<nq<C>, Range<C>> d;
    
    private f(Range<nq<C>> paramRange, Range<C> paramRange1, NavigableMap<nq<C>, Range<C>> paramNavigableMap)
    {
      this.a = ((Range)Preconditions.checkNotNull(paramRange));
      this.b = ((Range)Preconditions.checkNotNull(paramRange1));
      this.c = ((NavigableMap)Preconditions.checkNotNull(paramNavigableMap));
      this.d = new TreeRangeSet.d(paramNavigableMap);
    }
    
    @Nullable
    private Range<C> a(@Nullable Object paramObject)
    {
      if ((paramObject instanceof nq)) {
        try
        {
          paramObject = (nq)paramObject;
          if ((!this.a.contains((Comparable)paramObject)) || (((nq)paramObject).a(this.b.b) < 0) || (((nq)paramObject).a(this.b.c) >= 0)) {
            break label149;
          }
          if (((nq)paramObject).equals(this.b.b))
          {
            paramObject = (Range)Maps.c(this.c.floorEntry(paramObject));
            if ((paramObject != null) && (((Range)paramObject).c.a(this.b.b) > 0)) {
              return ((Range)paramObject).intersection(this.b);
            }
          }
          else
          {
            paramObject = (Range)this.c.get(paramObject);
            if (paramObject != null)
            {
              paramObject = ((Range)paramObject).intersection(this.b);
              return (Range<C>)paramObject;
            }
          }
        }
        catch (ClassCastException paramObject)
        {
          return null;
        }
      }
      return null;
      label149:
      return null;
    }
    
    private NavigableMap<nq<C>, Range<C>> a(Range<nq<C>> paramRange)
    {
      if (!paramRange.isConnected(this.a)) {
        return ImmutableSortedMap.of();
      }
      return new f(this.a.intersection(paramRange), this.b, this.c);
    }
    
    final Iterator<Map.Entry<nq<C>, Range<C>>> a()
    {
      if (this.b.isEmpty()) {
        return Iterators.emptyIterator();
      }
      if (this.a.c.a(this.b.b)) {
        return Iterators.emptyIterator();
      }
      Object localObject2;
      Object localObject1;
      boolean bool;
      if (this.a.b.a(this.b.b))
      {
        localObject2 = this.d;
        localObject1 = this.b.b;
        bool = false;
      }
      for (;;)
      {
        new AbstractIterator() {};
        NavigableMap localNavigableMap = this.c;
        Comparable localComparable = this.a.b.c();
        localObject1 = localComparable;
        localObject2 = localNavigableMap;
        if (this.a.lowerBoundType() != BoundType.CLOSED) {
          break;
        }
        localObject1 = localComparable;
        bool = true;
        localObject2 = localNavigableMap;
      }
    }
    
    final Iterator<Map.Entry<nq<C>, Range<C>>> b()
    {
      if (this.b.isEmpty()) {
        return Iterators.emptyIterator();
      }
      nq localnq = (nq)Ordering.natural().min(this.a.c, nq.b(this.b.c));
      NavigableMap localNavigableMap = this.c;
      Comparable localComparable = localnq.c();
      if (localnq.b() == BoundType.CLOSED) {}
      for (boolean bool = true;; bool = false) {
        new AbstractIterator() {};
      }
    }
    
    public final Comparator<? super nq<C>> comparator()
    {
      return Ordering.natural();
    }
    
    public final boolean containsKey(@Nullable Object paramObject)
    {
      return a(paramObject) != null;
    }
    
    public final int size()
    {
      return Iterators.size(a());
    }
  }
}


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