project-real-resurrection-3/rr3-apk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity
Files
v14
rr3-apk/decompiled-community/sources/okio/Buffer.java
Daniel Elliott c080f0d97f Add Discord community version (64-bit only) 
- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis
2026-02-18 15:48:36 -08:00

1264 lines
39 KiB
Java
Raw Permalink Blame History

package okio;
import android.support.v4.media.session.PlaybackStateCompat;
import androidx.work.WorkRequest;
import com.mbridge.msdk.playercommon.exoplayer2.C;
import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
import java.io.EOFException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.channels.ByteChannel;
import java.nio.charset.Charset;
/* loaded from: classes5.dex */
public final class Buffer implements BufferedSource, BufferedSink, Cloneable, ByteChannel {
public static final byte[] DIGITS = {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102};
public Segment head;
public long size;
@Override // okio.BufferedSource, okio.BufferedSink
public Buffer buffer() {
return this;
}
@Override // okio.Source, java.io.Closeable, java.lang.AutoCloseable
public void close() {
}
@Override // okio.BufferedSink
public BufferedSink emit() {
return this;
}
@Override // okio.BufferedSink
public Buffer emitCompleteSegments() {
return this;
}
@Override // okio.BufferedSource
public boolean exhausted() {
return this.size == 0;
}
@Override // okio.BufferedSink, okio.Sink, java.io.Flushable
public void flush() {
}
@Override // okio.BufferedSource
public Buffer getBuffer() {
return this;
}
@Override // java.nio.channels.Channel
public boolean isOpen() {
return true;
}
public final long size() {
return this.size;
}
@Override // okio.BufferedSource
public void require(long j) {
if (this.size < j) {
throw new EOFException();
}
}
@Override // okio.BufferedSource
public InputStream inputStream() {
return new InputStream() { // from class: okio.Buffer.2
@Override // java.io.InputStream, java.io.Closeable, java.lang.AutoCloseable
public void close() {
}
@Override // java.io.InputStream
public int read() {
Buffer buffer = Buffer.this;
if (buffer.size > 0) {
return buffer.readByte() & 255;
}
return -1;
}
@Override // java.io.InputStream
public int read(byte[] bArr, int i, int i2) {
return Buffer.this.read(bArr, i, i2);
}
@Override // java.io.InputStream
public int available() {
return (int) Math.min(Buffer.this.size, 2147483647L);
}
public String toString() {
return Buffer.this + ".inputStream()";
}
};
}
public final Buffer copyTo(Buffer buffer, long j, long j2) {
if (buffer == null) {
throw new IllegalArgumentException("out == null");
}
Util.checkOffsetAndCount(this.size, j, j2);
if (j2 == 0) {
return this;
}
buffer.size += j2;
Segment segment = this.head;
while (true) {
int i = segment.limit;
int i2 = segment.pos;
if (j < i - i2) {
break;
}
j -= i - i2;
segment = segment.next;
}
while (j2 > 0) {
Segment sharedCopy = segment.sharedCopy();
int i3 = (int) (sharedCopy.pos + j);
sharedCopy.pos = i3;
sharedCopy.limit = Math.min(i3 + ((int) j2), sharedCopy.limit);
Segment segment2 = buffer.head;
if (segment2 == null) {
sharedCopy.prev = sharedCopy;
sharedCopy.next = sharedCopy;
buffer.head = sharedCopy;
} else {
segment2.prev.push(sharedCopy);
}
j2 -= sharedCopy.limit - sharedCopy.pos;
segment = segment.next;
j = 0;
}
return this;
}
public final long completeSegmentByteCount() {
long j = this.size;
if (j == 0) {
return 0L;
}
Segment segment = this.head.prev;
return (segment.limit >= 8192 || !segment.owner) ? j : j - (r3 - segment.pos);
}
@Override // okio.BufferedSource
public byte readByte() {
long j = this.size;
if (j == 0) {
throw new IllegalStateException("size == 0");
}
Segment segment = this.head;
int i = segment.pos;
int i2 = segment.limit;
int i3 = i + 1;
byte b = segment.data[i];
this.size = j - 1;
if (i3 == i2) {
this.head = segment.pop();
SegmentPool.recycle(segment);
} else {
segment.pos = i3;
}
return b;
}
public final byte getByte(long j) {
int i;
Util.checkOffsetAndCount(this.size, j, 1L);
long j2 = this.size;
if (j2 - j <= j) {
long j3 = j - j2;
Segment segment = this.head;
do {
segment = segment.prev;
int i2 = segment.limit;
i = segment.pos;
j3 += i2 - i;
} while (j3 < 0);
return segment.data[i + ((int) j3)];
}
Segment segment2 = this.head;
while (true) {
int i3 = segment2.limit;
int i4 = segment2.pos;
long j4 = i3 - i4;
if (j >= j4) {
j -= j4;
segment2 = segment2.next;
} else {
return segment2.data[i4 + ((int) j)];
}
}
}
@Override // okio.BufferedSource
public short readShort() {
long j = this.size;
if (j < 2) {
throw new IllegalStateException("size < 2: " + this.size);
}
Segment segment = this.head;
int i = segment.pos;
int i2 = segment.limit;
if (i2 - i < 2) {
return (short) (((readByte() & 255) << 8) | (readByte() & 255));
}
byte[] bArr = segment.data;
int i3 = i + 1;
int i4 = (bArr[i] & 255) << 8;
int i5 = i + 2;
int i6 = (bArr[i3] & 255) | i4;
this.size = j - 2;
if (i5 == i2) {
this.head = segment.pop();
SegmentPool.recycle(segment);
} else {
segment.pos = i5;
}
return (short) i6;
}
@Override // okio.BufferedSource
public int readInt() {
long j = this.size;
if (j < 4) {
throw new IllegalStateException("size < 4: " + this.size);
}
Segment segment = this.head;
int i = segment.pos;
int i2 = segment.limit;
if (i2 - i < 4) {
return ((readByte() & 255) << 24) | ((readByte() & 255) << 16) | ((readByte() & 255) << 8) | (readByte() & 255);
}
byte[] bArr = segment.data;
int i3 = i + 3;
int i4 = ((bArr[i + 1] & 255) << 16) | ((bArr[i] & 255) << 24) | ((bArr[i + 2] & 255) << 8);
int i5 = i + 4;
int i6 = (bArr[i3] & 255) | i4;
this.size = j - 4;
if (i5 == i2) {
this.head = segment.pop();
SegmentPool.recycle(segment);
} else {
segment.pos = i5;
}
return i6;
}
@Override // okio.BufferedSource
public short readShortLe() {
return Util.reverseBytesShort(readShort());
}
@Override // okio.BufferedSource
public int readIntLe() {
return Util.reverseBytesInt(readInt());
}
/* JADX WARN: Removed duplicated region for block: B:35:0x009a */
/* JADX WARN: Removed duplicated region for block: B:37:0x00a8 */
/* JADX WARN: Removed duplicated region for block: B:46:0x00ac A[EDGE_INSN: B:46:0x00ac->B:40:0x00ac BREAK A[LOOP:0: B:4:0x000f->B:45:?], SYNTHETIC] */
/* JADX WARN: Removed duplicated region for block: B:47:0x00a4 */
@Override // okio.BufferedSource
/*
Code decompiled incorrectly, please refer to instructions dump.
To view partially-correct add '--show-bad-code' argument
*/
public long readDecimalLong() {
/*
r15 = this;
long r0 = r15.size
r2 = 0
int r0 = (r0 > r2 ? 1 : (r0 == r2 ? 0 : -1))
if (r0 == 0) goto Lb7
r0 = 0
r4 = -7
r1 = r0
r5 = r4
r3 = r2
r2 = r1
Lf:
okio.Segment r7 = r15.head
byte[] r8 = r7.data
int r9 = r7.pos
int r10 = r7.limit
L17:
if (r9 >= r10) goto L98
r11 = r8[r9]
r12 = 48
if (r11 < r12) goto L69
r12 = 57
if (r11 > r12) goto L69
int r12 = 48 - r11
r13 = -922337203685477580(0xf333333333333334, double:-8.390303882365713E246)
int r13 = (r3 > r13 ? 1 : (r3 == r13 ? 0 : -1))
if (r13 < 0) goto L3c
if (r13 != 0) goto L36
long r13 = (long) r12
int r13 = (r13 > r5 ? 1 : (r13 == r5 ? 0 : -1))
if (r13 >= 0) goto L36
goto L3c
L36:
r13 = 10
long r3 = r3 * r13
long r11 = (long) r12
long r3 = r3 + r11
goto L74
L3c:
okio.Buffer r0 = new okio.Buffer
r0.<init>()
okio.Buffer r0 = r0.writeDecimalLong(r3)
okio.Buffer r0 = r0.writeByte(r11)
if (r1 != 0) goto L4e
r0.readByte()
L4e:
java.lang.NumberFormatException r1 = new java.lang.NumberFormatException
java.lang.StringBuilder r2 = new java.lang.StringBuilder
r2.<init>()
java.lang.String r3 = "Number too large: "
r2.append(r3)
java.lang.String r0 = r0.readUtf8()
r2.append(r0)
java.lang.String r0 = r2.toString()
r1.<init>(r0)
throw r1
L69:
r12 = 45
r13 = 1
if (r11 != r12) goto L79
if (r0 != 0) goto L79
r11 = 1
long r5 = r5 - r11
r1 = r13
L74:
int r9 = r9 + 1
int r0 = r0 + 1
goto L17
L79:
if (r0 == 0) goto L7d
r2 = r13
goto L98
L7d:
java.lang.NumberFormatException r0 = new java.lang.NumberFormatException
java.lang.StringBuilder r1 = new java.lang.StringBuilder
r1.<init>()
java.lang.String r2 = "Expected leading [0-9] or '-' character but was 0x"
r1.append(r2)
java.lang.String r2 = java.lang.Integer.toHexString(r11)
r1.append(r2)
java.lang.String r1 = r1.toString()
r0.<init>(r1)
throw r0
L98:
if (r9 != r10) goto La4
okio.Segment r8 = r7.pop()
r15.head = r8
okio.SegmentPool.recycle(r7)
goto La6
La4:
r7.pos = r9
La6:
if (r2 != 0) goto Lac
okio.Segment r7 = r15.head
if (r7 != 0) goto Lf
Lac:
long r5 = r15.size
long r7 = (long) r0
long r5 = r5 - r7
r15.size = r5
if (r1 == 0) goto Lb5
goto Lb6
Lb5:
long r3 = -r3
Lb6:
return r3
Lb7:
java.lang.IllegalStateException r0 = new java.lang.IllegalStateException
java.lang.String r1 = "size == 0"
r0.<init>(r1)
throw r0
*/
throw new UnsupportedOperationException("Method not decompiled: okio.Buffer.readDecimalLong():long");
}
/* JADX WARN: Removed duplicated region for block: B:32:0x0090 */
/* JADX WARN: Removed duplicated region for block: B:34:0x009e */
/* JADX WARN: Removed duplicated region for block: B:40:0x00a2 A[EDGE_INSN: B:40:0x00a2->B:37:0x00a2 BREAK A[LOOP:0: B:4:0x000b->B:39:?], SYNTHETIC] */
/* JADX WARN: Removed duplicated region for block: B:41:0x009a */
@Override // okio.BufferedSource
/*
Code decompiled incorrectly, please refer to instructions dump.
To view partially-correct add '--show-bad-code' argument
*/
public long readHexadecimalUnsignedLong() {
/*
r14 = this;
long r0 = r14.size
r2 = 0
int r0 = (r0 > r2 ? 1 : (r0 == r2 ? 0 : -1))
if (r0 == 0) goto La9
r0 = 0
r1 = r0
r4 = r2
Lb:
okio.Segment r6 = r14.head
byte[] r7 = r6.data
int r8 = r6.pos
int r9 = r6.limit
L13:
if (r8 >= r9) goto L8e
r10 = r7[r8]
r11 = 48
if (r10 < r11) goto L22
r11 = 57
if (r10 > r11) goto L22
int r11 = r10 + (-48)
goto L37
L22:
r11 = 97
if (r10 < r11) goto L2d
r11 = 102(0x66, float:1.43E-43)
if (r10 > r11) goto L2d
int r11 = r10 + (-87)
goto L37
L2d:
r11 = 65
if (r10 < r11) goto L6f
r11 = 70
if (r10 > r11) goto L6f
int r11 = r10 + (-55)
L37:
r12 = -1152921504606846976(0xf000000000000000, double:-3.105036184601418E231)
long r12 = r12 & r4
int r12 = (r12 > r2 ? 1 : (r12 == r2 ? 0 : -1))
if (r12 != 0) goto L47
r10 = 4
long r4 = r4 << r10
long r10 = (long) r11
long r4 = r4 | r10
int r8 = r8 + 1
int r0 = r0 + 1
goto L13
L47:
okio.Buffer r0 = new okio.Buffer
r0.<init>()
okio.Buffer r0 = r0.writeHexadecimalUnsignedLong(r4)
okio.Buffer r0 = r0.writeByte(r10)
java.lang.NumberFormatException r1 = new java.lang.NumberFormatException
java.lang.StringBuilder r2 = new java.lang.StringBuilder
r2.<init>()
java.lang.String r3 = "Number too large: "
r2.append(r3)
java.lang.String r0 = r0.readUtf8()
r2.append(r0)
java.lang.String r0 = r2.toString()
r1.<init>(r0)
throw r1
L6f:
if (r0 == 0) goto L73
r1 = 1
goto L8e
L73:
java.lang.NumberFormatException r0 = new java.lang.NumberFormatException
java.lang.StringBuilder r1 = new java.lang.StringBuilder
r1.<init>()
java.lang.String r2 = "Expected leading [0-9a-fA-F] character but was 0x"
r1.append(r2)
java.lang.String r2 = java.lang.Integer.toHexString(r10)
r1.append(r2)
java.lang.String r1 = r1.toString()
r0.<init>(r1)
throw r0
L8e:
if (r8 != r9) goto L9a
okio.Segment r7 = r6.pop()
r14.head = r7
okio.SegmentPool.recycle(r6)
goto L9c
L9a:
r6.pos = r8
L9c:
if (r1 != 0) goto La2
okio.Segment r6 = r14.head
if (r6 != 0) goto Lb
La2:
long r1 = r14.size
long r6 = (long) r0
long r1 = r1 - r6
r14.size = r1
return r4
La9:
java.lang.IllegalStateException r0 = new java.lang.IllegalStateException
java.lang.String r1 = "size == 0"
r0.<init>(r1)
throw r0
*/
throw new UnsupportedOperationException("Method not decompiled: okio.Buffer.readHexadecimalUnsignedLong():long");
}
public ByteString readByteString() {
return new ByteString(readByteArray());
}
@Override // okio.BufferedSource
public ByteString readByteString(long j) {
return new ByteString(readByteArray(j));
}
@Override // okio.BufferedSource
public int select(Options options) {
int selectPrefix = selectPrefix(options, false);
if (selectPrefix == -1) {
return -1;
}
try {
skip(options.byteStrings[selectPrefix].size());
return selectPrefix;
} catch (EOFException unused) {
throw new AssertionError();
}
}
/* JADX WARN: Code restructure failed: missing block: B:34:0x0055, code lost:
if (r19 == false) goto L29;
*/
/* JADX WARN: Code restructure failed: missing block: B:35:0x0057, code lost:
return r3;
*/
/* JADX WARN: Code restructure failed: missing block: B:36:0x0058, code lost:
return r11;
*/
/*
Code decompiled incorrectly, please refer to instructions dump.
To view partially-correct add '--show-bad-code' argument
*/
public int selectPrefix(okio.Options r18, boolean r19) {
/*
Method dump skipped, instructions count: 158
To view this dump add '--comments-level debug' option
*/
throw new UnsupportedOperationException("Method not decompiled: okio.Buffer.selectPrefix(okio.Options, boolean):int");
}
@Override // okio.BufferedSource
public long readAll(Sink sink) {
long j = this.size;
if (j > 0) {
sink.write(this, j);
}
return j;
}
public String readUtf8() {
try {
return readString(this.size, Util.UTF_8);
} catch (EOFException e) {
throw new AssertionError(e);
}
}
public String readUtf8(long j) {
return readString(j, Util.UTF_8);
}
@Override // okio.BufferedSource
public String readString(Charset charset) {
try {
return readString(this.size, charset);
} catch (EOFException e) {
throw new AssertionError(e);
}
}
public String readString(long j, Charset charset) {
Util.checkOffsetAndCount(this.size, 0L, j);
if (charset == null) {
throw new IllegalArgumentException("charset == null");
}
if (j > 2147483647L) {
throw new IllegalArgumentException("byteCount > Integer.MAX_VALUE: " + j);
}
if (j == 0) {
return "";
}
Segment segment = this.head;
int i = segment.pos;
if (i + j > segment.limit) {
return new String(readByteArray(j), charset);
}
String str = new String(segment.data, i, (int) j, charset);
int i2 = (int) (segment.pos + j);
segment.pos = i2;
this.size -= j;
if (i2 == segment.limit) {
this.head = segment.pop();
SegmentPool.recycle(segment);
}
return str;
}
@Override // okio.BufferedSource
public String readUtf8LineStrict() {
return readUtf8LineStrict(Long.MAX_VALUE);
}
@Override // okio.BufferedSource
public String readUtf8LineStrict(long j) {
if (j < 0) {
throw new IllegalArgumentException("limit < 0: " + j);
}
long j2 = j != Long.MAX_VALUE ? j + 1 : Long.MAX_VALUE;
long indexOf = indexOf((byte) 10, 0L, j2);
if (indexOf != -1) {
return readUtf8Line(indexOf);
}
if (j2 < size() && getByte(j2 - 1) == 13 && getByte(j2) == 10) {
return readUtf8Line(j2);
}
Buffer buffer = new Buffer();
copyTo(buffer, 0L, Math.min(32L, size()));
throw new EOFException("\\n not found: limit=" + Math.min(size(), j) + " content=" + buffer.readByteString().hex() + (char) 8230);
}
public String readUtf8Line(long j) {
if (j > 0) {
long j2 = j - 1;
if (getByte(j2) == 13) {
String readUtf8 = readUtf8(j2);
skip(2L);
return readUtf8;
}
}
String readUtf82 = readUtf8(j);
skip(1L);
return readUtf82;
}
@Override // okio.BufferedSource
public byte[] readByteArray() {
try {
return readByteArray(this.size);
} catch (EOFException e) {
throw new AssertionError(e);
}
}
@Override // okio.BufferedSource
public byte[] readByteArray(long j) {
Util.checkOffsetAndCount(this.size, 0L, j);
if (j > 2147483647L) {
throw new IllegalArgumentException("byteCount > Integer.MAX_VALUE: " + j);
}
byte[] bArr = new byte[(int) j];
readFully(bArr);
return bArr;
}
@Override // okio.BufferedSource
public void readFully(byte[] bArr) {
int i = 0;
while (i < bArr.length) {
int read = read(bArr, i, bArr.length - i);
if (read == -1) {
throw new EOFException();
}
i += read;
}
}
public int read(byte[] bArr, int i, int i2) {
Util.checkOffsetAndCount(bArr.length, i, i2);
Segment segment = this.head;
if (segment == null) {
return -1;
}
int min = Math.min(i2, segment.limit - segment.pos);
System.arraycopy(segment.data, segment.pos, bArr, i, min);
int i3 = segment.pos + min;
segment.pos = i3;
this.size -= min;
if (i3 == segment.limit) {
this.head = segment.pop();
SegmentPool.recycle(segment);
}
return min;
}
@Override // java.nio.channels.ReadableByteChannel
public int read(ByteBuffer byteBuffer) {
Segment segment = this.head;
if (segment == null) {
return -1;
}
int min = Math.min(byteBuffer.remaining(), segment.limit - segment.pos);
byteBuffer.put(segment.data, segment.pos, min);
int i = segment.pos + min;
segment.pos = i;
this.size -= min;
if (i == segment.limit) {
this.head = segment.pop();
SegmentPool.recycle(segment);
}
return min;
}
public final void clear() {
try {
skip(this.size);
} catch (EOFException e) {
throw new AssertionError(e);
}
}
@Override // okio.BufferedSource
public void skip(long j) {
while (j > 0) {
if (this.head == null) {
throw new EOFException();
}
int min = (int) Math.min(j, r0.limit - r0.pos);
long j2 = min;
this.size -= j2;
j -= j2;
Segment segment = this.head;
int i = segment.pos + min;
segment.pos = i;
if (i == segment.limit) {
this.head = segment.pop();
SegmentPool.recycle(segment);
}
}
}
@Override // okio.BufferedSink
public Buffer write(ByteString byteString) {
if (byteString == null) {
throw new IllegalArgumentException("byteString == null");
}
byteString.write(this);
return this;
}
@Override // okio.BufferedSink
public Buffer writeUtf8(String str) {
return writeUtf8(str, 0, str.length());
}
public Buffer writeUtf8(String str, int i, int i2) {
if (str == null) {
throw new IllegalArgumentException("string == null");
}
if (i < 0) {
throw new IllegalArgumentException("beginIndex < 0: " + i);
}
if (i2 < i) {
throw new IllegalArgumentException("endIndex < beginIndex: " + i2 + " < " + i);
}
if (i2 > str.length()) {
throw new IllegalArgumentException("endIndex > string.length: " + i2 + " > " + str.length());
}
while (i < i2) {
char charAt = str.charAt(i);
if (charAt < 128) {
Segment writableSegment = writableSegment(1);
byte[] bArr = writableSegment.data;
int i3 = writableSegment.limit - i;
int min = Math.min(i2, 8192 - i3);
int i4 = i + 1;
bArr[i + i3] = (byte) charAt;
while (i4 < min) {
char charAt2 = str.charAt(i4);
if (charAt2 >= 128) {
break;
}
bArr[i4 + i3] = (byte) charAt2;
i4++;
}
int i5 = writableSegment.limit;
int i6 = (i3 + i4) - i5;
writableSegment.limit = i5 + i6;
this.size += i6;
i = i4;
} else {
if (charAt < 2048) {
writeByte((charAt >> 6) | PsExtractor.AUDIO_STREAM);
writeByte((charAt & '?') | 128);
} else if (charAt < 55296 || charAt > 57343) {
writeByte((charAt >> '\f') | 224);
writeByte(((charAt >> 6) & 63) | 128);
writeByte((charAt & '?') | 128);
} else {
int i7 = i + 1;
char charAt3 = i7 < i2 ? str.charAt(i7) : (char) 0;
if (charAt > 56319 || charAt3 < 56320 || charAt3 > 57343) {
writeByte(63);
i = i7;
} else {
int i8 = (((charAt & 10239) << 10) | (9215 & charAt3)) + 65536;
writeByte((i8 >> 18) | PsExtractor.VIDEO_STREAM_MASK);
writeByte(((i8 >> 12) & 63) | 128);
writeByte(((i8 >> 6) & 63) | 128);
writeByte((i8 & 63) | 128);
i += 2;
}
}
i++;
}
}
return this;
}
public Buffer writeUtf8CodePoint(int i) {
if (i < 128) {
writeByte(i);
} else if (i < 2048) {
writeByte((i >> 6) | PsExtractor.AUDIO_STREAM);
writeByte((i & 63) | 128);
} else if (i < 65536) {
if (i >= 55296 && i <= 57343) {
writeByte(63);
} else {
writeByte((i >> 12) | 224);
writeByte(((i >> 6) & 63) | 128);
writeByte((i & 63) | 128);
}
} else if (i <= 1114111) {
writeByte((i >> 18) | PsExtractor.VIDEO_STREAM_MASK);
writeByte(((i >> 12) & 63) | 128);
writeByte(((i >> 6) & 63) | 128);
writeByte((i & 63) | 128);
} else {
throw new IllegalArgumentException("Unexpected code point: " + Integer.toHexString(i));
}
return this;
}
public Buffer writeString(String str, Charset charset) {
return writeString(str, 0, str.length(), charset);
}
public Buffer writeString(String str, int i, int i2, Charset charset) {
if (str == null) {
throw new IllegalArgumentException("string == null");
}
if (i < 0) {
throw new IllegalAccessError("beginIndex < 0: " + i);
}
if (i2 < i) {
throw new IllegalArgumentException("endIndex < beginIndex: " + i2 + " < " + i);
}
if (i2 <= str.length()) {
if (charset == null) {
throw new IllegalArgumentException("charset == null");
}
if (charset.equals(Util.UTF_8)) {
return writeUtf8(str, i, i2);
}
byte[] bytes = str.substring(i, i2).getBytes(charset);
return write(bytes, 0, bytes.length);
}
throw new IllegalArgumentException("endIndex > string.length: " + i2 + " > " + str.length());
}
@Override // okio.BufferedSink
public Buffer write(byte[] bArr) {
if (bArr == null) {
throw new IllegalArgumentException("source == null");
}
return write(bArr, 0, bArr.length);
}
@Override // okio.BufferedSink
public Buffer write(byte[] bArr, int i, int i2) {
if (bArr == null) {
throw new IllegalArgumentException("source == null");
}
long j = i2;
Util.checkOffsetAndCount(bArr.length, i, j);
int i3 = i2 + i;
while (i < i3) {
Segment writableSegment = writableSegment(1);
int min = Math.min(i3 - i, 8192 - writableSegment.limit);
System.arraycopy(bArr, i, writableSegment.data, writableSegment.limit, min);
i += min;
writableSegment.limit += min;
}
this.size += j;
return this;
}
@Override // java.nio.channels.WritableByteChannel
public int write(ByteBuffer byteBuffer) {
if (byteBuffer == null) {
throw new IllegalArgumentException("source == null");
}
int remaining = byteBuffer.remaining();
int i = remaining;
while (i > 0) {
Segment writableSegment = writableSegment(1);
int min = Math.min(i, 8192 - writableSegment.limit);
byteBuffer.get(writableSegment.data, writableSegment.limit, min);
i -= min;
writableSegment.limit += min;
}
this.size += remaining;
return remaining;
}
@Override // okio.BufferedSink
public long writeAll(Source source) {
if (source == null) {
throw new IllegalArgumentException("source == null");
}
long j = 0;
while (true) {
long read = source.read(this, PlaybackStateCompat.ACTION_PLAY_FROM_URI);
if (read == -1) {
return j;
}
j += read;
}
}
@Override // okio.BufferedSink
public Buffer writeByte(int i) {
Segment writableSegment = writableSegment(1);
byte[] bArr = writableSegment.data;
int i2 = writableSegment.limit;
writableSegment.limit = i2 + 1;
bArr[i2] = (byte) i;
this.size++;
return this;
}
@Override // okio.BufferedSink
public Buffer writeShort(int i) {
Segment writableSegment = writableSegment(2);
byte[] bArr = writableSegment.data;
int i2 = writableSegment.limit;
bArr[i2] = (byte) ((i >>> 8) & 255);
bArr[i2 + 1] = (byte) (i & 255);
writableSegment.limit = i2 + 2;
this.size += 2;
return this;
}
@Override // okio.BufferedSink
public Buffer writeInt(int i) {
Segment writableSegment = writableSegment(4);
byte[] bArr = writableSegment.data;
int i2 = writableSegment.limit;
bArr[i2] = (byte) ((i >>> 24) & 255);
bArr[i2 + 1] = (byte) ((i >>> 16) & 255);
bArr[i2 + 2] = (byte) ((i >>> 8) & 255);
bArr[i2 + 3] = (byte) (i & 255);
writableSegment.limit = i2 + 4;
this.size += 4;
return this;
}
@Override // okio.BufferedSink
public Buffer writeIntLe(int i) {
return writeInt(Util.reverseBytesInt(i));
}
@Override // okio.BufferedSink
public Buffer writeDecimalLong(long j) {
boolean z;
if (j == 0) {
return writeByte(48);
}
int i = 1;
if (j < 0) {
j = -j;
if (j < 0) {
return writeUtf8("-9223372036854775808");
}
z = true;
} else {
z = false;
}
if (j >= 100000000) {
i = j < 1000000000000L ? j < 10000000000L ? j < C.NANOS_PER_SECOND ? 9 : 10 : j < 100000000000L ? 11 : 12 : j < 1000000000000000L ? j < 10000000000000L ? 13 : j < 100000000000000L ? 14 : 15 : j < 100000000000000000L ? j < 10000000000000000L ? 16 : 17 : j < 1000000000000000000L ? 18 : 19;
} else if (j >= WorkRequest.MIN_BACKOFF_MILLIS) {
i = j < 1000000 ? j < 100000 ? 5 : 6 : j < 10000000 ? 7 : 8;
} else if (j >= 100) {
i = j < 1000 ? 3 : 4;
} else if (j >= 10) {
i = 2;
}
if (z) {
i++;
}
Segment writableSegment = writableSegment(i);
byte[] bArr = writableSegment.data;
int i2 = writableSegment.limit + i;
while (j != 0) {
i2--;
bArr[i2] = DIGITS[(int) (j % 10)];
j /= 10;
}
if (z) {
bArr[i2 - 1] = 45;
}
writableSegment.limit += i;
this.size += i;
return this;
}
@Override // okio.BufferedSink
public Buffer writeHexadecimalUnsignedLong(long j) {
if (j == 0) {
return writeByte(48);
}
int numberOfTrailingZeros = (Long.numberOfTrailingZeros(Long.highestOneBit(j)) / 4) + 1;
Segment writableSegment = writableSegment(numberOfTrailingZeros);
byte[] bArr = writableSegment.data;
int i = writableSegment.limit;
for (int i2 = (i + numberOfTrailingZeros) - 1; i2 >= i; i2--) {
bArr[i2] = DIGITS[(int) (15 & j)];
j >>>= 4;
}
writableSegment.limit += numberOfTrailingZeros;
this.size += numberOfTrailingZeros;
return this;
}
public Segment writableSegment(int i) {
if (i < 1 || i > 8192) {
throw new IllegalArgumentException();
}
Segment segment = this.head;
if (segment == null) {
Segment take = SegmentPool.take();
this.head = take;
take.prev = take;
take.next = take;
return take;
}
Segment segment2 = segment.prev;
return (segment2.limit + i > 8192 || !segment2.owner) ? segment2.push(SegmentPool.take()) : segment2;
}
@Override // okio.Sink
public void write(Buffer buffer, long j) {
if (buffer == null) {
throw new IllegalArgumentException("source == null");
}
if (buffer == this) {
throw new IllegalArgumentException("source == this");
}
Util.checkOffsetAndCount(buffer.size, 0L, j);
while (j > 0) {
Segment segment = buffer.head;
if (j < segment.limit - segment.pos) {
Segment segment2 = this.head;
Segment segment3 = segment2 != null ? segment2.prev : null;
if (segment3 != null && segment3.owner) {
if ((segment3.limit + j) - (segment3.shared ? 0 : segment3.pos) <= PlaybackStateCompat.ACTION_PLAY_FROM_URI) {
segment.writeTo(segment3, (int) j);
buffer.size -= j;
this.size += j;
return;
}
}
buffer.head = segment.split((int) j);
}
Segment segment4 = buffer.head;
long j2 = segment4.limit - segment4.pos;
buffer.head = segment4.pop();
Segment segment5 = this.head;
if (segment5 == null) {
this.head = segment4;
segment4.prev = segment4;
segment4.next = segment4;
} else {
segment5.prev.push(segment4).compact();
}
buffer.size -= j2;
this.size += j2;
j -= j2;
}
}
@Override // okio.Source
public long read(Buffer buffer, long j) {
if (buffer == null) {
throw new IllegalArgumentException("sink == null");
}
if (j < 0) {
throw new IllegalArgumentException("byteCount < 0: " + j);
}
long j2 = this.size;
if (j2 == 0) {
return -1L;
}
if (j > j2) {
j = j2;
}
buffer.write(this, j);
return j;
}
@Override // okio.BufferedSource
public long indexOf(byte b) {
return indexOf(b, 0L, Long.MAX_VALUE);
}
public long indexOf(byte b, long j, long j2) {
Segment segment;
long j3 = 0;
if (j < 0 || j2 < j) {
throw new IllegalArgumentException(String.format("size=%s fromIndex=%s toIndex=%s", Long.valueOf(this.size), Long.valueOf(j), Long.valueOf(j2)));
}
long j4 = this.size;
long j5 = j2 > j4 ? j4 : j2;
if (j == j5 || (segment = this.head) == null) {
return -1L;
}
if (j4 - j < j) {
while (j4 > j) {
segment = segment.prev;
j4 -= segment.limit - segment.pos;
}
} else {
while (true) {
long j6 = (segment.limit - segment.pos) + j3;
if (j6 >= j) {
break;
}
segment = segment.next;
j3 = j6;
}
j4 = j3;
}
long j7 = j;
while (j4 < j5) {
byte[] bArr = segment.data;
int min = (int) Math.min(segment.limit, (segment.pos + j5) - j4);
for (int i = (int) ((segment.pos + j7) - j4); i < min; i++) {
if (bArr[i] == b) {
return (i - segment.pos) + j4;
}
}
j4 += segment.limit - segment.pos;
segment = segment.next;
j7 = j4;
}
return -1L;
}
@Override // okio.Source
public Timeout timeout() {
return Timeout.NONE;
}
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof Buffer)) {
return false;
}
Buffer buffer = (Buffer) obj;
long j = this.size;
if (j != buffer.size) {
return false;
}
long j2 = 0;
if (j == 0) {
return true;
}
Segment segment = this.head;
Segment segment2 = buffer.head;
int i = segment.pos;
int i2 = segment2.pos;
while (j2 < this.size) {
long min = Math.min(segment.limit - i, segment2.limit - i2);
int i3 = 0;
while (i3 < min) {
int i4 = i + 1;
int i5 = i2 + 1;
if (segment.data[i] != segment2.data[i2]) {
return false;
}
i3++;
i = i4;
i2 = i5;
}
if (i == segment.limit) {
segment = segment.next;
i = segment.pos;
}
if (i2 == segment2.limit) {
segment2 = segment2.next;
i2 = segment2.pos;
}
j2 += min;
}
return true;
}
public int hashCode() {
Segment segment = this.head;
if (segment == null) {
return 0;
}
int i = 1;
do {
int i2 = segment.limit;
for (int i3 = segment.pos; i3 < i2; i3++) {
i = (i * 31) + segment.data[i3];
}
segment = segment.next;
} while (segment != this.head);
return i;
}
public String toString() {
return snapshot().toString();
}
public Buffer clone() {
Buffer buffer = new Buffer();
if (this.size == 0) {
return buffer;
}
Segment sharedCopy = this.head.sharedCopy();
buffer.head = sharedCopy;
sharedCopy.prev = sharedCopy;
sharedCopy.next = sharedCopy;
Segment segment = this.head;
while (true) {
segment = segment.next;
if (segment == this.head) {
buffer.size = this.size;
return buffer;
}
buffer.head.prev.push(segment.sharedCopy());
}
}
public final ByteString snapshot() {
long j = this.size;
if (j > 2147483647L) {
throw new IllegalArgumentException("size > Integer.MAX_VALUE: " + this.size);
}
return snapshot((int) j);
}
public final ByteString snapshot(int i) {
if (i == 0) {
return ByteString.EMPTY;
}
return new SegmentedByteString(this, i);
}
}
Reference in New Issue View Git Blame Copy Permalink