bc-envelope-pattern 0.12.1

Pattern matcher for Gordian Envelope
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

// Structure patterns - patterns dealing with envelope structure

mod assertions_pattern;
mod digest_pattern;
mod leaf_structure_pattern;
mod node_pattern;
mod object_pattern;
mod obscured_pattern;
mod predicate_pattern;
mod subject_pattern;
mod wrapped_pattern;

use std::collections::HashMap;

pub(crate) use assertions_pattern::AssertionsPattern;
use bc_envelope::prelude::*;
pub(crate) use digest_pattern::DigestPattern;
pub(crate) use leaf_structure_pattern::LeafStructurePattern;
pub(crate) use node_pattern::NodePattern;
pub(crate) use object_pattern::ObjectPattern;
pub(crate) use obscured_pattern::ObscuredPattern;
pub(crate) use predicate_pattern::PredicatePattern;
pub(crate) use subject_pattern::SubjectPattern;
pub(crate) use wrapped_pattern::WrappedPattern;

use crate::pattern::{Matcher, Path, Pattern, vm::Instr};

/// Pattern for matching envelope structure elements.
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum StructurePattern {
    /// Matches assertions.
    Assertions(AssertionsPattern),
    /// Matches digests.
    Digest(DigestPattern),
    /// Matches leaf envelopes.
    Leaf(LeafStructurePattern),
    /// Matches nodes.
    Node(NodePattern),
    /// Matches objects.
    Object(ObjectPattern),
    /// Matches obscured elements.
    Obscured(ObscuredPattern),
    /// Matches predicates.
    Predicate(PredicatePattern),
    /// Matches subjects.
    Subject(SubjectPattern),
    /// Matches wrapped envelopes.
    Wrapped(WrappedPattern),
}

impl Matcher for StructurePattern {
    fn paths_with_captures(
        &self,
        haystack: &Envelope,
    ) -> (Vec<Path>, HashMap<String, Vec<Path>>) {
        match self {
            StructurePattern::Assertions(pattern) => {
                pattern.paths_with_captures(haystack)
            }
            StructurePattern::Digest(pattern) => {
                pattern.paths_with_captures(haystack)
            }
            StructurePattern::Leaf(pattern) => {
                pattern.paths_with_captures(haystack)
            }
            StructurePattern::Node(pattern) => {
                pattern.paths_with_captures(haystack)
            }
            StructurePattern::Object(pattern) => {
                pattern.paths_with_captures(haystack)
            }
            StructurePattern::Obscured(pattern) => {
                pattern.paths_with_captures(haystack)
            }
            StructurePattern::Predicate(pattern) => {
                pattern.paths_with_captures(haystack)
            }
            StructurePattern::Subject(pattern) => {
                pattern.paths_with_captures(haystack)
            }
            StructurePattern::Wrapped(pattern) => {
                pattern.paths_with_captures(haystack)
            }
        }
    }

    fn compile(
        &self,
        code: &mut Vec<Instr>,
        lits: &mut Vec<Pattern>,
        captures: &mut Vec<String>,
    ) {
        match self {
            StructurePattern::Subject(s) => s.compile(code, lits, captures),
            StructurePattern::Assertions(s) => s.compile(code, lits, captures),
            StructurePattern::Wrapped(s) => s.compile(code, lits, captures),
            StructurePattern::Object(s) => s.compile(code, lits, captures),
            StructurePattern::Digest(s) => s.compile(code, lits, captures),
            StructurePattern::Leaf(s) => s.compile(code, lits, captures),
            StructurePattern::Node(s) => s.compile(code, lits, captures),
            StructurePattern::Obscured(s) => s.compile(code, lits, captures),
            StructurePattern::Predicate(s) => s.compile(code, lits, captures),
        }
    }

    fn is_complex(&self) -> bool {
        match self {
            StructurePattern::Assertions(pattern) => pattern.is_complex(),
            StructurePattern::Digest(pattern) => pattern.is_complex(),
            StructurePattern::Leaf(pattern) => pattern.is_complex(),
            StructurePattern::Node(pattern) => pattern.is_complex(),
            StructurePattern::Object(pattern) => pattern.is_complex(),
            StructurePattern::Obscured(pattern) => pattern.is_complex(),
            StructurePattern::Predicate(pattern) => pattern.is_complex(),
            StructurePattern::Subject(pattern) => pattern.is_complex(),
            StructurePattern::Wrapped(pattern) => pattern.is_complex(),
        }
    }
}

impl std::fmt::Display for StructurePattern {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            StructurePattern::Assertions(pattern) => write!(f, "{}", pattern),
            StructurePattern::Digest(pattern) => write!(f, "{}", pattern),
            StructurePattern::Leaf(pattern) => write!(f, "{}", pattern),
            StructurePattern::Node(pattern) => write!(f, "{}", pattern),
            StructurePattern::Object(pattern) => write!(f, "{}", pattern),
            StructurePattern::Obscured(pattern) => write!(f, "{}", pattern),
            StructurePattern::Predicate(pattern) => write!(f, "{}", pattern),
            StructurePattern::Subject(pattern) => write!(f, "{}", pattern),
            StructurePattern::Wrapped(pattern) => write!(f, "{}", pattern),
        }
    }
}