Immutable sequence of bytes. Provides conversions to and frombyte[],java.lang.String,ByteBuffer,InputStream,OutputStream. Also provides a conversion toCodedInputStream.

LikeString, the contents of aByteString can never be observed to change, not even in the presence of a data race or incorrect API usage in the client code.

Substring is supported by sharing the reference to the immutable underlying bytes. Concatenation is likewise supported without copying (long strings) by building a tree of pieces inRopeByteString.

Inheritance

Implements

Inherited Members

EmptyByteString.

Copies the given bytes into aByteString.

Copies the given bytes into aByteString.

Concatenates all byte strings in the iterable and returns the result. This is designed to run in O(list size), not O(total bytes).

The returnedByteString is not necessarily a unique object. If the list is empty, the returned object is the singleton emptyByteString. If the list has only one element, thatByteString will be returned without copying.

Encodestext into a sequence of bytes using the named charset and returns the result as aByteString.

Encodestext into a sequence of bytes using the named charset and returns the result as aByteString.

Copies the remaining bytes from ajava.nio.ByteBuffer into aByteString.

Copies the nextsize bytes from ajava.nio.ByteBuffer into a ByteString.

Encodestext into a sequence of UTF-8 bytes and returns the result as a ByteString.

Creates a newOutput. CallOutput#toByteString() to create the ByteString instance.

AByteString.Output offers the same functionality as aByteArrayOutputStream, except that it returns aByteString rather than abyte array.

Creates a newOutput with the given initial capacity. CallOutput#toByteString() to create theByteString instance.

AByteString.Output offers the same functionality as aByteArrayOutputStream, except that it returns aByteString rather than abyte array.

Completely reads the given stream's bytes into aByteString, blocking if necessary until all bytes are read through to the end of the stream.

Performance notes: The returnedByteString is an immutable tree of byte arrays ("chunks") of the stream data. The first chunk is small, with subsequent chunks each being double the size, up to 8K.

Each byte read from the input stream will be copied twice to ensure that the resulting ByteString is truly immutable.

Completely reads the given stream's bytes into aByteString, blocking if necessary until all bytes are read through to the end of the stream.

Performance notes: The returnedByteString is an immutable tree of byte arrays ("chunks") of the stream data. The chunkSize parameter sets the size of these byte arrays.

Each byte read from the input stream will be copied twice to ensure that the resulting ByteString is truly immutable.

Helper method that takes the chunk size range as a parameter.

Returns aComparator which comparesByteString-s lexicographically as sequences of unsigned bytes (i.e. values between 0 and 255, inclusive).

For example,(byte) -1 is considered to be greater than(byte) 1 because it is interpreted as an unsigned value,255:

• -1 -> 0b11111111 (two's complement) -> 255
• 1 -> 0b00000001 -> 1

Constructs a read-onlyjava.nio.ByteBuffer whose content is equal to the contents of this byte string. The result uses the same backing array as the byte string, if possible.

Constructs a list of read-onlyjava.nio.ByteBuffer objects such that the concatenation of their contents is equal to the contents of this byte string. The result uses the same backing arrays as the byte string.

By returning a list, implementations of this method may be able to avoid copying even when there are multiple backing arrays.

Gets the byte at the given index. This method should be used only for random access to individual bytes. To access bytes sequentially, use theByteIterator returned by#iterator(), and call#substring(int, int) first if necessary.

Concatenate the givenByteString to this one. Short concatenations, of total size smaller thanByteString#CONCATENATE_BY_COPY_SIZE, are produced by copying the underlying bytes (as per Rope.java, BAP95. In general, the concatenate involves no copying.

Copies bytes into a buffer at the given offset.

To copy a subset of bytes, you call this method on the return value of#substring(int, int). Example:byteString.substring(start, end).copyTo(target, offset)

Deprecated.Instead, callbyteString.substring(sourceOffset, sourceOffset + numberToCopy).copyTo(target, targetOffset)

Copies bytes into a buffer.

Copies bytes into a ByteBuffer.

To copy a subset of bytes, you call this method on the return value of#substring(int, int). Example:byteString.substring(start, end).copyTo(target)

Internal (package private) implementation of#copyTo(byte[],int,int,int). It assumes that all error checking has already been performed and thatnumberToCopy > 0.

Tests if this bytestring ends with the specified suffix. Similar toString#endsWith(String)

Return the depth of the tree representing thisByteString, if any, whose root is this node. If this is a leaf node, return 0.

Compute the hashCode using the traditional algorithm fromByteString.

Returntrue if this ByteString is literal (a leaf node) or a flat-enough tree in the sense ofRopeByteString.

Returnstrue if the size is0,false otherwise.

Tells whether thisByteString represents a well-formed UTF-8 byte sequence, such that the original bytes can be converted to a String object and then round tripped back to bytes without loss.

More precisely, returnstrue whenever:

Arrays.equals(byteString.toByteArray(),newString(byteString.toByteArray(),"UTF-8").getBytes("UTF-8"))

This method returnsfalse for "overlong" byte sequences, as well as for 3-byte sequences that would map to a surrogate character, in accordance with the restricted definition of UTF-8 introduced in Unicode 3.1. Note that the UTF-8 decoder included in Oracle's JDK has been modified to also reject "overlong" byte sequences, but (as of 2011) still accepts 3-byte surrogate character byte sequences.

See the Unicode Standard,
Table 3-6.UTF-8 Bit Distribution,
Table 3-7.Well Formed UTF-8 Byte Sequences.

Return aByteString.ByteIterator over the bytes in the ByteString. To avoid auto-boxing, you may get the iterator manually and callByteIterator#nextByte().

Creates aCodedInputStream which can be used to read the bytes. Using this is often more efficient than creating aCodedInputStream that wraps the result of#newInput().

Creates anInputStream which can be used to read the bytes.

TheInputStream returned by this method is guaranteed to be completely non-blocking. The methodInputStream#available() returns the number of bytes remaining in the stream. The methodsInputStream#read(byte[]),InputStream#read(byte[],int,int) andInputStream#skip(long) will read/skip as many bytes as are available. The methodInputStream#markSupported() returnstrue.

The methods in the returnedInputStream mightnot be thread safe.

Compute the hash across the value bytes starting with the given hash, and return the result. This is used to compute the hash across strings represented as a set of pieces by allowing the hash computation to be continued from piece to piece.

Tells whether the given byte sequence is a well-formed, malformed, or incomplete UTF-8 byte sequence. This method accepts and returns a partial state result, allowing the bytes for a complete UTF-8 byte sequence to be composed from multipleByteString segments.

Return the cached hash code if available.

Gets the number of bytes.

Tests if this bytestring starts with the specified prefix. Similar toString#startsWith(String)

Return the substring frombeginIndex, inclusive, to the end of the string.

Return the substring frombeginIndex, inclusive, toendIndex, exclusive.

Copies bytes to abyte[].

Constructs a newString by decoding the bytes using the specified charset.

Constructs a newString by decoding the bytes using the specified charset. Returns the same empty String if empty.

Constructs a newString by decoding the bytes using the specified charset.

Constructs a newString by decoding the bytes as UTF-8.

Writes a copy of the contents of this byte string to the specified output stream argument.