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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
use std::{cmp::Ordering, collections::HashMap};
use bstr::BStr;
use crate::{
file::{self, SectionBodyIdsLut, SectionId},
lookup,
parse::section,
File,
};
/// Private helper functions
impl<'event> File<'event> {
/// Adds a new section to the config file, returning the section id of the newly added section.
pub(crate) fn push_section_internal(&mut self, mut section: file::Section<'event>) -> SectionId {
let new_section_id = SectionId(self.section_id_counter);
section.id = new_section_id;
self.sections.insert(new_section_id, section);
let header = &self.sections[&new_section_id].header;
let lookup = self.section_lookup_tree.entry(header.name.clone()).or_default();
let mut found_node = false;
if let Some(subsection_name) = header.subsection_name.clone() {
for node in lookup.iter_mut() {
if let SectionBodyIdsLut::NonTerminal(subsections) = node {
found_node = true;
subsections
.entry(subsection_name.clone())
.or_default()
.push(new_section_id);
break;
}
}
if !found_node {
let mut map = HashMap::new();
map.insert(subsection_name, vec![new_section_id]);
lookup.push(SectionBodyIdsLut::NonTerminal(map));
}
} else {
for node in lookup.iter_mut() {
if let SectionBodyIdsLut::Terminal(vec) = node {
found_node = true;
vec.push(new_section_id);
break;
}
}
if !found_node {
lookup.push(SectionBodyIdsLut::Terminal(vec![new_section_id]));
}
}
self.section_order.push_back(new_section_id);
self.section_id_counter += 1;
new_section_id
}
/// Inserts `section` after the section that comes `before` it, and maintains correct ordering in all of our lookup structures.
pub(crate) fn insert_section_after(&mut self, mut section: file::Section<'event>, before: SectionId) -> SectionId {
let lookup_section_order = {
let section_order = &self.section_order;
move |section_id| {
section_order
.iter()
.enumerate()
.find_map(|(idx, id)| (*id == section_id).then_some(idx))
.expect("before-section exists")
}
};
let before_order = lookup_section_order(before);
let new_section_id = SectionId(self.section_id_counter);
section.id = new_section_id;
self.sections.insert(new_section_id, section);
let header = &self.sections[&new_section_id].header;
let lookup = self.section_lookup_tree.entry(header.name.clone()).or_default();
let mut found_node = false;
if let Some(subsection_name) = header.subsection_name.clone() {
for node in lookup.iter_mut() {
if let SectionBodyIdsLut::NonTerminal(subsections) = node {
found_node = true;
let sections_with_name_and_subsection_name =
subsections.entry(subsection_name.clone()).or_default();
let insert_pos = find_insert_pos_by_order(
sections_with_name_and_subsection_name,
before_order,
lookup_section_order,
);
sections_with_name_and_subsection_name.insert(insert_pos, new_section_id);
break;
}
}
if !found_node {
let mut map = HashMap::new();
map.insert(subsection_name, vec![new_section_id]);
lookup.push(SectionBodyIdsLut::NonTerminal(map));
}
} else {
for node in lookup.iter_mut() {
if let SectionBodyIdsLut::Terminal(sections_with_name) = node {
found_node = true;
let insert_pos = find_insert_pos_by_order(sections_with_name, before_order, lookup_section_order);
sections_with_name.insert(insert_pos, new_section_id);
break;
}
}
if !found_node {
lookup.push(SectionBodyIdsLut::Terminal(vec![new_section_id]));
}
}
self.section_order.insert(before_order + 1, new_section_id);
self.section_id_counter += 1;
new_section_id
}
/// Returns the mapping between section and subsection name to section ids.
pub(crate) fn section_ids_by_name_and_subname<'a>(
&'a self,
section_name: &'a str,
subsection_name: Option<&BStr>,
) -> Result<impl Iterator<Item = SectionId> + ExactSizeIterator + DoubleEndedIterator + '_, lookup::existing::Error>
{
let section_name = section::Name::from_str_unchecked(section_name);
let section_ids = self
.section_lookup_tree
.get(§ion_name)
.ok_or(lookup::existing::Error::SectionMissing)?;
let mut maybe_ids = None;
if let Some(subsection_name) = subsection_name {
for node in section_ids {
if let SectionBodyIdsLut::NonTerminal(subsection_lookup) = node {
maybe_ids = subsection_lookup.get(subsection_name).map(|v| v.iter().copied());
break;
}
}
} else {
for node in section_ids {
if let SectionBodyIdsLut::Terminal(subsection_lookup) = node {
maybe_ids = Some(subsection_lookup.iter().copied());
break;
}
}
}
maybe_ids.ok_or(lookup::existing::Error::SubSectionMissing)
}
pub(crate) fn section_ids_by_name<'a>(
&'a self,
section_name: &'a str,
) -> Result<impl Iterator<Item = SectionId> + '_, lookup::existing::Error> {
let section_name = section::Name::from_str_unchecked(section_name);
match self.section_lookup_tree.get(§ion_name) {
Some(lookup) => {
let mut lut = Vec::with_capacity(self.section_order.len());
for node in lookup {
match node {
SectionBodyIdsLut::Terminal(v) => lut.extend(v.iter().copied()),
SectionBodyIdsLut::NonTerminal(v) => lut.extend(v.values().flatten().copied()),
}
}
Ok(self.section_order.iter().filter(move |a| lut.contains(a)).copied())
}
None => Err(lookup::existing::Error::SectionMissing),
}
}
}
fn find_insert_pos_by_order(
sections_with_name: &[SectionId],
before_order: usize,
lookup_section_order: impl Fn(SectionId) -> usize,
) -> usize {
let mut insert_pos = sections_with_name.len(); // push back by default
for (idx, candidate_id) in sections_with_name.iter().enumerate() {
let candidate_order = lookup_section_order(*candidate_id);
match candidate_order.cmp(&before_order) {
Ordering::Less => {}
Ordering::Equal => {
insert_pos = idx + 1; // insert right after this one
break;
}
Ordering::Greater => {
insert_pos = idx; // insert before this one
break;
}
}
}
insert_pos
}
|
