Enum Claim 

pub enum Claim<T> {
    Claimed {
        token: ClaimToken,
    },
    Completed(T),
    InFlight,
}

The three things a claim can find, and the three responses a caller has.

Variants

Claimed

The key was absent. This caller owns it and must either complete it with a result or abandon it.

In both cases the key stays reserved until one of them happens, which is what stops a second caller from taking it in between.

Fields

token: ClaimToken

The token to present when recording or releasing.

Completed(T)

The key already completed. Hand the recorded result back and do not execute: the whole point is that the side effect does not run a second time.

InFlight

Another caller holds the key right now. Do not execute and do not steal it — the holder is a real request, and taking the key from it would run the same side effect twice from two callers.

Implementations

impl<T> Claim<T>

pub const fn is_execution_mine(&self) -> bool

Whether this caller is the one that should execute.

pub const fn recorded(&self) -> Option<&T>

The result, if the key had already completed.

pub const fn token(&self) -> Option<&ClaimToken>

The token, if the claim came back to this caller.

Trait Implementations

impl<T: Clone> Clone for Claim<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Claim<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for Claim<T>

impl<T: PartialEq> PartialEq for Claim<T>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T: PartialEq> StructuralPartialEq for Claim<T>