javax.realtime.device
Interface RawMemoryRegionFactory

public interface RawMemoryRegionFactory

A template for creating a factory implementation of a specific raw raw memory region. The application can implement this to add support for new regions to RawMemoryFactory. Implementations of this clas can be registered there.

Since:

RTSJ 2.0

Method Summary

RawByte	createRawByte(long base, int count, int stride) Create an instance of a class that implements RawByte and accesses memory of getRegion() in the address range described by base, stride, and count.
RawByteReader	createRawByteReader(long base, int count, int stride) Create an instance of a class that implements RawByteReader and accesses memory of getRegion() in the address range described by base, stride, and count.
RawByteWriter	createRawByteWriter(long base, int count, int stride) Create an instance of a class that implements RawByteWriter and accesses memory of getRegion() in the address range described by base, stride, and count.
RawDouble	createRawDouble(long base, int count, int stride) Create an instance of a class that implements RawDouble and accesses memory of getRegion() in the address range described by base, stride, and count.
RawDoubleReader	createRawDoubleReader(long base, int count, int stride) Create an instance of a class that implements RawDoubleReader and accesses memory of getRegion() in the address range described by base, stride, and count.
RawDoubleWriter	createRawDoubleWriter(long base, int count, int stride) Create an instance of a class that implements RawDoubleWriter and accesses memory of getRegion() in the address range described by base, stride, and count.
RawFloat	createRawFloat(long base, int count, int stride) Create an instance of a class that implements RawFloat and accesses memory of getRegion() in the address range described by base, stride, and count.
RawFloatReader	createRawFloatReader(long base, int count, int stride) Create an instance of a class that implements RawFloatReader and accesses memory of getRegion() in the address range described by base, stride, and count.
RawFloatWriter	createRawFloatWriter(long base, int count, int stride) Create an instance of a class that implements RawFloatWriter and accesses memory of getRegion() in the address range described by base, stride, and count.
RawInt	createRawInt(long base, int count, int stride) Create an instance of a class that implements RawInt and accesses memory of getRegion() in the address range described by base, stride, and count.
RawIntReader	createRawIntReader(long base, int count, int stride) Create an instance of a class that implements RawIntReader and accesses memory of getRegion() in the address range described by base, stride, and count.
RawIntWriter	createRawIntWriter(long base, int count, int stride) Create an instance of a class that implements RawIntWriter and accesses memory of getRegion() in the address range described by base, stride, and count.
RawLong	createRawLong(long base, int count, int stride) Create an instance of a class that implements RawLong and accesses memory of getRegion() in the address range described by base, stride, and count.
RawLongReader	createRawLongReader(long base, int count, int stride) Create an instance of a class that implements RawLongReader and accesses memory of getRegion() in the address range described by base, stride, and count.
RawLongWriter	createRawLongWriter(long base, int count, int stride) Create an instance of a class that implements RawLongWriter and accesses memory of getRegion() in the address range described by base, stride, and count.
RawShort	createRawShort(long base, int count, int stride) Create an instance of a class that implements RawShort and accesses memory of getRegion() in the address range described by base, stride, and count.
RawShortReader	createRawShortReader(long base, int count, int stride) Create an instance of a class that implements RawShortReader and accesses memory of getRegion() in the address range described by base, stride, and count.
RawShortWriter	createRawShortWriter(long base, int count, int stride) Create an instance of a class that implements RawShortWriter and accesses memory of getRegion() in the address range described by base, stride, and count.
RawMemoryRegion	getRegion() Get the region for which this factory creates raw memory objects.

Method Detail

getRegion

RawMemoryRegion getRegion()

Get the region for which this factory creates raw memory objects.

createRawByte

RawByte createRawByte(long base,
                      int count,
                      int stride)
                      throws SecurityException,
                             OffsetOutOfBoundsException,
                             SizeOutOfBoundsException,
                             UnsupportedRawMemoryRegionException,
                             MemoryTypeConflictException

Create an instance of a class that implements RawByte and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of byte × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawByte and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawByteReader

RawByteReader createRawByteReader(long base,
                                  int count,
                                  int stride)
                                  throws SecurityException,
                                         OffsetOutOfBoundsException,
                                         SizeOutOfBoundsException,
                                         UnsupportedRawMemoryRegionException,
                                         MemoryTypeConflictException

Create an instance of a class that implements RawByteReader and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of byte × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawByteReader and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawByteWriter

RawByteWriter createRawByteWriter(long base,
                                  int count,
                                  int stride)
                                  throws SecurityException,
                                         OffsetOutOfBoundsException,
                                         SizeOutOfBoundsException,
                                         UnsupportedRawMemoryRegionException,
                                         MemoryTypeConflictException

Create an instance of a class that implements RawByteWriter and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of byte × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawByteWriter and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawShort

RawShort createRawShort(long base,
                        int count,
                        int stride)
                        throws SecurityException,
                               OffsetOutOfBoundsException,
                               SizeOutOfBoundsException,
                               UnsupportedRawMemoryRegionException,
                               MemoryTypeConflictException

Create an instance of a class that implements RawShort and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of short × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawShort and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawShortReader

RawShortReader createRawShortReader(long base,
                                    int count,
                                    int stride)
                                    throws SecurityException,
                                           OffsetOutOfBoundsException,
                                           SizeOutOfBoundsException,
                                           UnsupportedRawMemoryRegionException,
                                           MemoryTypeConflictException

Create an instance of a class that implements RawShortReader and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of short × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawShortReader and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawShortWriter

RawShortWriter createRawShortWriter(long base,
                                    int count,
                                    int stride)
                                    throws SecurityException,
                                           OffsetOutOfBoundsException,
                                           SizeOutOfBoundsException,
                                           UnsupportedRawMemoryRegionException,
                                           MemoryTypeConflictException

Create an instance of a class that implements RawShortWriter and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of short × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawShortWriter and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawInt

RawInt createRawInt(long base,
                    int count,
                    int stride)
                    throws SecurityException,
                           OffsetOutOfBoundsException,
                           SizeOutOfBoundsException,
                           UnsupportedRawMemoryRegionException,
                           MemoryTypeConflictException

Create an instance of a class that implements RawInt and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of int × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawInt and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawIntReader

RawIntReader createRawIntReader(long base,
                                int count,
                                int stride)
                                throws SecurityException,
                                       OffsetOutOfBoundsException,
                                       SizeOutOfBoundsException,
                                       UnsupportedRawMemoryRegionException,
                                       MemoryTypeConflictException

Create an instance of a class that implements RawIntReader and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of int × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawIntReader and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawIntWriter

RawIntWriter createRawIntWriter(long base,
                                int count,
                                int stride)
                                throws SecurityException,
                                       OffsetOutOfBoundsException,
                                       SizeOutOfBoundsException,
                                       UnsupportedRawMemoryRegionException,
                                       MemoryTypeConflictException

Create an instance of a class that implements RawIntWriter and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of int × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawIntWriter and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawLong

RawLong createRawLong(long base,
                      int count,
                      int stride)
                      throws SecurityException,
                             OffsetOutOfBoundsException,
                             SizeOutOfBoundsException,
                             UnsupportedRawMemoryRegionException,
                             MemoryTypeConflictException

Create an instance of a class that implements RawLong and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of long × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawLong and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawLongReader

RawLongReader createRawLongReader(long base,
                                  int count,
                                  int stride)
                                  throws SecurityException,
                                         OffsetOutOfBoundsException,
                                         SizeOutOfBoundsException,
                                         UnsupportedRawMemoryRegionException,
                                         MemoryTypeConflictException

Create an instance of a class that implements RawLongReader and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of long × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawLongReader and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawLongWriter

RawLongWriter createRawLongWriter(long base,
                                  int count,
                                  int stride)
                                  throws SecurityException,
                                         OffsetOutOfBoundsException,
                                         SizeOutOfBoundsException,
                                         UnsupportedRawMemoryRegionException,
                                         MemoryTypeConflictException

Create an instance of a class that implements RawLongWriter and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of long × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawLongWriter and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawFloat

RawFloat createRawFloat(long base,
                        int count,
                        int stride)
                        throws SecurityException,
                               OffsetOutOfBoundsException,
                               SizeOutOfBoundsException,
                               UnsupportedRawMemoryRegionException,
                               MemoryTypeConflictException

Create an instance of a class that implements RawFloat and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of float × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawFloat and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawFloatReader

RawFloatReader createRawFloatReader(long base,
                                    int count,
                                    int stride)
                                    throws SecurityException,
                                           OffsetOutOfBoundsException,
                                           SizeOutOfBoundsException,
                                           UnsupportedRawMemoryRegionException,
                                           MemoryTypeConflictException

Create an instance of a class that implements RawFloatReader and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of float × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawFloatReader and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawFloatWriter

RawFloatWriter createRawFloatWriter(long base,
                                    int count,
                                    int stride)
                                    throws SecurityException,
                                           OffsetOutOfBoundsException,
                                           SizeOutOfBoundsException,
                                           UnsupportedRawMemoryRegionException,
                                           MemoryTypeConflictException

Create an instance of a class that implements RawFloatWriter and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of float × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawFloatWriter and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawDouble

RawDouble createRawDouble(long base,
                          int count,
                          int stride)
                          throws SecurityException,
                                 OffsetOutOfBoundsException,
                                 SizeOutOfBoundsException,
                                 UnsupportedRawMemoryRegionException,
                                 MemoryTypeConflictException

Create an instance of a class that implements RawDouble and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of double × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawDouble and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawDoubleReader

RawDoubleReader createRawDoubleReader(long base,
                                      int count,
                                      int stride)
                                      throws SecurityException,
                                             OffsetOutOfBoundsException,
                                             SizeOutOfBoundsException,
                                             UnsupportedRawMemoryRegionException,
                                             MemoryTypeConflictException

Create an instance of a class that implements RawDoubleReader and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of double × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawDoubleReader and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0

createRawDoubleWriter

RawDoubleWriter createRawDoubleWriter(long base,
                                      int count,
                                      int stride)
                                      throws SecurityException,
                                             OffsetOutOfBoundsException,
                                             SizeOutOfBoundsException,
                                             UnsupportedRawMemoryRegionException,
                                             MemoryTypeConflictException

Create an instance of a class that implements RawDoubleWriter and accesses memory of getRegion() in the address range described by base, stride, and count. The actual extent of the memory addressed by the object is (stride - 1) × size of double × count. The object is allocated in the current memory area of the calling thread.

Parameters:

base - The starting physical address accessible through the returned instance.

count - The number of memory elements accessible through the returned instance.

stride - The distance to the next element in mulitple of element count.

Returns:

an object that implements RawDoubleWriter and supports access to the specified range in the memory region.

Throws:

IllegalArgumentException - when base is negative, or count is not greater than zero.

SecurityException - when the caller does not have permissions to access the given memory region or the specified range of addresses.

OffsetOutOfBoundsException - when base is invalid.

SizeOutOfBoundsException - when the memory addressed by the object would extend into an invalid range of memory.

MemoryTypeConflictException - when base does not point to memory that matches the type served by this factory.

UnsupportedRawMemoryRegionException

Since:

RTSJ 2.0