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

Modifier and Type	Method and Description
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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

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.

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

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.

Since:

RTSJ 2.0