CrackMe.apk
Download file
package com.google.common.collect;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.RandomAccess;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
public abstract class ImmutableList<E> extends ImmutableCollection<E> implements List<E>, RandomAccess {
private static final UnmodifiableListIterator<Object> EMPTY_ITR = new Itr(RegularImmutableList.EMPTY, 0);
@Deprecated
public final ImmutableList<E> asList() {
return this;
}
public static <E> ImmutableList<E> of() {
return RegularImmutableList.EMPTY;
}
public static <E> ImmutableList<E> of(E e) {
return construct(e);
}
public static <E> ImmutableList<E> of(E e, E e2) {
return construct(e, e2);
}
public static <E> ImmutableList<E> of(E e, E e2, E e3) {
return construct(e, e2, e3);
}
public static <E> ImmutableList<E> of(E e, E e2, E e3, E e4) {
return construct(e, e2, e3, e4);
}
public static <E> ImmutableList<E> of(E e, E e2, E e3, E e4, E e5) {
return construct(e, e2, e3, e4, e5);
}
public static <E> ImmutableList<E> of(E e, E e2, E e3, E e4, E e5, E e6) {
return construct(e, e2, e3, e4, e5, e6);
}
public static <E> ImmutableList<E> of(E e, E e2, E e3, E e4, E e5, E e6, E e7) {
return construct(e, e2, e3, e4, e5, e6, e7);
}
public static <E> ImmutableList<E> of(E e, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
return construct(e, e2, e3, e4, e5, e6, e7, e8);
}
public static <E> ImmutableList<E> of(E e, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
return construct(e, e2, e3, e4, e5, e6, e7, e8, e9);
}
public static <E> ImmutableList<E> of(E e, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
return construct(e, e2, e3, e4, e5, e6, e7, e8, e9, e10);
}
public static <E> ImmutableList<E> of(E e, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10, E e11) {
return construct(e, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11);
}
@SafeVarargs
public static <E> ImmutableList<E> of(E e, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10, E e11, E e12, E... eArr) {
E[] eArr2 = eArr;
Preconditions.checkArgument(eArr2.length <= 2147483635, "the total number of elements must fit in an int");
Object[] objArr = new Object[(eArr2.length + 12)];
objArr[0] = e;
objArr[1] = e2;
objArr[2] = e3;
objArr[3] = e4;
objArr[4] = e5;
objArr[5] = e6;
objArr[6] = e7;
objArr[7] = e8;
objArr[8] = e9;
objArr[9] = e10;
objArr[10] = e11;
objArr[11] = e12;
System.arraycopy(eArr2, 0, objArr, 12, eArr2.length);
return construct(objArr);
}
public static <E> ImmutableList<E> copyOf(Iterable<? extends E> iterable) {
Preconditions.checkNotNull(iterable);
if (iterable instanceof Collection) {
return copyOf((Collection) iterable);
}
return copyOf(iterable.iterator());
}
public static <E> ImmutableList<E> copyOf(Collection<? extends E> collection) {
if (!(collection instanceof ImmutableCollection)) {
return construct(collection.toArray());
}
ImmutableList<E> asList = ((ImmutableCollection) collection).asList();
return asList.isPartialView() ? asImmutableList(asList.toArray()) : asList;
}
public static <E> ImmutableList<E> copyOf(Iterator<? extends E> it) {
if (!it.hasNext()) {
return of();
}
Object next = it.next();
if (!it.hasNext()) {
return of(next);
}
return new Builder().add((Object) next).addAll((Iterator) it).build();
}
public static <E> ImmutableList<E> copyOf(E[] eArr) {
if (eArr.length == 0) {
return of();
}
return construct((Object[]) eArr.clone());
}
public static <E extends Comparable<? super E>> ImmutableList<E> sortedCopyOf(Iterable<? extends E> iterable) {
Comparable[] comparableArr = (Comparable[]) Iterables.toArray(iterable, (T[]) new Comparable[0]);
ObjectArrays.checkElementsNotNull((Object[]) comparableArr);
Arrays.sort(comparableArr);
return asImmutableList(comparableArr);
}
public static <E> ImmutableList<E> sortedCopyOf(Comparator<? super E> comparator, Iterable<? extends E> iterable) {
Preconditions.checkNotNull(comparator);
Object[] array = Iterables.toArray(iterable);
ObjectArrays.checkElementsNotNull(array);
Arrays.sort(array, comparator);
return asImmutableList(array);
}
private static <E> ImmutableList<E> construct(Object... objArr) {
return asImmutableList(ObjectArrays.checkElementsNotNull(objArr));
}
static <E> ImmutableList<E> asImmutableList(Object[] objArr) {
return asImmutableList(objArr, objArr.length);
}
static <E> ImmutableList<E> asImmutableList(Object[] objArr, int i) {
if (i == 0) {
return of();
}
return new RegularImmutableList(objArr, i);
}
ImmutableList() {
}
public UnmodifiableIterator<E> iterator() {
return listIterator();
}
public UnmodifiableListIterator<E> listIterator() {
return listIterator(0);
}
public UnmodifiableListIterator<E> listIterator(int i) {
Preconditions.checkPositionIndex(i, size());
if (isEmpty()) {
return EMPTY_ITR;
}
return new Itr(this, i);
}
static class Itr<E> extends AbstractIndexedListIterator<E> {
private final ImmutableList<E> list;
Itr(ImmutableList<E> immutableList, int i) {
super(immutableList.size(), i);
this.list = immutableList;
}
/* access modifiers changed from: protected */
public E get(int i) {
return this.list.get(i);
}
}
public int indexOf(@CheckForNull Object obj) {
if (obj == null) {
return -1;
}
return Lists.indexOfImpl(this, obj);
}
public int lastIndexOf(@CheckForNull Object obj) {
if (obj == null) {
return -1;
}
return Lists.lastIndexOfImpl(this, obj);
}
public boolean contains(@CheckForNull Object obj) {
return indexOf(obj) >= 0;
}
public ImmutableList<E> subList(int i, int i2) {
Preconditions.checkPositionIndexes(i, i2, size());
int i3 = i2 - i;
if (i3 == size()) {
return this;
}
if (i3 == 0) {
return of();
}
return subListUnchecked(i, i2);
}
/* access modifiers changed from: package-private */
public ImmutableList<E> subListUnchecked(int i, int i2) {
return new SubList(i, i2 - i);
}
class SubList extends ImmutableList<E> {
final transient int length;
final transient int offset;
/* access modifiers changed from: package-private */
public boolean isPartialView() {
return true;
}
public /* bridge */ /* synthetic */ Iterator iterator() {
return ImmutableList.super.iterator();
}
public /* bridge */ /* synthetic */ ListIterator listIterator() {
return ImmutableList.super.listIterator();
}
public /* bridge */ /* synthetic */ ListIterator listIterator(int i) {
return ImmutableList.super.listIterator(i);
}
SubList(int i, int i2) {
this.offset = i;
this.length = i2;
}
public int size() {
return this.length;
}
/* access modifiers changed from: package-private */
@CheckForNull
public Object[] internalArray() {
return ImmutableList.this.internalArray();
}
/* access modifiers changed from: package-private */
public int internalArrayStart() {
return ImmutableList.this.internalArrayStart() + this.offset;
}
/* access modifiers changed from: package-private */
public int internalArrayEnd() {
return ImmutableList.this.internalArrayStart() + this.offset + this.length;
}
public E get(int i) {
Preconditions.checkElementIndex(i, this.length);
return ImmutableList.this.get(i + this.offset);
}
public ImmutableList<E> subList(int i, int i2) {
Preconditions.checkPositionIndexes(i, i2, this.length);
ImmutableList immutableList = ImmutableList.this;
int i3 = this.offset;
return immutableList.subList(i + i3, i2 + i3);
}
}
@Deprecated
public final boolean addAll(int i, Collection<? extends E> collection) {
throw new UnsupportedOperationException();
}
@Deprecated
public final E set(int i, E e) {
throw new UnsupportedOperationException();
}
@Deprecated
public final void add(int i, E e) {
throw new UnsupportedOperationException();
}
@Deprecated
public final E remove(int i) {
throw new UnsupportedOperationException();
}
/* access modifiers changed from: package-private */
public int copyIntoArray(Object[] objArr, int i) {
int size = size();
for (int i2 = 0; i2 < size; i2++) {
objArr[i + i2] = get(i2);
}
return i + size;
}
public ImmutableList<E> reverse() {
return size() <= 1 ? this : new ReverseImmutableList(this);
}
private static class ReverseImmutableList<E> extends ImmutableList<E> {
private final transient ImmutableList<E> forwardList;
public /* bridge */ /* synthetic */ Iterator iterator() {
return ImmutableList.super.iterator();
}
public /* bridge */ /* synthetic */ ListIterator listIterator() {
return ImmutableList.super.listIterator();
}
public /* bridge */ /* synthetic */ ListIterator listIterator(int i) {
return ImmutableList.super.listIterator(i);
}
ReverseImmutableList(ImmutableList<E> immutableList) {
this.forwardList = immutableList;
}
private int reverseIndex(int i) {
return (size() - 1) - i;
}
private int reversePosition(int i) {
return size() - i;
}
public ImmutableList<E> reverse() {
return this.forwardList;
}
public boolean contains(@CheckForNull Object obj) {
return this.forwardList.contains(obj);
}
public int indexOf(@CheckForNull Object obj) {
int lastIndexOf = this.forwardList.lastIndexOf(obj);
if (lastIndexOf >= 0) {
return reverseIndex(lastIndexOf);
}
return -1;
}
public int lastIndexOf(@CheckForNull Object obj) {
int indexOf = this.forwardList.indexOf(obj);
if (indexOf >= 0) {
return reverseIndex(indexOf);
}
return -1;
}
public ImmutableList<E> subList(int i, int i2) {
Preconditions.checkPositionIndexes(i, i2, size());
return this.forwardList.subList(reversePosition(i2), reversePosition(i)).reverse();
}
public E get(int i) {
Preconditions.checkElementIndex(i, size());
return this.forwardList.get(reverseIndex(i));
}
public int size() {
return this.forwardList.size();
}
/* access modifiers changed from: package-private */
public boolean isPartialView() {
return this.forwardList.isPartialView();
}
}
public boolean equals(@CheckForNull Object obj) {
return Lists.equalsImpl(this, obj);
}
public int hashCode() {
int size = size();
int i = 1;
for (int i2 = 0; i2 < size; i2++) {
i = ~(~((i * 31) + get(i2).hashCode()));
}
return i;
}
static class SerializedForm implements Serializable {
private static final long serialVersionUID = 0;
final Object[] elements;
SerializedForm(Object[] objArr) {
this.elements = objArr;
}
/* access modifiers changed from: package-private */
public Object readResolve() {
return ImmutableList.copyOf((E[]) this.elements);
}
}
private void readObject(ObjectInputStream objectInputStream) throws InvalidObjectException {
throw new InvalidObjectException("Use SerializedForm");
}
/* access modifiers changed from: package-private */
public Object writeReplace() {
return new SerializedForm(toArray());
}
public static <E> Builder<E> builder() {
return new Builder<>();
}
public static <E> Builder<E> builderWithExpectedSize(int i) {
CollectPreconditions.checkNonnegative(i, "expectedSize");
return new Builder<>(i);
}
public static final class Builder<E> extends ImmutableCollection.ArrayBasedBuilder<E> {
public Builder() {
this(4);
}
Builder(int i) {
super(i);
}
public Builder<E> add(E e) {
super.add(e);
return this;
}
public Builder<E> add(E... eArr) {
super.add(eArr);
return this;
}
public Builder<E> addAll(Iterable<? extends E> iterable) {
super.addAll(iterable);
return this;
}
public Builder<E> addAll(Iterator<? extends E> it) {
super.addAll(it);
return this;
}
/* access modifiers changed from: package-private */
public Builder<E> combine(Builder<E> builder) {
addAll(builder.contents, builder.size);
return this;
}
public ImmutableList<E> build() {
this.forceCopy = true;
return ImmutableList.asImmutableList(this.contents, this.size);
}
}
}
Download file