Bytes (OpenHFT/Chronicle-Bytes 1.5.1 API)

All Superinterfaces:

Appendable, AutoCloseable, BytesIn<Underlying>, BytesOut<Underlying>, BytesPrepender<Bytes<Underlying>>, BytesStore<Bytes<Underlying>,Underlying>, ByteStringAppender<Bytes<Underlying>>, CharSequence, Closeable, RandomDataInput, RandomDataOutput<Bytes<Underlying>>, net.openhft.chronicle.core.ReferenceCounted, StreamingDataInput<Bytes<Underlying>>, StreamingDataOutput<Bytes<Underlying>>

All Known Implementing Classes:

AbstractBytes, CheckingMappedBytes, MappedBytes, NativeBytes, 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 long MAX_CAPACITY
- Fields inherited from interface net.openhft.chronicle.bytes.RandomDataInput
  charToString

Fields
Modifier and Type	Field and Description
`static int`	`DEFAULT_BYTE_BUFFER_CAPACITY`
`static long`	`MAX_CAPACITY`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`static Bytes`	`allocateDirect(byte[] bytes)` copies the contents of bytes into a direct byte buffer
`static VanillaBytes<Void>`	`allocateDirect(long capacity)` Allocate a fixed size buffer read for writing.
`static NativeBytes<Void>`	`allocateElasticDirect()` Allocate an elastic buffer with initially no size.
`static NativeBytes<Void>`	`allocateElasticDirect(long initialCapacity)` Allocate an elastic buffer with initially no size.
`default Bytes<Underlying>`	`bytesForRead()` Creates a slice of the current Bytes based on its position() and limit().
`BytesStore`	`bytesStore()`
`Bytes<Underlying>`	`compact()` Compact these Bytes by moving the readPosition to the start.
`BytesStore<Bytes<Underlying>,Underlying>`	`copy()`
`default long`	`copyTo(BytesStore store)` Copy the data to another BytesStore
`default void`	`copyTo(OutputStream out)`
`static Bytes<ByteBuffer>`	`elasticByteBuffer()`
`static Bytes<ByteBuffer>`	`elasticByteBuffer(int initialCapacity)` Returns an elastic wrapper for a direct ByteBuffer which will be resized as required, with the given initial capacity.
`static Bytes<ByteBuffer>`	`elasticByteBuffer(int initialCapacity, int maxSize)`
`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 <B extends BytesStore<B,Underlying>,Underlying> Bytes<Underlying>`	`expect(BytesStore<B,Underlying> bytesStore)` A Bytes suitable for writing to for testing purposes.
`static Bytes<byte[]>`	`expect(String text)` A Bytes suitable for writing to for testing purposes.
`static Bytes<byte[]>`	`from(CharSequence text)` Convert text to bytes using ISO-8859-1 encoding and return a Bytes ready for reading.
`static Bytes`	`fromHexString(String s)`
`default boolean`	`isClear()` The Bytes are clear if start() == readPosition() && writeLimit() == capacity()
`boolean`	`isElastic()`
`default boolean`	`isEmpty()`
`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 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 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 Reader`	`reader()` Access these bytes as an ISO-8859-1 encoded Reader
`default long`	`realCapacity()`
`default long`	`safeLimit()`
`default boolean`	`sharedMemory()`
`default boolean`	`skipTo(StopCharTester tester)` Skip text until a terminating character is reached.
`default String`	`toHexString()` display the hex data of `Bytes` from the position() to the limit()
`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 Bytes<Underlying>`	`unchecked(boolean unchecked)` Return a Bytes which is optionally unchecked.
`static Bytes<byte[]>`	`wrapForRead(byte[] byteArray)` Wrap the byte[] ready for reading
`static Bytes<ByteBuffer>`	`wrapForRead(ByteBuffer byteBuffer)`
`static Bytes<byte[]>`	`wrapForRead(CharSequence text)` Deprecated.
`static Bytes<byte[]>`	`wrapForWrite(byte[] byteArray)` Wrap the byte[] ready for writing
`static Bytes<ByteBuffer>`	`wrapForWrite(ByteBuffer byteBuffer)`

Methods inherited from interface net.openhft.chronicle.bytes.BytesStore
addAndGetByteNotAtomic, addAndGetDoubleNotAtomic, addAndGetFloatNotAtomic, addAndGetIntNotAtomic, addAndGetLongNotAtomic, addAndGetShortNotAtomic, addAndGetUnsignedByteNotAtomic, addAndGetUnsignedIntNotAtomic, addAndGetUnsignedShortNotAtomic, byteCheckSum, bytesForWrite, capacity, charAt, contentEquals, empty, endsWith, equalBytes, inside, isNative, isPresent, isPresent, length, longCheckSum, move, nativePointer, startsWith, subSequence, to8bitString, toDebugString, toDebugString, underlyingObject, wrap, wrap, wrap, wrap, writeMaxLong, zeroOut

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataInput
addAndGetDouble, addAndGetFloat, addAndGetInt, addAndGetLong, compareUtf8, copyTo, copyTo, createCharToString, findByte, nativeRead, parseLong, 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.RandomDataOutput
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.StreamingDataInput
inputStream, nativeRead, parseHexLong, parseUTF, parseUtf8, parseWithLength, peekUnsignedByte, read, read, read, read, read8bit, read8bit, read8bit, read8bit, readBoolean, readByte, readDouble, readEnum, readFloat, readInt, readLimit, readLong, readPosition, readPositionRemaining, readShort, readSkip, readStopBit, readStopBitDouble, readUnsignedByte, readUnsignedInt, readUnsignedInt24, readUnsignedShort, readUtf8, readUtf8, readUTFΔ, readUTFΔ, readVolatileInt, readVolatileLong, readWithLength

Methods inherited from interface net.openhft.chronicle.bytes.ByteStringAppender
append, append, append, append, append, append, append, append8bit, append8bit, appendBase, appendDateMillis, appendDecimal, appendTimeMillis, writer

Methods inherited from interface net.openhft.chronicle.bytes.StreamingDataOutput
appendUtf8, appendUtf8, appendUtf8, appendUtf8, copyFrom, nativeWrite, outputStream, write, write, write, write, write, write, write8bit, write8bit, write8bit, write8bit, writeBoolean, writeByte, writeDouble, writeEnum, writeFloat, writeInt, writeInt24, writeLimit, writeLong, writeOrderedInt, writeOrderedLong, writePosition, writePositionRemaining, writeShort, writeSkip, writeSome, writeSome, writeStopBit, writeStopBit, writeUnsignedByte, writeUnsignedInt, writeUnsignedShort, writeUtf8, writeUTFΔ

Methods inherited from interface net.openhft.chronicle.bytes.BytesPrepender
clearAndPad, prepend, prewrite, prewrite, prewriteByte, prewriteInt, prewriteLong, prewriteShort

- Field Detail
  - MAX_CAPACITY
```
static final long MAX_CAPACITY
```
    See Also:
    
    Constant Field Values
  - DEFAULT_BYTE_BUFFER_CAPACITY
```
static final int DEFAULT_BYTE_BUFFER_CAPACITY
```
    See Also:
    
    Constant Field Values
- Method Detail
  - elasticByteBuffer
```
static Bytes<ByteBuffer> elasticByteBuffer()
```
    Returns:
    
    an elastic wrapper for a direct ByteBuffer which will be resized as required.
  - elasticByteBuffer
```
static Bytes<ByteBuffer> elasticByteBuffer(int initialCapacity,
                                           int maxSize)
```
  - elasticByteBuffer
```
static Bytes<ByteBuffer> elasticByteBuffer(int initialCapacity)
```
    Returns an elastic wrapper for a direct ByteBuffer which will be resized as required, with the given initial capacity.
  - wrapForRead
```
static Bytes<ByteBuffer> wrapForRead(ByteBuffer byteBuffer)
```
    Parameters:
    
    byteBuffer - to read
    
    Returns:
    
    a Bytes which wrap a ByteBuffer and is ready for reading.
  - wrapForWrite
```
static Bytes<ByteBuffer> wrapForWrite(ByteBuffer byteBuffer)
```
    Parameters:
    
    byteBuffer - to read
    
    Returns:
    
    a Bytes which wrap a ByteBuffer and is ready for writing.
  - expect
```
@NotNull
static Bytes<byte[]> expect(@NotNull
                                     String text)
```
    A Bytes suitable for writing to for testing purposes. It checks the writes made are the expected ones. An AssertionError is thrown if unexpected data is written, an UnsupportedOperationException is thrown if a read is attempted.
    
    Parameters:
    
    text - expected
    
    Returns:
    
    the expected buffer as Bytes
  - expect
```
@NotNull
static <B extends BytesStore<B,Underlying>,Underlying> Bytes<Underlying> expect(BytesStore<B,Underlying> bytesStore)
```
    A Bytes suitable for writing to for testing purposes. It checks the writes made are the expected ones. An AssertionError is thrown if unexpected data is written, an UnsupportedOperationException is thrown if a read is attempted.
    
    Parameters:
    
    bytesStore - expected
    
    Returns:
    
    the expected buffer as Bytes
  - wrapForRead
```
static Bytes<byte[]> wrapForRead(byte[] byteArray)
```
    Wrap the byte[] ready for reading
    
    Parameters:
    
    byteArray - to wrap
    
    Returns:
    
    the Bytes ready for reading.
  - wrapForWrite
```
static Bytes<byte[]> wrapForWrite(byte[] byteArray)
```
    Wrap the byte[] ready for writing
    
    Parameters:
    
    byteArray - to wrap
    
    Returns:
    
    the Bytes ready for writing.
  - from
```
static Bytes<byte[]> from(@NotNull
                          CharSequence text)
                   throws IllegalArgumentException,
                          IllegalStateException
```
    Convert text to bytes using ISO-8859-1 encoding and return a Bytes ready for reading.
    
    Specified by:
    
    from in interface BytesStore<Bytes<Underlying>,Underlying>
    
    Parameters:
    
    text - to convert
    
    Returns:
    
    Bytes ready for reading.
    
    Throws:
    
    IllegalArgumentException
    
    IllegalStateException
  - wrapForRead
```
@Deprecated
static Bytes<byte[]> wrapForRead(@NotNull
                                             CharSequence text)
                                      throws IllegalArgumentException,
                                             IllegalStateException
```
    Deprecated.
    
    Throws:
    
    IllegalArgumentException
    
    IllegalStateException
  - allocateDirect
```
static VanillaBytes<Void> allocateDirect(long capacity)
                                  throws IllegalArgumentException
```
    Allocate a fixed size buffer read for writing.
    
    Parameters:
    
    capacity - minimum to allocate
    
    Returns:
    
    a new Bytes ready for writing.
    
    Throws:
    
    IllegalArgumentException
  - allocateElasticDirect
```
static NativeBytes<Void> allocateElasticDirect()
```
    Allocate an elastic buffer with initially no size.
    
    Returns:
    
    Bytes for writing.
  - allocateElasticDirect
```
static NativeBytes<Void> allocateElasticDirect(long initialCapacity)
                                        throws IllegalArgumentException
```
    Allocate an elastic buffer with initially no size.
    
    Returns:
    
    Bytes for writing.
    
    Throws:
    
    IllegalArgumentException
  - toString
```
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
```
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
```
static String toString(@NotNull
                       Bytes buffer,
                       long position,
                       long len)
                throws BufferUnderflowException,
                       net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    net.openhft.chronicle.core.io.IORuntimeException
  - allocateDirect
```
static Bytes allocateDirect(@NotNull
                            byte[] bytes)
                     throws IllegalArgumentException
```
    copies the contents of bytes into a direct byte buffer
    
    Parameters:
    
    bytes - the bytes to wrap
    
    Returns:
    
    a direct byte buffer contain the bytes
    
    Throws:
    
    IllegalArgumentException
  - fromHexString
```
static Bytes fromHexString(String s)
```
  - unchecked
```
default Bytes<Underlying> unchecked(boolean unchecked)
                             throws IllegalStateException
```
    Return a Bytes which is optionally unchecked. This allows bounds checks to be turned off.
    
    Parameters:
    
    unchecked - if true, minimal bounds checks will be performed.
    
    Returns:
    
    Bytes without bounds checking.
    
    Throws:
    
    IllegalStateException - if the underlying BytesStore has been released
  - safeLimit
```
default long safeLimit()
```
    Specified by:
    
    safeLimit in interface BytesStore<Bytes<Underlying>,Underlying>
    
    Returns:
    
    the size which can be safely read. If this isElastic() it can be lower than the point it can safely write.
  - isClear
```
default boolean isClear()
```
    Description copied from interface: BytesStore
    
    The Bytes are clear if start() == readPosition() && writeLimit() == capacity()
    
    Specified by:
    
    isClear in interface BytesStore<Bytes<Underlying>,Underlying>
    
    Returns:
    
    is the readPosition at the start and the writeLimit at the end.
  - realCapacity
```
default long realCapacity()
```
    Specified by:
    
    realCapacity in interface BytesStore<Bytes<Underlying>,Underlying>
    
    Specified by:
    
    realCapacity in interface RandomDataInput
    
    Returns:
    
    if isElastic, this can be much lower than the virtual capacity().
  - 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()
                             throws net.openhft.chronicle.core.io.IORuntimeException
```
    display the hex data of Bytes from the position() to the limit()
    
    Returns:
    
    hex representation of the buffer, from example [0D ,OA, FF]
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
  - toHexString
```
@NotNull
default String toHexString(long maxLength)
                             throws net.openhft.chronicle.core.io.IORuntimeException
```
    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]
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
  - toHexString
```
@NotNull
default String toHexString(long offset,
                                    long maxLength)
                             throws net.openhft.chronicle.core.io.IORuntimeException
```
    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]
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
  - isElastic
```
boolean isElastic()
```
    Returns:
    
    can the Bytes resize when more data is written than it's realCapacity()
  - ensureCapacity
```
default void ensureCapacity(long size)
                     throws IllegalArgumentException,
                            net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    IORuntimeException - if an error occured trying to resize the underlying buffer.
    
    net.openhft.chronicle.core.io.IORuntimeException
  - bytesForRead
```
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
```
BytesStore bytesStore()
```
    Specified by:
    
    bytesStore in interface BytesStore<Bytes<Underlying>,Underlying>
    
    Returns:
    
    the ByteStore this Bytes wraps.
  - isEqual
```
default boolean isEqual(String s)
```
  - isEmpty
```
default boolean isEmpty()
```
  - compact
```
Bytes<Underlying> compact()
```
    Compact these Bytes by moving the readPosition to the start.
    
    Returns:
    
    this
  - copyTo
```
default long copyTo(@NotNull
                    BytesStore store)
```
    Description copied from interface: BytesStore
    
    Copy the data to another BytesStore
    
    Specified by:
    
    copyTo in interface BytesStore<Bytes<Underlying>,Underlying>
    
    Specified by:
    
    copyTo in interface StreamingDataInput<Bytes<Underlying>>
    
    Parameters:
    
    store - to copy to
  - copyTo
```
default void copyTo(OutputStream out)
             throws IOException
```
    Specified by:
    
    copyTo in interface BytesStore<Bytes<Underlying>,Underlying>
    
    Specified by:
    
    copyTo in interface StreamingDataInput<Bytes<Underlying>>
    
    Throws:
    
    IOException
  - sharedMemory
```
default boolean sharedMemory()
```
    Returns:
    
    true if these Bytes use shared memory.
  - reader
```
default Reader reader()
```
    Access these bytes as an ISO-8859-1 encoded Reader
    
    Returns:
    
    as a Reader
  - parseBoolean
```
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.
  - 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
```
@Deprecated
default String parseUTF(@NotNull
                                    StopCharTester stopCharTester)
```
    Deprecated.
  - parseUtf8
```
default void parseUtf8(@NotNull
                       Appendable buffer,
                       @NotNull
                       StopCharTester stopCharTester)
```
    parse text with UTF-8 decoding as character terminated.
    
    Parameters:
    
    buffer - to populate
    
    stopCharTester - to check if the end has been reached.
  - parseUTF
```
@Deprecated
default void parseUTF(@NotNull
                                  Appendable buffer,
                                  @NotNull
                                  StopCharTester stopCharTester)
```
    Deprecated.
  - parseUtf8
```
default void parseUtf8(@NotNull
                       Appendable buffer,
                       @NotNull
                       StopCharsTester stopCharsTester)
                throws BufferUnderflowException,
                       BufferOverflowException,
                       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
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - parseUTF
```
@Deprecated
default void parseUTF(@NotNull
                                  Appendable buffer,
                                  @NotNull
                                  StopCharsTester stopCharsTester)
                           throws BufferUnderflowException,
                                  BufferOverflowException,
                                  net.openhft.chronicle.core.io.IORuntimeException
```
    Deprecated.
    
    Throws:
    
    BufferUnderflowException
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - parse8bit
```
default void parse8bit(Appendable buffer,
                       @NotNull
                       StopCharTester stopCharTester)
                throws BufferUnderflowException,
                       BufferOverflowException,
                       net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - parse8bit
```
default void parse8bit(Appendable buffer,
                       @NotNull
                       StopCharsTester stopCharsTester)
                throws BufferUnderflowException,
                       BufferOverflowException,
                       net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - parseLong
```
default long parseLong()
                throws BufferUnderflowException,
                       net.openhft.chronicle.core.io.IORuntimeException
```
    parse text as a long integer. The terminating character is consumed.
    
    Returns:
    
    a long.
    
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - parseDouble
```
default double parseDouble()
                    throws BufferUnderflowException,
                           net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    net.openhft.chronicle.core.io.IORuntimeException
  - 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)
                throws net.openhft.chronicle.core.io.IORuntimeException
```
    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.
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException

Interface Bytes<Underlying>

Field Summary

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

Method Summary

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

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

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

Methods inherited from interface java.lang.CharSequence

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

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

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

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

Field Detail

MAX_CAPACITY

DEFAULT_BYTE_BUFFER_CAPACITY

Method Detail

elasticByteBuffer

elasticByteBuffer

elasticByteBuffer

wrapForRead

wrapForWrite

expect

expect

wrapForRead

wrapForWrite

from

wrapForRead

allocateDirect

allocateElasticDirect

allocateElasticDirect

toString

toString

toString

allocateDirect

fromHexString

unchecked

safeLimit

isClear

realCapacity

copy

toHexString

toHexString

toHexString

isElastic

ensureCapacity

bytesForRead

bytesStore

isEqual

isEmpty

compact

copyTo

copyTo

sharedMemory

reader

parseBoolean

parseUtf8

parseUTF

parseUtf8

parseUTF

parseUtf8

parseUTF

parse8bit

parse8bit

parseLong

parseDouble

parseLongDecimal

lastDecimalPlaces

lastDecimalPlaces

skipTo