1 | use std::iter::FromIterator; |
2 | |
3 | use indexmap::map::IndexMap; |
4 | |
5 | use crate::key::Key; |
6 | use crate::repr::Decor; |
7 | use crate::value::DEFAULT_VALUE_DECOR; |
8 | use crate::{InlineTable, InternalString, Item, KeyMut, Value}; |
9 | |
10 | /// Type representing a TOML non-inline table |
11 | #[derive (Clone, Debug, Default)] |
12 | pub struct Table { |
13 | // Comments/spaces before and after the header |
14 | pub(crate) decor: Decor, |
15 | // Whether to hide an empty table |
16 | pub(crate) implicit: bool, |
17 | // Whether this is a proxy for dotted keys |
18 | pub(crate) dotted: bool, |
19 | // Used for putting tables back in their original order when serialising. |
20 | // |
21 | // `None` for user created tables (can be overridden with `set_position`) |
22 | doc_position: Option<usize>, |
23 | pub(crate) span: Option<std::ops::Range<usize>>, |
24 | pub(crate) items: KeyValuePairs, |
25 | } |
26 | |
27 | /// Constructors |
28 | /// |
29 | /// See also `FromIterator` |
30 | impl Table { |
31 | /// Creates an empty table. |
32 | pub fn new() -> Self { |
33 | Default::default() |
34 | } |
35 | |
36 | pub(crate) fn with_pos(doc_position: Option<usize>) -> Self { |
37 | Self { |
38 | doc_position, |
39 | ..Default::default() |
40 | } |
41 | } |
42 | |
43 | pub(crate) fn with_pairs(items: KeyValuePairs) -> Self { |
44 | Self { |
45 | items, |
46 | ..Default::default() |
47 | } |
48 | } |
49 | |
50 | /// Convert to an inline table |
51 | pub fn into_inline_table(mut self) -> InlineTable { |
52 | for (_, kv) in self.items.iter_mut() { |
53 | kv.value.make_value(); |
54 | } |
55 | let mut t = InlineTable::with_pairs(self.items); |
56 | t.fmt(); |
57 | t |
58 | } |
59 | } |
60 | |
61 | /// Formatting |
62 | impl Table { |
63 | /// Get key/values for values that are visually children of this table |
64 | /// |
65 | /// For example, this will return dotted keys |
66 | pub fn get_values(&self) -> Vec<(Vec<&Key>, &Value)> { |
67 | let mut values = Vec::new(); |
68 | let root = Vec::new(); |
69 | self.append_values(&root, &mut values); |
70 | values |
71 | } |
72 | |
73 | fn append_values<'s, 'c>( |
74 | &'s self, |
75 | parent: &[&'s Key], |
76 | values: &'c mut Vec<(Vec<&'s Key>, &'s Value)>, |
77 | ) { |
78 | for value in self.items.values() { |
79 | let mut path = parent.to_vec(); |
80 | path.push(&value.key); |
81 | match &value.value { |
82 | Item::Table(table) if table.is_dotted() => { |
83 | table.append_values(&path, values); |
84 | } |
85 | Item::Value(value) => { |
86 | if let Some(table) = value.as_inline_table() { |
87 | if table.is_dotted() { |
88 | table.append_values(&path, values); |
89 | } else { |
90 | values.push((path, value)); |
91 | } |
92 | } else { |
93 | values.push((path, value)); |
94 | } |
95 | } |
96 | _ => {} |
97 | } |
98 | } |
99 | } |
100 | |
101 | /// Auto formats the table. |
102 | pub fn fmt(&mut self) { |
103 | decorate_table(self); |
104 | } |
105 | |
106 | /// Sorts Key/Value Pairs of the table. |
107 | /// |
108 | /// Doesn't affect subtables or subarrays. |
109 | pub fn sort_values(&mut self) { |
110 | // Assuming standard tables have their doc_position set and this won't negatively impact them |
111 | self.items.sort_keys(); |
112 | for kv in self.items.values_mut() { |
113 | match &mut kv.value { |
114 | Item::Table(table) if table.is_dotted() => { |
115 | table.sort_values(); |
116 | } |
117 | _ => {} |
118 | } |
119 | } |
120 | } |
121 | |
122 | /// Sort Key/Value Pairs of the table using the using the comparison function `compare`. |
123 | /// |
124 | /// The comparison function receives two key and value pairs to compare (you can sort by keys or |
125 | /// values or their combination as needed). |
126 | pub fn sort_values_by<F>(&mut self, mut compare: F) |
127 | where |
128 | F: FnMut(&Key, &Item, &Key, &Item) -> std::cmp::Ordering, |
129 | { |
130 | self.sort_values_by_internal(&mut compare); |
131 | } |
132 | |
133 | fn sort_values_by_internal<F>(&mut self, compare: &mut F) |
134 | where |
135 | F: FnMut(&Key, &Item, &Key, &Item) -> std::cmp::Ordering, |
136 | { |
137 | let modified_cmp = |_: &InternalString, |
138 | val1: &TableKeyValue, |
139 | _: &InternalString, |
140 | val2: &TableKeyValue| |
141 | -> std::cmp::Ordering { |
142 | compare(&val1.key, &val1.value, &val2.key, &val2.value) |
143 | }; |
144 | |
145 | self.items.sort_by(modified_cmp); |
146 | |
147 | for kv in self.items.values_mut() { |
148 | match &mut kv.value { |
149 | Item::Table(table) if table.is_dotted() => { |
150 | table.sort_values_by_internal(compare); |
151 | } |
152 | _ => {} |
153 | } |
154 | } |
155 | } |
156 | |
157 | /// If a table has no key/value pairs and implicit, it will not be displayed. |
158 | /// |
159 | /// # Examples |
160 | /// |
161 | /// ```notrust |
162 | /// [target."x86_64/windows.json".dependencies] |
163 | /// ``` |
164 | /// |
165 | /// In the document above, tables `target` and `target."x86_64/windows.json"` are implicit. |
166 | /// |
167 | /// ``` |
168 | /// use toml_edit::Document; |
169 | /// let mut doc = "[a] \n[a.b] \n" .parse::<Document>().expect("invalid toml" ); |
170 | /// |
171 | /// doc["a" ].as_table_mut().unwrap().set_implicit(true); |
172 | /// assert_eq!(doc.to_string(), "[a.b] \n" ); |
173 | /// ``` |
174 | pub fn set_implicit(&mut self, implicit: bool) { |
175 | self.implicit = implicit; |
176 | } |
177 | |
178 | /// If a table has no key/value pairs and implicit, it will not be displayed. |
179 | pub fn is_implicit(&self) -> bool { |
180 | self.implicit |
181 | } |
182 | |
183 | /// Change this table's dotted status |
184 | pub fn set_dotted(&mut self, yes: bool) { |
185 | self.dotted = yes; |
186 | } |
187 | |
188 | /// Check if this is a wrapper for dotted keys, rather than a standard table |
189 | pub fn is_dotted(&self) -> bool { |
190 | self.dotted |
191 | } |
192 | |
193 | /// Sets the position of the `Table` within the `Document`. |
194 | pub fn set_position(&mut self, doc_position: usize) { |
195 | self.doc_position = Some(doc_position); |
196 | } |
197 | |
198 | /// The position of the `Table` within the `Document`. |
199 | /// |
200 | /// Returns `None` if the `Table` was created manually (i.e. not via parsing) |
201 | /// in which case its position is set automatically. This can be overridden with |
202 | /// [`Table::set_position`]. |
203 | pub fn position(&self) -> Option<usize> { |
204 | self.doc_position |
205 | } |
206 | |
207 | /// Returns the surrounding whitespace |
208 | pub fn decor_mut(&mut self) -> &mut Decor { |
209 | &mut self.decor |
210 | } |
211 | |
212 | /// Returns the decor associated with a given key of the table. |
213 | pub fn decor(&self) -> &Decor { |
214 | &self.decor |
215 | } |
216 | |
217 | /// Returns the decor associated with a given key of the table. |
218 | pub fn key_decor_mut(&mut self, key: &str) -> Option<&mut Decor> { |
219 | self.items.get_mut(key).map(|kv| &mut kv.key.decor) |
220 | } |
221 | |
222 | /// Returns the decor associated with a given key of the table. |
223 | pub fn key_decor(&self, key: &str) -> Option<&Decor> { |
224 | self.items.get(key).map(|kv| &kv.key.decor) |
225 | } |
226 | |
227 | /// Returns the location within the original document |
228 | pub(crate) fn span(&self) -> Option<std::ops::Range<usize>> { |
229 | self.span.clone() |
230 | } |
231 | |
232 | pub(crate) fn despan(&mut self, input: &str) { |
233 | self.span = None; |
234 | self.decor.despan(input); |
235 | for kv in self.items.values_mut() { |
236 | kv.key.despan(input); |
237 | kv.value.despan(input); |
238 | } |
239 | } |
240 | } |
241 | |
242 | impl Table { |
243 | /// Returns an iterator over all key/value pairs, including empty. |
244 | pub fn iter(&self) -> Iter<'_> { |
245 | Box::new( |
246 | self.items |
247 | .iter() |
248 | .filter(|(_, kv)| !kv.value.is_none()) |
249 | .map(|(key, kv)| (&key[..], &kv.value)), |
250 | ) |
251 | } |
252 | |
253 | /// Returns an mutable iterator over all key/value pairs, including empty. |
254 | pub fn iter_mut(&mut self) -> IterMut<'_> { |
255 | Box::new( |
256 | self.items |
257 | .iter_mut() |
258 | .filter(|(_, kv)| !kv.value.is_none()) |
259 | .map(|(_, kv)| (kv.key.as_mut(), &mut kv.value)), |
260 | ) |
261 | } |
262 | |
263 | /// Returns the number of non-empty items in the table. |
264 | pub fn len(&self) -> usize { |
265 | self.items.iter().filter(|i| !(i.1).value.is_none()).count() |
266 | } |
267 | |
268 | /// Returns true if the table is empty. |
269 | pub fn is_empty(&self) -> bool { |
270 | self.len() == 0 |
271 | } |
272 | |
273 | /// Clears the table, removing all key-value pairs. Keeps the allocated memory for reuse. |
274 | pub fn clear(&mut self) { |
275 | self.items.clear() |
276 | } |
277 | |
278 | /// Gets the given key's corresponding entry in the Table for in-place manipulation. |
279 | pub fn entry<'a>(&'a mut self, key: &str) -> Entry<'a> { |
280 | // Accept a `&str` rather than an owned type to keep `InternalString`, well, internal |
281 | match self.items.entry(key.into()) { |
282 | indexmap::map::Entry::Occupied(entry) => Entry::Occupied(OccupiedEntry { entry }), |
283 | indexmap::map::Entry::Vacant(entry) => Entry::Vacant(VacantEntry { entry, key: None }), |
284 | } |
285 | } |
286 | |
287 | /// Gets the given key's corresponding entry in the Table for in-place manipulation. |
288 | pub fn entry_format<'a>(&'a mut self, key: &Key) -> Entry<'a> { |
289 | // Accept a `&Key` to be consistent with `entry` |
290 | match self.items.entry(key.get().into()) { |
291 | indexmap::map::Entry::Occupied(entry) => Entry::Occupied(OccupiedEntry { entry }), |
292 | indexmap::map::Entry::Vacant(entry) => Entry::Vacant(VacantEntry { |
293 | entry, |
294 | key: Some(key.to_owned()), |
295 | }), |
296 | } |
297 | } |
298 | |
299 | /// Returns an optional reference to an item given the key. |
300 | pub fn get<'a>(&'a self, key: &str) -> Option<&'a Item> { |
301 | self.items.get(key).and_then(|kv| { |
302 | if !kv.value.is_none() { |
303 | Some(&kv.value) |
304 | } else { |
305 | None |
306 | } |
307 | }) |
308 | } |
309 | |
310 | /// Returns an optional mutable reference to an item given the key. |
311 | pub fn get_mut<'a>(&'a mut self, key: &str) -> Option<&'a mut Item> { |
312 | self.items.get_mut(key).and_then(|kv| { |
313 | if !kv.value.is_none() { |
314 | Some(&mut kv.value) |
315 | } else { |
316 | None |
317 | } |
318 | }) |
319 | } |
320 | |
321 | /// Return references to the key-value pair stored for key, if it is present, else None. |
322 | pub fn get_key_value<'a>(&'a self, key: &str) -> Option<(&'a Key, &'a Item)> { |
323 | self.items.get(key).and_then(|kv| { |
324 | if !kv.value.is_none() { |
325 | Some((&kv.key, &kv.value)) |
326 | } else { |
327 | None |
328 | } |
329 | }) |
330 | } |
331 | |
332 | /// Return mutable references to the key-value pair stored for key, if it is present, else None. |
333 | pub fn get_key_value_mut<'a>(&'a mut self, key: &str) -> Option<(KeyMut<'a>, &'a mut Item)> { |
334 | self.items.get_mut(key).and_then(|kv| { |
335 | if !kv.value.is_none() { |
336 | Some((kv.key.as_mut(), &mut kv.value)) |
337 | } else { |
338 | None |
339 | } |
340 | }) |
341 | } |
342 | |
343 | /// Returns true if the table contains an item with the given key. |
344 | pub fn contains_key(&self, key: &str) -> bool { |
345 | if let Some(kv) = self.items.get(key) { |
346 | !kv.value.is_none() |
347 | } else { |
348 | false |
349 | } |
350 | } |
351 | |
352 | /// Returns true if the table contains a table with the given key. |
353 | pub fn contains_table(&self, key: &str) -> bool { |
354 | if let Some(kv) = self.items.get(key) { |
355 | kv.value.is_table() |
356 | } else { |
357 | false |
358 | } |
359 | } |
360 | |
361 | /// Returns true if the table contains a value with the given key. |
362 | pub fn contains_value(&self, key: &str) -> bool { |
363 | if let Some(kv) = self.items.get(key) { |
364 | kv.value.is_value() |
365 | } else { |
366 | false |
367 | } |
368 | } |
369 | |
370 | /// Returns true if the table contains an array of tables with the given key. |
371 | pub fn contains_array_of_tables(&self, key: &str) -> bool { |
372 | if let Some(kv) = self.items.get(key) { |
373 | kv.value.is_array_of_tables() |
374 | } else { |
375 | false |
376 | } |
377 | } |
378 | |
379 | /// Inserts a key-value pair into the map. |
380 | pub fn insert(&mut self, key: &str, item: Item) -> Option<Item> { |
381 | let kv = TableKeyValue::new(Key::new(key), item); |
382 | self.items.insert(key.into(), kv).map(|kv| kv.value) |
383 | } |
384 | |
385 | /// Inserts a key-value pair into the map. |
386 | pub fn insert_formatted(&mut self, key: &Key, item: Item) -> Option<Item> { |
387 | let kv = TableKeyValue::new(key.to_owned(), item); |
388 | self.items.insert(key.get().into(), kv).map(|kv| kv.value) |
389 | } |
390 | |
391 | /// Removes an item given the key. |
392 | pub fn remove(&mut self, key: &str) -> Option<Item> { |
393 | self.items.shift_remove(key).map(|kv| kv.value) |
394 | } |
395 | |
396 | /// Removes a key from the map, returning the stored key and value if the key was previously in the map. |
397 | pub fn remove_entry(&mut self, key: &str) -> Option<(Key, Item)> { |
398 | self.items.shift_remove(key).map(|kv| (kv.key, kv.value)) |
399 | } |
400 | } |
401 | |
402 | impl std::fmt::Display for Table { |
403 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
404 | use crate::encode::Encode; |
405 | let children: Vec<(Vec<&Key>, &Value)> = self.get_values(); |
406 | // print table body |
407 | for (key_path: Vec<&Key>, value: &Value) in children { |
408 | key_path.as_slice().encode(buf:f, input:None, DEFAULT_KEY_DECOR)?; |
409 | write!(f, "=" )?; |
410 | value.encode(buf:f, input:None, DEFAULT_VALUE_DECOR)?; |
411 | writeln!(f)?; |
412 | } |
413 | Ok(()) |
414 | } |
415 | } |
416 | |
417 | impl<K: Into<Key>, V: Into<Value>> Extend<(K, V)> for Table { |
418 | fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) { |
419 | for (key: K, value: V) in iter { |
420 | let key: Key = key.into(); |
421 | let value: Item = Item::Value(value.into()); |
422 | let value: TableKeyValue = TableKeyValue::new(key, value); |
423 | self.items.insert(key:value.key.get().into(), value); |
424 | } |
425 | } |
426 | } |
427 | |
428 | impl<K: Into<Key>, V: Into<Value>> FromIterator<(K, V)> for Table { |
429 | fn from_iter<I>(iter: I) -> Self |
430 | where |
431 | I: IntoIterator<Item = (K, V)>, |
432 | { |
433 | let mut table: Table = Table::new(); |
434 | table.extend(iter); |
435 | table |
436 | } |
437 | } |
438 | |
439 | impl IntoIterator for Table { |
440 | type Item = (InternalString, Item); |
441 | type IntoIter = IntoIter; |
442 | |
443 | fn into_iter(self) -> Self::IntoIter { |
444 | Box::new(self.items.into_iter().map(|(k: InternalString, kv: TableKeyValue)| (k, kv.value))) |
445 | } |
446 | } |
447 | |
448 | impl<'s> IntoIterator for &'s Table { |
449 | type Item = (&'s str, &'s Item); |
450 | type IntoIter = Iter<'s>; |
451 | |
452 | fn into_iter(self) -> Self::IntoIter { |
453 | self.iter() |
454 | } |
455 | } |
456 | |
457 | pub(crate) type KeyValuePairs = IndexMap<InternalString, TableKeyValue>; |
458 | |
459 | fn decorate_table(table: &mut Table) { |
460 | for (key_decor: &mut Decor, value: &mut Value) in tableimpl Iterator |
461 | .items |
462 | .iter_mut() |
463 | .filter(|&(_, ref kv: &&mut TableKeyValue)| kv.value.is_value()) |
464 | .map(|(_, kv: &mut TableKeyValue)| (&mut kv.key.decor, kv.value.as_value_mut().unwrap())) |
465 | { |
466 | key_decor.clear(); |
467 | value.decor_mut().clear(); |
468 | } |
469 | } |
470 | |
471 | // `key1 = value1` |
472 | pub(crate) const DEFAULT_KEY_DECOR: (&str, &str) = ("" , " " ); |
473 | pub(crate) const DEFAULT_TABLE_DECOR: (&str, &str) = (" \n" , "" ); |
474 | pub(crate) const DEFAULT_KEY_PATH_DECOR: (&str, &str) = ("" , "" ); |
475 | |
476 | #[derive (Debug, Clone)] |
477 | pub(crate) struct TableKeyValue { |
478 | pub(crate) key: Key, |
479 | pub(crate) value: Item, |
480 | } |
481 | |
482 | impl TableKeyValue { |
483 | pub(crate) fn new(key: Key, value: Item) -> Self { |
484 | TableKeyValue { key, value } |
485 | } |
486 | } |
487 | |
488 | /// An owned iterator type over `Table`'s key/value pairs. |
489 | pub type IntoIter = Box<dyn Iterator<Item = (InternalString, Item)>>; |
490 | /// An iterator type over `Table`'s key/value pairs. |
491 | pub type Iter<'a> = Box<dyn Iterator<Item = (&'a str, &'a Item)> + 'a>; |
492 | /// A mutable iterator type over `Table`'s key/value pairs. |
493 | pub type IterMut<'a> = Box<dyn Iterator<Item = (KeyMut<'a>, &'a mut Item)> + 'a>; |
494 | |
495 | /// This trait represents either a `Table`, or an `InlineTable`. |
496 | pub trait TableLike: crate::private::Sealed { |
497 | /// Returns an iterator over key/value pairs. |
498 | fn iter(&self) -> Iter<'_>; |
499 | /// Returns an mutable iterator over all key/value pairs, including empty. |
500 | fn iter_mut(&mut self) -> IterMut<'_>; |
501 | /// Returns the number of nonempty items. |
502 | fn len(&self) -> usize { |
503 | self.iter().filter(|&(_, v)| !v.is_none()).count() |
504 | } |
505 | /// Returns true if the table is empty. |
506 | fn is_empty(&self) -> bool { |
507 | self.len() == 0 |
508 | } |
509 | /// Clears the table, removing all key-value pairs. Keeps the allocated memory for reuse. |
510 | fn clear(&mut self); |
511 | /// Gets the given key's corresponding entry in the Table for in-place manipulation. |
512 | fn entry<'a>(&'a mut self, key: &str) -> Entry<'a>; |
513 | /// Gets the given key's corresponding entry in the Table for in-place manipulation. |
514 | fn entry_format<'a>(&'a mut self, key: &Key) -> Entry<'a>; |
515 | /// Returns an optional reference to an item given the key. |
516 | fn get<'s>(&'s self, key: &str) -> Option<&'s Item>; |
517 | /// Returns an optional mutable reference to an item given the key. |
518 | fn get_mut<'s>(&'s mut self, key: &str) -> Option<&'s mut Item>; |
519 | /// Return references to the key-value pair stored for key, if it is present, else None. |
520 | fn get_key_value<'a>(&'a self, key: &str) -> Option<(&'a Key, &'a Item)>; |
521 | /// Return mutable references to the key-value pair stored for key, if it is present, else None. |
522 | fn get_key_value_mut<'a>(&'a mut self, key: &str) -> Option<(KeyMut<'a>, &'a mut Item)>; |
523 | /// Returns true if the table contains an item with the given key. |
524 | fn contains_key(&self, key: &str) -> bool; |
525 | /// Inserts a key-value pair into the map. |
526 | fn insert(&mut self, key: &str, value: Item) -> Option<Item>; |
527 | /// Removes an item given the key. |
528 | fn remove(&mut self, key: &str) -> Option<Item>; |
529 | |
530 | /// Get key/values for values that are visually children of this table |
531 | /// |
532 | /// For example, this will return dotted keys |
533 | fn get_values(&self) -> Vec<(Vec<&Key>, &Value)>; |
534 | |
535 | /// Auto formats the table. |
536 | fn fmt(&mut self); |
537 | /// Sorts Key/Value Pairs of the table. |
538 | /// |
539 | /// Doesn't affect subtables or subarrays. |
540 | fn sort_values(&mut self); |
541 | /// Change this table's dotted status |
542 | fn set_dotted(&mut self, yes: bool); |
543 | /// Check if this is a wrapper for dotted keys, rather than a standard table |
544 | fn is_dotted(&self) -> bool; |
545 | |
546 | /// Returns the decor associated with a given key of the table. |
547 | fn key_decor_mut(&mut self, key: &str) -> Option<&mut Decor>; |
548 | /// Returns the decor associated with a given key of the table. |
549 | fn key_decor(&self, key: &str) -> Option<&Decor>; |
550 | } |
551 | |
552 | impl TableLike for Table { |
553 | fn iter(&self) -> Iter<'_> { |
554 | self.iter() |
555 | } |
556 | fn iter_mut(&mut self) -> IterMut<'_> { |
557 | self.iter_mut() |
558 | } |
559 | fn clear(&mut self) { |
560 | self.clear(); |
561 | } |
562 | fn entry<'a>(&'a mut self, key: &str) -> Entry<'a> { |
563 | self.entry(key) |
564 | } |
565 | fn entry_format<'a>(&'a mut self, key: &Key) -> Entry<'a> { |
566 | self.entry_format(key) |
567 | } |
568 | fn get<'s>(&'s self, key: &str) -> Option<&'s Item> { |
569 | self.get(key) |
570 | } |
571 | fn get_mut<'s>(&'s mut self, key: &str) -> Option<&'s mut Item> { |
572 | self.get_mut(key) |
573 | } |
574 | fn get_key_value<'a>(&'a self, key: &str) -> Option<(&'a Key, &'a Item)> { |
575 | self.get_key_value(key) |
576 | } |
577 | fn get_key_value_mut<'a>(&'a mut self, key: &str) -> Option<(KeyMut<'a>, &'a mut Item)> { |
578 | self.get_key_value_mut(key) |
579 | } |
580 | fn contains_key(&self, key: &str) -> bool { |
581 | self.contains_key(key) |
582 | } |
583 | fn insert(&mut self, key: &str, value: Item) -> Option<Item> { |
584 | self.insert(key, value) |
585 | } |
586 | fn remove(&mut self, key: &str) -> Option<Item> { |
587 | self.remove(key) |
588 | } |
589 | |
590 | fn get_values(&self) -> Vec<(Vec<&Key>, &Value)> { |
591 | self.get_values() |
592 | } |
593 | fn fmt(&mut self) { |
594 | self.fmt() |
595 | } |
596 | fn sort_values(&mut self) { |
597 | self.sort_values() |
598 | } |
599 | fn is_dotted(&self) -> bool { |
600 | self.is_dotted() |
601 | } |
602 | fn set_dotted(&mut self, yes: bool) { |
603 | self.set_dotted(yes) |
604 | } |
605 | |
606 | fn key_decor_mut(&mut self, key: &str) -> Option<&mut Decor> { |
607 | self.key_decor_mut(key) |
608 | } |
609 | fn key_decor(&self, key: &str) -> Option<&Decor> { |
610 | self.key_decor(key) |
611 | } |
612 | } |
613 | |
614 | /// A view into a single location in a map, which may be vacant or occupied. |
615 | pub enum Entry<'a> { |
616 | /// An occupied Entry. |
617 | Occupied(OccupiedEntry<'a>), |
618 | /// A vacant Entry. |
619 | Vacant(VacantEntry<'a>), |
620 | } |
621 | |
622 | impl<'a> Entry<'a> { |
623 | /// Returns the entry key |
624 | /// |
625 | /// # Examples |
626 | /// |
627 | /// ``` |
628 | /// use toml_edit::Table; |
629 | /// |
630 | /// let mut map = Table::new(); |
631 | /// |
632 | /// assert_eq!("hello" , map.entry("hello" ).key()); |
633 | /// ``` |
634 | pub fn key(&self) -> &str { |
635 | match self { |
636 | Entry::Occupied(e) => e.key(), |
637 | Entry::Vacant(e) => e.key(), |
638 | } |
639 | } |
640 | |
641 | /// Ensures a value is in the entry by inserting the default if empty, and returns |
642 | /// a mutable reference to the value in the entry. |
643 | pub fn or_insert(self, default: Item) -> &'a mut Item { |
644 | match self { |
645 | Entry::Occupied(entry) => entry.into_mut(), |
646 | Entry::Vacant(entry) => entry.insert(default), |
647 | } |
648 | } |
649 | |
650 | /// Ensures a value is in the entry by inserting the result of the default function if empty, |
651 | /// and returns a mutable reference to the value in the entry. |
652 | pub fn or_insert_with<F: FnOnce() -> Item>(self, default: F) -> &'a mut Item { |
653 | match self { |
654 | Entry::Occupied(entry) => entry.into_mut(), |
655 | Entry::Vacant(entry) => entry.insert(default()), |
656 | } |
657 | } |
658 | } |
659 | |
660 | /// A view into a single occupied location in a `IndexMap`. |
661 | pub struct OccupiedEntry<'a> { |
662 | pub(crate) entry: indexmap::map::OccupiedEntry<'a, InternalString, TableKeyValue>, |
663 | } |
664 | |
665 | impl<'a> OccupiedEntry<'a> { |
666 | /// Gets a reference to the entry key |
667 | /// |
668 | /// # Examples |
669 | /// |
670 | /// ``` |
671 | /// use toml_edit::Table; |
672 | /// |
673 | /// let mut map = Table::new(); |
674 | /// |
675 | /// assert_eq!("foo" , map.entry("foo" ).key()); |
676 | /// ``` |
677 | pub fn key(&self) -> &str { |
678 | self.entry.key().as_str() |
679 | } |
680 | |
681 | /// Gets a mutable reference to the entry key |
682 | pub fn key_mut(&mut self) -> KeyMut<'_> { |
683 | self.entry.get_mut().key.as_mut() |
684 | } |
685 | |
686 | /// Gets a reference to the value in the entry. |
687 | pub fn get(&self) -> &Item { |
688 | &self.entry.get().value |
689 | } |
690 | |
691 | /// Gets a mutable reference to the value in the entry. |
692 | pub fn get_mut(&mut self) -> &mut Item { |
693 | &mut self.entry.get_mut().value |
694 | } |
695 | |
696 | /// Converts the OccupiedEntry into a mutable reference to the value in the entry |
697 | /// with a lifetime bound to the map itself |
698 | pub fn into_mut(self) -> &'a mut Item { |
699 | &mut self.entry.into_mut().value |
700 | } |
701 | |
702 | /// Sets the value of the entry, and returns the entry's old value |
703 | pub fn insert(&mut self, mut value: Item) -> Item { |
704 | std::mem::swap(&mut value, &mut self.entry.get_mut().value); |
705 | value |
706 | } |
707 | |
708 | /// Takes the value out of the entry, and returns it |
709 | pub fn remove(self) -> Item { |
710 | self.entry.shift_remove().value |
711 | } |
712 | } |
713 | |
714 | /// A view into a single empty location in a `IndexMap`. |
715 | pub struct VacantEntry<'a> { |
716 | pub(crate) entry: indexmap::map::VacantEntry<'a, InternalString, TableKeyValue>, |
717 | pub(crate) key: Option<Key>, |
718 | } |
719 | |
720 | impl<'a> VacantEntry<'a> { |
721 | /// Gets a reference to the entry key |
722 | /// |
723 | /// # Examples |
724 | /// |
725 | /// ``` |
726 | /// use toml_edit::Table; |
727 | /// |
728 | /// let mut map = Table::new(); |
729 | /// |
730 | /// assert_eq!("foo" , map.entry("foo" ).key()); |
731 | /// ``` |
732 | pub fn key(&self) -> &str { |
733 | self.entry.key().as_str() |
734 | } |
735 | |
736 | /// Sets the value of the entry with the VacantEntry's key, |
737 | /// and returns a mutable reference to it |
738 | pub fn insert(self, value: Item) -> &'a mut Item { |
739 | let entry: VacantEntry<'_, InternalString, …> = self.entry; |
740 | let key: Key = self.key.unwrap_or_else(|| Key::new(key:entry.key().as_str())); |
741 | &mut entry.insert(TableKeyValue::new(key, value)).value |
742 | } |
743 | } |
744 | |