pipecircuit 0.0.10

Correct. Robust. Fast. Portable.
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

use super::{SlotSet, StableSlot};

#[derive(Debug)]
pub enum SlotSetInsertError {
    AlreadyPresent { slot: StableSlot },
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[must_use]
pub enum SlotSetInsertOutcome {
    Inserted { slot: StableSlot },
}

impl SlotSet {
    pub fn try_prepare_insert(
        &mut self,
        slot: StableSlot,
    ) -> Result<PreparedSlotSetInsert<'_>, SlotSetInsertError> {
        let insertion = self.try_apply_insert(slot)?;
        Ok(PreparedSlotSetInsert {
            set: self,
            insertion: Some(insertion),
            slot,
        })
    }

    pub(in crate::storage::warp_table::secondary_index) fn try_apply_insert(
        &mut self,
        slot: StableSlot,
    ) -> Result<AppliedSlotSetInsert, SlotSetInsertError> {
        if !self.0.insert(slot.value()) {
            return Err(SlotSetInsertError::AlreadyPresent { slot });
        }
        Ok(AppliedSlotSetInsert)
    }
}

pub(in crate::storage::warp_table::secondary_index) struct AppliedSlotSetInsert;

impl AppliedSlotSetInsert {
    pub(in crate::storage::warp_table::secondary_index) fn commit(self) {}

    pub(in crate::storage::warp_table::secondary_index) fn rollback(
        self,
        set: &mut SlotSet,
        slot: StableSlot,
    ) {
        match set.remove(slot) {
            super::SlotSetRemoveOutcome::Removed { .. }
            | super::SlotSetRemoveOutcome::Absent { .. } => {}
        }
    }
}

pub struct PreparedSlotSetInsert<'set> {
    set: &'set mut SlotSet,
    insertion: Option<AppliedSlotSetInsert>,
    slot: StableSlot,
}

impl PreparedSlotSetInsert<'_> {
    pub const fn slot(&self) -> StableSlot {
        self.slot
    }

    pub fn commit(mut self) -> SlotSetInsertOutcome {
        if let Some(insertion) = self.insertion.take() {
            insertion.commit();
        }
        SlotSetInsertOutcome::Inserted { slot: self.slot }
    }
}

impl Drop for PreparedSlotSetInsert<'_> {
    fn drop(&mut self) {
        if let Some(insertion) = self.insertion.take() {
            insertion.rollback(self.set, self.slot);
        }
    }
}