Struct SharedSlotBuffer 

pub struct SharedSlotBuffer<T: Copy + PartialEq + 'static> { /* private fields */ }

A reactive typed array backed by shared memory.

• get(index) performs a reactive read (tracks dependency via track_read)
• set(index, value) writes to shared memory + marks reactions dirty + notifies
• peek(index) reads without reactive tracking

The buffer owns no allocation — it operates on external memory via raw pointers.

Type Parameters

• T: Element type (must be Copy + PartialEq for equality checking)

Implementations

impl<T: Copy + PartialEq + 'static> SharedSlotBuffer<T>

pub unsafe fn new( ptr: *mut T, len: usize, default_value: T, notifier: impl Notifier, ) -> Self

Create a new SharedSlotBuffer over external memory.

Safety

• ptr must point to valid memory with at least len * size_of::<T>() bytes
• The memory must remain valid for the lifetime of this buffer
• If dirty is Some, it must point to valid memory with at least len bytes

pub unsafe fn with_dirty( ptr: *mut T, len: usize, dirty: *mut u8, default_value: T, notifier: impl Notifier, ) -> Self

Create with dirty flags.

Safety

Same as new(), plus dirty must point to valid memory with len bytes.

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

Reactive read — tracks dependency via the reactive graph.

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

Non-reactive read.

pub fn set(&self, index: usize, value: T)

Write + mark reactions dirty + set dirty flag + notify cross-side.

pub fn set_batch(&self, updates: &[(usize, T)])

Batch write — single notification at end.

pub fn notify_changed(&self)

Notify the Rust reactive graph that the other side changed data. Call this after waking from a cross-side notification.

pub fn source(&self) -> Rc<SourceInner<u32>>

Get the coarse-grained reactive source (for building deriveds that depend on this buffer).

pub fn clear(&self, index: usize)

Reset index to default value.

pub fn len(&self) -> usize

Get buffer length (capacity).

pub fn is_empty(&self) -> bool

Check if buffer is empty.