dcbor_pattern/pattern/meta/
mod.rs1mod and_pattern;
2mod any_pattern;
3mod capture_pattern;
4mod not_pattern;
5mod or_pattern;
6mod repeat_pattern;
7mod search_pattern;
8mod sequence_pattern;
9
10pub use and_pattern::*;
11pub use any_pattern::*;
12pub use capture_pattern::*;
13use dcbor::prelude::*;
14pub use not_pattern::*;
15pub use or_pattern::*;
16pub use repeat_pattern::*;
17pub use search_pattern::*;
18pub use sequence_pattern::*;
19
20use crate::pattern::{Matcher, Path, Pattern, vm::Instr};
21
22#[derive(Debug, Clone, PartialEq, Eq)]
24pub enum MetaPattern {
25 Any(AnyPattern),
27 And(AndPattern),
29 Or(OrPattern),
31 Not(NotPattern),
33 Repeat(RepeatPattern),
35 Capture(CapturePattern),
37 Search(SearchPattern),
39 Sequence(SequencePattern),
41}
42
43impl Matcher for MetaPattern {
44 fn paths(&self, haystack: &CBOR) -> Vec<Path> {
45 match self {
46 MetaPattern::Any(pattern) => pattern.paths(haystack),
47 MetaPattern::And(pattern) => pattern.paths(haystack),
48 MetaPattern::Or(pattern) => pattern.paths(haystack),
49 MetaPattern::Not(pattern) => pattern.paths(haystack),
50 MetaPattern::Repeat(pattern) => pattern.paths(haystack),
51 MetaPattern::Capture(pattern) => pattern.paths(haystack),
52 MetaPattern::Search(pattern) => pattern.paths(haystack),
53 MetaPattern::Sequence(pattern) => pattern.paths(haystack),
54 }
55 }
56
57 fn compile(
58 &self,
59 code: &mut Vec<Instr>,
60 lits: &mut Vec<Pattern>,
61 captures: &mut Vec<String>,
62 ) {
63 match self {
64 MetaPattern::Any(pattern) => pattern.compile(code, lits, captures),
65 MetaPattern::And(pattern) => pattern.compile(code, lits, captures),
66 MetaPattern::Or(pattern) => pattern.compile(code, lits, captures),
67 MetaPattern::Not(pattern) => pattern.compile(code, lits, captures),
68 MetaPattern::Repeat(pattern) => {
69 pattern.compile(code, lits, captures)
70 }
71 MetaPattern::Capture(pattern) => {
72 pattern.compile(code, lits, captures)
73 }
74 MetaPattern::Search(pattern) => {
75 pattern.compile(code, lits, captures)
76 }
77 MetaPattern::Sequence(pattern) => {
78 pattern.compile(code, lits, captures)
79 }
80 }
81 }
82
83 fn collect_capture_names(&self, names: &mut Vec<String>) {
84 match self {
85 MetaPattern::Any(pattern) => pattern.collect_capture_names(names),
86 MetaPattern::And(pattern) => pattern.collect_capture_names(names),
87 MetaPattern::Or(pattern) => pattern.collect_capture_names(names),
88 MetaPattern::Not(pattern) => pattern.collect_capture_names(names),
89 MetaPattern::Repeat(pattern) => {
90 pattern.collect_capture_names(names)
91 }
92 MetaPattern::Capture(pattern) => {
93 pattern.collect_capture_names(names)
94 }
95 MetaPattern::Search(pattern) => {
96 pattern.collect_capture_names(names)
97 }
98 MetaPattern::Sequence(pattern) => {
99 pattern.collect_capture_names(names)
100 }
101 }
102 }
103
104 fn is_complex(&self) -> bool {
105 match self {
106 MetaPattern::Any(pattern) => pattern.is_complex(),
107 MetaPattern::And(pattern) => pattern.is_complex(),
108 MetaPattern::Or(pattern) => pattern.is_complex(),
109 MetaPattern::Not(pattern) => pattern.is_complex(),
110 MetaPattern::Repeat(pattern) => pattern.is_complex(),
111 MetaPattern::Capture(pattern) => pattern.is_complex(),
112 MetaPattern::Search(pattern) => pattern.is_complex(),
113 MetaPattern::Sequence(pattern) => pattern.is_complex(),
114 }
115 }
116
117 fn paths_with_captures(
118 &self,
119 haystack: &CBOR,
120 ) -> (Vec<Path>, std::collections::HashMap<String, Vec<Path>>) {
121 match self {
122 MetaPattern::Any(pattern) => pattern.paths_with_captures(haystack),
123 MetaPattern::And(pattern) => pattern.paths_with_captures(haystack),
124 MetaPattern::Or(pattern) => pattern.paths_with_captures(haystack),
125 MetaPattern::Not(pattern) => pattern.paths_with_captures(haystack),
126 MetaPattern::Repeat(pattern) => {
127 pattern.paths_with_captures(haystack)
128 }
129 MetaPattern::Capture(pattern) => {
130 pattern.paths_with_captures(haystack)
131 }
132 MetaPattern::Search(pattern) => {
133 pattern.paths_with_captures(haystack)
134 }
135 MetaPattern::Sequence(pattern) => {
136 pattern.paths_with_captures(haystack)
137 }
138 }
139 }
140}
141
142impl std::fmt::Display for MetaPattern {
143 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
144 match self {
145 MetaPattern::Any(pattern) => pattern.fmt(f),
146 MetaPattern::And(pattern) => pattern.fmt(f),
147 MetaPattern::Or(pattern) => pattern.fmt(f),
148 MetaPattern::Not(pattern) => pattern.fmt(f),
149 MetaPattern::Repeat(pattern) => pattern.fmt(f),
150 MetaPattern::Capture(pattern) => pattern.fmt(f),
151 MetaPattern::Search(pattern) => pattern.fmt(f),
152 MetaPattern::Sequence(pattern) => pattern.fmt(f),
153 }
154 }
155}