CrackMe.apk
Download file
package com.google.common.collect;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableSet;
import com.google.errorprone.annotations.concurrent.LazyInit;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NavigableSet;
import java.util.SortedSet;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
public abstract class ImmutableSortedSet<E> extends ImmutableSortedSetFauxverideShim<E> implements NavigableSet<E>, SortedIterable<E> {
final transient Comparator<? super E> comparator;
@CheckForNull
@LazyInit
transient ImmutableSortedSet<E> descendingSet;
/* access modifiers changed from: package-private */
public abstract ImmutableSortedSet<E> createDescendingSet();
public abstract UnmodifiableIterator<E> descendingIterator();
/* access modifiers changed from: package-private */
public abstract ImmutableSortedSet<E> headSetImpl(E e, boolean z);
/* access modifiers changed from: package-private */
public abstract int indexOf(@CheckForNull Object obj);
public abstract UnmodifiableIterator<E> iterator();
/* access modifiers changed from: package-private */
public abstract ImmutableSortedSet<E> subSetImpl(E e, boolean z, E e2, boolean z2);
/* access modifiers changed from: package-private */
public abstract ImmutableSortedSet<E> tailSetImpl(E e, boolean z);
static <E> RegularImmutableSortedSet<E> emptySet(Comparator<? super E> comparator2) {
if (Ordering.natural().equals(comparator2)) {
return RegularImmutableSortedSet.NATURAL_EMPTY_SET;
}
return new RegularImmutableSortedSet<>(ImmutableList.of(), comparator2);
}
public static <E> ImmutableSortedSet<E> of() {
return RegularImmutableSortedSet.NATURAL_EMPTY_SET;
}
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e) {
return new RegularImmutableSortedSet(ImmutableList.of(e), Ordering.natural());
}
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e, E e2) {
return construct(Ordering.natural(), 2, e, e2);
}
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e, E e2, E e3) {
return construct(Ordering.natural(), 3, e, e2, e3);
}
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e, E e2, E e3, E e4) {
return construct(Ordering.natural(), 4, e, e2, e3, e4);
}
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e, E e2, E e3, E e4, E e5) {
return construct(Ordering.natural(), 5, e, e2, e3, e4, e5);
}
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e, E e2, E e3, E e4, E e5, E e6, E... eArr) {
int length = eArr.length + 6;
Comparable[] comparableArr = new Comparable[length];
comparableArr[0] = e;
comparableArr[1] = e2;
comparableArr[2] = e3;
comparableArr[3] = e4;
comparableArr[4] = e5;
comparableArr[5] = e6;
System.arraycopy(eArr, 0, comparableArr, 6, eArr.length);
return construct(Ordering.natural(), length, comparableArr);
}
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> copyOf(E[] eArr) {
return construct(Ordering.natural(), eArr.length, (Comparable[]) eArr.clone());
}
public static <E> ImmutableSortedSet<E> copyOf(Iterable<? extends E> iterable) {
return copyOf(Ordering.natural(), iterable);
}
public static <E> ImmutableSortedSet<E> copyOf(Collection<? extends E> collection) {
return copyOf(Ordering.natural(), collection);
}
public static <E> ImmutableSortedSet<E> copyOf(Iterator<? extends E> it) {
return copyOf(Ordering.natural(), it);
}
public static <E> ImmutableSortedSet<E> copyOf(Comparator<? super E> comparator2, Iterator<? extends E> it) {
return new Builder(comparator2).addAll((Iterator) it).build();
}
public static <E> ImmutableSortedSet<E> copyOf(Comparator<? super E> comparator2, Iterable<? extends E> iterable) {
Preconditions.checkNotNull(comparator2);
if (SortedIterables.hasSameComparator(comparator2, iterable) && (iterable instanceof ImmutableSortedSet)) {
ImmutableSortedSet<E> immutableSortedSet = (ImmutableSortedSet) iterable;
if (!immutableSortedSet.isPartialView()) {
return immutableSortedSet;
}
}
Object[] array = Iterables.toArray(iterable);
return construct(comparator2, array.length, array);
}
public static <E> ImmutableSortedSet<E> copyOf(Comparator<? super E> comparator2, Collection<? extends E> collection) {
return copyOf(comparator2, collection);
}
public static <E> ImmutableSortedSet<E> copyOfSorted(SortedSet<E> sortedSet) {
Comparator<? super E> comparator2 = SortedIterables.comparator(sortedSet);
ImmutableList<E> copyOf = ImmutableList.copyOf(sortedSet);
if (copyOf.isEmpty()) {
return emptySet(comparator2);
}
return new RegularImmutableSortedSet(copyOf, comparator2);
}
static <E> ImmutableSortedSet<E> construct(Comparator<? super E> comparator2, int i, E... eArr) {
if (i == 0) {
return emptySet(comparator2);
}
ObjectArrays.checkElementsNotNull(eArr, i);
Arrays.sort(eArr, 0, i, comparator2);
int i2 = 1;
for (int i3 = 1; i3 < i; i3++) {
E e = eArr[i3];
if (comparator2.compare(e, eArr[i2 - 1]) != 0) {
eArr[i2] = e;
i2++;
}
}
Arrays.fill(eArr, i2, i, (Object) null);
if (i2 < eArr.length / 2) {
eArr = Arrays.copyOf(eArr, i2);
}
return new RegularImmutableSortedSet(ImmutableList.asImmutableList(eArr, i2), comparator2);
}
public static <E> Builder<E> orderedBy(Comparator<E> comparator2) {
return new Builder<>(comparator2);
}
public static <E extends Comparable<?>> Builder<E> reverseOrder() {
return new Builder<>(Collections.reverseOrder());
}
public static <E extends Comparable<?>> Builder<E> naturalOrder() {
return new Builder<>(Ordering.natural());
}
public static final class Builder<E> extends ImmutableSet.Builder<E> {
private final Comparator<? super E> comparator;
public Builder(Comparator<? super E> comparator2) {
this.comparator = (Comparator) Preconditions.checkNotNull(comparator2);
}
public Builder<E> add(E e) {
super.add((Object) e);
return this;
}
public Builder<E> add(E... eArr) {
super.add((Object[]) eArr);
return this;
}
public Builder<E> addAll(Iterable<? extends E> iterable) {
super.addAll((Iterable) iterable);
return this;
}
public Builder<E> addAll(Iterator<? extends E> it) {
super.addAll((Iterator) it);
return this;
}
/* access modifiers changed from: package-private */
public Builder<E> combine(ImmutableSet.Builder<E> builder) {
super.combine(builder);
return this;
}
public ImmutableSortedSet<E> build() {
ImmutableSortedSet<E> construct = ImmutableSortedSet.construct(this.comparator, this.size, this.contents);
this.size = construct.size();
this.forceCopy = true;
return construct;
}
}
/* access modifiers changed from: package-private */
public int unsafeCompare(Object obj, @CheckForNull Object obj2) {
return unsafeCompare(this.comparator, obj, obj2);
}
static int unsafeCompare(Comparator<?> comparator2, Object obj, @CheckForNull Object obj2) {
return comparator2.compare(obj, obj2);
}
ImmutableSortedSet(Comparator<? super E> comparator2) {
this.comparator = comparator2;
}
public Comparator<? super E> comparator() {
return this.comparator;
}
public ImmutableSortedSet<E> headSet(E e) {
return headSet(e, false);
}
public ImmutableSortedSet<E> headSet(E e, boolean z) {
return headSetImpl(Preconditions.checkNotNull(e), z);
}
public ImmutableSortedSet<E> subSet(E e, E e2) {
return subSet(e, true, e2, false);
}
public ImmutableSortedSet<E> subSet(E e, boolean z, E e2, boolean z2) {
Preconditions.checkNotNull(e);
Preconditions.checkNotNull(e2);
Preconditions.checkArgument(this.comparator.compare(e, e2) <= 0);
return subSetImpl(e, z, e2, z2);
}
public ImmutableSortedSet<E> tailSet(E e) {
return tailSet(e, true);
}
public ImmutableSortedSet<E> tailSet(E e, boolean z) {
return tailSetImpl(Preconditions.checkNotNull(e), z);
}
@CheckForNull
public E lower(E e) {
return Iterators.getNext(headSet(e, false).descendingIterator(), null);
}
@CheckForNull
public E floor(E e) {
return Iterators.getNext(headSet(e, true).descendingIterator(), null);
}
@CheckForNull
public E ceiling(E e) {
return Iterables.getFirst(tailSet(e, true), null);
}
@CheckForNull
public E higher(E e) {
return Iterables.getFirst(tailSet(e, false), null);
}
public E first() {
return iterator().next();
}
public E last() {
return descendingIterator().next();
}
@CheckForNull
@Deprecated
public final E pollFirst() {
throw new UnsupportedOperationException();
}
@CheckForNull
@Deprecated
public final E pollLast() {
throw new UnsupportedOperationException();
}
public ImmutableSortedSet<E> descendingSet() {
ImmutableSortedSet<E> immutableSortedSet = this.descendingSet;
if (immutableSortedSet != null) {
return immutableSortedSet;
}
ImmutableSortedSet<E> createDescendingSet = createDescendingSet();
this.descendingSet = createDescendingSet;
createDescendingSet.descendingSet = this;
return createDescendingSet;
}
private static class SerializedForm<E> implements Serializable {
private static final long serialVersionUID = 0;
final Comparator<? super E> comparator;
final Object[] elements;
public SerializedForm(Comparator<? super E> comparator2, Object[] objArr) {
this.comparator = comparator2;
this.elements = objArr;
}
/* access modifiers changed from: package-private */
public Object readResolve() {
return new Builder(this.comparator).add(this.elements).build();
}
}
private void readObject(ObjectInputStream objectInputStream) throws InvalidObjectException {
throw new InvalidObjectException("Use SerializedForm");
}
/* access modifiers changed from: package-private */
public Object writeReplace() {
return new SerializedForm(this.comparator, toArray());
}
}
Download file