Struct SharedCursor 

pub struct SharedCursor { /* private fields */ }

A shared cursor that can be accessed across processes

This implements the disruptor pattern’s cursor concept for multi-process scenarios. Each cursor tracks a sequence position and can be safely shared between processes using shared memory with cache-line padding to prevent false sharing.

Implementations

impl SharedCursor

pub fn new_auto(initial_value: i64) -> MultiProcessResult<(Self, String)>

Create a new shared cursor with automatic naming

pub fn new(name: &str, initial_value: i64) -> MultiProcessResult<Self>

Create a new shared cursor in a new shared memory segment (legacy method)

pub fn recreate(name: &str, initial_value: i64) -> MultiProcessResult<Self>

Explicitly recreate a shared cursor by unlinking and creating a fresh segment.

This is intended for crash-restart recovery paths when a stale segment may remain after an unclean shutdown. This operation is destructive for any currently attached process using the same name.

pub fn attach(name: &str) -> MultiProcessResult<Self>

Attach to an existing shared cursor in an existing shared memory segment

pub fn new_or_attach(name: &str, initial_value: i64) -> MultiProcessResult<Self>

Create a new shared cursor, or attach to existing one if it already exists

pub fn is_owner(&self) -> bool

Return whether this mapping currently owns unlink responsibility.

pub fn set_owner(&mut self, is_owner: bool) -> bool

Transfer or release ownership of the underlying shared-memory name.

Consumer sequence cursors use this to become persistent restart anchors: the first attaching consumer may create the cursor segment, but it must not unlink that name when the process exits, or subsequent restarts would reset the logical consumer position back to the initial value.

pub fn load(&self, ordering: Ordering) -> i64

Load the current value

pub fn store(&self, value: i64, ordering: Ordering)

Store a new value

pub fn compare_exchange( &self, current: i64, new: i64, success: Ordering, failure: Ordering, ) -> Result<i64, i64>

Compare and swap

pub fn compare_exchange_weak( &self, current: i64, new: i64, success: Ordering, failure: Ordering, ) -> Result<i64, i64>

Compare and swap (weak version, may fail spuriously)

pub fn fetch_add(&self, val: i64, ordering: Ordering) -> i64

Fetch and add

pub fn swap(&self, val: i64, ordering: Ordering) -> i64

Atomic exchange

Trait Implementations

impl Clone for SharedCursor

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Drop for SharedCursor

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl SharedCursorTrait<i64> for SharedCursor

fn load(&self, ordering: Ordering) -> i64

Load the current value with the given memory ordering

fn store(&self, value: i64, ordering: Ordering)

Store a new value with the given memory ordering

fn compare_exchange( &self, current: i64, new: i64, success: Ordering, failure: Ordering, ) -> Result<i64, i64>

Compare and exchange operation with success and failure memory orderings

impl Send for SharedCursor

impl Sync for SharedCursor