net.openhft.chronicle.bytes

Interface Bytes<Underlying>

All Superinterfaces:

Appendable, BytesComment<BytesOut<Underlying>>, BytesIn<Underlying>, BytesOut<Underlying>, BytesPrepender<Bytes<Underlying>>, BytesStore<Bytes<Underlying>,Underlying>, ByteStringAppender<Bytes<Underlying>>, ByteStringParser<Bytes<Underlying>>, CharSequence, RandomDataInput, RandomDataOutput<Bytes<Underlying>>, net.openhft.chronicle.core.io.ReferenceCounted, net.openhft.chronicle.core.io.ReferenceOwner, StreamingCommon<Bytes<Underlying>>, StreamingDataInput<Bytes<Underlying>>, StreamingDataOutput<Bytes<Underlying>>

All Known Implementing Classes:

AbstractBytes, EnbeddedBytes, GuardedNativeBytes, HexDumpBytes, MappedBytes, NativeBytes, NativeBytes.NativeSubBytes, OnHeapBytes, SubBytes, UncheckedBytes, UncheckedNativeBytes, VanillaBytes

public interface Bytes<Underlying>
extends BytesStore<Bytes<Underlying>,Underlying>, BytesIn<Underlying>, BytesOut<Underlying>

Bytes is a pointer to a region of memory within a BytesStore. It can be for a fixed region of memory or an "elastic" buffer which can be resized, but not for a fixed region.

This is a BytesStore which is mutable and not thread safe. It has a write position and read position which must follow these constraints

start() <= readPosition() <= writePosition() <= writeLimit() <= capacity()

Also readLimit() == writePosition() && readPosition() <= safeLimit()

Field Summary

Fields

Modifier and Type	Field and Description
static int	DEFAULT_BYTE_BUFFER_CAPACITY
static int	MAX_BYTE_BUFFER_CAPACITY Deprecated.
static long	MAX_CAPACITY
static int	MAX_HEAP_CAPACITY

Fields inherited from interface net.openhft.chronicle.bytes.RandomDataInput

charToString

Fields inherited from interface net.openhft.chronicle.bytes.StreamingDataOutput

JAVA9_STRING_CODER_LATIN, JAVA9_STRING_CODER_UTF16

Method Summary

Modifier and Type	Method and Description
static @NotNull VanillaBytes	allocateDirect(@NotNull byte[] bytes) Creates and returns a new fix sized wrapper for native (64-bit address) memory with the contents copied from the given bytes array.
static @NotNull VanillaBytes<Void>	allocateDirect(long capacity) Creates and returns a new fix sized wrapper for native (64-bit address) memory with the given capacity.
static @NotNull NativeBytes<Void>	allocateElasticDirect() Creates and returns a new elastic wrapper for native (64-bit address) memory with zero initial capacity which will be resized as required.
static @NotNull NativeBytes<Void>	allocateElasticDirect(long initialCapacity) Creates and returns a new elastic wrapper for native (64-bit address) memory with the given initialCapacity which will be resized as required.
static @NotNull OnHeapBytes	allocateElasticOnHeap() Creates and returns a new elastic wrapper for on heap memory with the initialCapacity 32 bytes which will be resized as required.
static @NotNull OnHeapBytes	allocateElasticOnHeap(int initialCapacity) Creates and returns a new elastic wrapper for on heap memory with the specified initialCapacity which will be resized as required.
default @NotNull Bytes<Underlying>	bytesForRead() Creates a slice of the current Bytes based on its readPosition and limit.
@Nullable BytesStore	bytesStore()
@NotNull Bytes<Underlying>	clear() Set the readPosition= writePosition = start, writeLimit = capacity
@NotNull Bytes<Underlying>	compact() Compact these Bytes by moving the readPosition to the start.
BytesStore<Bytes<Underlying>,Underlying>	copy()
default long	copyTo(@NotNull BytesStore store) Copies bytes from this Bytes to another ByteStore.
default void	copyTo(@NotNull OutputStream out) Copies bytes from this Bytes to a specified OutputStream.
static @NotNull Bytes<?>	directFrom(@NotNull String text) Converts text to bytes using ISO-8859-1 encoding and return a Bytes ready for reading.
static @NotNull Bytes<ByteBuffer>	elasticByteBuffer() Creates and returns a new elastic wrapper for a direct (off-heap) ByteBuffer with a default capacity which will be resized as required.
static @NotNull Bytes<ByteBuffer>	elasticByteBuffer(int initialCapacity) Creates and returns a new elastic wrapper for a direct (off-heap) ByteBuffer with the given initialCapacity which will be resized as required.
static @NotNull Bytes<ByteBuffer>	elasticByteBuffer(int initialCapacity, int maxCapacity) Creates and returns a new elastic wrapper for a direct (off-heap) ByteBuffer with the given initialCapacity which will be resized as required up to the given maxSize.
static @NotNull Bytes<ByteBuffer>	elasticHeapByteBuffer() Creates and returns a new elastic wrapper for a heap ByteBuffer with the initialCapacity 128 bytes which will be resized as required.
static @NotNull Bytes<ByteBuffer>	elasticHeapByteBuffer(int initialCapacity) Creates and returns a new elastic wrapper for a heap ByteBuffer with the given initialCapacity which will be resized as required.
default void	ensureCapacity(long desiredCapacity) Grows the buffer if the buffer is elastic, if the buffer is not elastic and there is not enough capacity then this method will throws BufferOverflowException
static <T> Bytes<T>	forFieldGroup(T t, String groupName)
static @NotNull Bytes<?>	from(@NotNull CharSequence text) Converts text to bytes using ISO-8859-1 encoding and returns a Bytes ready for reading.
static @NotNull Bytes<byte[]>	from(@NotNull String text) Converts text to bytes using ISO-8859-1 encoding and returns a Bytes ready for reading.
static Bytes<?>	fromDirect(@NotNull CharSequence text)
static @NotNull Bytes	fromHexString(@NotNull String s)
static Bytes<?>	fromString(String text) Deprecated.
default long	indexOf(@NotNull Bytes source) Returns the index within this Bytes of the first occurrence of the specified sub-bytes.
default long	indexOf(@NotNull Bytes source, int fromIndex) Deprecated.
static int	indexOf(@NotNull BytesStore source, @NotNull BytesStore target, int fromIndex) Code shared by String and StringBuffer to do searches.
default int	indexOf(@NotNull BytesStore source, int fromIndex) Returns the index within this Bytes of the first occurrence of the specified sub-bytes.
default boolean	isClear() Returns if the readPosition is at the start and the writeLimit is at the end.
boolean	isElastic() Returns if this Bytes is elastic.
default boolean	isEqual(String s)
default @NotNull BigDecimal	readBigDecimal()
default @NotNull BigInteger	readBigInteger()
default <T extends ReadBytesMarshallable> T	readMarshallableLength16(Class<T> tClass, T object)
default void	readWithLength(long length, @NotNull BytesOut<Underlying> bytesOut)
default boolean	readWrite() Returns true.
default long	realCapacity() Returns the actual capacity that can be potentially read.
default long	safeLimit()
default boolean	sharedMemory()
default @NotNull String	toHexString()
default @NotNull String	toHexString(long maxLength) Displays the hex data of Bytes from the readPosition up to the specified length.
default @NotNull String	toHexString(long offset, long maxLength) Displays the hex data of Bytes with the specified maximum length from the specified offset.
static @NotNull String	toString(@NotNull Bytes<?> buffer) Creates and returns a string from the readPosition to the readLimit, The buffer is not modified by this call
static @NotNull String	toString(@NotNull Bytes<?> buffer, long maxLen) Creates and returns a string from the readPosition to the readLimit with a specified maximum length, The buffer is not modified by this call.
static @NotNull String	toString(@NotNull Bytes buffer, long position, long len) Creates and returns a string from the bytes of a given buffer with a specified length and from an specified offset.
default boolean	unchecked()
default @NotNull Bytes<Underlying>	unchecked(boolean unchecked) Returns a Bytes which is optionally unchecked.
default void	unwrite(long fromOffset, int count) Will un-write a specified number of bytes from an offset from this Bytes.
static Bytes<byte[]>	valueOf(String text)
static @NotNull Bytes<byte[]>	wrapForRead(@NotNull byte[] byteArray) Wraps the byte[] ready for reading Method for convenience only - might not be ideal for performance (creates garbage).
static @NotNull Bytes<ByteBuffer>	wrapForRead(@NotNull ByteBuffer byteBuffer) Wrap the ByteBuffer ready for reading Method for convenience only - might not be ideal for performance (creates garbage).
static @NotNull Bytes<byte[]>	wrapForWrite(@NotNull byte[] byteArray) Wraps the byte[] ready for writing Method for convenience only - might not be ideal for performance (creates garbage).
static @NotNull Bytes<ByteBuffer>	wrapForWrite(@NotNull ByteBuffer byteBuffer) Wraps the ByteBuffer ready for writing Method for convenience only - might not be ideal for performance (creates garbage).
default Bytes	write(InputStream inputStream)
default void	writeMarshallableLength16(WriteBytesMarshallable marshallable)

Methods inherited from interface net.openhft.chronicle.bytes.BytesStore

addAndGetDoubleNotAtomic, addAndGetFloatNotAtomic, addAndGetIntNotAtomic, addAndGetShortNotAtomic, addAndGetUnsignedByteNotAtomic, byteCheckSum, byteCheckSum, bytesForWrite, capacity, charAt, cipher, cipher, contentEquals, elasticByteBuffer, empty, endsWith, equalBytes, forFields, from, hash, inside, inside, isDirectMemory, isEmpty, isEqual, lazyNativeBytesStoreWithFixedCapacity, length, move, nativePointer, nativeStore, nativeStoreWithFixedCapacity, startsWith, startsWith, subSequence, to8bitString, toDebugString, toDebugString, underlyingObject, wrap, wrap, wrap, writeMaxInt, writeMaxLong, zeroOut

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataOutput

append, append, nativeWrite, write, write, write, write, write, write8bit, write8bit, writeBoolean, writeByte, writeByte, writeDouble, writeFloat, writeInt, writeInt24, writeLong, writeOrderedDouble, writeOrderedFloat, writeOrderedInt, writeOrderedLong, writeShort, writeUnsignedByte, writeUnsignedInt, writeUnsignedShort, writeUtf8, writeUtf8Limited, writeVolatileByte, writeVolatileDouble, writeVolatileFloat, writeVolatileInt, writeVolatileLong, writeVolatileShort

Methods inherited from interface java.lang.CharSequence

chars, codePoints, toString

Methods inherited from interface net.openhft.chronicle.bytes.BytesIn

bytesMethodReader, bytesMethodReaderBuilder, readObject

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataInput

addAndGetDouble, addAndGetFloat, addAndGetInt, addAndGetLong, canReadDirect, compareUtf8, copyTo, copyTo, createCharToString, fastHash, findByte, nativeRead, parseLong, peekUnsignedByte, peekVolatileInt, printable, read, readBoolean, readByte, readDouble, readFloat, readIncompleteLong, readInt, readLong, readShort, readUnsignedByte, readUnsignedInt, readUnsignedInt24, readUnsignedShort, readUtf8, readUtf8Limited, readUtf8Limited, readVolatileByte, readVolatileDouble, readVolatileFloat, readVolatileInt, readVolatileLong, readVolatileShort, subBytes, toByteArray, toTemporaryDirectByteBuffer

Methods inherited from interface net.openhft.chronicle.bytes.ByteStringParser

lastDecimalPlaces, lastDecimalPlaces, lastNumberHadDigits, lastNumberHadDigits, parse8bit, parse8bit, parse8bit, parse8bit, parse8bit, parseBigDecimal, parseBoolean, parseBoolean, parseDouble, parseFloat, parseInt, parseLong, parseLongDecimal, parseUTF, parseUTF, parseUTF, parseUtf8, parseUtf8, parseUtf8, reader, skipTo

Methods inherited from interface net.openhft.chronicle.bytes.StreamingDataInput

inputStream, lenient, lenient, parseHexLong, parseUTF, parseUtf8, parseUtf8, peekUnsignedByte, rawReadByte, rawReadInt, rawReadLong, read, read, read, read, read, read, read8bit, read8bit, read8bit, read8bit, readBoolean, readByte, readChar, readDouble, readEnum, readFloat, readHistogram, readIncompleteLong, readInt, readInt24, readLimit, readLimitToCapacity, readLong, readPosition, readPositionForHeader, readPositionRemaining, readPositionUnlimited, readShort, readSkip, readStopBit, readStopBitChar, readStopBitDecimal, readStopBitDouble, readUnsignedByte, readUnsignedInt, readUnsignedInt24, readUnsignedShort, readUtf8, readUtf8, readUtf8, readUtf8, readUTFΔ, readUTFΔ, readVolatileInt, readVolatileLong, readWithLength, readWithLength, readWithLength0, uncheckedReadSkipBackOne, uncheckedReadSkipOne, uncheckedReadUnsignedByte, unsafeRead, unsafeReadObject, unsafeReadObject

Methods inherited from interface net.openhft.chronicle.bytes.BytesOut

bytesMethodWriter, writeObject

Methods inherited from interface net.openhft.chronicle.bytes.ByteStringAppender

append, append, append, append, append, append, append, append, append, append, append8bit, append8bit, append8bit, append8bit, append8bit, appendBase, appendBase16, appendBase16, appendDateMillis, appendDecimal, appendTimeMillis, writer

Methods inherited from interface net.openhft.chronicle.bytes.StreamingDataOutput

alignBy, appendUtf8, appendUtf8, appendUtf8, appendUtf8, appendUtf8, appendUtf8, canWriteDirect, copyFrom, outputStream, rawWriteByte, rawWriteInt, rawWriteLong, unsafeWrite, unsafeWriteObject, unsafeWriteObject, write, write, write, write, write, write, write, write, write8bit, write8bit, write8bit, write8bit, write8bit, writeBigDecimal, writeBigInteger, writeBoolean, writeByte, writeChar, writeDouble, writeDoubleAndInt, writeEnum, writeFloat, writeHistogram, writeInt, writeInt24, writeIntAdv, writeLimit, writeLong, writeLongAdv, writeOrderedInt, writeOrderedLong, writePosition, writePositionForHeader, writePositionRemaining, writeShort, writeSkip, writeSome, writeSome, writeStopBit, writeStopBit, writeStopBit, writeStopBitDecimal, writeUnsignedByte, writeUnsignedInt, writeUnsignedInt24, writeUnsignedShort, writeUtf8, writeUtf8, writeUTFΔ, writeWithLength

Methods inherited from interface net.openhft.chronicle.bytes.BytesPrepender

clearAndPad, prepend, prewrite, prewrite, prewriteByte, prewriteInt, prewriteLong, prewriteShort

Methods inherited from interface net.openhft.chronicle.bytes.BytesComment

comment, indent, retainsComments

Field Detail

MAX_CAPACITY

static final long MAX_CAPACITY

See Also:

Constant Field Values

MAX_HEAP_CAPACITY

static final int MAX_HEAP_CAPACITY

See Also:

Constant Field Values

MAX_BYTE_BUFFER_CAPACITY

@Deprecated
static final int MAX_BYTE_BUFFER_CAPACITY

Deprecated.

See Also:

Constant Field Values

DEFAULT_BYTE_BUFFER_CAPACITY

static final int DEFAULT_BYTE_BUFFER_CAPACITY

See Also:

Constant Field Values

Method Detail

elasticByteBuffer

@NotNull
static @NotNull Bytes<ByteBuffer> elasticByteBuffer()

Creates and returns a new elastic wrapper for a direct (off-heap) ByteBuffer with a default capacity which will be resized as required.

Returns:

a new elastic wrapper for a direct (off-heap) ByteBuffer with a default capacity which will be resized as required

elasticByteBuffer

@NotNull
static @NotNull Bytes<ByteBuffer> elasticByteBuffer(int initialCapacity)

Creates and returns a new elastic wrapper for a direct (off-heap) ByteBuffer with the given initialCapacity which will be resized as required.

Parameters:

initialCapacity - the initial non-negative capacity given in bytes

Returns:

a new elastic wrapper for a direct (off-heap) ByteBuffer with the given initialCapacity which will be resized as required

elasticByteBuffer

@NotNull
static @NotNull Bytes<ByteBuffer> elasticByteBuffer(int initialCapacity,
                                                             int maxCapacity)

Creates and returns a new elastic wrapper for a direct (off-heap) ByteBuffer with the given initialCapacity which will be resized as required up to the given maxSize.

Parameters:

initialCapacity - the initial non-negative capacity given in bytes

maxCapacity - the max capacity given in bytes equal or greater than initialCapacity

Returns:

a new elastic wrapper for a direct (off-heap) ByteBuffer with the given initialCapacity which will be resized as required up to the given maxCapacity

elasticHeapByteBuffer

@NotNull
static @NotNull Bytes<ByteBuffer> elasticHeapByteBuffer(int initialCapacity)

Creates and returns a new elastic wrapper for a heap ByteBuffer with the given initialCapacity which will be resized as required.

Parameters:

initialCapacity - the initial non-negative capacity given in bytes

Returns:

a new elastic wrapper for a heap ByteBuffer with the given initialCapacity which will be resized as required

elasticHeapByteBuffer

@NotNull
static @NotNull Bytes<ByteBuffer> elasticHeapByteBuffer()

Creates and returns a new elastic wrapper for a heap ByteBuffer with the initialCapacity 128 bytes which will be resized as required.

Returns:

a new elastic wrapper for a heap ByteBuffer with the initialCapacity 128 bytes which will be resized as required

forFieldGroup

static <T> Bytes<T> forFieldGroup(T t,
                                  String groupName)

wrapForRead

@NotNull
static @NotNull Bytes<ByteBuffer> wrapForRead(@NotNull
                                                       @NotNull ByteBuffer byteBuffer)

Wrap the ByteBuffer ready for reading Method for convenience only - might not be ideal for performance (creates garbage). To avoid garbage, use something like this example:

 import net.openhft.chronicle.bytes.Bytes;
 import java.nio.ByteBuffer;

 public class ChronicleBytesWithByteBufferExampleTest {
     private static final String HELLO_WORLD = "hello world";

     public static void main(String[] args)
 throws InterruptedException {
         //setup Bytes and ByteBuffer to write from
         Bytes b = Bytes.elasticByteBuffer();
         ByteBuffer toWriteFrom = ByteBuffer.allocate(HELLO_WORLD.length());
         toWriteFrom.put(HELLO_WORLD.getBytes(), 0, HELLO_WORLD.length());
         toWriteFrom.flip();
         byte[] toReadTo = new byte[HELLO_WORLD.length()];

         doWrite(b, toWriteFrom);
         ByteBuffer byteBuffer = doRead(b);

         //check result
         final StringBuilder sb = new StringBuilder();
         for (int i = 0; i < HELLO_WORLD.length(); i++) {
             sb.append((char) byteBuffer.get());
         }
         assert sb.toString().equals(HELLO_WORLD): "Failed - strings not equal!";
     }

     private static void doWrite(Bytes b, ByteBuffer toWrite) {
         //no garbage when writing to Bytes from ByteBuffer
         b.clear();
         b.write(b.writePosition(), toWrite, toWrite.position(), toWrite.limit());
     }

     private static ByteBuffer doRead(Bytes b) {
         //no garbage when getting the underlying ByteBuffer
         assert b.underlyingObject() instanceof ByteBuffer;
         ByteBuffer byteBuffer = (ByteBuffer) b.underlyingObject();
         return byteBuffer;
     }
 }
 

Parameters:

byteBuffer - to wrap

Returns:

a Bytes which wraps the provided ByteBuffer and is ready for reading.

wrapForWrite

@NotNull
static @NotNull Bytes<ByteBuffer> wrapForWrite(@NotNull
                                                        @NotNull ByteBuffer byteBuffer)

Wraps the ByteBuffer ready for writing Method for convenience only - might not be ideal for performance (creates garbage). To avoid garbage, use something like this example:

 import net.openhft.chronicle.bytes.Bytes;
 import java.nio.ByteBuffer;

 public class ChronicleBytesWithByteBufferExampleTest {
     private static final String HELLO_WORLD = "hello world";

     public static void main(String[] args)
 throws InterruptedException {
         //setup Bytes and ByteBuffer to write from
         Bytes b = Bytes.elasticByteBuffer();
         ByteBuffer toWriteFrom = ByteBuffer.allocate(HELLO_WORLD.length());
         toWriteFrom.put(HELLO_WORLD.getBytes(), 0, HELLO_WORLD.length());
         toWriteFrom.flip();
         byte[] toReadTo = new byte[HELLO_WORLD.length()];

         doWrite(b, toWriteFrom);
         ByteBuffer byteBuffer = doRead(b);

         //check result
         final StringBuilder sb = new StringBuilder();
         for (int i = 0; i < HELLO_WORLD.length(); i++) {
             sb.append((char) byteBuffer.get());
         }
         assert sb.toString().equals(HELLO_WORLD): "Failed - strings not equal!";
     }

     private static void doWrite(Bytes b, ByteBuffer toWrite) {
         //no garbage when writing to Bytes from ByteBuffer
         b.clear();
         b.write(b.writePosition(), toWrite, toWrite.position(), toWrite.limit());
     }

     private static ByteBuffer doRead(Bytes b) {
         //no garbage when getting the underlying ByteBuffer
         assert b.underlyingObject() instanceof ByteBuffer;
         ByteBuffer byteBuffer = (ByteBuffer) b.underlyingObject();
         return byteBuffer;
     }
 }
 

Parameters:

byteBuffer - to wrap

Returns:

a Bytes which wraps the provided ByteBuffer and is ready for writing.

wrapForRead

@NotNull
static @NotNull Bytes<byte[]> wrapForRead(@NotNull
                                                   @NotNull byte[] byteArray)

Wraps the byte[] ready for reading Method for convenience only - might not be ideal for performance (creates garbage). To avoid garbage, use something like this example:

 import net.openhft.chronicle.bytes.Bytes;
 import java.nio.charset.Charset;

 public class ChronicleBytesWithPrimByteArrayExampleTest {
     private static final Charset ISO_8859 = Charset.forName("ISO-8859-1");
     private static final String HELLO_WORLD = "hello world";

     public static void main(String[] args) {
         //setup Bytes and byte[]s to write from and read to
         Bytes b = Bytes.elasticByteBuffer();
         byte[] toWriteFrom = HELLO_WORLD.getBytes(ISO_8859);
         byte[] toReadTo = new byte[HELLO_WORLD.length()];

         doWrite(b, toWriteFrom);
         doRead(b, toReadTo);

         //check result
         final StringBuilder sb = new StringBuilder();
         for (int i = 0; i < HELLO_WORLD.length(); i++) {
             sb.append((char) toReadTo[i]);
         }
         assert sb.toString().equals(HELLO_WORLD): "Failed - strings not equal!";
     }

     private static void doWrite(Bytes b, byte[] toWrite) {
         //no garbage when writing to Bytes from byte[]
         b.clear();
         b.write(toWrite);
     }

     private static void doRead(Bytes b, byte[] toReadTo) {
         //no garbage when reading from Bytes into byte[]
         b.read( toReadTo, 0, HELLO_WORLD.length());
     }
 }
 

Parameters:

byteArray - to wrap

Returns:

the Bytes ready for reading.

wrapForWrite

@NotNull
static @NotNull Bytes<byte[]> wrapForWrite(@NotNull
                                                    @NotNull byte[] byteArray)

Wraps the byte[] ready for writing Method for convenience only - might not be ideal for performance (creates garbage). To avoid garbage, use something like this example:

 import net.openhft.chronicle.bytes.Bytes;
 import java.nio.charset.Charset;

 public class ChronicleBytesWithPrimByteArrayExampleTest {
     private static final Charset ISO_8859 = Charset.forName("ISO-8859-1");
     private static final String HELLO_WORLD = "hello world";

     public static void main(String[] args) {
         //setup Bytes and byte[]s to write from and read to
         Bytes b = Bytes.elasticByteBuffer();
         byte[] toWriteFrom = HELLO_WORLD.getBytes(ISO_8859);
         byte[] toReadTo = new byte[HELLO_WORLD.length()];

         doWrite(b, toWriteFrom);
         doRead(b, toReadTo);

         //check result
         final StringBuilder sb = new StringBuilder();
         for (int i = 0; i < HELLO_WORLD.length(); i++) {
             sb.append((char) toReadTo[i]);
         }
         assert sb.toString().equals(HELLO_WORLD): "Failed - strings not equal!";
     }

     private static void doWrite(Bytes b, byte[] toWrite) {
         //no garbage when writing to Bytes from byte[]
         b.clear();
         b.write(toWrite);
     }

     private static void doRead(Bytes b, byte[] toReadTo) {
         //no garbage when reading from Bytes into byte[]
         b.read( toReadTo, 0, HELLO_WORLD.length());
     }
 }
 

Parameters:

byteArray - to wrap

Returns:

the Bytes ready for writing.

from

@NotNull
static @NotNull Bytes<?> from(@NotNull
                                       @NotNull CharSequence text)

Converts text to bytes using ISO-8859-1 encoding and returns a Bytes ready for reading.

Note: this returns a direct Bytes now

Specified by:

from in interface BytesStore<Bytes<Underlying>,Underlying>

Parameters:

text - to convert

Returns:

Bytes ready for reading.

fromDirect

static Bytes<?> fromDirect(@NotNull
                           @NotNull CharSequence text)

fromString

@Deprecated
static Bytes<?> fromString(String text)

Deprecated.

directFrom

@NotNull
static @NotNull Bytes<?> directFrom(@NotNull
                                             @NotNull String text)

Converts text to bytes using ISO-8859-1 encoding and return a Bytes ready for reading.

Note: this returns a direct Bytes now

Parameters:

text - to convert

Returns:

Bytes ready for reading.

from

@NotNull
static @NotNull Bytes<byte[]> from(@NotNull
                                            @NotNull String text)

Converts text to bytes using ISO-8859-1 encoding and returns a Bytes ready for reading.

The returned Bytes is allocated on the heap.

Specified by:

from in interface BytesStore<Bytes<Underlying>,Underlying>

Parameters:

text - to convert

Returns:

Bytes ready for reading.

valueOf

@UsedViaReflection
static Bytes<byte[]> valueOf(String text)

allocateDirect

@NotNull
static @NotNull VanillaBytes<Void> allocateDirect(long capacity)
                                                    throws IllegalArgumentException

Creates and returns a new fix sized wrapper for native (64-bit address) memory with the given capacity.

Parameters:

capacity - the non-negative capacity given in bytes

Returns:

a new fix sized wrapper for native (64-bit address) memory with the given capacity

Throws:

IllegalArgumentException

allocateElasticDirect

@NotNull
static @NotNull NativeBytes<Void> allocateElasticDirect()

Creates and returns a new elastic wrapper for native (64-bit address) memory with zero initial capacity which will be resized as required.

Returns:

a new elastic wrapper for native (64-bit address) memory with zero initial capacity which will be resized as required

allocateElasticDirect

@NotNull
static @NotNull NativeBytes<Void> allocateElasticDirect(long initialCapacity)
                                                          throws IllegalArgumentException

Creates and returns a new elastic wrapper for native (64-bit address) memory with the given initialCapacity which will be resized as required.

Parameters:

initialCapacity - the initial non-negative capacity given in bytes

Returns:

a new elastic wrapper for native (64-bit address) memory with the given initialCapacity which will be resized as required

Throws:

IllegalArgumentException

allocateElasticOnHeap

@NotNull
static @NotNull OnHeapBytes allocateElasticOnHeap()

Creates and returns a new elastic wrapper for on heap memory with the initialCapacity 32 bytes which will be resized as required.

Returns:

a new elastic wrapper for on heap memory

allocateElasticOnHeap

@NotNull
static @NotNull OnHeapBytes allocateElasticOnHeap(int initialCapacity)

Creates and returns a new elastic wrapper for on heap memory with the specified initialCapacity which will be resized as required.

Parameters:

initialCapacity - the initial capacity of the wrapper in bytes

Returns:

a new elastic wrapper for on-heap memory with an initial capacity of initialCapacity

toString

@NotNull
static @NotNull String toString(@NotNull
                                         @NotNull Bytes<?> buffer)
                                  throws BufferUnderflowException,
                                         IllegalStateException,
                                         IllegalArgumentException

Creates and returns a string from the readPosition to the readLimit, The buffer is not modified by this call

Parameters:

buffer - the buffer to use

Returns:

a string contain the text from the readPosition to the readLimit

Throws:

BufferUnderflowException

IllegalStateException

IllegalArgumentException

toString

@NotNull
static @NotNull String toString(@NotNull
                                         @NotNull Bytes<?> buffer,
                                         long maxLen)
                                  throws BufferUnderflowException,
                                         IllegalStateException,
                                         IllegalArgumentException

Creates and returns a string from the readPosition to the readLimit with a specified maximum length, The buffer is not modified by this call.

If the length of the string between readPosition to readLimit is greater than the specified maximum length, the "..." will be appended to the resulting string; in this case the length of the resulting string will be the specified maximum length+3.

Parameters:

buffer - the buffer to use

maxLen - the maximum length from the buffer, used to create a new string

Returns:

a string contain the text from the readPosition to the readLimit of the buffer

Throws:

BufferUnderflowException

IllegalStateException

IllegalArgumentException

toString

@NotNull
static @NotNull String toString(@NotNull
                                         @NotNull Bytes buffer,
                                         long position,
                                         long len)

Creates and returns a string from the bytes of a given buffer with a specified length and from an specified offset. The buffer is not modified by this call.

Parameters:

buffer - the buffer to use

position - the offset position to create the string from

len - the number of characters to include in the string

Returns:

a string with length len contain the text from offset position

allocateDirect

@NotNull
static @NotNull VanillaBytes allocateDirect(@NotNull
                                                     @NotNull byte[] bytes)
                                              throws IllegalArgumentException

Creates and returns a new fix sized wrapper for native (64-bit address) memory with the contents copied from the given bytes array.

Changes in the given bytes will not be affected by writes in the returned wrapper or vice versa.

Parameters:

bytes - array to copy

Returns:

a new fix sized wrapper for native (64-bit address) memory with the contents copied from the given bytes array

Throws:

IllegalArgumentException

fromHexString

@NotNull
static @NotNull Bytes fromHexString(@NotNull
                                             @NotNull String s)

indexOf

static int indexOf(@NotNull
                   @NotNull BytesStore source,
                   @NotNull
                   @NotNull BytesStore target,
                   int fromIndex)
            throws IllegalStateException

Code shared by String and StringBuffer to do searches. The source is the character array being searched, and the target is the string being searched for.

Parameters:

source - the read bytes being searched.

target - the read bytes being searched for.

fromIndex - the index to begin searching from,

Returns:

the index of where the text was found.

Throws:

IllegalStateException

unchecked

@NotNull
default @NotNull Bytes<Underlying> unchecked(boolean unchecked)
                                               throws IllegalStateException

Returns a Bytes which is optionally unchecked. This allows bounds checks to be turned off. Note: this means that the result is no longer elastic, even if this is elastic.

Parameters:

unchecked - if true, minimal bounds checks will be performed

Returns:

Bytes without bounds checking

Throws:

IllegalStateException - if the underlying BytesStore has been released

unchecked

default boolean unchecked()

safeLimit

default long safeLimit()

Specified by:

safeLimit in interface BytesStore<Bytes<Underlying>,Underlying>

Returns:

how many bytes can be safely read, i.e. what is the real capacity of the underlying data.

isClear

default boolean isClear()

Description copied from interface: BytesStore

Returns if the readPosition is at the start and the writeLimit is at the end.

I.e start() == readPosition() && writeLimit() == capacity()

Specified by:

isClear in interface BytesStore<Bytes<Underlying>,Underlying>

Returns:

if the readPosition is at the start and the writeLimit is at the end

realCapacity

default long realCapacity()

Description copied from interface: RandomDataInput

Returns the actual capacity that can be potentially read.

Specified by:

realCapacity in interface BytesStore<Bytes<Underlying>,Underlying>

Specified by:

realCapacity in interface RandomDataInput

Specified by:

realCapacity in interface StreamingDataOutput<Bytes<Underlying>>

Returns:

the actual capacity available before resizing

copy

BytesStore<Bytes<Underlying>,Underlying> copy()
                                       throws IllegalStateException

Specified by:

copy in interface BytesStore<Bytes<Underlying>,Underlying>

Returns:

a copy of this Bytes from position() to limit().

Throws:

IllegalStateException

toHexString

@NotNull
default @NotNull String toHexString()

toHexString

@NotNull
default @NotNull String toHexString(long maxLength)

Displays the hex data of Bytes from the readPosition up to the specified length.

Parameters:

maxLength - limit the number of bytes to be dumped

Returns:

hex representation of the buffer, from example [0D ,OA, FF]

toHexString

@NotNull
default @NotNull String toHexString(long offset,
                                             long maxLength)

Displays the hex data of Bytes with the specified maximum length from the specified offset.

Parameters:

offset - the specified offset to start from

maxLength - limit the number of bytes to be dumped

Returns:

hex representation of the buffer, from example [0D ,OA, FF]

isElastic

boolean isElastic()

Returns if this Bytes is elastic. I.e. it can resize when more data is written than it's realCapacity().

Returns:

if this Bytes is elastic

ensureCapacity

default void ensureCapacity(long desiredCapacity)
                     throws IllegalArgumentException,
                            IllegalStateException

Grows the buffer if the buffer is elastic, if the buffer is not elastic and there is not enough capacity then this method will throws BufferOverflowException

Parameters:

desiredCapacity - the capacity that you required

Throws:

IllegalArgumentException - if the buffer is not elastic and there is not enough space

IllegalStateException

bytesForRead

@NotNull
default @NotNull Bytes<Underlying> bytesForRead()
                                                  throws IllegalStateException

Creates a slice of the current Bytes based on its readPosition and limit. As a sub-section of a Bytes it cannot be elastic.

Specified by:

bytesForRead in interface BytesStore<Bytes<Underlying>,Underlying>

Returns:

a slice of the existing Bytes where the start is moved to the readPosition and the current limit determines the capacity.

Throws:

IllegalStateException - if the underlying BytesStore has been released

bytesStore

@Nullable
@Nullable BytesStore bytesStore()

Specified by:

bytesStore in interface BytesStore<Bytes<Underlying>,Underlying>

Returns:

the ByteStore this Bytes wraps.

isEqual

default boolean isEqual(String s)
                 throws IllegalStateException

Throws:

IllegalStateException

compact

@NotNull
@NotNull Bytes<Underlying> compact()
                                     throws IllegalStateException

Compact these Bytes by moving the readPosition to the start.

Returns:

this

Throws:

IllegalStateException

copyTo

default long copyTo(@NotNull
                    @NotNull BytesStore store)
             throws IllegalStateException

Copies bytes from this Bytes to another ByteStore.

Specified by:

copyTo in interface BytesStore<Bytes<Underlying>,Underlying>

Specified by:

copyTo in interface StreamingDataInput<Bytes<Underlying>>

Parameters:

store - the BytesStore to copy to

Returns:

the number of bytes copied

Throws:

IllegalStateException - if this BytesStore has been released

copyTo

default void copyTo(@NotNull
                    @NotNull OutputStream out)
             throws IOException,
                    IllegalStateException

Copies bytes from this Bytes to a specified OutputStream.

Specified by:

copyTo in interface BytesStore<Bytes<Underlying>,Underlying>

Specified by:

copyTo in interface StreamingDataInput<Bytes<Underlying>>

Parameters:

out - the specified OutputStream that this BytesStore is copied to

Throws:

IllegalStateException - if this Bytes has been released

IOException - if an I/O error occurs

See Also:

OutputStream

sharedMemory

default boolean sharedMemory()

Returns:

true if these Bytes use shared memory.

unwrite

default void unwrite(long fromOffset,
                     int count)
              throws BufferUnderflowException,
                     BufferOverflowException,
                     IllegalStateException

Will un-write a specified number of bytes from an offset from this Bytes.

Calling this method will update the cursors of this Bytes.

Parameters:

fromOffset - the offset from the target bytes

count - the number of bytes to un-write

Throws:

BufferUnderflowException

BufferOverflowException

IllegalStateException

readBigDecimal

@NotNull
default @NotNull BigDecimal readBigDecimal()
                                             throws ArithmeticException,
                                                    BufferUnderflowException,
                                                    IllegalStateException

Throws:

ArithmeticException

BufferUnderflowException

IllegalStateException

readBigInteger

@NotNull
default @NotNull BigInteger readBigInteger()
                                             throws ArithmeticException,
                                                    BufferUnderflowException,
                                                    IllegalStateException

Throws:

ArithmeticException

BufferUnderflowException

IllegalStateException

indexOf

default long indexOf(@NotNull
                     @NotNull Bytes source)
              throws IllegalStateException

Returns the index within this Bytes of the first occurrence of the specified sub-bytes.

The returned index is the smallest value k for which:

 this.startsWith(bytes, k)
 

If no such value of k exists, then -1 is returned.

Parameters:

source - the sub-bytes to search for.

Returns:

the index of the first occurrence of the specified sub-bytes, or -1 if there is no such occurrence.

Throws:

IllegalStateException

indexOf

default int indexOf(@NotNull
                    @NotNull BytesStore source,
                    int fromIndex)
             throws IllegalStateException

Returns the index within this Bytes of the first occurrence of the specified sub-bytes.

The returned index is the smallest value k for which:

 this.startsWith(bytes, k)
 

If no such value of k exists, then -1 is returned.

Parameters:

source - the sub-bytes to search for.

fromIndex - start the search from this offset

Returns:

the index of the first occurrence of the specified sub-bytes, or -1 if there is no such occurrence.

Throws:

IllegalStateException

indexOf

@Deprecated
default long indexOf(@NotNull
                                 @NotNull Bytes source,
                                 int fromIndex)
                          throws IllegalStateException

Deprecated.

Throws:

IllegalStateException

clear

@NotNull
@NotNull Bytes<Underlying> clear()
                                   throws IllegalStateException

Description copied from interface: StreamingCommon

Set the readPosition= writePosition = start, writeLimit = capacity

Specified by:

clear in interface StreamingCommon<Bytes<Underlying>>

Returns:

this

Throws:

IllegalStateException

readWrite

default boolean readWrite()

Description copied from interface: BytesStore

Returns true.

Specified by:

readWrite in interface BytesStore<Bytes<Underlying>,Underlying>

Returns:

whether this BytesStore is writable.

readWithLength

default void readWithLength(long length,
                            @NotNull
                            @NotNull BytesOut<Underlying> bytesOut)
                     throws BufferUnderflowException,
                            net.openhft.chronicle.core.io.IORuntimeException,
                            BufferOverflowException,
                            IllegalStateException

Throws:

BufferUnderflowException

net.openhft.chronicle.core.io.IORuntimeException

BufferOverflowException

IllegalStateException

readMarshallableLength16

default <T extends ReadBytesMarshallable> T readMarshallableLength16(Class<T> tClass,
                                                                     T object)
                                                              throws BufferUnderflowException,
                                                                     IllegalStateException

Specified by:

readMarshallableLength16 in interface BytesIn<Underlying>

Throws:

BufferUnderflowException

IllegalStateException

writeMarshallableLength16

default void writeMarshallableLength16(WriteBytesMarshallable marshallable)
                                throws IllegalArgumentException,
                                       BufferOverflowException,
                                       IllegalStateException,
                                       BufferUnderflowException

Specified by:

writeMarshallableLength16 in interface BytesOut<Underlying>

Throws:

IllegalArgumentException

BufferOverflowException

IllegalStateException

BufferUnderflowException

write

default Bytes write(InputStream inputStream)
             throws IOException,
                    BufferOverflowException,
                    IllegalStateException

Throws:

IOException

BufferOverflowException

IllegalStateException