o3 0.3.0

shared-nothing primitives
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

use std::cell::Cell;
use std::cmp::Ordering;
use std::marker::PhantomPinned;
use std::pin::Pin;

pub(crate) struct PinnedItem<'a> {
    value: Cell<u32>,
    address: Cell<*const Self>,
    drops: &'a Cell<usize>,
    _pin: PhantomPinned,
}

impl<'a> PinnedItem<'a> {
    pub(crate) fn new(value: u32, drops: &'a Cell<usize>) -> Self {
        Self {
            value: Cell::new(value),
            address: Cell::new(std::ptr::null()),
            drops,
            _pin: PhantomPinned,
        }
    }

    pub(crate) fn bind(self: Pin<&Self>) {
        self.address.set(std::ptr::from_ref(self.get_ref()));
    }

    pub(crate) fn set(self: Pin<&mut Self>, value: u32) {
        self.as_ref().value.set(value);
    }

    pub(crate) fn value(self: Pin<&Self>) -> u32 {
        self.value.get()
    }
}

impl Drop for PinnedItem<'_> {
    fn drop(&mut self) {
        if !self.address.get().is_null() {
            assert_eq!(self.address.get(), std::ptr::from_ref(self));
        }
        self.drops.set(self.drops.get() + 1);
    }
}

pub(crate) struct PanicDrop<'a> {
    order: u8,
    drops: &'a Cell<usize>,
    panic_once: &'a Cell<bool>,
}

impl<'a> PanicDrop<'a> {
    pub(crate) fn new(order: u8, drops: &'a Cell<usize>, panic_once: &'a Cell<bool>) -> Self {
        Self {
            order,
            drops,
            panic_once,
        }
    }
}

impl Drop for PanicDrop<'_> {
    fn drop(&mut self) {
        self.drops.set(self.drops.get() + 1);
        if self.panic_once.replace(false) {
            panic!("drop panic");
        }
    }
}

impl PartialEq for PanicDrop<'_> {
    fn eq(&self, other: &Self) -> bool {
        self.order == other.order
    }
}

impl Eq for PanicDrop<'_> {}

impl PartialOrd for PanicDrop<'_> {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for PanicDrop<'_> {
    fn cmp(&self, other: &Self) -> Ordering {
        self.order.cmp(&other.order)
    }
}