package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import java.io.Serializable;
import java.util.Comparator;
import java.util.Iterator;
import java.util.SortedSet;
import javax.annotation.Nullable;
import nq;

@GwtCompatible
public final class Range<C extends Comparable>
  implements Predicate<C>, Serializable
{
  static final Ordering<Range<?>> a = new Ordering() {};
  private static final Function<Range, nq> d = new Function() {};
  private static final Function<Range, nq> e = new Function() {};
  private static final Range<Comparable> f = new Range(nq.d(), nq.e());
  private static final long serialVersionUID = 0L;
  public final nq<C> b;
  public final nq<C> c;
  
  private Range(nq<C> paramnq1, nq<C> paramnq2)
  {
    if ((paramnq1.a(paramnq2) > 0) || (paramnq1 == nq.e()) || (paramnq2 == nq.d()))
    {
      paramnq1 = String.valueOf(b(paramnq1, paramnq2));
      if (paramnq1.length() != 0) {}
      for (paramnq1 = "Invalid range: ".concat(paramnq1);; paramnq1 = new String("Invalid range: ")) {
        throw new IllegalArgumentException(paramnq1);
      }
    }
    this.b = ((nq)Preconditions.checkNotNull(paramnq1));
    this.c = ((nq)Preconditions.checkNotNull(paramnq2));
  }
  
  public static int a(Comparable paramComparable1, Comparable paramComparable2)
  {
    return paramComparable1.compareTo(paramComparable2);
  }
  
  static <C extends Comparable<?>> Function<Range<C>, nq<C>> a()
  {
    return d;
  }
  
  public static <C extends Comparable<?>> Range<C> a(nq<C> paramnq1, nq<C> paramnq2)
  {
    return new Range(paramnq1, paramnq2);
  }
  
  public static <C extends Comparable<?>> Range<C> all()
  {
    return f;
  }
  
  public static <C extends Comparable<?>> Range<C> atLeast(C paramC)
  {
    return a(nq.b(paramC), nq.e());
  }
  
  public static <C extends Comparable<?>> Range<C> atMost(C paramC)
  {
    return a(nq.d(), nq.c(paramC));
  }
  
  static <C extends Comparable<?>> Function<Range<C>, nq<C>> b()
  {
    return e;
  }
  
  private static String b(nq<?> paramnq1, nq<?> paramnq2)
  {
    StringBuilder localStringBuilder = new StringBuilder(16);
    paramnq1.a(localStringBuilder);
    localStringBuilder.append('‥');
    paramnq2.b(localStringBuilder);
    return localStringBuilder.toString();
  }
  
  public static <C extends Comparable<?>> Range<C> closed(C paramC1, C paramC2)
  {
    return a(nq.b(paramC1), nq.c(paramC2));
  }
  
  public static <C extends Comparable<?>> Range<C> closedOpen(C paramC1, C paramC2)
  {
    return a(nq.b(paramC1), nq.b(paramC2));
  }
  
  public static <C extends Comparable<?>> Range<C> downTo(C paramC, BoundType paramBoundType)
  {
    switch (4.a[paramBoundType.ordinal()])
    {
    default: 
      throw new AssertionError();
    case 1: 
      return greaterThan(paramC);
    }
    return atLeast(paramC);
  }
  
  public static <C extends Comparable<?>> Range<C> encloseAll(Iterable<C> paramIterable)
  {
    Preconditions.checkNotNull(paramIterable);
    if ((paramIterable instanceof ContiguousSet)) {
      return ((ContiguousSet)paramIterable).range();
    }
    Iterator localIterator = paramIterable.iterator();
    Comparable localComparable1 = (Comparable)Preconditions.checkNotNull(localIterator.next());
    Comparable localComparable2;
    for (paramIterable = localComparable1; localIterator.hasNext(); paramIterable = (Comparable)Ordering.natural().max(paramIterable, localComparable2))
    {
      localComparable2 = (Comparable)Preconditions.checkNotNull(localIterator.next());
      localComparable1 = (Comparable)Ordering.natural().min(localComparable1, localComparable2);
    }
    return closed(localComparable1, paramIterable);
  }
  
  public static <C extends Comparable<?>> Range<C> greaterThan(C paramC)
  {
    return a(nq.c(paramC), nq.e());
  }
  
  public static <C extends Comparable<?>> Range<C> lessThan(C paramC)
  {
    return a(nq.d(), nq.b(paramC));
  }
  
  public static <C extends Comparable<?>> Range<C> open(C paramC1, C paramC2)
  {
    return a(nq.c(paramC1), nq.b(paramC2));
  }
  
  public static <C extends Comparable<?>> Range<C> openClosed(C paramC1, C paramC2)
  {
    return a(nq.c(paramC1), nq.c(paramC2));
  }
  
  public static <C extends Comparable<?>> Range<C> range(C paramC1, BoundType paramBoundType1, C paramC2, BoundType paramBoundType2)
  {
    Preconditions.checkNotNull(paramBoundType1);
    Preconditions.checkNotNull(paramBoundType2);
    if (paramBoundType1 == BoundType.OPEN)
    {
      paramC1 = nq.c(paramC1);
      if (paramBoundType2 != BoundType.OPEN) {
        break label48;
      }
    }
    label48:
    for (paramBoundType1 = nq.b(paramC2);; paramBoundType1 = nq.c(paramC2))
    {
      return a(paramC1, paramBoundType1);
      paramC1 = nq.b(paramC1);
      break;
    }
  }
  
  public static <C extends Comparable<?>> Range<C> singleton(C paramC)
  {
    return closed(paramC, paramC);
  }
  
  public static <C extends Comparable<?>> Range<C> upTo(C paramC, BoundType paramBoundType)
  {
    switch (4.a[paramBoundType.ordinal()])
    {
    default: 
      throw new AssertionError();
    case 1: 
      return lessThan(paramC);
    }
    return atMost(paramC);
  }
  
  @Deprecated
  public final boolean apply(C paramC)
  {
    return contains(paramC);
  }
  
  public final Range<C> canonical(DiscreteDomain<C> paramDiscreteDomain)
  {
    Preconditions.checkNotNull(paramDiscreteDomain);
    nq localnq = this.b.c(paramDiscreteDomain);
    paramDiscreteDomain = this.c.c(paramDiscreteDomain);
    if ((localnq == this.b) && (paramDiscreteDomain == this.c)) {
      return this;
    }
    return a(localnq, paramDiscreteDomain);
  }
  
  public final boolean contains(C paramC)
  {
    Preconditions.checkNotNull(paramC);
    return (this.b.a(paramC)) && (!this.c.a(paramC));
  }
  
  public final boolean containsAll(Iterable<? extends C> paramIterable)
  {
    if (Iterables.isEmpty(paramIterable)) {
      return true;
    }
    if ((paramIterable instanceof SortedSet))
    {
      SortedSet localSortedSet = (SortedSet)paramIterable;
      Comparator localComparator = localSortedSet.comparator();
      if ((Ordering.natural().equals(localComparator)) || (localComparator == null)) {
        return (contains((Comparable)localSortedSet.first())) && (contains((Comparable)localSortedSet.last()));
      }
    }
    paramIterable = paramIterable.iterator();
    while (paramIterable.hasNext()) {
      if (!contains((Comparable)paramIterable.next())) {
        return false;
      }
    }
    return true;
  }
  
  public final boolean encloses(Range<C> paramRange)
  {
    return (this.b.a(paramRange.b) <= 0) && (this.c.a(paramRange.c) >= 0);
  }
  
  public final boolean equals(@Nullable Object paramObject)
  {
    boolean bool2 = false;
    boolean bool1 = bool2;
    if ((paramObject instanceof Range))
    {
      paramObject = (Range)paramObject;
      bool1 = bool2;
      if (this.b.equals(((Range)paramObject).b))
      {
        bool1 = bool2;
        if (this.c.equals(((Range)paramObject).c)) {
          bool1 = true;
        }
      }
    }
    return bool1;
  }
  
  public final boolean hasLowerBound()
  {
    return this.b != nq.d();
  }
  
  public final boolean hasUpperBound()
  {
    return this.c != nq.e();
  }
  
  public final int hashCode()
  {
    return this.b.hashCode() * 31 + this.c.hashCode();
  }
  
  public final Range<C> intersection(Range<C> paramRange)
  {
    int i = this.b.a(paramRange.b);
    int j = this.c.a(paramRange.c);
    if ((i >= 0) && (j <= 0)) {
      return this;
    }
    if ((i <= 0) && (j >= 0)) {
      return paramRange;
    }
    nq localnq;
    if (i >= 0)
    {
      localnq = this.b;
      if (j > 0) {
        break label79;
      }
    }
    label79:
    for (paramRange = this.c;; paramRange = paramRange.c)
    {
      return a(localnq, paramRange);
      localnq = paramRange.b;
      break;
    }
  }
  
  public final boolean isConnected(Range<C> paramRange)
  {
    return (this.b.a(paramRange.c) <= 0) && (paramRange.b.a(this.c) <= 0);
  }
  
  public final boolean isEmpty()
  {
    return this.b.equals(this.c);
  }
  
  public final BoundType lowerBoundType()
  {
    return this.b.a();
  }
  
  public final C lowerEndpoint()
  {
    return this.b.c();
  }
  
  final Object readResolve()
  {
    Range localRange = this;
    if (equals(f)) {
      localRange = all();
    }
    return localRange;
  }
  
  public final Range<C> span(Range<C> paramRange)
  {
    int i = this.b.a(paramRange.b);
    int j = this.c.a(paramRange.c);
    if ((i <= 0) && (j >= 0)) {
      return this;
    }
    if ((i >= 0) && (j <= 0)) {
      return paramRange;
    }
    nq localnq;
    if (i <= 0)
    {
      localnq = this.b;
      if (j < 0) {
        break label79;
      }
    }
    label79:
    for (paramRange = this.c;; paramRange = paramRange.c)
    {
      return a(localnq, paramRange);
      localnq = paramRange.b;
      break;
    }
  }
  
  public final String toString()
  {
    return b(this.b, this.c);
  }
  
  public final BoundType upperBoundType()
  {
    return this.c.b();
  }
  
  public final C upperEndpoint()
  {
    return this.c.c();
  }
}


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