graphrecords-query 0.5.0

High-performance graph-based data records
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use crate::{Diagnostic, IndexDomain};
use std::{
    error::Error,
    fmt::{self, Debug, Display, Formatter},
};

pub struct DuplicateIndex<I: IndexDomain> {
    index: I::Owned,
}

impl<I: IndexDomain> DuplicateIndex<I> {
    #[must_use]
    pub const fn new(index: I::Owned) -> Self {
        Self { index }
    }

    #[must_use]
    pub const fn index(&self) -> &I::Owned {
        &self.index
    }
}

impl<I: IndexDomain> Debug for DuplicateIndex<I> {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("DuplicateIndex")
            .field("index", &self.index)
            .finish()
    }
}

impl<I: IndexDomain> Display for DuplicateIndex<I> {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        write!(
            formatter,
            "index `{}` occurs more than once in one indexed operand",
            self.index
        )
    }
}

impl<I: IndexDomain> Error for DuplicateIndex<I> {}

impl<I: IndexDomain> Diagnostic for DuplicateIndex<I> {
    fn name() -> &'static str {
        "DuplicateIndex"
    }

    fn help(&self) -> Option<String> {
        Some("construct each index at most once in one indexed operand".to_string())
    }
}

pub struct DuplicateExpandedChildIndex<C: IndexDomain> {
    index: C::Owned,
}

impl<C: IndexDomain> DuplicateExpandedChildIndex<C> {
    #[must_use]
    pub const fn new(index: C::Owned) -> Self {
        Self { index }
    }

    #[must_use]
    pub const fn index(&self) -> &C::Owned {
        &self.index
    }
}

impl<C: IndexDomain> Debug for DuplicateExpandedChildIndex<C> {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("DuplicateExpandedChildIndex")
            .field("index", &self.index)
            .finish()
    }
}

impl<C: IndexDomain> Display for DuplicateExpandedChildIndex<C> {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        write!(
            formatter,
            "expanded child index `{}` occurs more than once under one parent",
            self.index
        )
    }
}

impl<C: IndexDomain> Error for DuplicateExpandedChildIndex<C> {}

impl<C: IndexDomain> Diagnostic for DuplicateExpandedChildIndex<C> {
    fn name() -> &'static str {
        "DuplicateExpandedChildIndex"
    }

    fn help(&self) -> Option<String> {
        Some("emit each child index at most once for one expanded parent".to_string())
    }
}

pub struct NoChildIndex<P: IndexDomain> {
    parent: P::Owned,
}

impl<P: IndexDomain> NoChildIndex<P> {
    #[must_use]
    pub const fn new(parent: P::Owned) -> Self {
        Self { parent }
    }

    #[must_use]
    pub const fn parent_index(&self) -> &P::Owned {
        &self.parent
    }
}

impl<P: IndexDomain> Debug for NoChildIndex<P> {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("NoChildIndex")
            .field("parent", &self.parent)
            .finish()
    }
}

impl<P: IndexDomain> Display for NoChildIndex<P> {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        write!(
            formatter,
            "address `source({})` has no child component",
            self.parent
        )
    }
}

impl<P: IndexDomain> Error for NoChildIndex<P> {}

impl<P: IndexDomain> Diagnostic for NoChildIndex<P> {
    fn name() -> &'static str {
        "NoChildIndex"
    }

    fn help(&self) -> Option<String> {
        Some(
            "source(...) addresses mark parents whose expansion failed; handle those elements with on_error before projecting child indices"
                .to_string(),
        )
    }
}