Struct SharedCell 

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

Implementations

impl<T: Copy + 'static> SharedCell<T>

pub fn create(path: impl AsRef<Path>) -> Result<Self, SharedCellError>

Obtain the cell at path, initializing an empty one if the path does not yet exist and attaching to it if it does. Attaching leaves the current value and version in place; a region built for a different payload type is a LayoutMismatch. reset reinitializes.

pub fn reset(path: impl AsRef<Path>) -> Result<Self, SharedCellError>

Truncate the cell at path and initialize an empty one, discarding whatever value a live peer holds. For a caller that knows it owns the path.

pub fn open(path: impl AsRef<Path>) -> Result<Self, SharedCellError>

pub fn set(&self, value: T)

Atomically replace the cell value. SeqLock protocol: odd version during the memcpy, even after.

pub fn get(&self) -> T

Read the current value via the SeqLock retry loop. Always returns; the loop is bounded by writer frequency.

pub fn version(&self) -> u32

pub fn flush_async(&self) -> Result<(), SharedCellError>

Non-blocking flush: schedules a writeback via the OS. Note: Windows is only partially async (sync to page cache, not to disk).

pub fn flush(&self) -> Result<(), SharedCellError>

Trait Implementations

impl<T: Copy + Send + Sync + 'static> AdaptiveInstance for SharedCell<T>

fn header(&self) -> &HandshakeHeader

fn ring(&self) -> &ObservationRing

fn make_policy(&self) -> Box<dyn Policy>

fn apply_migration(&self, new_tag: u32)

Called by the sidecar when the policy returns a new strategy tag. Default implementation: just set the tag on the header. Primitives that need heavier migration (data-layout swap) override this to perform the swap before (or after) updating the tag.

impl<T: Copy + Send + 'static> Send for SharedCell<T>

impl<T: Copy + Sync + 'static> Sync for SharedCell<T>