MappedBytes (OpenHFT/Chronicle-Bytes 2.20.107 API)

java.lang.Object
- net.openhft.chronicle.core.io.AbstractReferenceCounted
- - net.openhft.chronicle.bytes.AbstractBytes<Void>
  - - net.openhft.chronicle.bytes.MappedBytes

All Implemented Interfaces:

Closeable, Appendable, AutoCloseable, CharSequence, Bytes<Void>, BytesComment<BytesOut<Void>>, BytesIn<Void>, BytesOut<Void>, BytesPrepender<Bytes<Void>>, BytesStore<Bytes<Void>,Void>, ByteStringAppender<Bytes<Void>>, RandomDataInput, RandomDataOutput<Bytes<Void>>, StreamingCommon<Bytes<Void>>, StreamingDataOutput<Bytes<Void>>, net.openhft.chronicle.core.io.QueryCloseable, net.openhft.chronicle.core.io.ReferenceCounted, net.openhft.chronicle.core.io.ReferenceCountedTracer, net.openhft.chronicle.core.io.ReferenceOwner
```
public class MappedBytes
extends AbstractBytes<Void>
implements net.openhft.chronicle.core.io.Closeable
```
Bytes to wrap memory mapped data.
NOTE These Bytes are single Threaded as are all Bytes.

Field Summary
- Fields inherited from class net.openhft.chronicle.bytes.AbstractBytes
  isPresent, readPosition, writeLimit, writePosition
- Fields inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted
  WARN_COUNT, WARN_NS
- Fields inherited from interface net.openhft.chronicle.bytes.Bytes
  DEFAULT_BYTE_BUFFER_CAPACITY, MAX_BYTE_BUFFER_CAPACITY, MAX_CAPACITY, 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
- Fields inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
  INIT

Constructor Summary

Constructors
Modifier Constructor and Description

protected MappedBytes(@NotNull MappedFile mappedFile)

protected MappedBytes(@NotNull MappedFile mappedFile, String name)

Constructors
Modifier	Constructor and Description
`protected`	`MappedBytes(@NotNull MappedFile mappedFile)`
`protected`	`MappedBytes(@NotNull MappedFile mappedFile, String name)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`long`	`addressForRead(long offset)` Obtain the underlying addressForRead.
`long`	`addressForRead(long offset, int buffer)`
`long`	`addressForWrite(long offset)` Obtain the underlying addressForRead.
`@NotNull Bytes<Void>`	`append8bit(@NotNull CharSequence cs, int start, int end)` Append a portion of a String to the Bytes in ISO-8859-1
`@NotNull Bytes<Void>`	`appendUtf8(char[] chars, int offset, int length)`
`@NotNull Bytes<Void>`	`appendUtf8(@NotNull CharSequence cs, int start, int length)`
`default ByteOrder`	`byteOrder()`
`@NotNull MappedBytesStore`	`bytesStore()`
`protected void`	`bytesStore(BytesStore bytesStore)`
`long`	`capacity()`
`@NotNull Bytes<Void>`	`clear()` Set the readPosition= writePosition = start, writeLimit = capacity
`void`	`close()`
`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`	`compareAndSwapLong(long offset, long expected, long value)` Perform a 64-bit CAS at a given offset.
`BytesStore<Bytes<Void>,Void>`	`copy()`
`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`
`boolean`	`isBackingFileReadOnly()`
`boolean`	`isClosed()`
`boolean`	`isDirectMemory()`
`boolean`	`isElastic()` Returns if this Bytes is elastic.
`static @NotNull MappedBytes`	`mappedBytes(@NotNull File file, long chunkSize)`
`static @NotNull MappedBytes`	`mappedBytes(@NotNull File file, long chunkSize, long overlapSize)`
`static @NotNull MappedBytes`	`mappedBytes(@NotNull File file, long chunkSize, long overlapSize, boolean readOnly)`
`static @NotNull MappedBytes`	`mappedBytes(@NotNull MappedFile rw)`
`static @NotNull MappedBytes`	`mappedBytes(@NotNull String filename, long chunkSize)`
`@NotNull MappedFile`	`mappedFile()`
`default void`	`parse8bit(Appendable buffer, @NotNull StopCharsTester stopCharsTester)` parse text with ISO-8859-1 decoding as character terminated.
`default void`	`parse8bit(Appendable buffer, @NotNull StopCharTester stopCharTester)` parse text with ISO-8859-1 decoding as character terminated.
`default void`	`parse8bit(Bytes buffer, @NotNull StopCharsTester stopCharsTester)`
`default String`	`parse8bit(@NotNull StopCharTester stopCharTester)` parse text with ISO-8859-1 decoding as character terminated.
`default void`	`parse8bit(StringBuilder buffer, @NotNull StopCharsTester stopCharsTester)`
`default @NotNull BigDecimal`	`parseBigDecimal()`
`default @Nullable Boolean`	`parseBoolean()`
`default @Nullable Boolean`	`parseBoolean(@NotNull 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(@NotNull Appendable buffer, @NotNull StopCharsTester stopCharsTester)` Deprecated.
`default void`	`parseUTF(@NotNull Appendable buffer, @NotNull StopCharTester stopCharTester)` Deprecated.
`default @NotNull String`	`parseUTF(@NotNull StopCharTester stopCharTester)` Deprecated.
`default void`	`parseUtf8(@NotNull Appendable buffer, @NotNull StopCharsTester stopCharsTester)` parse text with UTF-8 decoding as one or two character terminated.
`default void`	`parseUtf8(@NotNull Appendable buffer, @NotNull StopCharTester stopCharTester)` parse text with UTF-8 decoding as character terminated.
`default @NotNull String`	`parseUtf8(@NotNull StopCharTester stopCharTester)` parse text with UTF-8 decoding as character terminated.
`int`	`peekUnsignedByte()`
`int`	`peekUnsignedByte(long offset)` Read an unsigned byte at an offset, or -1
`int`	`peekVolatileInt()`
`protected void`	`performRelease()`
`protected boolean`	`performReleaseInBackground()`
`@Nullable String`	`read8bit()`
`protected void`	`readCheckOffset(long offset, long adding, boolean given)`
`default @NotNull Reader`	`reader()` Access these bytes as an ISO-8859-1 encoded Reader
`Bytes<Void>`	`readLimitToCapacity()`
`static @NotNull MappedBytes`	`readOnly(@NotNull File file)`
`@NotNull Bytes<Void>`	`readPosition(long position)`
`@NotNull Bytes<Void>`	`readPositionRemaining(long position, long remaining)`
`default long`	`readRemaining()`
`@NotNull Bytes<Void>`	`readSkip(long bytesToSkip)` Skip a number of bytes by moving the readPosition.
`long`	`readStopBit()`
`char`	`readStopBitChar()`
`byte`	`readVolatileByte(long offset)` Read a 8-bit byte from memory with a load barrier.
`int`	`readVolatileInt(long offset)` Read a 32-bit int from memory with a load barrier.
`long`	`readVolatileLong(long offset)` Read a 64-bit long from memory with a load barrier.
`short`	`readVolatileShort(long offset)` Read a 16-bit short from memory with a load barrier.
`long`	`realCapacity()` Returns the actual capacity that can be potentially read.
`void`	`release(net.openhft.chronicle.core.io.ReferenceOwner id)`
`void`	`releaseLast(net.openhft.chronicle.core.io.ReferenceOwner id)`
`void`	`setNewChunkListener(NewChunkListener listener)`
`boolean`	`sharedMemory()`
`default boolean`	`skipTo(@NotNull StopCharTester tester)` Skip text until a terminating character is reached.
`long`	`start()`
`@NotNull String`	`toString()`
`@NotNull MappedBytes`	`write(@NotNull byte[] bytes, int offset, int length)` Write all data or fail.
`@NotNull Bytes<Void>`	`write(@NotNull BytesStore bytes, long offset, long length)` Write all data or fail.
`@NotNull MappedBytes`	`write(long offsetInRDO, byte[] bytes, int offset, int length)`
`@NotNull MappedBytes`	`write(long offsetInRDO, @NotNull RandomDataInput bytes)`
`@NotNull MappedBytes`	`write(long writeOffset, RandomDataInput bytes, long readOffset, long length)`
`@NotNull MappedBytes`	`write(@NotNull RandomDataInput bytes)` Write all data or fail.
`@NotNull Bytes<Void>`	`write(@NotNull RandomDataInput bytes, long offset, long length)` Write all data or fail.
`@NotNull MappedBytes`	`write8bit(@Nullable BytesStore bs)`
`@NotNull MappedBytes`	`write8bit(@NotNull CharSequence s, int start, int length)`
`@NotNull Bytes<Void>`	`writeByte(byte i8)`
`protected void`	`writeCheckOffset(long offset, long adding)`
`@NotNull Bytes<Void>`	`writeOrderedInt(long offset, int i)` Perform a non stalling write with a store barrier.
`@NotNull Bytes<Void>`	`writePosition(long position)`
`default long`	`writeRemaining()`
`@NotNull Bytes<Void>`	`writeStopBit(char n)`
`@NotNull Bytes<Void>`	`writeStopBit(long n)` Write a stop bit encoded long
`@NotNull Bytes<Void>`	`writeUtf8(CharSequence str)` Write the same encoding as `writeUTF` with the following changes.
`@NotNull Bytes<Void>`	`writeUtf8(String str)`

Methods inherited from class net.openhft.chronicle.bytes.AbstractBytes
addressForWritePosition, append, byteCheckSum, byteCheckSum, byteCheckSum, canReadDirect, canWriteDirect, clearAndPad, compact, compareAndSwapInt, equals, hashCode, isPresent, isPresent, lastDecimalPlaces, lastDecimalPlaces, lenient, lenient, move, nativeRead, nativeRead, nativeWrite, nativeWrite, prewrite, prewrite, prewriteByte, prewriteInt, prewriteLong, prewriteOffsetPositionMoved, prewriteShort, readByte, readByte, readDouble, readDouble, readFloat, readFloat, readInt, readInt, readLimit, readLimit, readLong, readLong, readOffsetPositionMoved, readPosition, readShort, readShort, readUnsignedByte, readUnsignedByte, readVolatileInt, readVolatileLong, realWriteRemaining, safeCopySize, testAndSetInt, uncheckedReadSkipBackOne, uncheckedReadSkipOne, uncheckedReadUnsignedByte, underlyingObject, write, writeByte, writeDouble, writeDouble, writeDoubleAndInt, writeFloat, writeFloat, writeInt, writeInt, writeIntAdv, writeLimit, writeLimit, writeLong, writeLong, writeLongAdv, writeOffsetPositionMoved, writeOffsetPositionMoved, writeOrderedInt, writeOrderedLong, writeOrderedLong, writePosition, writeShort, writeShort, writeSkip, writeSome, writeVolatileByte, writeVolatileInt, writeVolatileLong, writeVolatileShort

Methods inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted
assertReferencesReleased, createdHere, disableReferenceTracing, enableReferenceTracing, refCount, referenceId, reserve, reservedBy, reserveTransfer, threadSafetyCheck, throwExceptionIfNotReleased, throwExceptionIfReleased, tryReserve, unmonitor, warnAndReleaseIfNotReleased

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface net.openhft.chronicle.core.io.Closeable
closeQuietly, closeQuietly, notifyClosing

Methods inherited from interface net.openhft.chronicle.core.io.QueryCloseable
isClosing, throwExceptionIfClosed

Methods inherited from interface net.openhft.chronicle.bytes.Bytes
allocateDirect, allocateDirect, allocateElasticDirect, allocateElasticDirect, allocateElasticOnHeap, allocateElasticOnHeap, bytesForRead, copyTo, copyTo, directFrom, elasticByteBuffer, elasticByteBuffer, elasticByteBuffer, elasticHeapByteBuffer, elasticHeapByteBuffer, from, from, fromHexString, fromString, indexOf, indexOf, indexOf, indexOf, isClear, isEqual, readBigDecimal, readBigInteger, readMarshallableLength16, readWithLength, readWrite, safeLimit, toHexString, toHexString, toHexString, toString, toString, toString, unchecked, unchecked, unwrite, valueOf, wrapForRead, wrapForRead, wrapForWrite, wrapForWrite, write, writeMarshallableLength16

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

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataOutput
append, append, write, write, writeBoolean, writeByte, writeInt24, writeOrderedDouble, writeOrderedFloat, writeUnsignedByte, writeUnsignedInt, writeUnsignedShort, writeUtf8, writeUtf8Limited, writeVolatileDouble, writeVolatileFloat

Methods inherited from interface java.lang.CharSequence
chars, codePoints

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, compareUtf8, copyTo, copyTo, createCharToString, fastHash, findByte, parseLong, printable, read, readBoolean, readIncompleteLong, readUnsignedInt, readUnsignedInt24, readUnsignedShort, readUtf8, readUtf8Limited, readUtf8Limited, readVolatileDouble, readVolatileFloat, subBytes, toByteArray, toTemporaryDirectByteBuffer

Methods inherited from interface net.openhft.chronicle.bytes.StreamingDataInput
inputStream, parseHexLong, parseUTF, parseUtf8, parseUtf8, rawReadByte, rawReadInt, rawReadLong, read, read, read, read, read, read8bit, read8bit, read8bit, readBoolean, readChar, readEnum, readHistogram, readIncompleteLong, readInt24, readPositionUnlimited, readStopBitDecimal, readStopBitDouble, readUnsignedInt, readUnsignedInt24, readUnsignedShort, readUtf8, readUtf8, readUTFΔ, readUTFΔ, readWithLength, readWithLength, readWithLength0, unsafeReadObject, unsafeReadObject

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, 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, copyFrom, outputStream, rawWriteByte, rawWriteInt, rawWriteLong, unsafeWriteObject, unsafeWriteObject, write, write, write, write, write8bit, write8bit, writeBigDecimal, writeBigInteger, writeBoolean, writeChar, writeEnum, writeHistogram, writeInt24, writePositionRemaining, writeSome, writeStopBit, writeStopBitDecimal, writeUnsignedByte, writeUnsignedInt, writeUnsignedInt24, writeUnsignedShort, writeUTFΔ, writeWithLength

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceCounted
refCount, releaseLast, reserve, reservedBy, reserveTransfer, tryReserve

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
referenceId, referenceName, temporary

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

Methods inherited from interface net.openhft.chronicle.bytes.BytesComment
comment, indent, retainsComments

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceCountedTracer
onReleased

Constructor Detail

MappedBytes

protected MappedBytes(@NotNull
                      @NotNull MappedFile mappedFile)
               throws IllegalStateException

Throws:: IllegalStateException

MappedBytes

protected MappedBytes(@NotNull
                      @NotNull MappedFile mappedFile,
                      String name)
               throws IllegalStateException

Throws:: IllegalStateException

Method Detail

mappedBytes

@NotNull
public static @NotNull MappedBytes mappedBytes(@NotNull
                                                        @NotNull String filename,
                                                        long chunkSize)
                                                 throws FileNotFoundException,
                                                        IllegalStateException

Throws:: FileNotFoundException; IllegalStateException

mappedBytes

@NotNull
public static @NotNull MappedBytes mappedBytes(@NotNull
                                                        @NotNull File file,
                                                        long chunkSize)
                                                 throws FileNotFoundException,
                                                        IllegalStateException

Throws:: FileNotFoundException; IllegalStateException

mappedBytes

@NotNull
public static @NotNull MappedBytes mappedBytes(@NotNull
                                                        @NotNull File file,
                                                        long chunkSize,
                                                        long overlapSize)
                                                 throws FileNotFoundException,
                                                        IllegalStateException

Throws:: FileNotFoundException; IllegalStateException

mappedBytes

@NotNull
public static @NotNull MappedBytes mappedBytes(@NotNull
                                                        @NotNull File file,
                                                        long chunkSize,
                                                        long overlapSize,
                                                        boolean readOnly)
                                                 throws FileNotFoundException,
                                                        IllegalStateException

Throws:: FileNotFoundException; IllegalStateException

mappedBytes

@NotNull
public static @NotNull MappedBytes mappedBytes(@NotNull
                                                        @NotNull MappedFile rw)

readOnly

@NotNull
public static @NotNull MappedBytes readOnly(@NotNull
                                                     @NotNull File file)
                                              throws FileNotFoundException

Throws:: FileNotFoundException

bytesStore
```
protected void bytesStore(BytesStore bytesStore)
```
Overrides:

bytesStore in class AbstractBytes<Void>

toString
```
@NotNull
public @NotNull String toString()
```
Specified by:

toString in interface CharSequence

Overrides:

toString in class AbstractBytes<Void>

write

@NotNull
public @NotNull MappedBytes write(@NotNull
                                           @NotNull byte[] bytes,
                                           int offset,
                                           int length)

Description copied from interface: StreamingDataOutput

Write all data or fail.

Specified by:: write in interface StreamingDataOutput<Bytes<Void>>
Overrides:: write in class AbstractBytes<Void>

write

@NotNull
public @NotNull MappedBytes write(long offsetInRDO,
                                           byte[] bytes,
                                           int offset,
                                           int length)

Specified by:: write in interface RandomDataOutput<Bytes<Void>>
Overrides:: write in class AbstractBytes<Void>

write

@NotNull
public @NotNull MappedBytes write(long writeOffset,
                                           RandomDataInput bytes,
                                           long readOffset,
                                           long length)
                                    throws BufferOverflowException,
                                           BufferUnderflowException

Specified by:: write in interface RandomDataOutput<Bytes<Void>>
Overrides:: write in class AbstractBytes<Void>
Throws:: BufferOverflowException; BufferUnderflowException

write
```
@NotNull
public @NotNull MappedBytes write(@NotNull
                                           @NotNull RandomDataInput bytes)
                                    throws BufferOverflowException
```
Description copied from interface: StreamingDataOutput

Write all data or fail.

Specified by:

write in interface StreamingDataOutput<Bytes<Void>>

Overrides:

write in class AbstractBytes<Void>

Throws:

BufferOverflowException

write

@NotNull
public @NotNull MappedBytes write(long offsetInRDO,
                                           @NotNull
                                           @NotNull RandomDataInput bytes)
                                    throws BufferOverflowException

Throws:: BufferOverflowException

setNewChunkListener

public void setNewChunkListener(NewChunkListener listener)

mappedFile

@NotNull
public @NotNull MappedFile mappedFile()

copy
```
public BytesStore<Bytes<Void>,Void> copy()
```
Specified by:

copy in interface Bytes<Void>

Specified by:

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

Returns:

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

capacity
```
public long capacity()
```
Specified by:

capacity in interface BytesStore<Bytes<Void>,Void>

Overrides:

capacity in class AbstractBytes<Void>

Returns:

The maximum limit you can set.

readLimitToCapacity

public Bytes<Void> readLimitToCapacity()
                                throws BufferUnderflowException

Throws:: BufferUnderflowException

realCapacity
```
public long realCapacity()
```
Description copied from interface: RandomDataInput

Returns the actual capacity that can be potentially read.

Specified by:

realCapacity in interface Bytes<Void>

Specified by:

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

Specified by:

realCapacity in interface RandomDataInput

Specified by:

realCapacity in interface StreamingDataOutput<Bytes<Void>>

Overrides:

realCapacity in class AbstractBytes<Void>

Returns:

the actual capacity available before resizing.

readPositionRemaining

@NotNull
public @NotNull Bytes<Void> readPositionRemaining(long position,
                                                           long remaining)
                                                    throws BufferUnderflowException

Throws:: BufferUnderflowException

readPosition

@NotNull
public @NotNull Bytes<Void> readPosition(long position)
                                           throws BufferUnderflowException

Overrides:: readPosition in class AbstractBytes<Void>
Throws:: BufferUnderflowException

addressForRead
```
public long addressForRead(long offset)
                    throws BufferUnderflowException
```
Obtain the underlying addressForRead. This is for expert users only.

Overrides:

addressForRead in class AbstractBytes<Void>

Parameters:

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

Returns:

the underlying addressForRead of the buffer

Throws:

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

addressForRead

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

Throws:: UnsupportedOperationException; BufferUnderflowException

addressForWrite
```
public long addressForWrite(long offset)
                     throws UnsupportedOperationException,
                            BufferOverflowException
```
Obtain the underlying addressForRead. This is for expert users only.

Overrides:

addressForWrite in class AbstractBytes<Void>

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

readCheckOffset

protected void readCheckOffset(long offset,
                               long adding,
                               boolean given)
                        throws BufferUnderflowException

Throws:: BufferUnderflowException

read8bit

@Nullable
public @Nullable String read8bit()
                                    throws net.openhft.chronicle.core.io.IORuntimeException,
                                           BufferUnderflowException

Throws:: net.openhft.chronicle.core.io.IORuntimeException; BufferUnderflowException

writeCheckOffset

protected void writeCheckOffset(long offset,
                                long adding)
                         throws BufferOverflowException

Throws:: BufferOverflowException

ensureCapacity
```
public void ensureCapacity(long size)
                    throws IllegalArgumentException
```
Description copied from interface: Bytes

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

Specified by:

ensureCapacity in interface Bytes<Void>

Parameters:

size - the capacity that you required

Throws:

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

readSkip
```
@NotNull
public @NotNull Bytes<Void> readSkip(long bytesToSkip)
                                       throws BufferUnderflowException
```
Description copied from interface: StreamingDataInput

Skip a number of bytes by moving the readPosition. Must be less than or equal to the readLimit.

Overrides:

readSkip in class AbstractBytes<Void>

Parameters:

bytesToSkip - bytes to skip.

Returns:

this

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

bytesStore
```
@NotNull
public @NotNull MappedBytesStore bytesStore()
```
Specified by:

bytesStore in interface Bytes<Void>

Specified by:

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

Overrides:

bytesStore in class AbstractBytes<Void>

Returns:

the ByteStore this Bytes wraps.

start
```
public long start()
```
Overrides:

start in class AbstractBytes<Void>

Returns:

The smallest position allowed in this buffer.

writePosition
```
@NotNull
public @NotNull Bytes<Void> writePosition(long position)
                                            throws BufferOverflowException
```
Specified by:

writePosition in interface StreamingDataOutput<Bytes<Void>>

Overrides:

writePosition in class AbstractBytes<Void>

Throws:

BufferOverflowException

clear
```
@NotNull
public @NotNull Bytes<Void> clear()
```
Description copied from interface: StreamingCommon

Set the readPosition= writePosition = start, writeLimit = capacity

Specified by:

clear in interface Bytes<Void>

Specified by:

clear in interface StreamingCommon<Bytes<Void>>

Overrides:

clear in class AbstractBytes<Void>

Returns:

this

writeByte
```
@NotNull
public @NotNull Bytes<Void> writeByte(byte i8)
                                        throws BufferOverflowException
```
Specified by:

writeByte in interface StreamingDataOutput<Bytes<Void>>

Overrides:

writeByte in class AbstractBytes<Void>

Throws:

BufferOverflowException

performRelease
```
protected void performRelease()
                       throws IllegalStateException
```
Overrides:

performRelease in class AbstractBytes<Void>

Throws:

IllegalStateException

performReleaseInBackground
```
protected boolean performReleaseInBackground()
```
Overrides:

performReleaseInBackground in class net.openhft.chronicle.core.io.AbstractReferenceCounted

isElastic
```
public boolean isElastic()
```
Description copied from interface: Bytes

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

Specified by:

isElastic in interface Bytes<Void>

Returns:

if this Bytes is elastic

isBackingFileReadOnly

public boolean isBackingFileReadOnly()

write

@NotNull
public @NotNull Bytes<Void> write(@NotNull
                                           @NotNull RandomDataInput bytes,
                                           long offset,
                                           long length)
                                    throws BufferUnderflowException,
                                           BufferOverflowException

Description copied from interface: StreamingDataOutput

Write all data or fail.

Specified by:: write in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferUnderflowException; BufferOverflowException

write

@NotNull
public @NotNull Bytes<Void> write(@NotNull
                                           @NotNull BytesStore bytes,
                                           long offset,
                                           long length)
                                    throws BufferUnderflowException,
                                           BufferOverflowException

Description copied from interface: StreamingDataOutput

Write all data or fail.

Specified by:: write in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferUnderflowException; BufferOverflowException

append8bit

@NotNull
public @NotNull Bytes<Void> append8bit(@NotNull
                                                @NotNull CharSequence cs,
                                                int start,
                                                int end)
                                         throws IllegalArgumentException,
                                                BufferOverflowException,
                                                BufferUnderflowException,
                                                IndexOutOfBoundsException

Description copied from interface: ByteStringAppender

Append a portion of a String to the Bytes in ISO-8859-1

Specified by:: append8bit in interface ByteStringAppender<Bytes<Void>>
Parameters:: cs - to copy; start - index of the first char inclusive; end - index of the last char exclusive.
Returns:: this
Throws:: BufferOverflowException - If the string as too large to write in the capacity available; BufferUnderflowException - if the capacity of the underlying buffer was exceeded; IndexOutOfBoundsException - if the start or the end are not valid for the CharSequence; IllegalArgumentException

write8bit

@NotNull
public @NotNull MappedBytes write8bit(@NotNull
                                               @NotNull CharSequence s,
                                               int start,
                                               int length)

Specified by:: write8bit in interface StreamingDataOutput<Bytes<Void>>

appendUtf8

@NotNull
public @NotNull Bytes<Void> appendUtf8(@NotNull
                                                @NotNull CharSequence cs,
                                                int start,
                                                int length)
                                         throws BufferOverflowException,
                                                IllegalArgumentException

Specified by:: appendUtf8 in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalArgumentException

sharedMemory
```
public boolean sharedMemory()
```
Specified by:

sharedMemory in interface Bytes<Void>

Returns:

true if these Bytes use shared memory.

writeOrderedInt
```
@NotNull
public @NotNull Bytes<Void> writeOrderedInt(long offset,
                                                     int i)
                                              throws BufferOverflowException
```
Description copied from interface: RandomDataOutput

Perform a non stalling write with a store barrier.

Specified by:

writeOrderedInt in interface RandomDataOutput<Bytes<Void>>

Overrides:

writeOrderedInt in class AbstractBytes<Void>

Parameters:

offset - to write to

i - value to write

Returns:

this

Throws:

BufferOverflowException - if the capacity was exceeded

readVolatileByte
```
public byte readVolatileByte(long offset)
                      throws BufferUnderflowException
```
Description copied from interface: RandomDataInput

Read a 8-bit byte from memory with a load barrier.

Specified by:

readVolatileByte in interface RandomDataInput

Overrides:

readVolatileByte in class AbstractBytes<Void>

Parameters:

offset - to read

Returns:

the byte value

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readVolatileShort
```
public short readVolatileShort(long offset)
                        throws BufferUnderflowException
```
Description copied from interface: RandomDataInput

Read a 16-bit short from memory with a load barrier.

Specified by:

readVolatileShort in interface RandomDataInput

Overrides:

readVolatileShort in class AbstractBytes<Void>

Parameters:

offset - to read

Returns:

the short value

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readVolatileInt
```
public int readVolatileInt(long offset)
                    throws BufferUnderflowException
```
Description copied from interface: RandomDataInput

Read a 32-bit int from memory with a load barrier.

Specified by:

readVolatileInt in interface RandomDataInput

Overrides:

readVolatileInt in class AbstractBytes<Void>

Parameters:

offset - to read

Returns:

the int value

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readVolatileLong
```
public long readVolatileLong(long offset)
                      throws BufferUnderflowException
```
Description copied from interface: RandomDataInput

Read a 64-bit long from memory with a load barrier.

Specified by:

readVolatileLong in interface RandomDataInput

Overrides:

readVolatileLong in class AbstractBytes<Void>

Parameters:

offset - to read

Returns:

the long value

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

peekUnsignedByte
```
public int peekUnsignedByte()
```
Overrides:

peekUnsignedByte in class AbstractBytes<Void>

peekUnsignedByte
```
public int peekUnsignedByte(long offset)
                     throws BufferUnderflowException
```
Description copied from interface: RandomDataInput

Read an unsigned byte at an offset, or -1

Specified by:

peekUnsignedByte in interface RandomDataInput

Overrides:

peekUnsignedByte in class AbstractBytes<Void>

Parameters:

offset - to read

Returns:

the unsigned byte or -1

Throws:

BufferUnderflowException

peekVolatileInt
```
public int peekVolatileInt()
```
Specified by:

peekVolatileInt in interface RandomDataInput

release
```
public void release(net.openhft.chronicle.core.io.ReferenceOwner id)
             throws IllegalStateException
```
Specified by:

release in interface net.openhft.chronicle.core.io.ReferenceCounted

Overrides:

release in class net.openhft.chronicle.core.io.AbstractReferenceCounted

Throws:

IllegalStateException

releaseLast
```
public void releaseLast(net.openhft.chronicle.core.io.ReferenceOwner id)
                 throws IllegalStateException
```
Specified by:

releaseLast in interface net.openhft.chronicle.core.io.ReferenceCounted

Overrides:

releaseLast in class net.openhft.chronicle.core.io.AbstractReferenceCounted

Throws:

IllegalStateException

close
```
public void close()
```
Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable

isClosed
```
public boolean isClosed()
```
Specified by:

isClosed in interface net.openhft.chronicle.core.io.QueryCloseable

writeUtf8
```
@NotNull
public @NotNull Bytes<Void> writeUtf8(CharSequence str)
                                        throws BufferOverflowException
```
Description copied from interface: StreamingDataOutput

Write the same encoding as writeUTF with the following changes. 1) The length is stop bit encoded i.e. one byte longer for short strings, but is not limited in length. 2) The string can be null.

Specified by:

writeUtf8 in interface StreamingDataOutput<Bytes<Void>>

Parameters:

str - the string value to be written. Can be null.

Throws:

BufferOverflowException - if there is not enough space left

writeUtf8

@NotNull
public @NotNull Bytes<Void> writeUtf8(String str)
                                        throws BufferOverflowException

Specified by:: writeUtf8 in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException

appendUtf8

@NotNull
public @NotNull Bytes<Void> appendUtf8(char[] chars,
                                                int offset,
                                                int length)
                                         throws BufferOverflowException,
                                                IllegalArgumentException

Specified by:: appendUtf8 in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalArgumentException

readStopBit

public long readStopBit()
                 throws net.openhft.chronicle.core.io.IORuntimeException

Throws:: net.openhft.chronicle.core.io.IORuntimeException

readStopBitChar

public char readStopBitChar()
                     throws net.openhft.chronicle.core.io.IORuntimeException

Throws:: net.openhft.chronicle.core.io.IORuntimeException

writeStopBit
```
@NotNull
public @NotNull Bytes<Void> writeStopBit(long n)
                                           throws BufferOverflowException
```
Description copied from interface: StreamingDataOutput

Write a stop bit encoded long

Specified by:

writeStopBit in interface StreamingDataOutput<Bytes<Void>>

Parameters:

n - long to write

Returns:

this.

Throws:

BufferOverflowException

writeStopBit

@NotNull
public @NotNull Bytes<Void> writeStopBit(char n)
                                           throws BufferOverflowException

Specified by:: writeStopBit in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException

isDirectMemory
```
public boolean isDirectMemory()
```
Specified by:

isDirectMemory in interface BytesStore<Bytes<Void>,Void>

Overrides:

isDirectMemory in class AbstractBytes<Void>

Returns:

whether it uses direct memory or not.

write8bit

@NotNull
public @NotNull MappedBytes write8bit(@Nullable
                                               @Nullable BytesStore bs)
                                        throws BufferOverflowException

Specified by:: write8bit in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException

compareAndSwapLong
```
public boolean compareAndSwapLong(long offset,
                                  long expected,
                                  long value)
                           throws BufferOverflowException
```
Perform a 64-bit CAS at a given offset.

Overrides:

compareAndSwapLong in class AbstractBytes<Void>

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

reader
```
@NotNull
public @NotNull Reader reader()
```
Access these bytes as an ISO-8859-1 encoded Reader

Returns:

as a Reader

parseBoolean
```
@Nullable
public @Nullable Boolean parseBoolean(@NotNull
                                                @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
public @Nullable Boolean parseBoolean()

parseUtf8
```
@NotNull
public @NotNull String parseUtf8(@NotNull
                                          @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
public @NotNull String parseUTF(@NotNull
                                                      @NotNull StopCharTester stopCharTester)

Deprecated.

parseUtf8

public void parseUtf8(@NotNull
                      @NotNull Appendable buffer,
                      @NotNull
                      @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
public void parseUTF(@NotNull
                                 @NotNull Appendable buffer,
                                 @NotNull
                                 @NotNull StopCharTester stopCharTester)
                          throws BufferUnderflowException

Deprecated.

Throws:: BufferUnderflowException

parseUtf8

public void parseUtf8(@NotNull
                      @NotNull Appendable buffer,
                      @NotNull
                      @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
public void parseUTF(@NotNull
                                 @NotNull Appendable buffer,
                                 @NotNull
                                 @NotNull StopCharsTester stopCharsTester)
                          throws BufferUnderflowException,
                                 net.openhft.chronicle.core.io.IORuntimeException

Deprecated.

Throws:: BufferUnderflowException; net.openhft.chronicle.core.io.IORuntimeException

parse8bit

public void parse8bit(Appendable buffer,
                      @NotNull
                      @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
```
public String parse8bit(@NotNull
                        @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

public void parse8bit(Appendable buffer,
                      @NotNull
                      @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

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

Throws:: BufferUnderflowException

parse8bit

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

Throws:: BufferUnderflowException

parseInt
```
public int parseInt()
             throws BufferUnderflowException
```
parse text as an int. The terminating character is consumed.

Returns:

an int.

Throws:

BufferUnderflowException

parseLong
```
public long parseLong()
               throws BufferUnderflowException
```
parse text as a long integer. The terminating character is consumed.

Returns:

a long.

Throws:

BufferUnderflowException

parseFloat
```
public 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
```
public 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
```
public 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

skipTo
```
public boolean skipTo(@NotNull
                      @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
public @NotNull BigDecimal parseBigDecimal()

readRemaining
```
public long readRemaining()
```
Returns:

How many more bytes can we read.

writeRemaining
```
public long writeRemaining()
```
Returns:

How many more bytes can we written.

byteOrder
```
public ByteOrder byteOrder()
```

compareAndSwapFloat

public 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

public 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

Class MappedBytes

Field Summary

Fields inherited from class net.openhft.chronicle.bytes.AbstractBytes

Fields inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted

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

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

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

Fields inherited from interface net.openhft.chronicle.core.io.ReferenceOwner

Constructor Summary

Method Summary

Methods inherited from class net.openhft.chronicle.bytes.AbstractBytes

Methods inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted

Methods inherited from class java.lang.Object

Methods inherited from interface net.openhft.chronicle.core.io.Closeable

Methods inherited from interface net.openhft.chronicle.core.io.QueryCloseable

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

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

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

Methods inherited from interface java.lang.CharSequence

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

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

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

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

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.core.io.ReferenceCounted

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceOwner

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

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

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceCountedTracer

Constructor Detail

MappedBytes

MappedBytes

Method Detail

mappedBytes

mappedBytes

mappedBytes

mappedBytes

mappedBytes

readOnly

bytesStore

toString

write

write

write

write

write

setNewChunkListener

mappedFile

copy

capacity

readLimitToCapacity

realCapacity

readPositionRemaining

readPosition

addressForRead

addressForRead

addressForWrite

readCheckOffset

read8bit

writeCheckOffset

ensureCapacity

readSkip

bytesStore

start

writePosition

clear

writeByte

performRelease

performReleaseInBackground

isElastic

isBackingFileReadOnly

write

write

append8bit

write8bit

appendUtf8

sharedMemory

writeOrderedInt

readVolatileByte