Trait atomic_cell::compare_update::CompareUpdate

pub trait CompareUpdate<Current, T> {
    type Error;
    type Retry;
    type Final;

    fn initial(self) -> (Self::Retry, Current, T);
    fn retry(
        retry: Self::Retry,
        current: Current,
        val: T
    ) -> Result<(Self::Retry, T), Self::Error>;
    fn finalize(retry: Self::Retry, val: T) -> Self::Final;
}

How to treat data across retries of AtomicCell::compare_update_raw

Required Associated Types

type Error

The error type for CompareUpdate::retrys

type Retry

Backup data for retries

type Final

The final data returned

Required Methods

fn initial(self) -> (Self::Retry, Current, T)

Create the values for the first compare_exchange_weak and some backup data for retries. U is the assumed current value

fn retry(
    retry: Self::Retry,
    current: Current,
    val: T
) -> Result<(Self::Retry, T), Self::Error>

Try to create the data for the next iteration current is the value returned from the failed attempt to exchange val is the value which was failed to be stored by the previous iteration

fn finalize(retry: Self::Retry, val: T) -> Self::Final

Combine the retry data and the swapped out value into the CompareUpdate::Final data.

Implementations on Foreign Types

impl<FI, U, T, F, C, E, FF, R> CompareUpdate<U, T> for (FI, F, FF)where
    FI: FnOnce() -> (C, U, T),
    F: FnMut(C, U, T) -> Result<(C, T), E>,
    FF: FnOnce(C, T) -> R,

type Error = E

type Retry = (C, F, FF)

type Final = R

fn initial(self) -> (Self::Retry, U, T)

fn retry(
    (c, f, ff): Self::Retry,
    current: U,
    val: T
) -> Result<(Self::Retry, T), Self::Error>

fn finalize((c, _, ff): Self::Retry, val: T) -> Self::Final

impl<FI, U, T, F, C, E> CompareUpdate<U, T> for (FI, F)where
    FI: FnOnce() -> (C, U, T),
    F: FnMut(C, U, T) -> Result<(C, T), E>,

type Error = E

type Retry = (C, F)

type Final = T

fn initial(self) -> (Self::Retry, U, T)

fn retry(
    (c, f): Self::Retry,
    current: U,
    val: T
) -> Result<(Self::Retry, T), Self::Error>

fn finalize(_retry: Self::Retry, val: T) -> Self::Final

impl<U, T, F, C, E> CompareUpdate<U, T> for (C, U, T, F)where
    F: FnMut(C, U, T) -> Result<(C, T), E>,

type Error = E

type Retry = (C, F)

type Final = T

fn initial(self) -> (Self::Retry, U, T)

fn retry(
    (c, f): Self::Retry,
    current: U,
    val: T
) -> Result<(Self::Retry, T), Self::Error>

fn finalize(_retry: Self::Retry, val: T) -> Self::Final

impl<U, T, F, C, E, FF, R> CompareUpdate<U, T> for (C, U, T, F, FF)where
    F: FnMut(C, U, T) -> Result<(C, T), E>,
    FF: FnOnce(C, T) -> R,

type Error = E

type Retry = (C, F, FF)

type Final = R

fn initial(self) -> (Self::Retry, U, T)

fn retry(
    (c, f, ff): Self::Retry,
    current: U,
    val: T
) -> Result<(Self::Retry, T), Self::Error>

fn finalize((c, _, ff): Self::Retry, val: T) -> Self::Final

Implementors