Struct MemHedgeRead 

pub struct MemHedgeRead<'a, 's, T, const N: usize> { /* private fields */ }

🫗 🧵 🍃 ⬡ Binds a hedge-control cell to a replicated logical slice view.

---

^{📍 sys/mem/cell}

---

MemHedgeRead does not spawn workers or perform any platform-specific work. It only provides the protocol-facing surface that connects:

• MemReplicaSlice as the replicated data source,
• MemHedgeCtrl as the shared coordination state.

This is the first layer where the hedged-read pattern becomes explicit.

Implementations

impl<'a, 's, T, const N: usize> MemHedgeRead<'a, 's, T, N>

pub const fn new( ctrl: &'a MemHedgeCtrl, replicas: &'a MemReplicaSlice<'s, T, N>, ) -> Self

Creates a hedge-read façade over ctrl and replicas.

pub const fn ctrl(&self) -> &'a MemHedgeCtrl

Returns the underlying hedge-control cell.

pub const fn replicas(&self) -> &'a MemReplicaSlice<'s, T, N>

Returns the underlying replicated slice view.

pub fn arm(&self, logical_index: usize) -> Result<usize, MemHedgeError>

Arms a hedged read request for logical_index.

This validates that the requested index lies within the initialized logical length of the replicated view before delegating to MemHedgeCtrl::arm.

Errors

Returns:

• MemHedgeError::OutOfBounds if logical_index >= replicas.len().
• any error returned by MemHedgeCtrl::arm.

pub fn clear(&self)

Clears the current request state.

This delegates to MemHedgeCtrl::clear.

pub fn epoch(&self) -> usize

Returns the current request epoch.

pub fn logical_index(&self) -> usize

Returns the currently requested logical index.

pub fn state(&self) -> MemHedgeState

Returns the current hedge lifecycle state.

pub fn winner(&self) -> Option<usize>

Returns the winning replica index, if any.

pub fn read(&self) -> Result<&T, MemHedgeError>

Reads the first replica for the currently active request.

This is a convenience alias for read_replica with replica = 0.

Errors

Returns:

• MemHedgeError::NotArmed if no request is active,
• MemHedgeError::OutOfBounds if the active logical index is not readable in the bound replica view.

pub fn read_replica(&self, replica: usize) -> Result<&T, MemHedgeError>

Reads one replica for the currently active request.

This uses the logical index published in the bound MemHedgeCtrl.

Errors

Returns:

• MemHedgeError::NotArmed if no request is active,
• MemHedgeError::InvalidReplica if replica >= N,
• MemHedgeError::OutOfBounds if the active logical index is not readable in the bound replica view.

pub fn try_read_claim( &self, replica: usize, ) -> Result<Option<&T>, MemHedgeError>

Reads one replica and then attempts to claim the active request.

This is the worker-facing convenience operation:

• read the replica corresponding to replica,
• try to claim victory for that replica,
• return the read value only if this replica won.

Returns:

• Ok(Some(&T)) if this replica became the winner,
• Ok(None) if another replica won first while the request was still armed,
• Err(...) if the request was not active or the indices were invalid.

Trait Implementations

impl<'a, 's, T: Clone, const N: usize> Clone for MemHedgeRead<'a, 's, T, N>

fn clone(&self) -> MemHedgeRead<'a, 's, T, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, 's, T: Copy, const N: usize> Copy for MemHedgeRead<'a, 's, T, N>

impl<'a, 's, T: Debug, const N: usize> Debug for MemHedgeRead<'a, 's, T, N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.