294 lines
8.7 KiB
Java
294 lines
8.7 KiB
Java
// Protocol Buffers - Google's data interchange format
|
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
// https://developers.google.com/protocol-buffers/
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following disclaimer
|
|
// in the documentation and/or other materials provided with the
|
|
// distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived from
|
|
// this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
package com.google.protobuf;
|
|
|
|
import static com.google.protobuf.Internal.checkNotNull;
|
|
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.InvalidObjectException;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.OutputStream;
|
|
import java.nio.Buffer;
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.ByteOrder;
|
|
import java.nio.InvalidMarkException;
|
|
import java.nio.charset.Charset;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
|
|
/** A {@link ByteString} that wraps around a {@link ByteBuffer}. */
|
|
final class NioByteString extends ByteString.LeafByteString {
|
|
private final ByteBuffer buffer;
|
|
|
|
NioByteString(ByteBuffer buffer) {
|
|
checkNotNull(buffer, "buffer");
|
|
|
|
// Use native byte order for fast fixed32/64 operations.
|
|
this.buffer = buffer.slice().order(ByteOrder.nativeOrder());
|
|
}
|
|
|
|
// =================================================================
|
|
// Serializable
|
|
|
|
/** Magic method that lets us override serialization behavior. */
|
|
private Object writeReplace() {
|
|
return ByteString.copyFrom(buffer.slice());
|
|
}
|
|
|
|
/** Magic method that lets us override deserialization behavior. */
|
|
private void readObject(@SuppressWarnings("unused") ObjectInputStream in) throws IOException {
|
|
throw new InvalidObjectException("NioByteString instances are not to be serialized directly");
|
|
}
|
|
|
|
// =================================================================
|
|
|
|
@Override
|
|
public byte byteAt(int index) {
|
|
try {
|
|
return buffer.get(index);
|
|
} catch (ArrayIndexOutOfBoundsException e) {
|
|
throw e;
|
|
} catch (IndexOutOfBoundsException e) {
|
|
throw new ArrayIndexOutOfBoundsException(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public byte internalByteAt(int index) {
|
|
// it isn't possible to avoid the bounds checking inside of ByteBuffer, so just use the default
|
|
// implementation.
|
|
return byteAt(index);
|
|
}
|
|
|
|
@Override
|
|
public int size() {
|
|
return buffer.remaining();
|
|
}
|
|
|
|
@Override
|
|
public ByteString substring(int beginIndex, int endIndex) {
|
|
try {
|
|
ByteBuffer slice = slice(beginIndex, endIndex);
|
|
return new NioByteString(slice);
|
|
} catch (ArrayIndexOutOfBoundsException e) {
|
|
throw e;
|
|
} catch (IndexOutOfBoundsException e) {
|
|
throw new ArrayIndexOutOfBoundsException(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void copyToInternal(
|
|
byte[] target, int sourceOffset, int targetOffset, int numberToCopy) {
|
|
ByteBuffer slice = buffer.slice();
|
|
((Buffer) slice).position(sourceOffset);
|
|
slice.get(target, targetOffset, numberToCopy);
|
|
}
|
|
|
|
@Override
|
|
public void copyTo(ByteBuffer target) {
|
|
target.put(buffer.slice());
|
|
}
|
|
|
|
@Override
|
|
public void writeTo(OutputStream out) throws IOException {
|
|
out.write(toByteArray());
|
|
}
|
|
|
|
@Override
|
|
boolean equalsRange(ByteString other, int offset, int length) {
|
|
return substring(0, length).equals(other.substring(offset, offset + length));
|
|
}
|
|
|
|
@Override
|
|
void writeToInternal(OutputStream out, int sourceOffset, int numberToWrite) throws IOException {
|
|
if (buffer.hasArray()) {
|
|
// Optimized write for array-backed buffers.
|
|
// Note that we're taking the risk that a malicious OutputStream could modify the array.
|
|
int bufferOffset = buffer.arrayOffset() + buffer.position() + sourceOffset;
|
|
out.write(buffer.array(), bufferOffset, numberToWrite);
|
|
return;
|
|
}
|
|
|
|
ByteBufferWriter.write(slice(sourceOffset, sourceOffset + numberToWrite), out);
|
|
}
|
|
|
|
@Override
|
|
void writeTo(ByteOutput output) throws IOException {
|
|
output.writeLazy(buffer.slice());
|
|
}
|
|
|
|
@Override
|
|
public ByteBuffer asReadOnlyByteBuffer() {
|
|
return buffer.asReadOnlyBuffer();
|
|
}
|
|
|
|
@Override
|
|
public List<ByteBuffer> asReadOnlyByteBufferList() {
|
|
return Collections.singletonList(asReadOnlyByteBuffer());
|
|
}
|
|
|
|
@Override
|
|
protected String toStringInternal(Charset charset) {
|
|
final byte[] bytes;
|
|
final int offset;
|
|
final int length;
|
|
if (buffer.hasArray()) {
|
|
bytes = buffer.array();
|
|
offset = buffer.arrayOffset() + buffer.position();
|
|
length = buffer.remaining();
|
|
} else {
|
|
// TODO(nathanmittler): Can we optimize this?
|
|
bytes = toByteArray();
|
|
offset = 0;
|
|
length = bytes.length;
|
|
}
|
|
return new String(bytes, offset, length, charset);
|
|
}
|
|
|
|
@Override
|
|
public boolean isValidUtf8() {
|
|
return Utf8.isValidUtf8(buffer);
|
|
}
|
|
|
|
@Override
|
|
protected int partialIsValidUtf8(int state, int offset, int length) {
|
|
return Utf8.partialIsValidUtf8(state, buffer, offset, offset + length);
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object other) {
|
|
if (other == this) {
|
|
return true;
|
|
}
|
|
if (!(other instanceof ByteString)) {
|
|
return false;
|
|
}
|
|
ByteString otherString = ((ByteString) other);
|
|
if (size() != otherString.size()) {
|
|
return false;
|
|
}
|
|
if (size() == 0) {
|
|
return true;
|
|
}
|
|
if (other instanceof NioByteString) {
|
|
return buffer.equals(((NioByteString) other).buffer);
|
|
}
|
|
if (other instanceof RopeByteString) {
|
|
return other.equals(this);
|
|
}
|
|
return buffer.equals(otherString.asReadOnlyByteBuffer());
|
|
}
|
|
|
|
@Override
|
|
protected int partialHash(int h, int offset, int length) {
|
|
for (int i = offset; i < offset + length; i++) {
|
|
h = h * 31 + buffer.get(i);
|
|
}
|
|
return h;
|
|
}
|
|
|
|
@Override
|
|
public InputStream newInput() {
|
|
return new InputStream() {
|
|
private final ByteBuffer buf = buffer.slice();
|
|
|
|
@Override
|
|
public void mark(int readlimit) {
|
|
buf.mark();
|
|
}
|
|
|
|
@Override
|
|
public boolean markSupported() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void reset() throws IOException {
|
|
try {
|
|
buf.reset();
|
|
} catch (InvalidMarkException e) {
|
|
throw new IOException(e);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int available() throws IOException {
|
|
return buf.remaining();
|
|
}
|
|
|
|
@Override
|
|
public int read() throws IOException {
|
|
if (!buf.hasRemaining()) {
|
|
return -1;
|
|
}
|
|
return buf.get() & 0xFF;
|
|
}
|
|
|
|
@Override
|
|
public int read(byte[] bytes, int off, int len) throws IOException {
|
|
if (!buf.hasRemaining()) {
|
|
return -1;
|
|
}
|
|
|
|
len = Math.min(len, buf.remaining());
|
|
buf.get(bytes, off, len);
|
|
return len;
|
|
}
|
|
};
|
|
}
|
|
|
|
@Override
|
|
public CodedInputStream newCodedInput() {
|
|
return CodedInputStream.newInstance(buffer, true);
|
|
}
|
|
|
|
/**
|
|
* Creates a slice of a range of this buffer.
|
|
*
|
|
* @param beginIndex the beginning index of the slice (inclusive).
|
|
* @param endIndex the end index of the slice (exclusive).
|
|
* @return the requested slice.
|
|
*/
|
|
private ByteBuffer slice(int beginIndex, int endIndex) {
|
|
if (beginIndex < buffer.position() || endIndex > buffer.limit() || beginIndex > endIndex) {
|
|
throw new IllegalArgumentException(
|
|
String.format("Invalid indices [%d, %d]", beginIndex, endIndex));
|
|
}
|
|
|
|
ByteBuffer slice = buffer.slice();
|
|
((Buffer) slice).position(beginIndex - buffer.position());
|
|
((Buffer) slice).limit(endIndex - buffer.position());
|
|
return slice;
|
|
}
|
|
}
|