CrackMe.apk
Download file
package com.google.common.base;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
public final class Splitter {
/* access modifiers changed from: private */
public final int limit;
/* access modifiers changed from: private */
public final boolean omitEmptyStrings;
private final Strategy strategy;
/* access modifiers changed from: private */
public final CharMatcher trimmer;
private interface Strategy {
Iterator<String> iterator(Splitter splitter, CharSequence charSequence);
}
private Splitter(Strategy strategy2) {
this(strategy2, false, CharMatcher.none(), Integer.MAX_VALUE);
}
private Splitter(Strategy strategy2, boolean z, CharMatcher charMatcher, int i) {
this.strategy = strategy2;
this.omitEmptyStrings = z;
this.trimmer = charMatcher;
this.limit = i;
}
public static Splitter on(char c) {
return on(CharMatcher.is(c));
}
public static Splitter on(final CharMatcher charMatcher) {
Preconditions.checkNotNull(charMatcher);
return new Splitter(new Strategy() {
public SplittingIterator iterator(Splitter splitter, CharSequence charSequence) {
return new SplittingIterator(splitter, charSequence) {
/* access modifiers changed from: package-private */
public int separatorEnd(int i) {
return i + 1;
}
/* access modifiers changed from: package-private */
public int separatorStart(int i) {
return CharMatcher.this.indexIn(this.toSplit, i);
}
};
}
});
}
public static Splitter on(final String str) {
Preconditions.checkArgument(str.length() != 0, "The separator may not be the empty string.");
if (str.length() == 1) {
return on(str.charAt(0));
}
return new Splitter(new Strategy() {
public SplittingIterator iterator(Splitter splitter, CharSequence charSequence) {
return new SplittingIterator(splitter, charSequence) {
public int separatorStart(int i) {
int length = str.length();
int length2 = this.toSplit.length() - length;
while (i <= length2) {
int i2 = 0;
while (i2 < length) {
if (this.toSplit.charAt(i2 + i) != str.charAt(i2)) {
i++;
} else {
i2++;
}
}
return i;
}
return -1;
}
public int separatorEnd(int i) {
return i + str.length();
}
};
}
});
}
public static Splitter on(Pattern pattern) {
return on((CommonPattern) new JdkPattern(pattern));
}
private static Splitter on(final CommonPattern commonPattern) {
Preconditions.checkArgument(!commonPattern.matcher("").matches(), "The pattern may not match the empty string: %s", (Object) commonPattern);
return new Splitter(new Strategy() {
public SplittingIterator iterator(Splitter splitter, CharSequence charSequence) {
final CommonMatcher matcher = CommonPattern.this.matcher(charSequence);
return new SplittingIterator(this, splitter, charSequence) {
public int separatorStart(int i) {
if (matcher.find(i)) {
return matcher.start();
}
return -1;
}
public int separatorEnd(int i) {
return matcher.end();
}
};
}
});
}
public static Splitter onPattern(String str) {
return on(Platform.compilePattern(str));
}
public static Splitter fixedLength(final int i) {
Preconditions.checkArgument(i > 0, "The length may not be less than 1");
return new Splitter(new Strategy() {
public SplittingIterator iterator(Splitter splitter, CharSequence charSequence) {
return new SplittingIterator(splitter, charSequence) {
public int separatorEnd(int i) {
return i;
}
public int separatorStart(int i) {
int i2 = i + i;
if (i2 < this.toSplit.length()) {
return i2;
}
return -1;
}
};
}
});
}
public Splitter omitEmptyStrings() {
return new Splitter(this.strategy, true, this.trimmer, this.limit);
}
public Splitter limit(int i) {
Preconditions.checkArgument(i > 0, "must be greater than zero: %s", i);
return new Splitter(this.strategy, this.omitEmptyStrings, this.trimmer, i);
}
public Splitter trimResults() {
return trimResults(CharMatcher.whitespace());
}
public Splitter trimResults(CharMatcher charMatcher) {
Preconditions.checkNotNull(charMatcher);
return new Splitter(this.strategy, this.omitEmptyStrings, charMatcher, this.limit);
}
public Iterable<String> split(final CharSequence charSequence) {
Preconditions.checkNotNull(charSequence);
return new Iterable<String>() {
public Iterator<String> iterator() {
return Splitter.this.splittingIterator(charSequence);
}
public String toString() {
Joiner on = Joiner.on(", ");
StringBuilder sb = new StringBuilder();
sb.append('[');
StringBuilder appendTo = on.appendTo(sb, (Iterable<? extends Object>) this);
appendTo.append(']');
return appendTo.toString();
}
};
}
/* access modifiers changed from: private */
public Iterator<String> splittingIterator(CharSequence charSequence) {
return this.strategy.iterator(this, charSequence);
}
public List<String> splitToList(CharSequence charSequence) {
Preconditions.checkNotNull(charSequence);
Iterator<String> splittingIterator = splittingIterator(charSequence);
ArrayList arrayList = new ArrayList();
while (splittingIterator.hasNext()) {
arrayList.add(splittingIterator.next());
}
return Collections.unmodifiableList(arrayList);
}
public MapSplitter withKeyValueSeparator(String str) {
return withKeyValueSeparator(on(str));
}
public MapSplitter withKeyValueSeparator(char c) {
return withKeyValueSeparator(on(c));
}
public MapSplitter withKeyValueSeparator(Splitter splitter) {
return new MapSplitter(splitter);
}
public static final class MapSplitter {
private static final String INVALID_ENTRY_MESSAGE = "Chunk [%s] is not a valid entry";
private final Splitter entrySplitter;
private final Splitter outerSplitter;
private MapSplitter(Splitter splitter, Splitter splitter2) {
this.outerSplitter = splitter;
this.entrySplitter = (Splitter) Preconditions.checkNotNull(splitter2);
}
public Map<String, String> split(CharSequence charSequence) {
LinkedHashMap linkedHashMap = new LinkedHashMap();
for (String next : this.outerSplitter.split(charSequence)) {
Iterator access$000 = this.entrySplitter.splittingIterator(next);
Preconditions.checkArgument(access$000.hasNext(), INVALID_ENTRY_MESSAGE, (Object) next);
String str = (String) access$000.next();
Preconditions.checkArgument(!linkedHashMap.containsKey(str), "Duplicate key [%s] found.", (Object) str);
Preconditions.checkArgument(access$000.hasNext(), INVALID_ENTRY_MESSAGE, (Object) next);
linkedHashMap.put(str, (String) access$000.next());
Preconditions.checkArgument(!access$000.hasNext(), INVALID_ENTRY_MESSAGE, (Object) next);
}
return Collections.unmodifiableMap(linkedHashMap);
}
}
private static abstract class SplittingIterator extends AbstractIterator<String> {
int limit;
int offset = 0;
final boolean omitEmptyStrings;
final CharSequence toSplit;
final CharMatcher trimmer;
/* access modifiers changed from: package-private */
public abstract int separatorEnd(int i);
/* access modifiers changed from: package-private */
public abstract int separatorStart(int i);
protected SplittingIterator(Splitter splitter, CharSequence charSequence) {
this.trimmer = splitter.trimmer;
this.omitEmptyStrings = splitter.omitEmptyStrings;
this.limit = splitter.limit;
this.toSplit = charSequence;
}
/* access modifiers changed from: protected */
@CheckForNull
public String computeNext() {
int i;
int i2 = this.offset;
while (true) {
int i3 = this.offset;
if (i3 == -1) {
return (String) endOfData();
}
int separatorStart = separatorStart(i3);
if (separatorStart == -1) {
separatorStart = this.toSplit.length();
this.offset = -1;
} else {
this.offset = separatorEnd(separatorStart);
}
int i4 = this.offset;
if (i4 == i2) {
int i5 = i4 + 1;
this.offset = i5;
if (i5 > this.toSplit.length()) {
this.offset = -1;
}
} else {
while (i2 < separatorStart && this.trimmer.matches(this.toSplit.charAt(i2))) {
i2++;
}
while (i > i2 && this.trimmer.matches(this.toSplit.charAt(i - 1))) {
separatorStart = i - 1;
}
if (!this.omitEmptyStrings || i2 != i) {
int i6 = this.limit;
} else {
i2 = this.offset;
}
}
}
int i62 = this.limit;
if (i62 == 1) {
i = this.toSplit.length();
this.offset = -1;
while (i > i2 && this.trimmer.matches(this.toSplit.charAt(i - 1))) {
i--;
}
} else {
this.limit = i62 - 1;
}
return this.toSplit.subSequence(i2, i).toString();
}
}
}
Download file