RandomDataInput (OpenHFT/Chronicle-Bytes 1.7.6 API)

All Known Subinterfaces:

Bytes<Underlying>, BytesStore<B,Underlying>

All Known Implementing Classes:

AbstractBytes, AbstractBytesStore, CheckingMappedBytes, ExpectedBytesStore, HeapBytesStore, MappedBytes, MappedBytesStore, NativeBytes, NativeBytesStore, NoBytesStore, PointerBytesStore, UncheckedBytes, UncheckedNativeBytes, VanillaBytes
```
public interface RandomDataInput
```
This allows random access to the underling bytes. This instance can be used across threads as it is stateless. The thread safety of the underlying data depends on how the methods are used.

Field Summary

Fields
Modifier and Type Field and Description

static String[] charToString

Fields
Modifier and Type	Field and Description
`static String[]`	`charToString`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default double`	`addAndGetDouble(long offset, double adding)` Perform an atomic add and get operation for a 64-bit double
`default float`	`addAndGetFloat(long offset, float adding)` Perform an atomic add and get operation for a 32-bit float
`default int`	`addAndGetInt(long offset, int adding)` Perform an atomic add and get operation for a 32-bit int
`default long`	`addAndGetLong(long offset, long adding)` Perform an atomic add and get operation for a 64-bit long
`long`	`address(long offset)` Obtain the underlying address.
`default ByteOrder`	`byteOrder()`
`Bytes`	`bytesForRead()`
`Bytes`	`bytesForWrite()`
`default long`	`capacity()`
`default boolean`	`compareAndSwapDouble(long offset, double expected, double value)` Perform a 64-bit double CAS at a given offset.
`default boolean`	`compareAndSwapFloat(long offset, float expected, float value)` Perform a 32-bit float CAS at a given offset.
`boolean`	`compareAndSwapInt(long offset, int expected, int value)` Perform a 32-bit CAS at a given offset.
`boolean`	`compareAndSwapLong(long offset, long expected, long value)` Perform a 64-bit CAS at a given offset.
`default boolean`	`compareUtf8(long offset, CharSequence other)` Compares the UTF-8 encoded char sequence, written in this `RandomDataInput` at the given offset, with the given char sequence.
`default int`	`copyTo(byte[] bytes)` Read a byte[] from memory.
`default int`	`copyTo(ByteBuffer bb)`
`static String[]`	`createCharToString()`
`default int`	`fastHash(long offset, int length)`
`default int`	`findByte(byte stopByte)`
`boolean`	`isDirectMemory()`
`void`	`nativeRead(long position, long address, long size)` expert level method for copying data to native memory.
`default long`	`parseLong(long offset)`
`int`	`peekUnsignedByte(long offset)` Read an unsigned byte at an offset, or -1
`default int`	`peekVolatileInt()`
`default String`	`printable(long offset)` Read the byte at an offset and converts it into a printable
`default long`	`read(long offsetInRDI, byte[] bytes, int offset, int length)`
`default boolean`	`readBoolean(long offset)` Read boolean at an offset
`byte`	`readByte(long offset)` Read byte at an offset
`double`	`readDouble(long offset)` Read a double at an offset
`float`	`readFloat(long offset)` Read a float at an offset
`default long`	`readIncompleteLong(long offset)` Read a long which is zero padded (high bytes) if the available bytes is less than 8.
`int`	`readInt(long offset)` Read an int at an offset
`default long`	`readLimit()`
`long`	`readLong(long offset)` Read a long at an offset
`default long`	`readPosition()` The read position must be start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
`default long`	`readRemaining()`
`short`	`readShort(long offset)` Read a short at an offset
`default int`	`readUnsignedByte(long offset)` Read an unsigned byte at an offset
`default long`	`readUnsignedInt(long offset)` Read an unsigned int at an offset
`default int`	`readUnsignedInt24(long offset)` Read an unsigned int at an offset
`default int`	`readUnsignedShort(long offset)` Read an unsigned short at an offset
`default <ACS extends Appendable & CharSequence> long`	`readUtf8(long offset, ACS sb)` Truncates `sb` (it must be a `StringBuilder` or `Bytes`) and reads a char sequence from the given `offset`, encoded as Utf8, into it.
`default <ACS extends Appendable & CharSequence> long`	`readUtf8Limited(long offset, ACS sb, int maxUtf8Len)` Truncates `sb` (it must be a `StringBuilder` or `Bytes`) and reads a char sequence from the given `offset`, encoded as Utf8, into it.
`default String`	`readUtf8Limited(long offset, int maxUtf8Len)` Reads a char sequence from the given `offset`, encoded as Utf8.
`default byte`	`readVolatileByte(long offset)` Read a 8-bit byte from memory with a load barrier.
`default double`	`readVolatileDouble(long offset)` Read a 64-bit double from memory with a load barrier.
`default float`	`readVolatileFloat(long offset)` Read a float from memory with a load barrier.
`int`	`readVolatileInt(long offset)` Read a 32-bit int from memory with a load barrier.
`default long`	`readVolatileLong(long offset)` Read a 64-bit long from memory with a load barrier.
`default short`	`readVolatileShort(long offset)` Read a 16-bit short from memory with a load barrier.
`long`	`realCapacity()`
`boolean`	`sharedMemory()`
`default long`	`start()`
`default BytesStore`	`subBytes(long start, long length)` Copy a sub sequence of bytes as a BytesStore.
`default byte[]`	`toByteArray()`
`default ByteBuffer`	`toTemporaryDirectByteBuffer()`
`default long`	`writeLimit()`
`default long`	`writePosition()` The read position must be readPosition() <= writePosition() && writePosition() <= writeLimit()
`default long`	`writeRemaining()`

Methods inherited from interface net.openhft.chronicle.core.ReferenceCounted
close, refCount, release, release, releaseAll, reserve, tryReserve

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

- Field Detail
  - charToString
```
static final String[] charToString
```
- Method Detail
  - createCharToString
```
@NotNull
static String[] createCharToString()
```
  - peekVolatileInt
```
default int peekVolatileInt()
```
  - readBoolean
```
default boolean readBoolean(long offset)
                     throws BufferUnderflowException
```
    Read boolean at an offset
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the boolean
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readByte
```
byte readByte(long offset)
       throws BufferUnderflowException
```
    Read byte at an offset
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the byte
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readUnsignedByte
```
default int readUnsignedByte(long offset)
                      throws BufferUnderflowException
```
    Read an unsigned byte at an offset
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the unsigned byte
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - peekUnsignedByte
```
int peekUnsignedByte(long offset)
```
    Read an unsigned byte at an offset, or -1
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the unsigned byte or -1
  - readShort
```
short readShort(long offset)
         throws BufferUnderflowException
```
    Read a short at an offset
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the short
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readUnsignedShort
```
default int readUnsignedShort(long offset)
                       throws BufferUnderflowException
```
    Read an unsigned short at an offset
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the unsigned short
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readUnsignedInt24
```
default int readUnsignedInt24(long offset)
                       throws BufferUnderflowException
```
    Read an unsigned int at an offset
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the int
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readInt
```
int readInt(long offset)
     throws BufferUnderflowException
```
    Read an int at an offset
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the int
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readUnsignedInt
```
default long readUnsignedInt(long offset)
                      throws BufferUnderflowException
```
    Read an unsigned int at an offset
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the unsigned int
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readLong
```
long readLong(long offset)
       throws BufferUnderflowException
```
    Read a long at an offset
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the long
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readFloat
```
float readFloat(long offset)
         throws BufferUnderflowException
```
    Read a float at an offset
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the float
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readDouble
```
double readDouble(long offset)
           throws BufferUnderflowException
```
    Read a double at an offset
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the double
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - printable
```
default String printable(long offset)
                  throws BufferUnderflowException
```
    Read the byte at an offset and converts it into a printable
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the byte in a printable form.
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readVolatileByte
```
default byte readVolatileByte(long offset)
                       throws BufferUnderflowException
```
    Read a 8-bit byte from memory with a load barrier.
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the byte value
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readVolatileShort
```
default short readVolatileShort(long offset)
                         throws BufferUnderflowException
```
    Read a 16-bit short from memory with a load barrier.
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the short value
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readVolatileInt
```
int readVolatileInt(long offset)
             throws BufferUnderflowException
```
    Read a 32-bit int from memory with a load barrier.
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the int value
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readVolatileFloat
```
default float readVolatileFloat(long offset)
                         throws BufferUnderflowException
```
    Read a float from memory with a load barrier.
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the float value
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readVolatileLong
```
default long readVolatileLong(long offset)
                       throws BufferUnderflowException
```
    Read a 64-bit long from memory with a load barrier.
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the long value
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readVolatileDouble
```
default double readVolatileDouble(long offset)
                           throws BufferUnderflowException
```
    Read a 64-bit double from memory with a load barrier.
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the double value
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - parseLong
```
default long parseLong(long offset)
                throws BufferUnderflowException
```
    Throws:
    
    BufferUnderflowException
  - nativeRead
```
void nativeRead(long position,
                long address,
                long size)
         throws BufferUnderflowException
```
    expert level method for copying data to native memory.
    
    Parameters:
    
    position - within the ByteStore to copy.
    
    address - in native memory
    
    size - in bytes
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - copyTo
```
default int copyTo(@NotNull
                   byte[] bytes)
            throws BufferUnderflowException
```
    Read a byte[] from memory.
    
    Returns:
    
    the length actually read.
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - copyTo
```
default int copyTo(@NotNull
                   ByteBuffer bb)
            throws BufferUnderflowException
```
    Throws:
    
    BufferUnderflowException
  - readIncompleteLong
```
default long readIncompleteLong(long offset)
```
    Read a long which is zero padded (high bytes) if the available bytes is less than 8. If the offset is at or beyond the readLimit, this will return 0L.
    
    Parameters:
    
    offset - to read from
    
    Returns:
    
    the long which might be padded.
  - realCapacity
```
long realCapacity()
```
    Returns:
    
    the actual capacity you can potentially read.
  - addAndGetInt
```
default int addAndGetInt(long offset,
                         int adding)
                  throws BufferUnderflowException
```
    Perform an atomic add and get operation for a 32-bit int
    
    Parameters:
    
    offset - to add and get
    
    adding - value to add, can be 1
    
    Returns:
    
    the sum
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - addAndGetLong
```
default long addAndGetLong(long offset,
                           long adding)
                    throws BufferUnderflowException
```
    Perform an atomic add and get operation for a 64-bit long
    
    Parameters:
    
    offset - to add and get
    
    adding - value to add, can be 1
    
    Returns:
    
    the sum
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - addAndGetFloat
```
default float addAndGetFloat(long offset,
                             float adding)
                      throws BufferUnderflowException
```
    Perform an atomic add and get operation for a 32-bit float
    
    Parameters:
    
    offset - to add and get
    
    adding - value to add, can be 1
    
    Returns:
    
    the sum
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - addAndGetDouble
```
default double addAndGetDouble(long offset,
                               double adding)
                        throws BufferUnderflowException
```
    Perform an atomic add and get operation for a 64-bit double
    
    Parameters:
    
    offset - to add and get
    
    adding - value to add, can be 1
    
    Returns:
    
    the sum
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - subBytes
```
default BytesStore subBytes(long start,
                            long length)
```
    Copy a sub sequence of bytes as a BytesStore.
    
    Parameters:
    
    start - of bytes
    
    length - of bytes
    
    Returns:
    
    ByteStore copy.
  - findByte
```
default int findByte(byte stopByte)
```
  - readUtf8
```
default <ACS extends Appendable & CharSequence> long readUtf8(long offset,
                                                              @NotNull
                                                              ACS sb)
                                                       throws net.openhft.chronicle.core.io.IORuntimeException,
                                                              IllegalArgumentException,
                                                              BufferUnderflowException
```
    Truncates sb (it must be a StringBuilder or Bytes) and reads a char sequence from the given offset, encoded as Utf8, into it. Returns offset after the read Utf8, if a normal char sequence was read, or -1 - offset, if null was observed (in this case, sb is truncated too, but not updated then, by querying sb only this case is indistinguishable from reading an empty char sequence).
    
    Type Parameters:
    
    ACS - buffer type, must be StringBuilder or Bytes
    
    Parameters:
    
    offset - the offset in this RandomDataInput to read char sequence from
    
    sb - the buffer to read char sequence into (truncated first)
    
    Returns:
    
    offset after the normal read char sequence, or -1 - offset, if char sequence is null
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
    
    IllegalArgumentException
    
    BufferUnderflowException
    
    See Also:
    
    RandomDataOutput.writeUtf8(long, CharSequence)
  - readUtf8Limited
```
default <ACS extends Appendable & CharSequence> long readUtf8Limited(long offset,
                                                                     @NotNull
                                                                     ACS sb,
                                                                     int maxUtf8Len)
                                                              throws net.openhft.chronicle.core.io.IORuntimeException,
                                                                     IllegalArgumentException,
                                                                     BufferUnderflowException,
                                                                     IllegalStateException
```
    Truncates sb (it must be a StringBuilder or Bytes) and reads a char sequence from the given offset, encoded as Utf8, into it. Returns offset after the read Utf8, if a normal char sequence was read, or -1 - offset, if null was observed (in this case, sb is truncated too, but not updated then, by querying sb only this case is indistinguishable from reading an empty char sequence). If length of Utf8 encoding of the char sequence exceeds maxUtf8Len, IllegalStateException is thrown.
    
    Type Parameters:
    
    ACS - buffer type, must be StringBuilder or Bytes
    
    Parameters:
    
    offset - the offset in this RandomDataInput to read char sequence from
    
    sb - the buffer to read char sequence into (truncated first)
    
    maxUtf8Len - the maximum allowed length of the char sequence in Utf8 encoding
    
    Returns:
    
    offset after the normal read char sequence, or -1 - offset, if char sequence is null
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
    
    IllegalArgumentException
    
    BufferUnderflowException
    
    IllegalStateException
    
    See Also:
    
    RandomDataOutput.writeUtf8Limited(long, CharSequence, int)
  - readUtf8Limited
```
@Nullable
default String readUtf8Limited(long offset,
                                         int maxUtf8Len)
                                  throws BufferUnderflowException,
                                         net.openhft.chronicle.core.io.IORuntimeException,
                                         IllegalArgumentException,
                                         IllegalStateException
```
    Reads a char sequence from the given offset, encoded as Utf8. If length of Utf8 encoding of the char sequence exceeds maxUtf8Len, IllegalStateException is thrown.
    
    Parameters:
    
    offset - the offset in this RandomDataInput to read char sequence from
    
    maxUtf8Len - the maximum allowed length of the char sequence in Utf8 encoding
    
    Returns:
    
    the char sequence was read
    
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
    
    IllegalArgumentException
    
    IllegalStateException
    
    See Also:
    
    RandomDataOutput.writeUtf8Limited(long, CharSequence, int)
  - compareUtf8
```
default boolean compareUtf8(long offset,
                            @Nullable
                            CharSequence other)
                     throws net.openhft.chronicle.core.io.IORuntimeException
```
    Compares the UTF-8 encoded char sequence, written in this RandomDataInput at the given offset, with the given char sequence. Returns true, if they are equal. Both char sequences (encoded in bytes and the given) may be null.
    
    Parameters:
    
    offset - the offset in this RandomDataInput where the char sequence to compare is written
    
    other - the second char sequence to compare
    
    Returns:
    
    true if two char sequences are equal
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - if the contents are not a valid string.
  - toByteArray
```
default byte[] toByteArray()
                    throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - read
```
default long read(long offsetInRDI,
                  byte[] bytes,
                  int offset,
                  int length)
```
  - toTemporaryDirectByteBuffer
```
default ByteBuffer toTemporaryDirectByteBuffer()
```
  - fastHash
```
default int fastHash(long offset,
                     int length)
```
  - start
```
default long start()
```
    Returns:
    
    The smallest position allowed in this buffer.
  - capacity
```
default long capacity()
```
    Returns:
    
    the highest limit allowed for this buffer.
  - readPosition
```
default long readPosition()
```
    The read position must be start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
    
    Returns:
    
    position to read from.
  - writePosition
```
default long writePosition()
```
    The read position must be readPosition() <= writePosition() && writePosition() <= writeLimit()
    
    Returns:
    
    position to write to.
  - readRemaining
```
default long readRemaining()
```
    Returns:
    
    How many more bytes can we read.
  - writeRemaining
```
default long writeRemaining()
```
    Returns:
    
    How many more bytes can we written.
  - readLimit
```
default long readLimit()
```
    Returns:
    
    the highest offset or position allowed for this buffer.
  - writeLimit
```
default long writeLimit()
```
  - address
```
long address(long offset)
      throws UnsupportedOperationException,
             IllegalArgumentException
```
    Obtain the underlying address. This is for expert users only.
    
    Parameters:
    
    offset - within this buffer. address(start()) is the actual address of the first byte.
    
    Returns:
    
    the underlying address of the buffer
    
    Throws:
    
    UnsupportedOperationException - if the underlying buffer is on the heap
    
    IllegalArgumentException - if the offset is before the start() or the after the capacity()
  - byteOrder
```
default ByteOrder byteOrder()
```
  - bytesForRead
```
Bytes bytesForRead()
            throws IllegalStateException
```
    Returns:
    
    the streaming bytes for reading.
    
    Throws:
    
    IllegalStateException
  - bytesForWrite
```
Bytes bytesForWrite()
             throws IllegalStateException
```
    Returns:
    
    the streaming bytes for writing.
    
    Throws:
    
    IllegalStateException
  - compareAndSwapInt
```
boolean compareAndSwapInt(long offset,
                          int expected,
                          int value)
                   throws BufferOverflowException,
                          IllegalArgumentException
```
    Perform a 32-bit CAS at a given offset.
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
    
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
  - compareAndSwapLong
```
boolean compareAndSwapLong(long offset,
                           long expected,
                           long value)
                    throws BufferOverflowException,
                           IllegalArgumentException
```
    Perform a 64-bit CAS at a given offset.
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
    
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
  - compareAndSwapFloat
```
default boolean compareAndSwapFloat(long offset,
                                    float expected,
                                    float value)
                             throws BufferOverflowException,
                                    IllegalArgumentException
```
    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
    
    IllegalArgumentException
  - compareAndSwapDouble
```
default boolean compareAndSwapDouble(long offset,
                                     double expected,
                                     double value)
                              throws BufferOverflowException,
                                     IllegalArgumentException
```
    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
    
    IllegalArgumentException
  - sharedMemory
```
boolean sharedMemory()
```
    Returns:
    
    true if these Bytes use shared memory.
  - isDirectMemory
```
boolean isDirectMemory()
```

Interface RandomDataInput

Field Summary

Method Summary

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

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

Field Detail

charToString

Method Detail

createCharToString

peekVolatileInt

readBoolean

readByte

readUnsignedByte

peekUnsignedByte

readShort

readUnsignedShort

readUnsignedInt24

readInt

readUnsignedInt

readLong

readFloat

readDouble

printable

readVolatileByte

readVolatileShort

readVolatileInt

readVolatileFloat

readVolatileLong

readVolatileDouble

parseLong

nativeRead

copyTo

copyTo

readIncompleteLong

realCapacity

addAndGetInt

addAndGetLong

addAndGetFloat

addAndGetDouble

subBytes

findByte

readUtf8

readUtf8Limited

readUtf8Limited

compareUtf8

toByteArray

read

toTemporaryDirectByteBuffer

fastHash

start

capacity

readPosition

writePosition

readRemaining

writeRemaining

readLimit

writeLimit

address

byteOrder

bytesForRead

bytesForWrite

compareAndSwapInt

compareAndSwapLong

compareAndSwapFloat

compareAndSwapDouble

sharedMemory

isDirectMemory