pipecircuit 0.0.21

Correct. Robust. Fast. Portable. Pick four.
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use super::inconsistency;
use core::iter::FusedIterator;

use super::{SlotLocation, StableSlot, StableSlots, StableSlotsInconsistency};
use crate::storage::warp_table::secondary_index::{SlotSet, SlotSetSlots};

pub trait StableSlotResolver {
    fn resolve_stable_slot(
        &self,
        slot: StableSlot,
    ) -> Result<StableSlotResolveOutcome, StableSlotsInconsistency>;
}

#[derive(
    ::core::clone::Clone,
    ::core::marker::Copy,
    ::core::fmt::Debug,
    ::core::cmp::Eq,
    ::core::cmp::PartialEq,
)]
#[must_use]
pub enum StableSlotResolveOutcome {
    Resolved { slot: StableSlot, dense_row: usize },
}

#[must_use]
pub struct StableSlotResolutions<'slots> {
    slots: SlotSetSlots<'slots>,
    stable_slots: &'slots StableSlots,
}

impl Iterator for StableSlotResolutions<'_> {
    type Item = Result<StableSlotResolveOutcome, StableSlotsInconsistency>;

    fn next(&mut self) -> Option<Self::Item> {
        self.slots
            .next()
            .map(|slot| self.stable_slots.resolve(slot))
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.slots.size_hint()
    }
}

impl DoubleEndedIterator for StableSlotResolutions<'_> {
    fn next_back(&mut self) -> Option<Self::Item> {
        self.slots
            .next_back()
            .map(|slot| self.stable_slots.resolve(slot))
    }
}

#[cfg(target_pointer_width = "64")]
impl ExactSizeIterator for StableSlotResolutions<'_> {}

impl FusedIterator for StableSlotResolutions<'_> {}

impl StableSlots {
    pub fn resolve_slots<'slots>(
        &'slots self,
        slots: &'slots SlotSet,
    ) -> StableSlotResolutions<'slots> {
        StableSlotResolutions {
            slots: slots.slots(),
            stable_slots: self,
        }
    }

    pub fn resolve(
        &self,
        slot: StableSlot,
    ) -> Result<StableSlotResolveOutcome, StableSlotsInconsistency> {
        let slot_index = inconsistency::slot_index::<usize>(slot)?;
        match self
            .slot_locations
            .get(slot_index)
            .ok_or(StableSlotsInconsistency::SlotUnavailable { slot })?
        {
            SlotLocation::Occupied(stored_row) => {
                let dense_row = inconsistency::stored_row(slot, *stored_row)?;
                Ok(StableSlotResolveOutcome::Resolved { slot, dense_row })
            }
            SlotLocation::Free(_) => Err(StableSlotsInconsistency::SlotVacant { slot }),
        }
    }

    pub fn slot(&self, row: usize) -> Result<StableSlot, StableSlotsInconsistency> {
        let slot = self
            .row_to_slot
            .get(row)
            .copied()
            .ok_or(StableSlotsInconsistency::RowUnavailable { row })?;
        self.validate_location(slot, row)?;
        Ok(slot)
    }

    pub(super) fn validate_location(
        &self,
        slot: StableSlot,
        expected_row: usize,
    ) -> Result<usize, StableSlotsInconsistency> {
        let expected = inconsistency::row(expected_row)?;
        let slot_index = inconsistency::slot_index::<usize>(slot)?;
        match self
            .slot_locations
            .get(slot_index)
            .ok_or(StableSlotsInconsistency::SlotUnavailable { slot })?
        {
            SlotLocation::Occupied(actual) if *actual == expected => Ok(slot_index),
            SlotLocation::Occupied(actual) => Err(StableSlotsInconsistency::SlotRowMismatch {
                slot,
                expected,
                actual: *actual,
            }),
            SlotLocation::Free(_) => Err(StableSlotsInconsistency::SlotVacant { slot }),
        }
    }
}