CrackMe.apk
Download file
package com.google.common.collect;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Table;
import com.google.common.collect.Tables;
import com.google.errorprone.annotations.DoNotMock;
import java.io.Serializable;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
public abstract class ImmutableTable<R, C, V> extends AbstractTable<R, C, V> implements Serializable {
public abstract ImmutableMap<C, Map<R, V>> columnMap();
/* access modifiers changed from: package-private */
public abstract ImmutableSet<Table.Cell<R, C, V>> createCellSet();
/* access modifiers changed from: package-private */
public abstract SerializedForm createSerializedForm();
/* access modifiers changed from: package-private */
public abstract ImmutableCollection<V> createValues();
public abstract ImmutableMap<R, Map<C, V>> rowMap();
public /* bridge */ /* synthetic */ boolean containsColumn(@CheckForNull Object obj) {
return super.containsColumn(obj);
}
public /* bridge */ /* synthetic */ boolean containsRow(@CheckForNull Object obj) {
return super.containsRow(obj);
}
public /* bridge */ /* synthetic */ boolean equals(@CheckForNull Object obj) {
return super.equals(obj);
}
@CheckForNull
public /* bridge */ /* synthetic */ Object get(@CheckForNull Object obj, @CheckForNull Object obj2) {
return super.get(obj, obj2);
}
public /* bridge */ /* synthetic */ int hashCode() {
return super.hashCode();
}
public /* bridge */ /* synthetic */ boolean isEmpty() {
return super.isEmpty();
}
public /* bridge */ /* synthetic */ String toString() {
return super.toString();
}
public static <R, C, V> ImmutableTable<R, C, V> of() {
return SparseImmutableTable.EMPTY;
}
public static <R, C, V> ImmutableTable<R, C, V> of(R r, C c, V v) {
return new SingletonImmutableTable(r, c, v);
}
public static <R, C, V> ImmutableTable<R, C, V> copyOf(Table<? extends R, ? extends C, ? extends V> table) {
if (table instanceof ImmutableTable) {
return (ImmutableTable) table;
}
return copyOf(table.cellSet());
}
static <R, C, V> ImmutableTable<R, C, V> copyOf(Iterable<? extends Table.Cell<? extends R, ? extends C, ? extends V>> iterable) {
Builder builder = builder();
for (Table.Cell put : iterable) {
builder.put(put);
}
return builder.build();
}
public static <R, C, V> Builder<R, C, V> builder() {
return new Builder<>();
}
static <R, C, V> Table.Cell<R, C, V> cellOf(R r, C c, V v) {
return Tables.immutableCell(Preconditions.checkNotNull(r, "rowKey"), Preconditions.checkNotNull(c, "columnKey"), Preconditions.checkNotNull(v, "value"));
}
@DoNotMock
public static final class Builder<R, C, V> {
private final List<Table.Cell<R, C, V>> cells = Lists.newArrayList();
@CheckForNull
private Comparator<? super C> columnComparator;
@CheckForNull
private Comparator<? super R> rowComparator;
public Builder<R, C, V> orderRowsBy(Comparator<? super R> comparator) {
this.rowComparator = (Comparator) Preconditions.checkNotNull(comparator, "rowComparator");
return this;
}
public Builder<R, C, V> orderColumnsBy(Comparator<? super C> comparator) {
this.columnComparator = (Comparator) Preconditions.checkNotNull(comparator, "columnComparator");
return this;
}
public Builder<R, C, V> put(R r, C c, V v) {
this.cells.add(ImmutableTable.cellOf(r, c, v));
return this;
}
public Builder<R, C, V> put(Table.Cell<? extends R, ? extends C, ? extends V> cell) {
if (cell instanceof Tables.ImmutableCell) {
Preconditions.checkNotNull(cell.getRowKey(), "row");
Preconditions.checkNotNull(cell.getColumnKey(), "column");
Preconditions.checkNotNull(cell.getValue(), "value");
this.cells.add(cell);
} else {
put(cell.getRowKey(), cell.getColumnKey(), cell.getValue());
}
return this;
}
public Builder<R, C, V> putAll(Table<? extends R, ? extends C, ? extends V> table) {
for (Table.Cell<? extends R, ? extends C, ? extends V> put : table.cellSet()) {
put(put);
}
return this;
}
/* access modifiers changed from: package-private */
public Builder<R, C, V> combine(Builder<R, C, V> builder) {
this.cells.addAll(builder.cells);
return this;
}
public ImmutableTable<R, C, V> build() {
return buildOrThrow();
}
public ImmutableTable<R, C, V> buildOrThrow() {
int size = this.cells.size();
if (size == 0) {
return ImmutableTable.of();
}
if (size != 1) {
return RegularImmutableTable.forCells(this.cells, this.rowComparator, this.columnComparator);
}
return new SingletonImmutableTable((Table.Cell) Iterables.getOnlyElement(this.cells));
}
}
ImmutableTable() {
}
public ImmutableSet<Table.Cell<R, C, V>> cellSet() {
return (ImmutableSet) super.cellSet();
}
/* access modifiers changed from: package-private */
public final UnmodifiableIterator<Table.Cell<R, C, V>> cellIterator() {
throw new AssertionError("should never be called");
}
public ImmutableCollection<V> values() {
return (ImmutableCollection) super.values();
}
/* access modifiers changed from: package-private */
public final Iterator<V> valuesIterator() {
throw new AssertionError("should never be called");
}
public ImmutableMap<R, V> column(C c) {
Preconditions.checkNotNull(c, "columnKey");
return (ImmutableMap) MoreObjects.firstNonNull((ImmutableMap) columnMap().get(c), ImmutableMap.of());
}
public ImmutableSet<C> columnKeySet() {
return columnMap().keySet();
}
public ImmutableMap<C, V> row(R r) {
Preconditions.checkNotNull(r, "rowKey");
return (ImmutableMap) MoreObjects.firstNonNull((ImmutableMap) rowMap().get(r), ImmutableMap.of());
}
public ImmutableSet<R> rowKeySet() {
return rowMap().keySet();
}
public boolean contains(@CheckForNull Object obj, @CheckForNull Object obj2) {
return get(obj, obj2) != null;
}
public boolean containsValue(@CheckForNull Object obj) {
return values().contains(obj);
}
@Deprecated
public final void clear() {
throw new UnsupportedOperationException();
}
@CheckForNull
@Deprecated
public final V put(R r, C c, V v) {
throw new UnsupportedOperationException();
}
@Deprecated
public final void putAll(Table<? extends R, ? extends C, ? extends V> table) {
throw new UnsupportedOperationException();
}
@CheckForNull
@Deprecated
public final V remove(@CheckForNull Object obj, @CheckForNull Object obj2) {
throw new UnsupportedOperationException();
}
static final class SerializedForm implements Serializable {
private static final long serialVersionUID = 0;
private final int[] cellColumnIndices;
private final int[] cellRowIndices;
private final Object[] cellValues;
private final Object[] columnKeys;
private final Object[] rowKeys;
private SerializedForm(Object[] objArr, Object[] objArr2, Object[] objArr3, int[] iArr, int[] iArr2) {
this.rowKeys = objArr;
this.columnKeys = objArr2;
this.cellValues = objArr3;
this.cellRowIndices = iArr;
this.cellColumnIndices = iArr2;
}
static SerializedForm create(ImmutableTable<?, ?, ?> immutableTable, int[] iArr, int[] iArr2) {
return new SerializedForm(immutableTable.rowKeySet().toArray(), immutableTable.columnKeySet().toArray(), immutableTable.values().toArray(), iArr, iArr2);
}
/* access modifiers changed from: package-private */
public Object readResolve() {
Object[] objArr = this.cellValues;
if (objArr.length == 0) {
return ImmutableTable.of();
}
int i = 0;
if (objArr.length == 1) {
return ImmutableTable.of(this.rowKeys[0], this.columnKeys[0], objArr[0]);
}
ImmutableList.Builder builder = new ImmutableList.Builder(objArr.length);
while (true) {
Object[] objArr2 = this.cellValues;
if (i >= objArr2.length) {
return RegularImmutableTable.forOrderedComponents(builder.build(), ImmutableSet.copyOf((E[]) this.rowKeys), ImmutableSet.copyOf((E[]) this.columnKeys));
}
builder.add((Object) ImmutableTable.cellOf(this.rowKeys[this.cellRowIndices[i]], this.columnKeys[this.cellColumnIndices[i]], objArr2[i]));
i++;
}
}
}
/* access modifiers changed from: package-private */
public final Object writeReplace() {
return createSerializedForm();
}
}
Download file