toml-spanner 1.0.2

High Performance Toml parser and deserializer that preserves span information with fast compile times.
Documentation 
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

#![allow(dead_code)]
use toml_spanner::{Arena, Context, Failed, FromToml, Item, Value};

const TOML_DOCUMENT: &str = r#"
enabled = false
number = 37

[[nested]]
number = 43

[[nested]]
enabled = true
number = 12
"#;

#[derive(Debug)]
struct Config {
    enabled: bool,
    nested: Vec<Config>,
    number: u32,
}

impl<'de> FromToml<'de> for Config {
    fn from_toml(ctx: &mut Context<'de>, item: &Item<'de>) -> Result<Self, Failed> {
        let mut th = item.table_helper(ctx)?;
        let config = Config {
            enabled: th.optional("enabled").unwrap_or(false),
            number: th.required("number")?,
            nested: th.optional("nested").unwrap_or_default(),
        };
        th.require_empty()?;
        Ok(config)
    }
}

fn main() {
    let arena = Arena::new();

    let mut doc = toml_spanner::parse(TOML_DOCUMENT, &arena).unwrap();

    assert_eq!(doc["nested"][1]["enabled"].as_bool(), Some(true));

    match doc["nested"].value() {
        Some(Value::Array(array)) => assert_eq!(array.len(), 2),
        Some(other) => panic!("Expected Array but found: {:#?}", other),
        None => panic!("Expected value but found nothing"),
    }

    match doc.to::<Config>() {
        Ok(config) => println!("parsed: {:#?}", config),
        Err(e) => {
            println!("Deserialization Failure");
            for error in &e.errors {
                println!("error: {}", error);
            }
        }
    }
}