toml_edit/
array_of_tables.rs

1use std::iter::FromIterator;
2
3use crate::{Array, Item, Table};
4
5/// A top-level sequence of [`Table`]s, each under their own header
6#[derive(Clone, Debug, Default)]
7pub struct ArrayOfTables {
8    // Always Vec<Item::Table>, just `Item` to make `Index` work
9    pub(crate) span: Option<std::ops::Range<usize>>,
10    pub(crate) values: Vec<Item>,
11}
12
13/// Constructors
14///
15/// See also `FromIterator`
16impl ArrayOfTables {
17    /// Creates an empty array of tables.
18    pub fn new() -> Self {
19        Default::default()
20    }
21}
22
23/// Formatting
24impl ArrayOfTables {
25    /// Convert to an inline array
26    pub fn into_array(mut self) -> Array {
27        for value in self.values.iter_mut() {
28            value.make_value();
29        }
30        let mut a = Array::with_vec(self.values);
31        a.fmt();
32        a
33    }
34
35    /// The location within the original document
36    ///
37    /// This generally requires a [`Document`][crate::Document].
38    pub fn span(&self) -> Option<std::ops::Range<usize>> {
39        self.span.clone()
40    }
41
42    pub(crate) fn despan(&mut self, input: &str) {
43        self.span = None;
44        for value in &mut self.values {
45            value.despan(input);
46        }
47    }
48}
49
50impl ArrayOfTables {
51    /// Returns an iterator over tables.
52    pub fn iter(&self) -> ArrayOfTablesIter<'_> {
53        Box::new(self.values.iter().filter_map(Item::as_table))
54    }
55
56    /// Returns an iterator over tables.
57    pub fn iter_mut(&mut self) -> ArrayOfTablesIterMut<'_> {
58        Box::new(self.values.iter_mut().filter_map(Item::as_table_mut))
59    }
60
61    /// Returns the length of the underlying Vec.
62    /// To get the actual number of items use `a.iter().count()`.
63    pub fn len(&self) -> usize {
64        self.values.len()
65    }
66
67    /// Returns true if `self.len() == 0`.
68    pub fn is_empty(&self) -> bool {
69        self.len() == 0
70    }
71
72    /// Removes all the tables.
73    pub fn clear(&mut self) {
74        self.values.clear();
75    }
76
77    /// Returns an optional reference to the table.
78    pub fn get(&self, index: usize) -> Option<&Table> {
79        self.values.get(index).and_then(Item::as_table)
80    }
81
82    /// Returns an optional mutable reference to the table.
83    pub fn get_mut(&mut self, index: usize) -> Option<&mut Table> {
84        self.values.get_mut(index).and_then(Item::as_table_mut)
85    }
86
87    /// Appends a table to the array.
88    pub fn push(&mut self, table: Table) {
89        self.values.push(Item::Table(table));
90    }
91
92    /// Removes a table with the given index.
93    pub fn remove(&mut self, index: usize) -> Table {
94        self.values
95            .remove(index)
96            .into_table()
97            .expect("cannot have any other item in an array-of-tables")
98    }
99
100    /// Retains only the elements specified by the `keep` predicate.
101    ///
102    /// In other words, remove all tables for which `keep(&table)` returns `false`.
103    ///
104    /// This method operates in place, visiting each element exactly once in the
105    /// original order, and preserves the order of the retained elements.
106    pub fn retain<F>(&mut self, mut keep: F)
107    where
108        F: FnMut(&Table) -> bool,
109    {
110        self.values
111            .retain(|item| item.as_table().map(&mut keep).unwrap_or(false));
112    }
113}
114
115/// An iterator type over [`ArrayOfTables`]'s [`Table`]s
116pub type ArrayOfTablesIter<'a> = Box<dyn Iterator<Item = &'a Table> + 'a>;
117/// An iterator type over [`ArrayOfTables`]'s [`Table`]s
118pub type ArrayOfTablesIterMut<'a> = Box<dyn Iterator<Item = &'a mut Table> + 'a>;
119/// An iterator type over [`ArrayOfTables`]'s [`Table`]s
120pub type ArrayOfTablesIntoIter = Box<dyn Iterator<Item = Table>>;
121
122impl Extend<Table> for ArrayOfTables {
123    fn extend<T: IntoIterator<Item = Table>>(&mut self, iter: T) {
124        for value in iter {
125            self.push(value);
126        }
127    }
128}
129
130impl FromIterator<Table> for ArrayOfTables {
131    fn from_iter<I>(iter: I) -> Self
132    where
133        I: IntoIterator<Item = Table>,
134    {
135        let v = iter.into_iter().map(Item::Table);
136        Self {
137            values: v.collect(),
138            span: None,
139        }
140    }
141}
142
143impl IntoIterator for ArrayOfTables {
144    type Item = Table;
145    type IntoIter = ArrayOfTablesIntoIter;
146
147    fn into_iter(self) -> Self::IntoIter {
148        Box::new(
149            self.values
150                .into_iter()
151                .filter(|v| v.is_table())
152                .map(|v| v.into_table().unwrap()),
153        )
154    }
155}
156
157impl<'s> IntoIterator for &'s ArrayOfTables {
158    type Item = &'s Table;
159    type IntoIter = ArrayOfTablesIter<'s>;
160
161    fn into_iter(self) -> Self::IntoIter {
162        self.iter()
163    }
164}
165
166#[cfg(feature = "display")]
167impl std::fmt::Display for ArrayOfTables {
168    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
169        // HACK: Without the header, we don't really have a proper way of printing this
170        self.clone().into_array().fmt(f)
171    }
172}
toml_edit/array_of_tables.rs

toml_edit/
array_of_tables.rs
