atomic_cell 0.2.0

Lock-free thread-safe mutable memory locations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! The [`CompareUpdate`] trait used for [`AtomicCell::compare_update_raw`]
//! 
//! [`AtomicCell::compare_update_raw`]: crate::AtomicCell::compare_update_raw

/// How to treat data across retries of [`AtomicCell::compare_update_raw`]
/// 
/// [`AtomicCell::compare_update_raw`]: crate::AtomicCell::compare_update_raw
pub trait CompareUpdate<Current, T> {
    /// The error type for [`CompareUpdate::retry`]s
    type Error;

    /// Backup data for retries
    type Retry;

    /// The final data returned
    type Final;

    /// Create the values for the first `compare_exchange_weak` and some backup data for retries.
    /// `U` is the assumed `current` value
    fn initial(self) -> (Self::Retry, Current, T);

    /// 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 retry(retry: Self::Retry, current: Current, val: T)
        -> Result<(Self::Retry, T), Self::Error>;

    /// Combine the retry data and the swapped out value into the [`CompareUpdate::Final`] data.
    fn finalize(retry: Self::Retry, val: T) -> Self::Final;
}

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) {
        let (c, u, t) = self.0();
        ((c, self.1, self.2), u, t)
    }

    fn retry(
        (c, mut f, ff): Self::Retry,
        current: U,
        val: T,
    ) -> Result<(Self::Retry, T), Self::Error> {
        f(c, current, val).map(|(c, t)| ((c, f, ff), t))
    }

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

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) {
        let (c, u, t) = self.0();
        ((c, self.1), u, t)
    }

    fn retry((c, mut f): Self::Retry, current: U, val: T) -> Result<(Self::Retry, T), Self::Error> {
        f(c, current, val).map(|(c, t)| ((c, f), t))
    }

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

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) {
        ((self.0, self.3), self.1, self.2)
    }

    fn retry((c, mut f): Self::Retry, current: U, val: T) -> Result<(Self::Retry, T), Self::Error> {
        f(c, current, val).map(|(c, t)| ((c, f), t))
    }

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

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) {
        ((self.0, self.3, self.4), self.1, self.2)
    }

    fn retry(
        (c, mut f, ff): Self::Retry,
        current: U,
        val: T,
    ) -> Result<(Self::Retry, T), Self::Error> {
        f(c, current, val).map(|(c, t)| ((c, f, ff), t))
    }

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