MappedNativeBytes (OpenHFT/Java-Lang/lang 6.8.19-SNAPSHOT API)

java.lang.Object
- net.openhft.lang.io.AbstractBytes
- - net.openhft.lang.io.MappedNativeBytes

All Implemented Interfaces:

DataInput, DataOutput, ObjectInput, ObjectOutput, Appendable, AutoCloseable, CharSequence, RandomAccess, Bytes, BytesCommon, BytesStore, ByteStringAppender, ByteStringParser, RandomDataInput, RandomDataOutput, RandomDataUpdate, BytesMarshallable, ReferenceCounted
```
public class MappedNativeBytes
extends AbstractBytes
```
works in conjunction with a MappedFile to map additional memory blocks when required This implementation is very similar to NativeBytes, accept that the memory address resolution is left to ChronicleUnsafe, rather than being part of this class.

Field Summary

Fields
Modifier and Type	Field and Description
`protected long`	`capacity`
`protected long`	`limit`
`protected long`	`position`
`protected long`	`start`
`ThreadLocal<ChronicleUnsafe>`	`threadLocal`

Fields inherited from class net.openhft.lang.io.AbstractBytes
END_OF_BUFFER, finished, SLEEP_THRESHOLD, UNSIGNED_INT_MASK

Constructor Summary

Constructors
Constructor and Description
`MappedNativeBytes(MappedFile mappedFile, boolean isSingleThreaded)`
`MappedNativeBytes(ObjectSerializer objectSerializer, long sliceStart, long capacity, AtomicInteger refCount, MappedFile mappedFile, boolean singleThreaded)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`long`	`address()`
`void`	`alignPositionAddr(int powerOf2)` Align the position address to a power of 2.
`ByteOrder`	`byteOrder()`
`MappedNativeBytes`	`bytes()` Create a bytes whose content is the whole bytes store.
`MappedNativeBytes`	`bytes(long offset, long length)` Slice a `Bytes` object with start address of `address+ offset` and capacity of `length`.
`long`	`capacity()`
`void`	`checkEndOfBuffer()`
`protected void`	`cleanup()`
`boolean`	`compare(long offset, RandomDataInput input, long inputOffset, long len)`
`boolean`	`compareAndSwapInt(long offset, int expected, int x)` Perform a compare and set operation.
`boolean`	`compareAndSwapLong(long offset, long expected, long x)` Perform a compare and set operation.
`ChronicleUnsafe`	`getChronicleUnsafe()`
`MappedNativeBytes`	`lazyPosition(long position)` Change the position acknowleging there is no thread safety assumptions.
`long`	`limit()`
`MappedNativeBytes`	`limit(long limit)`
`Bytes`	`load()` Access every page to ensure those pages are in memory.
`long`	`position()`
`MappedNativeBytes`	`position(long position)`
`long`	`positionAddr()`
`void`	`positionAddr(long positionAddr)`
`int`	`read(byte[] bytes, int off, int len)` Reads into an array of bytes.
`byte`	`readByte()` Reads and returns one input byte.
`byte`	`readByte(long offset)` Reads and returns one input byte.
`char`	`readChar()` Reads two input bytes and returns a `char` value.
`char`	`readChar(long offset)` Reads two input bytes and returns a `char` value.
`double`	`readDouble()` Reads eight input bytes and returns a `double` value.
`double`	`readDouble(long offset)` Reads eight input bytes and returns a `double` value.
`float`	`readFloat()` Reads four input bytes and returns a `float` value.
`float`	`readFloat(long offset)` Reads four input bytes and returns a `float` value.
`void`	`readFully(byte[] b, int off, int len)` Reads `len` bytes from an input stream.
`void`	`readFully(char[] data, int off, int len)`
`void`	`readFully(long offset, byte[] bytes, int off, int len)`
`int`	`readInt()` Reads four input bytes and returns an `int` value.
`int`	`readInt(long offset)` Reads four input bytes and returns an `int` value.
`long`	`readLong()` Reads eight input bytes and returns a `long` value.
`long`	`readLong(long offset)` Reads eight input bytes and returns a `long` value.
`void`	`readObject(Object object, int start, int end)` Read the object from start to end bytes
`short`	`readShort()` Reads two input bytes and returns a `short` value.
`short`	`readShort(long offset)` Reads two input bytes and returns a `short` value.
`int`	`readVolatileInt()` This is the same as readInt() except a read barrier is performed first.
`int`	`readVolatileInt(long offset)` This is the same as readInt() except a read barrier is performed first.
`long`	`readVolatileLong()` This is the same readLong() except a dread barrier is performed first
`long`	`readVolatileLong(long offset)` This is the same readLong() except a dread barrier is performed first
`long`	`remaining()`
`MappedNativeBytes`	`slice()` Creates a new bytes whose content is a shared subsequence of this bytes' content.
`MappedNativeBytes`	`slice(long offset, long length)` Creates a new bytes whose content is a shared subsequence of this bytes' content.
`ByteBuffer`	`sliceAsByteBuffer(ByteBuffer toReuse)` Returns a `ByteBuffer` whose content is a shared subsequence of this bytes' content.
`protected ByteBuffer`	`sliceAsByteBuffer(ByteBuffer toReuse, Object att)`
`long`	`startAddr()`
`CharSequence`	`subSequence(int start, int end)`
`void`	`write(byte[] bytes, int off, int len)` Writes `len` bytes from array `bytes`, in order, to the output stream.
`void`	`write(int b)` Writes to the output stream the eight low-order bits of the argument `b`.
`void`	`write(long offset, byte[] bytes)` Writes to the output stream all the bytes in array `bytes`.
`void`	`write(long offset, byte[] bytes, int off, int len)`
`void`	`write(RandomDataInput bytes, long position, long length)` Copy from one Bytes to another, moves the position of "this" RandomDataOutput by the length.
`void`	`writeByte(long offset, int b)` Writes to the output stream the eight low-order bits of the argument `b`.
`void`	`writeChar(int v)` Writes a `char` value, which is comprised of two bytes, to the output stream.
`void`	`writeChar(long offset, int v)` Writes a `char` value, which is comprised of two bytes, to the output stream.
`void`	`writeDouble(double v)` Writes a `double` value, which is comprised of eight bytes, to the output stream.
`void`	`writeDouble(long offset, double v)` Writes a `double` value, which is comprised of eight bytes, to the output stream.
`void`	`writeFloat(float v)` Writes a `float` value, which is comprised of four bytes, to the output stream.
`void`	`writeFloat(long offset, float v)` Writes a `float` value, which is comprised of four bytes, to the output stream.
`void`	`writeInt(int v)` Writes an `int` value, which is comprised of four bytes, to the output stream.
`void`	`writeInt(long offset, int v)` Writes an `int` value, which is comprised of four bytes, to the output stream.
`void`	`writeLong(long v)` Writes a `long` value, which is comprised of eight bytes, to the output stream.
`void`	`writeLong(long offset, long v)` Writes a `long` value, which is comprised of eight bytes, to the output stream.
`void`	`writeObject(Object object, int start, int end)` Copy data from an Object from bytes start to end.
`void`	`writeOrderedInt(int v)` Same as writeInt but include an ordered write barrier.
`void`	`writeOrderedInt(long offset, int v)` Same as writeInt but include an ordered write barrier.
`void`	`writeOrderedLong(long v)` Same as writeLong but include an ordered write barrier.
`void`	`writeOrderedLong(long offset, long v)` Same as writeLong but include an ordered write barrier.
`void`	`writeShort(int v)` Writes two bytes to the output stream to represent the value of the argument.
`void`	`writeShort(long offset, int v)` Writes two bytes to the output stream to represent the value of the argument.
`Bytes`	`zeroOut()` fill the Bytes with zeros, and clear the position.
`Bytes`	`zeroOut(long start, long end)` fill the Bytes with zeros.
`Bytes`	`zeroOut(long start, long end, boolean ifNotZero)` fill the Bytes with zeros, and clear the position, avoiding touching pages unnecessarily

Methods inherited from class net.openhft.lang.io.AbstractBytes
addAndGetInt, addAtomicDouble, addAtomicFloat, addAtomicInt, addAtomicLong, addByte, addDouble, addFloat, addInt, addLong, addShort, addUnsignedByte, addUnsignedInt, addUnsignedShort, append, append, append, append, append, append, append, append, append, append, append, append, appendDateMillis, appendDateTimeMillis, appendTimeMillis, asString, asString, available, busyLockInt, busyLockLong, charAt, clear, clearThreadAssociation, close, compareAndSwapDouble, compareRest, file, findUTFLength, findUTFLength, findUTFLength, finish, flip, flush, free, getAndAdd, inputStream, isFinished, length, nextSetBit, objectSerializer, outputStream, parseBoolean, parseDecimal, parseDouble, parseEnum, parseLong, parseLong, parseUtf8, parseUtf8, read, read, read, read, read8bitText, readBoolean, readBoolean, readByteOrThrow, readCompactDouble, readCompactInt, readCompactLong, readCompactShort, readCompactUnsignedInt, readCompactUnsignedShort, readEnum, readEnum, readFully, readFully, readIncompleteLong, readInstance, readInt24, readInt24, readInt48, readInt48, readLine, readList, readMap, readMarshallable, readObject, readObject, readStopBit, readUnsignedByte, readUnsignedByte, readUnsignedByteOrThrow, readUnsignedInt, readUnsignedInt, readUnsignedShort, readUnsignedShort, readUTF, readUTF0, readUTF2, readUTF2, readUTFΔ, readUTFΔ, readUTFΔ, readVolatileDouble, readVolatileFloat, refCount, release, reserve, resetLockInt, resetLockLong, selfTerminating, selfTerminating, setObjectSerializer, size, skip, skipBytes, skipTo, startsWith, stepBackAndSkipTo, threadIdForLockInt, threadIdForLockLong, toDebugString, toDebugString, toHex, toHexString, toHexString, toString, toString, toString, tryLockInt, tryLockLong, tryLockNanosInt, tryLockNanosLong, tryRWReadLock, tryRWWriteLock, unlockInt, unlockLong, unlockRWReadLock, unlockRWWriteLock, write, write, write, write, write, write, write, write8bitText, writeBoolean, writeBoolean, writeByte, writeBytes, writeChars, writeChars, writeCompactDouble, writeCompactInt, writeCompactLong, writeCompactShort, writeCompactUnsignedInt, writeCompactUnsignedShort, writeEnum, writeEnum, writeInstance, writeInt24, writeInt24, writeInt48, writeInt48, writeList, writeMap, writeMarshallable, writeObject, writeOrderedDouble, writeOrderedFloat, writeStopBit, writeUnsignedByte, writeUnsignedByte, writeUnsignedInt, writeUnsignedInt, writeUnsignedShort, writeUnsignedShort, writeUTF, writeUTF0, writeUTF1, writeUTFΔ, writeUTFΔ

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

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

- Field Detail
  - threadLocal
```
@NotNull
public final ThreadLocal<ChronicleUnsafe> threadLocal
```
  - start
```
protected long start
```
  - position
```
protected long position
```
  - limit
```
protected long limit
```
  - capacity
```
protected long capacity
```
- Constructor Detail
  - MappedNativeBytes
```
public MappedNativeBytes(@NotNull
                         MappedFile mappedFile,
                         boolean isSingleThreaded)
```
  - MappedNativeBytes
```
public MappedNativeBytes(ObjectSerializer objectSerializer,
                         long sliceStart,
                         long capacity,
                         @NotNull
                         AtomicInteger refCount,
                         @NotNull
                         MappedFile mappedFile,
                         boolean singleThreaded)
```
- Method Detail
  - slice
```
public MappedNativeBytes slice()
```
    Description copied from interface: BytesCommon
    
    Creates a new bytes whose content is a shared subsequence of this bytes' content.
    The content of the new bytes will start at this bytes' current position. Changes to this bytes' content will be visible in the new bytes, and vice versa; the two bytes' position and limit values will be independent.
    The new bytes' position will be zero, its capacity and its limit will be the number of bytes remaining in this bytes.
    slice() is equivalent of slice(0, remaining()).
    
    Returns:
    
    the new bytes
    
    See Also:
    
    BytesCommon.slice(long, long)
  - slice
```
public MappedNativeBytes slice(long offset,
                               long length)
```
    Description copied from interface: BytesCommon
    
    Creates a new bytes whose content is a shared subsequence of this bytes' content.
    The content of the new bytes will start at this bytes' current BytesCommon.position()+ offset. Changes to this bytes' content will be visible in the new bytes, and vice versa; the two bytes' position and limit values will be independent.
    The new bytes' position will be zero, its capacity and its limit will be equal to length.
    offset can be negative (if current bytes' position is positive) and length can run out of current bytes' limit, the restriction is that new bytes' should be within this bytes' absolute bounds.
    
    Parameters:
    
    offset - relative offset of the new bytes from the current bytes' position
    
    length - capacity of the new bytes
    
    Returns:
    
    the new bytes
    
    See Also:
    
    BytesCommon.slice()
  - subSequence
```
public CharSequence subSequence(int start,
                                int end)
```
  - bytes
```
public MappedNativeBytes bytes()
```
    Description copied from interface: BytesStore
    
    Create a bytes whose content is the whole bytes store. Call of this method is equivalent to bytes(0, size()) call.
    
    Returns:
    
    the new bytes
    
    See Also:
    
    BytesStore.bytes(long, long)
  - bytes
```
public MappedNativeBytes bytes(long offset,
                               long length)
```
    Description copied from interface: BytesStore
    
    Slice a Bytes object with start address of address+ offset and capacity of length.
    If this BytesStore is Bytes itself rather than natural BytesStore object, this method will offset the new bytes from the bytes' start, not from bytes' position like BytesCommon.slice(long, long).
    offset should be non-negative, length should be positive, offset + length should be less or equal to size.
    
    Parameters:
    
    offset - offset of the new bytes from the bytes store address
    
    length - capacity and limit of the new bytes
    
    Returns:
    
    the sliced Bytes
    
    See Also:
    
    BytesStore.bytes()
  - address
```
public long address()
```
  - zeroOut
```
public Bytes zeroOut()
```
    Description copied from interface: RandomDataOutput
    
    fill the Bytes with zeros, and clear the position.
    
    Returns:
    
    this
  - zeroOut
```
public Bytes zeroOut(long start,
                     long end)
```
    Description copied from interface: RandomDataOutput
    
    fill the Bytes with zeros.
    
    Parameters:
    
    start - first byte to zero out
    
    end - the first byte after the last to zero out (exclusive bound)
    
    Returns:
    
    this
  - zeroOut
```
public Bytes zeroOut(long start,
                     long end,
                     boolean ifNotZero)
```
    Description copied from interface: RandomDataOutput
    
    fill the Bytes with zeros, and clear the position, avoiding touching pages unnecessarily
    
    Parameters:
    
    start - first byte to zero out
    
    end - the first byte after the last to zero out (exclusive bound)
    
    ifNotZero - only set to zero after checking the value is not zero.
    
    Returns:
    
    this
  - read
```
public int read(@NotNull
                byte[] bytes,
                int off,
                int len)
```
    Description copied from interface: RandomDataInput
    
    Reads into an array of bytes. This method will block until some input is available.
    
    Specified by:
    
    read in interface ObjectInput
    
    Specified by:
    
    read in interface RandomDataInput
    
    Specified by:
    
    read in class AbstractBytes
    
    Parameters:
    
    bytes - the buffer into which the data is read
    
    off - the start offset of the data
    
    len - the maximum number of bytes read
    
    Returns:
    
    the actual number of bytes read, -1 is returned when the end of the stream is reached.
  - readByte
```
public byte readByte()
```
    Description copied from interface: RandomDataInput
    
    Reads and returns one input byte. The byte is treated as a signed value in the range -128 through 127, inclusive. This method is suitable for reading the byte written by the writeByte method of interface DataOutput.
    
    Returns:
    
    the 8-bit value read.
  - readByte
```
public byte readByte(long offset)
```
    Description copied from interface: RandomDataInput
    
    Reads and returns one input byte. The byte is treated as a signed value in the range -128 through 127, inclusive. This method is suitable for reading the byte written by the writeByte method of interface RandomDataOutput.
    
    Parameters:
    
    offset - of byte to read.
    
    Returns:
    
    the 8-bit value read.
  - readFully
```
public void readFully(@NotNull
                      byte[] b,
                      int off,
                      int len)
```
    Description copied from interface: RandomDataInput
    Reads len bytes from an input stream.
    This method blocks until one of the following conditions occurs:
    - len bytes of input data are available, in which case a normal return is made.
    - End of file is detected, in which case an EOFException is thrown.
    - An I/O error occurs, in which case an IOException other than EOFException is thrown.
    If bytes is null, a NullPointerException is thrown. If off is negative, or len is negative, or off+len is greater than the length of the array bytes, then an IndexOutOfBoundsException is thrown. If len is zero, then no bytes are read. Otherwise, the first byte read is stored into element bytes[off], the next one into bytes[off+1], and so on. The number of bytes read is, at most, equal to len.
    Parameters:
    
    b - the buffer into which the data is read.
    
    off - an int specifying the offset into the data.
    
    len - an int specifying the number of bytes to read.
  - readFully
```
public void readFully(long offset,
                      byte[] bytes,
                      int off,
                      int len)
```
  - readFully
```
public void readFully(@NotNull
                      char[] data,
                      int off,
                      int len)
```
  - readShort
```
public short readShort()
```
    Description copied from interface: RandomDataInput
    Reads two input bytes and returns a short value. Let a be the first byte read and b be the second byte on big endian machines, and the opposite on little endian machines. The value returned is:
```
(short)((a << 8) | (b & 0xff))
 
```
    This method is suitable for reading the bytes written by the writeShort method of interface DataOutput.
    Returns:
    
    the 16-bit value read.
  - readShort
```
public short readShort(long offset)
```
    Description copied from interface: RandomDataInput
    Reads two input bytes and returns a short value. Let a be the first byte read and b be the second byte on big endian machines, and the opposite on little endian machines. The value returned is:
```
     (short)((a << 8) | (b & 0xff))
 
```
    This method is suitable for reading the bytes written by the writeShort method of interface RandomDataOutput.
    Parameters:
    
    offset - of short to read.
    
    Returns:
    
    the 16-bit value read.
  - readChar
```
public char readChar()
```
    Description copied from interface: RandomDataInput
    Reads two input bytes and returns a char value. Let a be the first byte read and b be the second byte on big endian machines, and the opposite on little endian machines. The value returned is:
```
(char)((a << 8) | (b & 0xff))
 
```
    This method is suitable for reading bytes written by the writeChar method of interface DataOutput.
    Returns:
    
    the char value read.
  - readChar
```
public char readChar(long offset)
```
    Description copied from interface: RandomDataInput
    Reads two input bytes and returns a char value. Let a be the first byte read and b be the second byte on big endian machines, and the opposite on little endian machines. The value returned is:
```
(char)((a << 8) | (b & 0xff))
 
```
    This method is suitable for reading bytes written by the writeChar method of interface RandomDataOutput.
    Parameters:
    
    offset - of the char to read.
    
    Returns:
    
    the char value read.
  - readInt
```
public int readInt()
```
    Description copied from interface: RandomDataInput
    Reads four input bytes and returns an int value. Let a-d be the first through fourth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((a & 0xff) << 24) | ((b & 0xff) << 16) | ((c & 0xff) << 8) | (d & 0xff))
 
```
    This method is suitable for reading bytes written by the writeInt method of interface DataOutput.
    Returns:
    
    the int value read.
  - readInt
```
public int readInt(long offset)
```
    Description copied from interface: RandomDataInput
    Reads four input bytes and returns an int value. Let a-d be the first through fourth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((a & 0xff) << 24) | ((b & 0xff) << 16) | ((c & 0xff) << 8) | (d & 0xff))
 
```
    This method is suitable for reading bytes written by the writeInt method of interface RandomDataOutput.
    Parameters:
    
    offset - to read from
    
    Returns:
    
    the int value read.
  - readVolatileInt
```
public int readVolatileInt()
```
    Description copied from interface: RandomDataInput
    This is the same as readInt() except a read barrier is performed first.
    Reads four input bytes and returns an int value. Let a-d be the first through fourth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((a & 0xff) << 24) | ((b & 0xff) << 16) | ((c & 0xff) << 8) | (d & 0xff))
 
```
    This method is suitable for reading bytes written by the writeOrderedInt or writeVolatileInt method of interface RandomDataOutput.
    Returns:
    
    the int value read.
  - readVolatileInt
```
public int readVolatileInt(long offset)
```
    Description copied from interface: RandomDataInput
    This is the same as readInt() except a read barrier is performed first.
    Reads four input bytes and returns an int value. Let a-d be the first through fourth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((a & 0xff) << 24) | ((b & 0xff) << 16) | ((c & 0xff) << 8) | (d & 0xff))
 
```
    This method is suitable for reading bytes written by the writeOrderedInt or writeVolatileInt method of interface RandomDataOutput.
    Parameters:
    
    offset - to read from
    
    Returns:
    
    the int value read.
  - readLong
```
public long readLong()
```
    Description copied from interface: RandomDataInput
    Reads eight input bytes and returns a long value. Let a-h be the first through eighth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((long)(a & 0xff) << 56) |
  ((long)(b & 0xff) << 48) |
  ((long)(c & 0xff) << 40) |
  ((long)(d & 0xff) << 32) |
  ((long)(e & 0xff) << 24) |
  ((long)(f & 0xff) << 16) |
  ((long)(g & 0xff) <<  8) |
  ((long)(h & 0xff)))
 
```
    This method is suitable for reading bytes written by the writeLong method of interface DataOutput.
    Returns:
    
    the long value read.
  - readLong
```
public long readLong(long offset)
```
    Description copied from interface: RandomDataInput
    Reads eight input bytes and returns a long value. Let a-h be the first through eighth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((long)(a & 0xff) << 56) |
  ((long)(b & 0xff) << 48) |
  ((long)(c & 0xff) << 40) |
  ((long)(d & 0xff) << 32) |
  ((long)(e & 0xff) << 24) |
  ((long)(f & 0xff) << 16) |
  ((long)(g & 0xff) <<  8) |
  ((long)(h & 0xff)))
 
```
    This method is suitable for reading bytes written by the writeLong method of interface RandomDataOutput.
    Parameters:
    
    offset - of the long to read
    
    Returns:
    
    the long value read.
  - readVolatileLong
```
public long readVolatileLong()
```
    Description copied from interface: RandomDataInput
    This is the same readLong() except a dread barrier is performed first
    Reads eight input bytes and returns a long value. Let a-h be the first through eighth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((long)(a & 0xff) << 56) |
  ((long)(b & 0xff) << 48) |
  ((long)(c & 0xff) << 40) |
  ((long)(d & 0xff) << 32) |
  ((long)(e & 0xff) << 24) |
  ((long)(f & 0xff) << 16) |
  ((long)(g & 0xff) <<  8) |
  ((long)(h & 0xff)))
 
```
    This method is suitable for reading bytes written by the writeOrderedLong or writeVolatileLong method of interface RandomDataOutput.
    Returns:
    
    the long value read.
  - readVolatileLong
```
public long readVolatileLong(long offset)
```
    Description copied from interface: RandomDataInput
    This is the same readLong() except a dread barrier is performed first
    Reads eight input bytes and returns a long value. Let a-h be the first through eighth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((long)(a & 0xff) << 56) |
  ((long)(b & 0xff) << 48) |
  ((long)(c & 0xff) << 40) |
  ((long)(d & 0xff) << 32) |
  ((long)(e & 0xff) << 24) |
  ((long)(f & 0xff) << 16) |
  ((long)(g & 0xff) <<  8) |
  ((long)(h & 0xff)))
 
```
    This method is suitable for reading bytes written by the writeOrderedLong or writeVolatileLong method of interface RandomDataOutput.
    Parameters:
    
    offset - of the long to read
    
    Returns:
    
    the long value read.
  - readFloat
```
public float readFloat()
```
    Description copied from interface: RandomDataInput
    
    Reads four input bytes and returns a float value. It does this by first constructing an int value in exactly the manner of the readInt method, then converting this int value to a float in exactly the manner of the method Float.intBitsToFloat. This method is suitable for reading bytes written by the writeFloat method of interface DataOutput.
    
    Returns:
    
    the float value read.
  - readFloat
```
public float readFloat(long offset)
```
    Description copied from interface: RandomDataInput
    
    Reads four input bytes and returns a float value. It does this by first constructing an int value in exactly the manner of the readInt method, then converting this int value to a float in exactly the manner of the method Float.intBitsToFloat. This method is suitable for reading bytes written by the writeFloat method of interface DataOutput.
    
    Parameters:
    
    offset - to read from
    
    Returns:
    
    the float value read.
  - readDouble
```
public double readDouble()
```
    Description copied from interface: RandomDataInput
    
    Reads eight input bytes and returns a double value. It does this by first constructing a long value in exactly the manner of the readLong method, then converting this long value to a double in exactly the manner of the method Double.longBitsToDouble. This method is suitable for reading bytes written by the writeDouble method of interface DataOutput.
    
    Returns:
    
    the double value read.
  - readDouble
```
public double readDouble(long offset)
```
    Description copied from interface: RandomDataInput
    
    Reads eight input bytes and returns a double value. It does this by first constructing a long value in exactly the manner of the readLong method, then converting this long value to a double in exactly the manner of the method Double.longBitsToDouble. This method is suitable for reading bytes written by the writeDouble method of interface DataOutput.
    
    Parameters:
    
    offset - to read from
    
    Returns:
    
    the double value read.
  - write
```
public void write(int b)
```
    Description copied from interface: RandomDataOutput
    
    Writes to the output stream the eight low-order bits of the argument b. The 24 high-order bits of b are ignored.
    
    Parameters:
    
    b - the byte to be written.
  - writeByte
```
public void writeByte(long offset,
                      int b)
```
    Description copied from interface: RandomDataOutput
    
    Writes to the output stream the eight low-order bits of the argument b. The 24 high-order bits of b are ignored.
    
    Parameters:
    
    offset - to write byte
    
    b - the byte to be written.
  - write
```
public void write(long offset,
                  @NotNull
                  byte[] bytes)
```
    Description copied from interface: RandomDataOutput
    
    Writes to the output stream all the bytes in array bytes. If bytes is null, a NullPointerException is thrown. If bytes.length is zero, then no bytes are written. Otherwise, the byte bytes[0] is written first, then bytes[1], and so on; the last byte written is bytes[bytes.length-1].
    
    Specified by:
    
    write in interface RandomDataOutput
    
    Overrides:
    
    write in class AbstractBytes
    
    Parameters:
    
    offset - to be written
    
    bytes - the data.
  - write
```
public void write(byte[] bytes,
                  int off,
                  int len)
```
    Description copied from interface: RandomDataOutput
    
    Writes len bytes from array bytes, in order, to the output stream. If bytes is null, a NullPointerException is thrown. If off is negative, or len is negative, or off+len is greater than the length of the array bytes, then an IndexOutOfBoundsException is thrown. If len is zero, then no bytes are written. Otherwise, the byte bytes[off] is written first, then bytes[off+1], and so on; the last byte written is bytes[off+len-1].
    
    Specified by:
    
    write in interface DataOutput
    
    Specified by:
    
    write in interface ObjectOutput
    
    Specified by:
    
    write in interface RandomDataOutput
    
    Overrides:
    
    write in class AbstractBytes
    
    Parameters:
    
    bytes - the data.
    
    off - the start offset in the data.
    
    len - the number of bytes to write.
  - write
```
public void write(long offset,
                  byte[] bytes,
                  int off,
                  int len)
```
    Specified by:
    
    write in interface RandomDataOutput
    
    Overrides:
    
    write in class AbstractBytes
  - writeShort
```
public void writeShort(int v)
```
    Description copied from interface: RandomDataOutput
    Writes two bytes to the output stream to represent the value of the argument. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 8))
 (byte)(0xff & v)
  
```
    The bytes written by this method may be read by the readShort method of interface DataInput , which will then return a short equal to (short)v.
    Parameters:
    
    v - the short value to be written.
  - writeShort
```
public void writeShort(long offset,
                       int v)
```
    Description copied from interface: RandomDataOutput
    Writes two bytes to the output stream to represent the value of the argument. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 8))
 (byte)(0xff & v)
  
```
    The bytes written by this method may be read by the readShort method of interface DataInput , which will then return a short equal to (short)v.
    Parameters:
    
    offset - to be written to
    
    v - the short value to be written.
  - writeChar
```
public void writeChar(int v)
```
    Description copied from interface: RandomDataOutput
    Writes a char value, which is comprised of two bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readChar method of interface DataInput , which will then return a char equal to (char)v.
    Parameters:
    
    v - the char value to be written.
  - writeChar
```
public void writeChar(long offset,
                      int v)
```
    Description copied from interface: RandomDataOutput
    Writes a char value, which is comprised of two bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readChar method of interface DataInput , which will then return a char equal to (char)v.
    Parameters:
    
    offset - to be written to
    
    v - the char value to be written.
  - writeInt
```
public void writeInt(int v)
```
    Description copied from interface: RandomDataOutput
    Writes an int value, which is comprised of four bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 24))
 (byte)(0xff & (v >> 16))
 (byte)(0xff & (v >>    8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readInt method of interface DataInput , which will then return an int equal to v.
    Parameters:
    
    v - the int value to be written.
  - writeInt
```
public void writeInt(long offset,
                     int v)
```
    Description copied from interface: RandomDataOutput
    Writes an int value, which is comprised of four bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 24))
 (byte)(0xff & (v >> 16))
 (byte)(0xff & (v >>    8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readInt method of interface DataInput , which will then return an int equal to v.
    Parameters:
    
    offset - to be written to
    
    v - the int value to be written.
  - writeOrderedInt
```
public void writeOrderedInt(int v)
```
    Description copied from interface: RandomDataOutput
    
    Same as writeInt but include an ordered write barrier. This means all writes will be visible on a read barrier if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read could see an old value
    This is much faster than a volatile write which stalls the pipeline. The data is visible to other threads at the same time.
    
    Parameters:
    
    v - value to write
  - writeOrderedInt
```
public void writeOrderedInt(long offset,
                            int v)
```
    Description copied from interface: RandomDataOutput
    
    Same as writeInt but include an ordered write barrier. This means all writes will be visible on a read barrier if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read could see an old value
    This is much faster than writeVolatileInt as the volatile write stalls the pipeline. The data is visible to other threads at the same time.
    
    Parameters:
    
    offset - to write to
    
    v - value to write
  - compareAndSwapInt
```
public boolean compareAndSwapInt(long offset,
                                 int expected,
                                 int x)
```
    Description copied from interface: RandomDataOutput
    
    Perform a compare and set operation. The value is set to x provided the expected value is set already. This operation is atomic.
    
    Parameters:
    
    offset - to write to.
    
    expected - to expect
    
    x - to set if expected was found
    
    Returns:
    
    true if set, false if the value was not expected
  - writeLong
```
public void writeLong(long v)
```
    Description copied from interface: RandomDataOutput
    Writes a long value, which is comprised of eight bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 56))
 (byte)(0xff & (v >> 48))
 (byte)(0xff & (v >> 40))
 (byte)(0xff & (v >> 32))
 (byte)(0xff & (v >> 24))
 (byte)(0xff & (v >> 16))
 (byte)(0xff & (v >>  8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readLong method of interface DataInput , which will then return a long equal to v.
    Parameters:
    
    v - the long value to be written.
  - writeLong
```
public void writeLong(long offset,
                      long v)
```
    Description copied from interface: RandomDataOutput
    Writes a long value, which is comprised of eight bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 56))
 (byte)(0xff & (v >> 48))
 (byte)(0xff & (v >> 40))
 (byte)(0xff & (v >> 32))
 (byte)(0xff & (v >> 24))
 (byte)(0xff & (v >> 16))
 (byte)(0xff & (v >>  8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readLong method of interface DataInput , which will then return a long equal to v.
    Parameters:
    
    offset - to be written to
    
    v - the long value to be written.
  - writeOrderedLong
```
public void writeOrderedLong(long v)
```
    Description copied from interface: RandomDataOutput
    
    Same as writeLong but include an ordered write barrier. This means all writes will be visible on a read barrier if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read could see an old value
    This is much faster than a volatile write which stalls the pipeline. The data is visible to other threads at the same time.
    
    Parameters:
    
    v - value to write
  - writeOrderedLong
```
public void writeOrderedLong(long offset,
                             long v)
```
    Description copied from interface: RandomDataOutput
    
    Same as writeLong but include an ordered write barrier. This means all writes will be visible on a read barrier if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read could see an old value
    This is much faster than a volatile write which stalls the pipeline. The data is visible to other threads at the same time.
    
    Parameters:
    
    offset - to be written to
    
    v - value to write
  - compareAndSwapLong
```
public boolean compareAndSwapLong(long offset,
                                  long expected,
                                  long x)
```
    Description copied from interface: RandomDataOutput
    
    Perform a compare and set operation. The value is set to x provided the expected value is set already. This operation is atomic.
    
    Parameters:
    
    offset - to write to.
    
    expected - to expect
    
    x - to set if expected was found
    
    Returns:
    
    true if set, false if the value was not expected
  - writeFloat
```
public void writeFloat(float v)
```
    Description copied from interface: RandomDataOutput
    
    Writes a float value, which is comprised of four bytes, to the output stream. It does this as if it first converts this float value to an int in exactly the manner of the Float.floatToIntBits method and then writes the int value in exactly the manner of the writeInt method. The bytes written by this method may be read by the readFloat method of interface DataInput, which will then return a float equal to v.
    
    Parameters:
    
    v - the float value to be written.
  - writeFloat
```
public void writeFloat(long offset,
                       float v)
```
    Description copied from interface: RandomDataOutput
    
    Writes a float value, which is comprised of four bytes, to the output stream. It does this as if it first converts this float value to an int in exactly the manner of the Float.floatToIntBits method and then writes the int value in exactly the manner of the writeInt method. The bytes written by this method may be read by the readFloat method of interface DataInput, which will then return a float equal to v.
    
    Parameters:
    
    offset - to write to
    
    v - the float value to be written.
  - writeDouble
```
public void writeDouble(double v)
```
    Description copied from interface: RandomDataOutput
    
    Writes a double value, which is comprised of eight bytes, to the output stream. It does this as if it first converts this double value to a long in exactly the manner of the Double.doubleToLongBits method and then writes the long value in exactly the manner of the writeLong method. The bytes written by this method may be read by the readDouble method of interface DataInput, which will then return a double equal to v.
    
    Parameters:
    
    v - the double value to be written.
  - writeDouble
```
public void writeDouble(long offset,
                        double v)
```
    Description copied from interface: RandomDataOutput
    
    Writes a double value, which is comprised of eight bytes, to the output stream. It does this as if it first converts this double value to a long in exactly the manner of the Double.doubleToLongBits method and then writes the long value in exactly the manner of the writeLong method. The bytes written by this method may be read by the readDouble method of interface DataInput, which will then return a double equal to v.
    
    Parameters:
    
    offset - to write to
    
    v - the double value to be written.
  - readObject
```
public void readObject(Object object,
                       int start,
                       int end)
```
    Description copied from interface: RandomDataInput
    
    Read the object from start to end bytes
    
    Parameters:
    
    object - to read into
    
    start - byte inclusive
    
    end - byte exclusive
  - writeObject
```
public void writeObject(Object object,
                        int start,
                        int end)
```
    Description copied from interface: RandomDataOutput
    
    Copy data from an Object from bytes start to end.
    
    Parameters:
    
    object - to copy from
    
    start - first byte inclusive
    
    end - last byte exclusive.
  - compare
```
public boolean compare(long offset,
                       RandomDataInput input,
                       long inputOffset,
                       long len)
```
    Specified by:
    
    compare in interface RandomDataInput
    
    Overrides:
    
    compare in class AbstractBytes
  - position
```
public long position()
```
    Returns:
    
    the offset read/written which must be >= limit()
  - position
```
public MappedNativeBytes position(long position)
```
    Parameters:
    
    position - to skip to
    
    Returns:
    
    this bytes object back
  - lazyPosition
```
public MappedNativeBytes lazyPosition(long position)
```
    Change the position acknowleging there is no thread safety assumptions. Best effort setting is fine. *
    
    Parameters:
    
    position - to set if we can.
    
    Returns:
    
    this
  - write
```
public void write(RandomDataInput bytes,
                  long position,
                  long length)
```
    Description copied from interface: RandomDataOutput
    
    Copy from one Bytes to another, moves the position of "this" RandomDataOutput by the length. The position of the RandomDataInput is not used or altered.
    
    Specified by:
    
    write in interface RandomDataOutput
    
    Overrides:
    
    write in class AbstractBytes
    
    Parameters:
    
    bytes - to copy
    
    position - to copy from
    
    length - to copy
  - capacity
```
public long capacity()
```
    Returns:
    
    space available
  - remaining
```
public long remaining()
```
    Returns:
    
    space remaining in bytes
  - limit
```
public long limit()
```
    Returns:
    
    the current limit which must be >= capacity()
  - limit
```
public MappedNativeBytes limit(long limit)
```
    Parameters:
    
    limit - the new limit which must be >= capacity()
    
    Returns:
    
    this bytes object back
  - byteOrder
```
@NotNull
public ByteOrder byteOrder()
```
    Returns:
    
    Byte order for reading binary
  - checkEndOfBuffer
```
public void checkEndOfBuffer()
                      throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException - if the bounds of the Bytes has been exceeded.
  - startAddr
```
public long startAddr()
```
  - cleanup
```
protected void cleanup()
```
    Specified by:
    
    cleanup in class AbstractBytes
  - load
```
public Bytes load()
```
    Description copied from interface: BytesCommon
    
    Access every page to ensure those pages are in memory.
    
    Returns:
    
    this.
  - alignPositionAddr
```
public void alignPositionAddr(int powerOf2)
```
    Description copied from interface: BytesCommon
    
    Align the position address to a power of 2.
    
    Parameters:
    
    powerOf2 - power of 2 to align to.
  - positionAddr
```
public void positionAddr(long positionAddr)
```
  - positionAddr
```
public long positionAddr()
```
  - sliceAsByteBuffer
```
public ByteBuffer sliceAsByteBuffer(ByteBuffer toReuse)
```
    Description copied from interface: BytesCommon
    
    Returns a ByteBuffer whose content is a shared subsequence of this bytes' content.
    The content of the returned ByteBuffer will start at this bytes' current position. Changes to this bytes' content will be visible in the returned ByteBuffer, and vice versa; this bytes' and the returned ByteBuffer's position and limit values will be independent.
    The returned ByteBuffer's position will be zero, its capacity and its limit will be the number of bytes remaining in this bytes.
    If this bytes object is able to reuse to given toReuse ByteBuffer, it will be reused and returned back from this method, otherwise a new ByteBuffer instance is created and returned.
    
    Specified by:
    
    sliceAsByteBuffer in interface BytesCommon
    
    Overrides:
    
    sliceAsByteBuffer in class AbstractBytes
    
    Parameters:
    
    toReuse - a ByteBuffer to reuse
    
    Returns:
    
    a ByteBuffer view of this Bytes
    
    See Also:
    
    BytesCommon.slice(), ByteBuffer.slice()
  - sliceAsByteBuffer
```
protected ByteBuffer sliceAsByteBuffer(ByteBuffer toReuse,
                                       Object att)
```
  - getChronicleUnsafe
```
@NotNull
public ChronicleUnsafe getChronicleUnsafe()
```

Class MappedNativeBytes

Field Summary

Fields inherited from class net.openhft.lang.io.AbstractBytes

Constructor Summary

Method Summary

Methods inherited from class net.openhft.lang.io.AbstractBytes

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.CharSequence

Field Detail

threadLocal

start

position

limit

capacity

Constructor Detail

MappedNativeBytes

MappedNativeBytes

Method Detail

slice

slice

subSequence

bytes

bytes

address

zeroOut

zeroOut

zeroOut

read

readByte

readByte

readFully

readFully

readFully

readShort

readShort

readChar

readChar

readInt

readInt

readVolatileInt

readVolatileInt

readLong

readLong

readVolatileLong

readVolatileLong

readFloat

readFloat

readDouble

readDouble

write

writeByte

write

write

write

writeShort

writeShort

writeChar

writeChar

writeInt

writeInt

writeOrderedInt

writeOrderedInt

compareAndSwapInt

writeLong

writeLong

writeOrderedLong

writeOrderedLong

compareAndSwapLong

writeFloat

writeFloat

writeDouble

writeDouble

readObject

writeObject

compare

position

position

lazyPosition

write

capacity