CrackMe.apk
Download file
package com.google.common.collect;
import com.google.common.base.Preconditions;
import java.io.Serializable;
import java.lang.Comparable;
import java.util.Collection;
import java.util.Objects;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
final class RegularContiguousSet<C extends Comparable> extends ContiguousSet<C> {
private static final long serialVersionUID = 0;
private final Range<C> range;
public boolean isEmpty() {
return false;
}
/* access modifiers changed from: package-private */
public boolean isPartialView() {
return false;
}
RegularContiguousSet(Range<C> range2, DiscreteDomain<C> discreteDomain) {
super(discreteDomain);
this.range = range2;
}
private ContiguousSet<C> intersectionInCurrentDomain(Range<C> range2) {
if (this.range.isConnected(range2)) {
return ContiguousSet.create(this.range.intersection(range2), this.domain);
}
return new EmptyContiguousSet(this.domain);
}
/* access modifiers changed from: package-private */
public ContiguousSet<C> headSetImpl(C c, boolean z) {
return intersectionInCurrentDomain(Range.upTo(c, BoundType.forBoolean(z)));
}
/* access modifiers changed from: package-private */
public ContiguousSet<C> subSetImpl(C c, boolean z, C c2, boolean z2) {
if (c.compareTo(c2) != 0 || z || z2) {
return intersectionInCurrentDomain(Range.range(c, BoundType.forBoolean(z), c2, BoundType.forBoolean(z2)));
}
return new EmptyContiguousSet(this.domain);
}
/* access modifiers changed from: package-private */
public ContiguousSet<C> tailSetImpl(C c, boolean z) {
return intersectionInCurrentDomain(Range.downTo(c, BoundType.forBoolean(z)));
}
/* access modifiers changed from: package-private */
public int indexOf(@CheckForNull Object obj) {
if (!contains(obj)) {
return -1;
}
DiscreteDomain discreteDomain = this.domain;
Comparable first = first();
Objects.requireNonNull(obj);
return (int) discreteDomain.distance(first, (Comparable) obj);
}
public UnmodifiableIterator<C> iterator() {
return new AbstractSequentialIterator<C>(first()) {
final C last;
{
this.last = RegularContiguousSet.this.last();
}
/* access modifiers changed from: protected */
@CheckForNull
public C computeNext(C c) {
if (RegularContiguousSet.equalsOrThrow(c, this.last)) {
return null;
}
return RegularContiguousSet.this.domain.next(c);
}
};
}
public UnmodifiableIterator<C> descendingIterator() {
return new AbstractSequentialIterator<C>(last()) {
final C first;
{
this.first = RegularContiguousSet.this.first();
}
/* access modifiers changed from: protected */
@CheckForNull
public C computeNext(C c) {
if (RegularContiguousSet.equalsOrThrow(c, this.first)) {
return null;
}
return RegularContiguousSet.this.domain.previous(c);
}
};
}
/* access modifiers changed from: private */
public static boolean equalsOrThrow(Comparable<?> comparable, @CheckForNull Comparable<?> comparable2) {
return comparable2 != null && Range.compareOrThrow(comparable, comparable2) == 0;
}
public C first() {
C leastValueAbove = this.range.lowerBound.leastValueAbove(this.domain);
Objects.requireNonNull(leastValueAbove);
Comparable comparable = (Comparable) leastValueAbove;
return leastValueAbove;
}
public C last() {
C greatestValueBelow = this.range.upperBound.greatestValueBelow(this.domain);
Objects.requireNonNull(greatestValueBelow);
Comparable comparable = (Comparable) greatestValueBelow;
return greatestValueBelow;
}
/* access modifiers changed from: package-private */
public ImmutableList<C> createAsList() {
return this.domain.supportsFastOffset ? new ImmutableAsList<C>() {
/* access modifiers changed from: package-private */
public ImmutableSortedSet<C> delegateCollection() {
return RegularContiguousSet.this;
}
public C get(int i) {
Preconditions.checkElementIndex(i, size());
return RegularContiguousSet.this.domain.offset(RegularContiguousSet.this.first(), (long) i);
}
} : super.createAsList();
}
public int size() {
long distance = this.domain.distance(first(), last());
if (distance >= 2147483647L) {
return Integer.MAX_VALUE;
}
return ((int) distance) + 1;
}
public boolean contains(@CheckForNull Object obj) {
if (obj == null) {
return false;
}
try {
return this.range.contains((Comparable) obj);
} catch (ClassCastException unused) {
return false;
}
}
public boolean containsAll(Collection<?> collection) {
return Collections2.containsAllImpl(this, collection);
}
public ContiguousSet<C> intersection(ContiguousSet<C> contiguousSet) {
Preconditions.checkNotNull(contiguousSet);
Preconditions.checkArgument(this.domain.equals(contiguousSet.domain));
if (contiguousSet.isEmpty()) {
return contiguousSet;
}
Comparable comparable = (Comparable) Ordering.natural().max(first(), (Comparable) contiguousSet.first());
Comparable comparable2 = (Comparable) Ordering.natural().min(last(), (Comparable) contiguousSet.last());
if (comparable.compareTo(comparable2) <= 0) {
return ContiguousSet.create(Range.closed(comparable, comparable2), this.domain);
}
return new EmptyContiguousSet(this.domain);
}
public Range<C> range() {
return range(BoundType.CLOSED, BoundType.CLOSED);
}
public Range<C> range(BoundType boundType, BoundType boundType2) {
return Range.create(this.range.lowerBound.withLowerBoundType(boundType, this.domain), this.range.upperBound.withUpperBoundType(boundType2, this.domain));
}
public boolean equals(@CheckForNull Object obj) {
if (obj == this) {
return true;
}
if (obj instanceof RegularContiguousSet) {
RegularContiguousSet regularContiguousSet = (RegularContiguousSet) obj;
if (this.domain.equals(regularContiguousSet.domain)) {
if (!first().equals(regularContiguousSet.first()) || !last().equals(regularContiguousSet.last())) {
return false;
}
return true;
}
}
return super.equals(obj);
}
public int hashCode() {
return Sets.hashCodeImpl(this);
}
private static final class SerializedForm<C extends Comparable> implements Serializable {
final DiscreteDomain<C> domain;
final Range<C> range;
private SerializedForm(Range<C> range2, DiscreteDomain<C> discreteDomain) {
this.range = range2;
this.domain = discreteDomain;
}
private Object readResolve() {
return new RegularContiguousSet(this.range, this.domain);
}
}
/* access modifiers changed from: package-private */
public Object writeReplace() {
return new SerializedForm(this.range, this.domain);
}
}
Download file