Struct Table 

pub struct Table<'de> { /* private fields */ }

A TOML table with span information.

A Table is the top-level value returned by parse and is also the value inside any [section] or inline { ... } table in TOML. It stores (Key, Item) pairs in insertion order.

Accessing values

• Index operators — table["key"] returns a MaybeItem that never panics on missing keys, and supports chained indexing.
• get / get_mut — return Option<&Item> / Option<&mut Item>.
• required / optional — deserialize and remove a field in one step, used when implementing Deserialize. After extracting all expected fields, call expect_empty to reject unknown keys.

Constructing tables

Tables are normally obtained from parse. To build one programmatically, create a table with Table::new and insert entries with Table::insert. An Arena is required for insertion because entries are arena-allocated.

Iteration

Table implements IntoIterator (both by reference and by value), yielding (Key, Item) pairs.

Removal via remove, required, and optional uses swap-remove and may reorder remaining entries.

Implementations

impl<'de> Table<'de>

pub fn new(span: Span) -> Table<'de>

Creates an empty table with the given span.

pub fn span(&self) -> Span

Returns the byte-offset span of this table in the source document.

impl<'de> Table<'de>

pub fn insert(&mut self, key: Key<'de>, value: Item<'de>, arena: &Arena)

Inserts a key-value pair. Does not check for duplicates.

pub fn len(&self) -> usize

Returns the number of entries.

pub fn is_empty(&self) -> bool

Returns true if the table has no entries.

pub fn get_key_value(&self, name: &str) -> Option<(&Key<'de>, &Item<'de>)>

Linear scan for a key, returning both key and value references.

pub fn get(&self, name: &str) -> Option<&Item<'de>>

Returns a reference to the value for name.

pub fn get_mut(&mut self, name: &str) -> Option<&mut Item<'de>>

Returns a mutable reference to the value for name.

pub fn contains_key(&self, name: &str) -> bool

Returns true if the table contains the key.

pub fn remove(&mut self, name: &str) -> Option<Item<'de>>

Removes the first entry matching name, returning its value. Uses swap-remove, so the ordering of remaining entries may change.

pub fn remove_entry(&mut self, name: &str) -> Option<(Key<'de>, Item<'de>)>

Removes the first entry matching name, returning the key-value pair. Uses swap-remove, so the ordering of remaining entries may change.

pub fn values_mut(&mut self) -> impl Iterator<Item = &mut Item<'de>>

Returns an iterator over mutable references to the values.

pub fn entries(&self) -> &[(Key<'de>, Item<'de>)]

Returns a slice of all entries.

pub fn into_item(self) -> Item<'de>

Converts this Table into an Item with the same span and payload.

pub fn required<T: Deserialize<'de>>( &mut self, name: &'static str, ) -> Result<T, Error>

Removes and deserializes a field, returning an error if the key is missing.

pub fn optional<T: Deserialize<'de>>( &mut self, name: &str, ) -> Result<Option<T>, Error>

Removes and deserializes a field, returning None if the key is missing.

pub fn expect_empty(&self) -> Result<(), Error>

Returns an error if the table still has unconsumed entries.

Call this after extracting all expected fields with required and optional to reject unknown keys.

Trait Implementations

impl Debug for Table<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Default for Table<'de>

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Index<&str> for Table<'de>

type Output = MaybeItem<'de>

The returned type after indexing.

fn index(&self, index: &str) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, 'de> IntoIterator for &'a Table<'de>

type Item = &'a (Key<'de>, Item<'de>)

The type of the elements being iterated over.

type IntoIter = Iter<'a, (Key<'de>, Item<'de>)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, 'de> IntoIterator for &'a mut Table<'de>

type Item = &'a mut (Key<'de>, Item<'de>)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, (Key<'de>, Item<'de>)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'de> IntoIterator for Table<'de>

type Item = (Key<'de>, Item<'de>)

The type of the elements being iterated over.

type IntoIter = IntoIter<'de>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.