prikk-store 0.23.0

Prikk storage crate scaffold.
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
124
125
126
127
128
129
130
131
132
133

use std::collections::BTreeSet;

use prikk_object::NodeId;

use crate::patch_replay::decode::DecodedPatchOperation;
use crate::path::RepoPath;

use super::types::{
    ConflictWitness, ConflictWitnessKind, OperationFacts, PairClass, RequiredOrder, UnknownReason,
};

pub(super) fn ordered(
    required_order: RequiredOrder,
    kind: ConflictWitnessKind,
    left: &OperationFacts,
    right: &OperationFacts,
    node_id: Option<NodeId>,
    path: Option<RepoPath>,
) -> PairClass {
    PairClass::OrderedDependency {
        required_order,
        witness: witness(kind, left.op_seq, right.op_seq, node_id, path, None),
    }
}

pub(super) fn conflict(
    kind: ConflictWitnessKind,
    left: &OperationFacts,
    right: &OperationFacts,
    node_id: Option<NodeId>,
    path: Option<RepoPath>,
) -> PairClass {
    PairClass::Conflict {
        witness: witness(kind, left.op_seq, right.op_seq, node_id, path, None),
    }
}

pub(super) fn conflict_with_span(
    kind: ConflictWitnessKind,
    left: &OperationFacts,
    right: &OperationFacts,
    node_id: NodeId,
    span_id: [u8; 32],
) -> PairClass {
    PairClass::Conflict {
        witness: witness(
            kind,
            left.op_seq,
            right.op_seq,
            Some(node_id),
            None,
            Some(span_id),
        ),
    }
}

pub(super) fn unknown(
    reason: UnknownReason,
    left: &DecodedPatchOperation,
    right: &DecodedPatchOperation,
    node_id: Option<NodeId>,
    path: Option<RepoPath>,
) -> PairClass {
    PairClass::Unknown {
        reason,
        witness: witness(
            match reason {
                UnknownReason::MalformedOperation => ConflictWitnessKind::MalformedOperation,
                UnknownReason::RenameDeferred | UnknownReason::SymlinkDeferred => {
                    ConflictWitnessKind::UnsupportedOperation
                }
                _ => ConflictWitnessKind::UnknownRelation,
            },
            left.op_seq,
            right.op_seq,
            node_id,
            path,
            None,
        ),
    }
}

pub(super) fn unknown_from_facts(
    reason: UnknownReason,
    left: &OperationFacts,
    right: &OperationFacts,
    node_id: Option<NodeId>,
    path: Option<RepoPath>,
) -> PairClass {
    PairClass::Unknown {
        reason,
        witness: witness(
            ConflictWitnessKind::UnknownRelation,
            left.op_seq,
            right.op_seq,
            node_id,
            path,
            None,
        ),
    }
}

fn witness(
    kind: ConflictWitnessKind,
    left_op_seq: u32,
    right_op_seq: u32,
    node_id: Option<NodeId>,
    path: Option<RepoPath>,
    text_span: Option<[u8; 32]>,
) -> ConflictWitness {
    ConflictWitness {
        kind,
        left_op_seq,
        right_op_seq,
        node_id,
        path,
        text_span,
    }
}

pub(super) fn common_node(left: &OperationFacts, right: &OperationFacts) -> Option<NodeId> {
    match (left.node_id, right.node_id) {
        (Some(left_id), Some(right_id)) if left_id == right_id => Some(left_id),
        _ => None,
    }
}

pub(super) fn first_intersection(
    left: &BTreeSet<RepoPath>,
    right: &BTreeSet<RepoPath>,
) -> Option<RepoPath> {
    left.iter().find(|path| right.contains(*path)).cloned()
}