pipecircuit 0.0.15

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
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
120
121
122
123

use super::WarpTableRowGetError;
use super::dense_key_index::{CommitInconsistency, IndexInconsistency};

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum WarpTableInconsistency {
    IdColumnLengthMismatch {
        ids: usize,
        rows: usize,
    },
    PrimaryBucketUnavailable {
        bucket: usize,
    },
    PrimaryStoredRowUnrepresentable {
        stored_row: u32,
    },
    IdUnavailable {
        row: usize,
    },
    PrimaryStoredRowMismatch {
        expected: usize,
        actual: usize,
    },
    PrimaryProbeLimitReached,
    ColumnUnavailable {
        column: usize,
        row: usize,
    },
    PrimaryInsertRowUnrepresentable {
        bucket: usize,
        row: usize,
    },
    PrimaryInsertRowReserved {
        bucket: usize,
        row: usize,
    },
    PrimaryInsertVacancyUnavailable {
        bucket: usize,
        row: usize,
    },
    PrimaryInsertVacancyOccupied {
        bucket: usize,
        row: usize,
        occupying_row: u32,
    },
    DenseRowUnavailable {
        row: usize,
        rows: usize,
    },
    IdentifierSequenceBlocked {
        attempts: usize,
    },
    CapacityReachedDuringGeneratedInsert,
}

#[cold]
#[track_caller]
#[allow(
    clippy::panic,
    reason = "a bounded table's broken internal invariant is a library defect, not a recoverable outcome"
)]
pub fn invariant_violation(reason: impl core::fmt::Debug) -> ! {
    panic!("WarpTable invariant violated: {reason:?}")
}

impl From<IndexInconsistency> for WarpTableInconsistency {
    fn from(reason: IndexInconsistency) -> Self {
        match reason {
            IndexInconsistency::BucketUnavailable { bucket } => {
                Self::PrimaryBucketUnavailable { bucket }
            }
            IndexInconsistency::StoredRowUnrepresentable { stored_row } => {
                Self::PrimaryStoredRowUnrepresentable { stored_row }
            }
            IndexInconsistency::KeyUnavailable { row } => Self::IdUnavailable { row },
            IndexInconsistency::StoredRowMismatch { expected, actual } => {
                Self::PrimaryStoredRowMismatch { expected, actual }
            }
            IndexInconsistency::ProbeLimitReached => Self::PrimaryProbeLimitReached,
        }
    }
}

impl From<WarpTableRowGetError> for WarpTableInconsistency {
    fn from(reason: WarpTableRowGetError) -> Self {
        match reason {
            WarpTableRowGetError::ColumnUnavailable { column, row } => {
                Self::ColumnUnavailable { column, row }
            }
        }
    }
}

impl From<CommitInconsistency> for WarpTableInconsistency {
    fn from(reason: CommitInconsistency) -> Self {
        match reason {
            CommitInconsistency::RowUnrepresentable { vacancy, row } => {
                Self::PrimaryInsertRowUnrepresentable {
                    bucket: vacancy.bucket(),
                    row,
                }
            }
            CommitInconsistency::RowReserved { vacancy, row } => Self::PrimaryInsertRowReserved {
                bucket: vacancy.bucket(),
                row,
            },
            CommitInconsistency::VacancyUnavailable { vacancy, row } => {
                Self::PrimaryInsertVacancyUnavailable {
                    bucket: vacancy.bucket(),
                    row,
                }
            }
            CommitInconsistency::VacancyOccupied {
                vacancy,
                row,
                occupying_row,
            } => Self::PrimaryInsertVacancyOccupied {
                bucket: vacancy.bucket(),
                row,
                occupying_row,
            },
        }
    }
}