pipecircuit 0.0.24

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

use super::{
    SlotSet,
    membership::{Chunk, Membership},
};
use crate::storage::{
    membership::{BucketMembership, MembershipChunks},
    query_workspace::chunk::read::ChunkRead,
};
use core::slice;

#[derive(Clone, Copy)]
pub(in crate::storage::warp_table) enum SlotSetRead<'a> {
    Empty,
    Owned(&'a SlotSet),
    Indexed(BucketMembership<'a>),
}
#[allow(
    clippy::large_enum_variant,
    reason = "borrowed index traversal retains its bounded stacks without allocation"
)]
pub(in crate::storage::warp_table) enum Chunks<'a> {
    Empty,
    Owned(slice::Iter<'a, Chunk>),
    Indexed(MembershipChunks<'a>),
}
impl<'a> Iterator for Chunks<'a> {
    type Item = (u16, ChunkRead<'a>);
    fn next(&mut self) -> Option<Self::Item> {
        match self {
            Self::Empty => None,
            Self::Owned(chunks) => chunks.next().map(|chunk| (chunk.high, chunk.read())),
            Self::Indexed(chunks) => chunks.next().map(|(high, chunk)| (high, chunk.0)),
        }
    }
}
impl DoubleEndedIterator for Chunks<'_> {
    fn next_back(&mut self) -> Option<Self::Item> {
        match self {
            Self::Empty => None,
            Self::Owned(chunks) => chunks.next_back().map(|chunk| (chunk.high, chunk.read())),
            Self::Indexed(chunks) => chunks.next_back().map(|(high, chunk)| (high, chunk.0)),
        }
    }
}
impl<'a> SlotSetRead<'a> {
    pub(in crate::storage::warp_table) fn chunks(self) -> Chunks<'a> {
        match self {
            Self::Empty => Chunks::Empty,
            Self::Owned(set) => Chunks::Owned(set.0.chunks.iter()),
            Self::Indexed(members) => Chunks::Indexed(members.chunks()),
        }
    }
    pub(in crate::storage::warp_table) fn len(self) -> u64 {
        match self {
            Self::Empty => 0,
            Self::Owned(set) => set.len(),
            Self::Indexed(members) => members.len() as u64,
        }
    }
    pub(in crate::storage::warp_table) fn slots(self) -> super::SlotSetSlots<'a> {
        super::lookup::read_slots(self)
    }
    pub(in crate::storage::warp_table) fn is_subset(self, other: Self) -> bool {
        if self.len() > other.len() {
            return false;
        }
        let mut right = other.chunks().peekable();
        self.chunks().all(|(high, left)| {
            while right.peek().is_some_and(|(key, _)| *key < high) {
                right.next();
            }
            let other = right
                .next_if(|(key, _)| *key == high)
                .map_or(ChunkRead::EMPTY, |(_, chunk)| chunk);
            left.is_subset(other)
        })
    }
    pub(in crate::storage::warp_table) fn is_disjoint(self, other: Self) -> bool {
        let mut right = other.chunks().peekable();
        self.chunks().all(|(high, left)| {
            while right.peek().is_some_and(|(key, _)| *key < high) {
                right.next();
            }
            let other = right
                .next_if(|(key, _)| *key == high)
                .map_or(ChunkRead::EMPTY, |(_, chunk)| chunk);
            left.is_disjoint(other)
        })
    }
}
impl SlotSet {
    pub(in crate::storage::warp_table) const fn read(&self) -> SlotSetRead<'_> {
        SlotSetRead::Owned(self)
    }
    pub(in crate::storage::warp_table) fn from_read(source: SlotSetRead<'_>) -> Self {
        Self(Membership {
            len: source.len(),
            chunks: source
                .chunks()
                .map(|(high, read)| Chunk::from_read(high, read))
                .collect(),
        })
    }
}