fast 0.4.0

A helper library
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

use crate::sync::AtomicOp;
use core::marker::PhantomData;
use core::sync::atomic::Ordering;

use super::{Atomic, Discriminant};

/// A type for managing mutually exclusive states (like an atomic enum)
pub struct Mutual<E: Discriminant>
where
    E::Repr: AtomicOp + Into<usize> + TryFrom<usize>,
{
    repr: <E::Repr as Atomic>::Atomic,
    _phantom: PhantomData<E>,
}

impl<E: Discriminant> Default for Mutual<E>
where
    <E as Discriminant>::Repr: AtomicOp + TryFrom<usize>,
    <<E as Discriminant>::Repr as Atomic>::Atomic: Default,
{
    fn default() -> Self {
        Self {
            repr: Default::default(),
            _phantom: Default::default(),
        }
    }
}

impl<E: Discriminant> Mutual<E>
where
    E::Repr: AtomicOp + Into<usize> + TryFrom<usize> + Copy + PartialEq,
{
    pub const fn new() -> Self {
        Self {
            repr: E::Repr::new(),
            _phantom: PhantomData,
        }
    }

    /// Set the state to the given variant
    pub fn set(&self, variant: E) {
        E::Repr::store(&self.repr, variant.discriminant(), Ordering::Release);
    }

    /// Get the current state if it matches the variant
    pub fn is(&self, variant: &E) -> bool {
        let current = E::Repr::load(&self.repr, Ordering::Acquire);
        current == variant.discriminant()
    }

    /// Try to transition from one state to another atomically
    pub fn compare_exchange(
        &self,
        expected: E,
        new: E,
        success: Ordering,
        failure: Ordering,
    ) -> Result<E::Repr, E::Repr> {
        E::Repr::compare_exchange(
            &self.repr,
            expected.discriminant(),
            new.discriminant(),
            success,
            failure,
        )
    }

    /// Get the raw discriminant value
    pub fn load(&self, order: Ordering) -> E::Repr {
        E::Repr::load(&self.repr, order)
    }
}