atomex 0.1.1

Atomics extensions in Rust
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


#[derive(Debug, Clone)]
pub enum CmpxchResult<T> {
    /// The compare_exchange successfully updated the value.
    Succ(T),

    /// The compare_exchange fails in contending.
    Fail(T),

    /// The compare_exchange is not performed because the value is unexpected.
    Unexpected(T),
}

impl<T> CmpxchResult<T> {
    pub fn into_inner(self) -> T {
        match self {
            CmpxchResult::Succ(t) => t,
            CmpxchResult::Fail(t) => t,
            CmpxchResult::Unexpected(t) => t,
        }
    }

    pub const fn is_succ(&self) -> bool {
        matches!(self, CmpxchResult::Succ(_))
    }

    pub const fn is_fail(&self) -> bool {
        matches!(self, CmpxchResult::Fail(_))
    }

    pub const fn is_unexpected(&self) -> bool {
        matches!(self, CmpxchResult::Unexpected(_))
    }

    pub fn succ(self) -> Option<T> {
        match self {
            CmpxchResult::Succ(t) => Option::Some(t),
            _ => Option::None,
        }
    }

    pub fn fail(self) -> Option<T> {
        match self {
            CmpxchResult::Fail(t) => Option::Some(t),
            _ => Option::None,
        }
    }

    pub fn unexpected(self) -> Option<T> {
        match self {
            CmpxchResult::Unexpected(t) => Option::Some(t),
            _ => Option::None,
        }
    }
}

impl<T> From<CmpxchResult<T>> for Result<T, T> {
    fn from(value: CmpxchResult<T>) -> Self {
        match value {
            CmpxchResult::Succ(t) => Result::Ok(t),
            CmpxchResult::Fail(t) => Result::Err(t),
            CmpxchResult::Unexpected(t) => Result::Err(t),
        }
    }
}