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>>, CharSequence, RandomDataInput, RandomDataOutput<Bytes<Underlying>>, net.openhft.chronicle.core.ReferenceCounted, StreamingCommon<Bytes<Underlying>>, StreamingDataOutput<Bytes<Underlying>>

All Known Implementing Classes:

AbstractBytes, GuardedNativeBytes, HexDumpBytes, MappedBytes, NativeBytes, NativeBytes.NativeSubBytes, 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() and readPosition() <= safeLimit();

Field Summary

Fields

Modifier and Type	Field and Description
static int	DEFAULT_BYTE_BUFFER_CAPACITY
static int	MAX_BYTE_BUFFER_CAPACITY
static long	MAX_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
long	addressForRead(long offset) Obtain the underlying addressForRead.
default long	addressForRead(long offset, int buffer)
long	addressForWrite(long offset) Obtain the underlying addressForRead.
long	addressForWritePosition()
static VanillaBytes	allocateDirect(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 VanillaBytes<Void>	allocateDirect(long capacity) Creates and returns a new fix sized wrapper for native (64-bit address) memory with the given capacity.
static 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 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.
default ByteOrder	byteOrder()
default Bytes<Underlying>	bytesForRead() Creates a slice of the current Bytes based on its position() and limit().
BytesStore	bytesStore()
Bytes<Underlying>	clear() Set the readPosition= writePosition = start, writeLimit = capacity
Bytes<Underlying>	compact() Compact these Bytes by moving the readPosition to the start.
default boolean	compareAndSwapDouble(long offset, double expected, double value) Perform a 64-bit double CAS at a given offset.
default boolean	compareAndSwapFloat(long offset, float expected, float value) Perform a 32-bit float CAS at a given offset.
boolean	compareAndSwapInt(long offset, int expected, int value) Perform a 32-bit CAS at a given offset.
boolean	compareAndSwapLong(long offset, long expected, long value) Perform a 64-bit CAS at a given offset.
BytesStore<Bytes<Underlying>,Underlying>	copy()
default long	copyTo(BytesStore store) copy bytes from one ByteStore to another
default void	copyTo(OutputStream out)
static 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 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 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 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 size) grow 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 Bytes<?>	from(CharSequence text) Convert text to bytes using ISO-8859-1 encoding and return a Bytes ready for reading.
static Bytes<?>	from(String text) Convert text to bytes using ISO-8859-1 encoding and return a Bytes ready for reading.
static Bytes	fromHexString(String s)
static Bytes<byte[]>	fromString(String text) Convert text to bytes using ISO-8859-1 encoding and return a Bytes ready for reading.
default long	indexOf(Bytes source) Returns the index within this bytes of the first occurrence of the specified sub-bytes.
default long	indexOf(Bytes source, int fromIndex) Deprecated.
static int	indexOf(BytesStore source, BytesStore target, int fromIndex) Code shared by String and StringBuffer to do searches.
default int	indexOf(BytesStore source, int fromIndex) Returns the index within this bytes of the first occurrence of the specified subbytes.
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)
int	lastDecimalPlaces()
void	lastDecimalPlaces(int lastDecimalPlaces) Store the last number of decimal places.
default void	parse8bit(Appendable buffer, StopCharsTester stopCharsTester) parse text with ISO-8859-1 decoding as character terminated.
default void	parse8bit(Appendable buffer, StopCharTester stopCharTester) parse text with ISO-8859-1 decoding as character terminated.
default void	parse8bit(Bytes buffer, StopCharsTester stopCharsTester)
default String	parse8bit(StopCharTester stopCharTester) parse text with ISO-8859-1 decoding as character terminated.
default void	parse8bit(StringBuilder buffer, StopCharsTester stopCharsTester)
default BigDecimal	parseBigDecimal()
default Boolean	parseBoolean()
default Boolean	parseBoolean(StopCharTester tester) Return true or false, or null if it could not be detected as true or false.
default double	parseDouble() parse text as a double decimal.
default float	parseFloat() parse text as a float decimal.
default int	parseInt() parse text as an int.
default long	parseLong() parse text as a long integer.
default long	parseLongDecimal() Parse the significant digits of a decimal number.
default void	parseUTF(Appendable buffer, StopCharsTester stopCharsTester) Deprecated.
default void	parseUTF(Appendable buffer, StopCharTester stopCharTester) Deprecated.
default String	parseUTF(StopCharTester stopCharTester) Deprecated.
default void	parseUtf8(Appendable buffer, StopCharsTester stopCharsTester) parse text with UTF-8 decoding as one or two character terminated.
default void	parseUtf8(Appendable buffer, StopCharTester stopCharTester) parse text with UTF-8 decoding as character terminated.
default String	parseUtf8(StopCharTester stopCharTester) parse text with UTF-8 decoding as character terminated.
default BigDecimal	readBigDecimal()
default BigInteger	readBigInteger()
default Reader	reader() Access these bytes as an ISO-8859-1 encoded Reader
default long	readLimit()
default <T extends ReadBytesMarshallable> T	readMarshallableLength16(Class<T> tClass, T object)
default long	readPosition() The read position must be start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
default long	readRemaining()
default void	readWithLength(long length, BytesOut<Underlying> bytesOut)
default boolean	readWrite()
default long	realCapacity() Returns the actual capacity that can be potentially read.
default long	safeLimit()
default boolean	sharedMemory()
default boolean	skipTo(StopCharTester tester) Skip text until a terminating character is reached.
default long	start()
void	testAndSetInt(long offset, int expected, int value)
default String	toHexString()
default String	toHexString(long maxLength) display the hex data of Bytes from the position() to the limit()
default String	toHexString(long offset, long maxLength) display the hex data of Bytes from the position() to the limit()
static String	toString(Bytes<?> buffer) Creates a string from the position to the limit, The buffer is not modified by this call
static String	toString(Bytes<?> buffer, long maxLen) Creates a string from the position to the limit, The buffer is not modified by this call
static String	toString(Bytes buffer, long position, long len) The buffer is not modified by this call
default boolean	unchecked()
default Bytes<Underlying>	unchecked(boolean unchecked) Return a Bytes which is optionally unchecked.
default void	unwrite(long fromOffset, int count) will unwrite from the offset upto the current write position of the destination bytes
static Bytes<byte[]>	wrapForRead(byte[] byteArray) Wrap the byte[] ready for reading Method for convenience only - might not be ideal for performance (creates garbage).
static Bytes<ByteBuffer>	wrapForRead(ByteBuffer byteBuffer) Wrap the ByteBuffer ready for reading Method for convenience only - might not be ideal for performance (creates garbage).
static Bytes<byte[]>	wrapForWrite(byte[] byteArray) Wrap the byte[] ready for writing Method for convenience only - might not be ideal for performance (creates garbage).
static Bytes<ByteBuffer>	wrapForWrite(ByteBuffer byteBuffer) Wrap the ByteBuffer ready for writing Method for convenience only - might not be ideal for performance (creates garbage).
default Bytes	write(InputStream inputStream)
default long	writeLimit()
default void	writeMarshallableLength16(WriteBytesMarshallable marshallable)
default long	writePosition() The read position must be readPosition() <= writePosition() && writePosition() <= writeLimit()
default long	writeRemaining()

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

addAndGetByteNotAtomic, addAndGetDoubleNotAtomic, addAndGetFloatNotAtomic, addAndGetIntNotAtomic, addAndGetLongNotAtomic, addAndGetShortNotAtomic, addAndGetUnsignedByteNotAtomic, addAndGetUnsignedIntNotAtomic, addAndGetUnsignedShortNotAtomic, byteCheckSum, byteCheckSum, bytesForWrite, capacity, charAt, checkRefCount, cipher, cipher, contentEquals, empty, endsWith, equalBytes, inside, inside, isDirectMemory, isEmpty, isPresent, isPresent, length, longCheckSum, move, nativePointer, startsWith, startsWith, subSequence, to8bitString, toDebugString, toDebugString, underlyingObject, wrap, wrap, wrap, writeMaxLong, zeroOut

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

append, append, nativeWrite, write, write, write, write, write, 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.StreamingDataInput

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

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

bytesMethodWriter, bytesMethodWriterBuilder, 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, nativeWrite, outputStream, rawWriteByte, rawWriteInt, realWriteRemaining, write, write, write, write, write, write, write, write, write8bit, write8bit, write8bit, write8bit, writeBigDecimal, writeBigInteger, writeBoolean, writeByte, writeChar, writeDouble, writeDoubleAndInt, writeEnum, writeFloat, writeHistogram, writeInt, writeInt24, writeIntAdv, writeLimit, writeLong, writeLongAdv, writeOrderedInt, writeOrderedLong, writePosition, writePositionRemaining, writeShort, writeSkip, writeSome, writeSome, writeStopBit, writeStopBit, writeStopBit, writeStopBitDecimal, writeUnsignedByte, writeUnsignedInt, writeUnsignedInt24, writeUnsignedShort, writeUtf8, writeUtf8, writeUTFΔ, writeWithLength

Methods inherited from interface net.openhft.chronicle.core.ReferenceCounted

refCount, release, release, releaseAll, reserve, tryReserve

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_BYTE_BUFFER_CAPACITY

static final int MAX_BYTE_BUFFER_CAPACITY

DEFAULT_BYTE_BUFFER_CAPACITY

static final int DEFAULT_BYTE_BUFFER_CAPACITY

See Also:

Constant Field Values

Method Detail

elasticByteBuffer

@NotNull
static 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 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 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 maxSize

elasticHeapByteBuffer

@NotNull
static 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

wrapForRead

@NotNull
static Bytes<ByteBuffer> wrapForRead(@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 Bytes<ByteBuffer> wrapForWrite(@NotNull
                                               ByteBuffer byteBuffer)

Wrap 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 Bytes<byte[]> wrapForRead(@NotNull
                                          byte[] byteArray)

Wrap 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 Bytes<byte[]> wrapForWrite(@NotNull
                                           byte[] byteArray)

Wrap 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 Bytes<?> from(@NotNull
                              CharSequence text)

Convert text to bytes using ISO-8859-1 encoding and return 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.

from

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

Convert 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.

fromString

@NotNull
static Bytes<byte[]> fromString(@NotNull
                                         String text)
                                  throws IllegalArgumentException,
                                         IllegalStateException

Convert text to bytes using ISO-8859-1 encoding and return a Bytes ready for reading. Note: this returns a heap Bytes

Parameters:

text - to convert

Returns:

Bytes ready for reading.

Throws:

IllegalArgumentException

IllegalStateException

allocateDirect

@NotNull
static 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 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 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

toString

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

Creates a string from the position to the limit, The buffer is not modified by this call

Parameters:

buffer - the buffer to use

Returns:

a string contain the text from the position to the limit

Throws:

BufferUnderflowException

toString

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

Creates a string from the position to the limit, The buffer is not modified by this call

Parameters:

buffer - the buffer to use

maxLen - of the result returned

Returns:

a string contain the text from the position to the limit

Throws:

BufferUnderflowException

toString

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

The buffer is not modified by this call

Parameters:

buffer - the buffer to use

position - the position to create the string from

len - the number of characters to show in the string

Returns:

a string contain the text from offset position

Throws:

BufferUnderflowException

allocateDirect

@NotNull
static VanillaBytes allocateDirect(@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 Bytes fromHexString(@NotNull
                                    String s)

indexOf

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

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.

unchecked

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

Return 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()

Specified by:

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

Returns:

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

toHexString

@NotNull
default String toHexString()

toHexString

@NotNull
default String toHexString(long maxLength)

display the hex data of Bytes from the position() to the limit()

Parameters:

maxLength - limit the number of bytes to be dumped.

Returns:

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

toHexString

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

display the hex data of Bytes from the position() to the limit()

Parameters:

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 size)
                     throws IllegalArgumentException

grow 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:

size - the capacity that you required

Throws:

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

bytesForRead

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

Creates a slice of the current Bytes based on its position() 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 position and the current limit determines the capacity.

Throws:

IllegalStateException - if the underlying BytesStore has been released

bytesStore

@Nullable
BytesStore bytesStore()

Specified by:

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

Returns:

the ByteStore this Bytes wraps.

isEqual

default boolean isEqual(String s)

compact

@NotNull
Bytes<Underlying> compact()

Compact these Bytes by moving the readPosition to the start.

Returns:

this

copyTo

default long copyTo(@NotNull
                    BytesStore store)

copy bytes from one ByteStore to another

Specified by:

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

Parameters:

store - to copy to

Returns:

the number of bytes copied.

copyTo

default void copyTo(OutputStream out)
             throws IOException

Specified by:

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

Throws:

IOException

sharedMemory

default boolean sharedMemory()

Returns:

true if these Bytes use shared memory.

unwrite

default void unwrite(long fromOffset,
                     int count)

will unwrite from the offset upto the current write position of the destination bytes

Parameters:

fromOffset - the offset from the target byytes

count - the number of bytes to un-write

readBigDecimal

@NotNull
default BigDecimal readBigDecimal()

readBigInteger

@NotNull
default BigInteger readBigInteger()

indexOf

default long indexOf(@NotNull
                     Bytes source)

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.

indexOf

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

Returns the index within this bytes of the first occurrence of the specified subbytes.

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 seach from this offset

Returns:

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

indexOf

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

Deprecated.

clear

@NotNull
Bytes<Underlying> clear()

Description copied from interface: StreamingCommon

Set the readPosition= writePosition = start, writeLimit = capacity

Specified by:

clear in interface StreamingCommon<Bytes<Underlying>>

Returns:

this

readWrite

default boolean readWrite()

Specified by:

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

Returns:

whether this BytesStore is writable.

readWithLength

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

Throws:

BufferUnderflowException

net.openhft.chronicle.core.io.IORuntimeException

readMarshallableLength16

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

Specified by:

readMarshallableLength16 in interface BytesIn<Underlying>

writeMarshallableLength16

default void writeMarshallableLength16(WriteBytesMarshallable marshallable)

Specified by:

writeMarshallableLength16 in interface BytesOut<Underlying>

write

default Bytes write(InputStream inputStream)
             throws IOException

Throws:

IOException

reader

@NotNull
default Reader reader()

Access these bytes as an ISO-8859-1 encoded Reader

Returns:

as a Reader

parseBoolean

@Nullable
default Boolean parseBoolean(@NotNull
                                       StopCharTester tester)

Return true or false, or null if it could not be detected as true or false. Case is not important

false: f, false, n, no, 0

true: t, true, y, yes, 1

Parameters:

tester - to detect the end of the text.

Returns:

true, false, or null if neither.

parseBoolean

@Nullable
default Boolean parseBoolean()

parseUtf8

@NotNull
default String parseUtf8(@NotNull
                                  StopCharTester stopCharTester)

parse text with UTF-8 decoding as character terminated.

Parameters:

stopCharTester - to check if the end has been reached.

Returns:

the text as a String.

parseUTF

@NotNull
 @Deprecated
default String parseUTF(@NotNull
                                              StopCharTester stopCharTester)

Deprecated.

parseUtf8

default void parseUtf8(@NotNull
                       Appendable buffer,
                       @NotNull
                       StopCharTester stopCharTester)
                throws BufferUnderflowException

parse text with UTF-8 decoding as character terminated.

Parameters:

buffer - to populate

stopCharTester - to check if the end has been reached.

Throws:

BufferUnderflowException

parseUTF

@Deprecated
default void parseUTF(@NotNull
                                  Appendable buffer,
                                  @NotNull
                                  StopCharTester stopCharTester)
                           throws BufferUnderflowException

Deprecated.

Throws:

BufferUnderflowException

parseUtf8

default void parseUtf8(@NotNull
                       Appendable buffer,
                       @NotNull
                       StopCharsTester stopCharsTester)
                throws BufferUnderflowException,
                       net.openhft.chronicle.core.io.IORuntimeException

parse text with UTF-8 decoding as one or two character terminated.

Parameters:

buffer - to populate

stopCharsTester - to check if the end has been reached.

Throws:

BufferUnderflowException

net.openhft.chronicle.core.io.IORuntimeException

parseUTF

@Deprecated
default void parseUTF(@NotNull
                                  Appendable buffer,
                                  @NotNull
                                  StopCharsTester stopCharsTester)
                           throws BufferUnderflowException,
                                  net.openhft.chronicle.core.io.IORuntimeException

Deprecated.

Throws:

BufferUnderflowException

net.openhft.chronicle.core.io.IORuntimeException

parse8bit

default void parse8bit(Appendable buffer,
                       @NotNull
                       StopCharTester stopCharTester)
                throws BufferUnderflowException

parse text with ISO-8859-1 decoding as character terminated.

Parameters:

buffer - to populate

stopCharTester - to check if the end has been reached.

Throws:

BufferUnderflowException

parse8bit

default String parse8bit(@NotNull
                         StopCharTester stopCharTester)
                  throws BufferUnderflowException

parse text with ISO-8859-1 decoding as character terminated.

Parameters:

stopCharTester - to check if the end has been reached.

Throws:

BufferUnderflowException

parse8bit

default void parse8bit(Appendable buffer,
                       @NotNull
                       StopCharsTester stopCharsTester)
                throws BufferUnderflowException

parse text with ISO-8859-1 decoding as character terminated.

Parameters:

buffer - to populate

stopCharsTester - to check if the end has been reached.

Throws:

BufferUnderflowException

parse8bit

default void parse8bit(Bytes buffer,
                       @NotNull
                       StopCharsTester stopCharsTester)
                throws BufferUnderflowException

Throws:

BufferUnderflowException

parse8bit

default void parse8bit(StringBuilder buffer,
                       @NotNull
                       StopCharsTester stopCharsTester)
                throws BufferUnderflowException

Throws:

BufferUnderflowException

parseInt

default int parseInt()
              throws BufferUnderflowException

parse text as an int. The terminating character is consumed.

Returns:

an int.

Throws:

BufferUnderflowException

parseLong

default long parseLong()
                throws BufferUnderflowException

parse text as a long integer. The terminating character is consumed.

Returns:

a long.

Throws:

BufferUnderflowException

parseFloat

default float parseFloat()
                  throws BufferUnderflowException

parse text as a float decimal. The terminating character is consumed.

The number of decimal places can be retrieved with lastDecimalPlaces()

Returns:

a float.

Throws:

BufferUnderflowException

parseDouble

default double parseDouble()
                    throws BufferUnderflowException

parse text as a double decimal. The terminating character is consumed.

The number of decimal places can be retrieved with lastDecimalPlaces()

Returns:

a double.

Throws:

BufferUnderflowException

parseLongDecimal

default long parseLongDecimal()
                       throws BufferUnderflowException

Parse the significant digits of a decimal number.

The number of decimal places can be retrieved with lastDecimalPlaces()

Returns:

the significant digits

Throws:

BufferUnderflowException

lastDecimalPlaces

int lastDecimalPlaces()

Returns:

the last number of decimal places for parseDouble or parseLongDecimal

lastDecimalPlaces

void lastDecimalPlaces(int lastDecimalPlaces)

Store the last number of decimal places. If

Parameters:

lastDecimalPlaces - set the number of decimal places if positive, otherwise 0.

skipTo

default boolean skipTo(@NotNull
                       StopCharTester tester)

Skip text until a terminating character is reached.

Parameters:

tester - to stop at

Returns:

true if a terminating character was found, false if the end of the buffer was reached.

parseBigDecimal

@NotNull
default BigDecimal parseBigDecimal()

start

default long start()

Returns:

The smallest position allowed in this buffer.

readPosition

default long readPosition()

The read position must be start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()

Returns:

position to read from.

writePosition

default long writePosition()

The read position must be readPosition() <= writePosition() && writePosition() <= writeLimit()

Returns:

position to write to.

readRemaining

default long readRemaining()

Returns:

How many more bytes can we read.

writeRemaining

default long writeRemaining()

Returns:

How many more bytes can we written.

readLimit

default long readLimit()

Returns:

the highest offset or position allowed for this buffer.

writeLimit

default long writeLimit()

addressForRead

long addressForRead(long offset)
             throws UnsupportedOperationException,
                    BufferUnderflowException

Obtain the underlying addressForRead. This is for expert users only.

Parameters:

offset - within this buffer. addressForRead(start()) is the actual addressForRead of the first byte.

Returns:

the underlying addressForRead of the buffer

Throws:

UnsupportedOperationException - if the underlying buffer is on the heap

BufferUnderflowException - if the offset is before the start() or the after the capacity()

addressForRead

default long addressForRead(long offset,
                            int buffer)
                     throws UnsupportedOperationException,
                            BufferUnderflowException

Throws:

UnsupportedOperationException

BufferUnderflowException

addressForWrite

long addressForWrite(long offset)
              throws UnsupportedOperationException,
                     BufferOverflowException

Obtain the underlying addressForRead. This is for expert users only.

Parameters:

offset - within this buffer. addressForRead(start()) is the actual addressForRead of the first byte.

Returns:

the underlying addressForRead of the buffer

Throws:

UnsupportedOperationException - if the underlying buffer is on the heap

BufferOverflowException - if the offset is before the start() or the after the capacity()

addressForWritePosition

long addressForWritePosition()
                      throws UnsupportedOperationException,
                             BufferOverflowException

Throws:

UnsupportedOperationException

BufferOverflowException

byteOrder

default ByteOrder byteOrder()

compareAndSwapInt

boolean compareAndSwapInt(long offset,
                          int expected,
                          int value)
                   throws BufferOverflowException

Perform a 32-bit CAS at a given offset.

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

testAndSetInt

void testAndSetInt(long offset,
                   int expected,
                   int value)

compareAndSwapLong

boolean compareAndSwapLong(long offset,
                           long expected,
                           long value)
                    throws BufferOverflowException

Perform a 64-bit CAS at a given offset.

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

compareAndSwapFloat

default boolean compareAndSwapFloat(long offset,
                                    float expected,
                                    float value)
                             throws BufferOverflowException

Perform a 32-bit float CAS at a given offset.

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

compareAndSwapDouble

default boolean compareAndSwapDouble(long offset,
                                     double expected,
                                     double value)
                              throws BufferOverflowException

Perform a 64-bit double CAS at a given offset.

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException