Struct ReactiveSharedArray 

pub struct ReactiveSharedArray<T: Copy> { /* private fields */ }

A reactive array backed by shared memory.

Reads from this array can trigger reactive subscriptions. The array is read-only from Rust’s perspective - writes come from the TypeScript side.

Type Parameters

• T: The element type (must be Copy for safe shared memory access)

Implementations

impl<T: Copy> ReactiveSharedArray<T>

pub unsafe fn new(ptr: *const T, len: usize, dirty: *const u8) -> Self

Create a new reactive shared array.

Safety

• ptr must point to valid shared memory with at least len * size_of::<T>() bytes
• dirty must point to valid shared memory with at least len bytes
• Both pointers must remain valid for the lifetime of this array

pub unsafe fn from_context( ctx: &SharedBufferContext, byte_offset: usize, len: usize, ) -> Self

Create from a SharedBufferContext with byte offset.

Safety

• The offset must be properly aligned for type T
• The region must not overlap with other mutable regions

pub fn get(&self, index: usize) -> T

Get a value at the given index.

pub fn is_dirty(&self, index: usize) -> bool

Check if an index is marked dirty.

pub fn clear_dirty(&self, index: usize)

Clear the dirty flag for an index.

pub fn dirty_indices(&self) -> Vec<usize>

Get all dirty indices.

pub fn bump_version(&self)

Increment version (called when processing changes).

pub fn version(&self) -> u32

Get current version.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub unsafe fn as_slice(&self) -> &[T]

Get a slice of the underlying data.

Safety

The returned slice is only valid while the TypeScript side is not writing. Use only within a synchronized section.

pub fn iter(&self) -> impl Iterator<Item = T> + '_

Iterate over all elements.

Trait Implementations

impl<T: Copy + Send> Send for ReactiveSharedArray<T>

impl<T: Copy + Sync> Sync for ReactiveSharedArray<T>