Struct toml_edit::Document

pub struct Document { /* private fields */ }

Type representing a TOML document

Implementations

impl Document

pub fn new() -> Self

Creates an empty document

pub fn as_item(&self) -> &Item

Returns a reference to the root item.

pub fn as_item_mut(&mut self) -> &mut Item

Returns a mutable reference to the root item.

pub fn as_table(&self) -> &Table

Returns a reference to the root table.

pub fn as_table_mut(&mut self) -> &mut Table

Returns a mutable reference to the root table.

pub fn iter(&self) -> Iter<'_>

Returns an iterator over the root table.

pub fn set_trailing(&mut self, trailing: &str)

Set whitespace after last element

pub fn trailing(&self) -> &str

Whitespace after last element

Methods from Deref<Target = Table>

pub fn get_values(&self) -> Vec<(Vec<&Key>, &Value)>

Get key/values for values that are visually children of this table

For example, this will return dotted keys

pub fn fmt(&mut self)

Auto formats the table.

pub fn sort_values(&mut self)

Sorts Key/Value Pairs of the table.

Doesn’t affect subtables or subarrays.

pub fn sort_values_by<F>(&mut self, compare: F) where
    F: FnMut(&Key, &Item, &Key, &Item) -> Ordering, 

Sort Key/Value Pairs of the table using the using the comparison function compare.

The comparison function receives two key and value pairs to compare (you can sort by keys or values or their combination as needed).

pub fn set_implicit(&mut self, implicit: bool)

If a table has no key/value pairs and implicit, it will not be displayed.

Examples

[target."x86_64/windows.json".dependencies]

In the document above, tables target and target."x86_64/windows.json" are implicit.

use toml_edit::Document;
let mut doc = "[a]\n[a.b]\n".parse::<Document>().expect("invalid toml");

doc["a"].as_table_mut().unwrap().set_implicit(true);
assert_eq!(doc.to_string(), "[a.b]\n");

pub fn is_implicit(&self) -> bool

If a table has no key/value pairs and implicit, it will not be displayed.

pub fn set_dotted(&mut self, yes: bool)

Change this table’s dotted status

pub fn is_dotted(&self) -> bool

Check if this is a wrapper for dotted keys, rather than a standard table

pub fn set_position(&mut self, doc_position: usize)

Sets the position of the Table within the Document.

pub fn position(&self) -> Option<usize>

The position of the Table within the Document.

Returns None if the Table was created manually (i.e. not via parsing) in which case its position is set automatically. This can be overridden with Table::set_position.

pub fn decor_mut(&mut self) -> &mut Decor

Returns the surrounding whitespace

pub fn decor(&self) -> &Decor

Returns the decor associated with a given key of the table.

pub fn key_decor_mut(&mut self, key: &str) -> Option<&mut Decor>

Returns the decor associated with a given key of the table.

pub fn key_decor(&self, key: &str) -> Option<&Decor>

Returns the decor associated with a given key of the table.

pub fn iter(&self) -> Iter<'_>

Returns an iterator over all key/value pairs, including empty.

pub fn iter_mut(&mut self) -> IterMut<'_>

Returns an mutable iterator over all key/value pairs, including empty.

pub fn len(&self) -> usize

Returns the number of non-empty items in the table.

pub fn is_empty(&self) -> bool

Returns true iff the table is empty.

pub fn clear(&mut self)

Clears the table, removing all key-value pairs. Keeps the allocated memory for reuse.

pub fn entry<'a>(&'a mut self, key: &str) -> Entry<'a>

Gets the given key’s corresponding entry in the Table for in-place manipulation.

pub fn entry_format<'a>(&'a mut self, key: &Key) -> Entry<'a>

Gets the given key’s corresponding entry in the Table for in-place manipulation.

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

Returns an optional reference to an item given the key.

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

Returns an optional mutable reference to an item given the key.

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

Return references to the key-value pair stored for key, if it is present, else None.

pub fn get_key_value_mut<'a>(
    &'a mut self,
    key: &str
) -> Option<(KeyMut<'a>, &'a mut Item)>

Return mutable references to the key-value pair stored for key, if it is present, else None.

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

Returns true iff the table contains an item with the given key.

pub fn contains_table(&self, key: &str) -> bool

Returns true iff the table contains a table with the given key.

pub fn contains_value(&self, key: &str) -> bool

Returns true iff the table contains a value with the given key.

pub fn contains_array_of_tables(&self, key: &str) -> bool

Returns true iff the table contains an array of tables with the given key.

pub fn insert(&mut self, key: &str, item: Item) -> Option<Item>

Inserts a key-value pair into the map.

pub fn insert_formatted(&mut self, key: &Key, item: Item) -> Option<Item>

Inserts a key-value pair into the map.

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

Removes an item given the key.

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

Removes a key from the map, returning the stored key and value if the key was previously in the map.

Trait Implementations

impl Clone for Document

fn clone(&self) -> Document

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Document

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

Formats the value using the given formatter.

impl Default for Document

fn default() -> Self

Returns the “default value” for a type.

impl Deref for Document

type Target = Table

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Document

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, 'a> Deserializer<'de> for Document

type Error = Error

The error type that can be returned if some error occurs during deserialization.

fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Require the Deserializer to figure out how to drive the visitor based on what data type is in the input.

fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an optional value.

fn deserialize_enum<V>(
    self,
    name: &'static str,
    variants: &'static [&'static str],
    visitor: V
) -> Result<V::Value, Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an enum value with a particular name and possible variants.

fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a bool value.

fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a u8 value.

fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a u16 value.

fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a u32 value.

fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a u64 value.

fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an i8 value.

fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an i16 value.

fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an i32 value.

fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an i64 value.

fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a f32 value.

fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a f64 value.

fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a char value.

fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a string value and does not benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a string value and would benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a sequence of values.

fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a byte array and does not benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a byte array and would benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a map of key-value pairs.

fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a unit value.

fn deserialize_newtype_struct<V>(
    self,
    name: &'static str,
    visitor: V
) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a newtype struct with a particular name.

fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type needs to deserialize a value whose type doesn’t matter because it is ignored.

fn deserialize_unit_struct<V>(
    self,
    name: &'static str,
    visitor: V
) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a unit struct with a particular name.

fn deserialize_tuple_struct<V>(
    self,
    name: &'static str,
    len: usize,
    visitor: V
) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a tuple struct with a particular name and number of fields.

fn deserialize_tuple<V>(
    self,
    len: usize,
    visitor: V
) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a sequence of values and knows how many values there are without looking at the serialized data.

fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting the name of a struct field or the discriminant of an enum variant.

fn deserialize_struct<V>(
    self,
    name: &'static str,
    fields: &'static [&'static str],
    visitor: V
) -> Result<V::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a struct with a particular name and fields.

fn deserialize_i128<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an i128 value.

fn deserialize_u128<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an u128 value.

fn is_human_readable(&self) -> bool

Determine whether Deserialize implementations should expect to deserialize their human-readable form.

impl Display for Document

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

Formats the value using the given formatter.

impl From<Table> for Document

fn from(root: Table) -> Self

Converts to this type from the input type.

impl FromStr for Document

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a document from a &str

type Err = TomlError

The associated error which can be returned from parsing.

impl<'s> Index<&'s str> for Document

type Output = Item

The returned type after indexing.

fn index(&self, key: &'s str) -> &Item

Performs the indexing (container[index]) operation.

impl<'s> IndexMut<&'s str> for Document

fn index_mut(&mut self, key: &'s str) -> &mut Item

Performs the mutable indexing (container[index]) operation.

impl<'de> IntoDeserializer<'de, Error> for Document

type Deserializer = Document

The type of the deserializer being converted into.

fn into_deserializer(self) -> Self

Convert this value into a deserializer.