postage 0.5.0

An async channel 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 std::cell::UnsafeCell;

use atomic::{Atomic, Ordering};

pub struct StateCell<S, T>
where
    S: Copy,
{
    state: Atomic<S>,
    data: UnsafeCell<Option<T>>,
}

impl<S, T> StateCell<S, T>
where
    S: Copy,
{
    pub fn new(state: S) -> Self {
        debug_assert!(Atomic::<S>::is_lock_free());

        Self {
            state: Atomic::new(state),
            data: UnsafeCell::new(None),
        }
    }

    pub unsafe fn compare_store(
        &self,
        current: S,
        locked: S,
        data: T,
        complete: S,
        success: Ordering,
        failure: Ordering,
    ) -> Result<S, (S, T)> {
        match self
            .state
            .compare_exchange(current, locked, success, failure)
        {
            Ok(s) => {
                *self.data.get() = Some(data);
                self.state.store(complete, Ordering::Release);
                Ok(s)
            }
            Err(s) => Err((s, data)),
        }
    }

    pub unsafe fn compare_take(
        &self,
        current: S,
        new: S,
        success: Ordering,
        failure: Ordering,
    ) -> Result<T, S> {
        match self.state.compare_exchange(current, new, success, failure) {
            Ok(_s) => Ok(self.take_internal()),
            Err(s) => Err(s),
        }
    }

    unsafe fn take_internal(&self) -> T {
        let reference = self.data.get().as_mut().unwrap();
        reference.take().unwrap()
    }
}

unsafe impl<S, T> Sync for StateCell<S, T>
where
    S: Copy,
    T: Send,
{
}