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
81
82
83
84
85
86
87
88
89

use super::dense_key_index::FindOutcome;
use super::inconsistency::invariant_violation;
use super::{
    WarpTable, WarpTableInconsistency, WarpTableRow, WarpTableRowGetOutcome,
    WarpTableRowReplaceError, WarpTableRowReplaceOutcome,
};

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[must_use]
pub enum WarpTableReplaceOutcome<Id, Row: WarpTableRow> {
    Replaced {
        id: Id,
        row: usize,
        previous: Row,
    },
    Absent {
        id: Id,
        rejected: Row,
    },
    UniqueConflict {
        id: Id,
        conflict: Row::UniqueConflict,
        rejected: Row,
    },
}

impl<Row: WarpTableRow, Brand> WarpTable<Row, Brand> {
    pub fn replace(
        &mut self,
        id: Row::Id,
        replacement: Row,
    ) -> WarpTableReplaceOutcome<Row::Id, Row> {
        let found = {
            let ids = &self.ids;
            if ids.len() != self.len {
                invariant_violation(WarpTableInconsistency::IdColumnLengthMismatch {
                    ids: ids.len(),
                    rows: self.len,
                });
            }
            self.primary_index.find(id, ids)
        };
        let row = match found {
            Ok(FindOutcome::Present { row, .. }) => row,
            Ok(FindOutcome::Absent) => {
                return WarpTableReplaceOutcome::Absent {
                    id,
                    rejected: replacement,
                };
            }
            Err(reason) => invariant_violation(WarpTableInconsistency::from(reason)),
        };
        match self.replace_at(id, row, replacement) {
            Ok(previous) => WarpTableReplaceOutcome::Replaced { id, row, previous },
            Err((conflict, rejected)) => WarpTableReplaceOutcome::UniqueConflict {
                id,
                conflict,
                rejected,
            },
        }
    }

    pub(super) fn replace_at(
        &mut self,
        id: Row::Id,
        row: usize,
        replacement: Row,
    ) -> Result<Row, (Row::UniqueConflict, Row)> {
        let WarpTableRowGetOutcome::Present { row: current } = Row::get(&id, &self.columns, row)
            .unwrap_or_else(|reason| invariant_violation(WarpTableInconsistency::from(reason)));
        if let Some(conflict) = Row::unique_replace_conflict(&self.indexes, current, &replacement) {
            return Err((conflict, replacement));
        }
        let WarpTableRowGetOutcome::Present { row: current } = Row::get(&id, &self.columns, row)
            .unwrap_or_else(|reason| invariant_violation(WarpTableInconsistency::from(reason)));
        let indexes_replace =
            Row::try_prepare_indexes_replace(&mut self.indexes, current, &replacement, row)
                .unwrap_or_else(|reason| invariant_violation(reason));
        match Row::replace(&mut self.columns, row, replacement) {
            Ok(WarpTableRowReplaceOutcome::Replaced { previous }) => {
                Row::commit_indexes_replace(indexes_replace);
                Ok(previous)
            }
            Err(WarpTableRowReplaceError::ColumnUnavailable { column, row, .. }) => {
                invariant_violation(WarpTableInconsistency::ColumnUnavailable { column, row })
            }
        }
    }
}