yam-core 0.1.0

Pure Rust YAML reader and writer (to be added)
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
59
60
61
62
63
64
65
66
67
68
69
70

use alloc::borrow::Cow;
use alloc::fmt::Display;
use alloc::vec::Vec;

use crate::tokenizer::ErrorType;
use crate::treebuild::YamlToken::Scalar;

pub enum YamlToken<'a, TAG = ()> {
    // strings, booleans, numbers, nulls, all treated the same
    Scalar(Cow<'a, [u8]>, TAG),

    // flow style like `[x, x, x]`
    // or block style like:
    //     - x
    //     - x
    Sequence(Vec<YamlToken<'a, TAG>>, TAG),

    // flow style like `{x: Y, a: B}`
    // or block style like:
    //     x: Y
    //     a: B
    Mapping(Vec<Entry<'a, TAG>>, TAG),
}

impl<'a, TAG> Display for YamlToken<'a, TAG> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            Scalar(val, _) => write!(f, "SCAL: {val:?}"),
            Self::Sequence(val, _) => {
                write!(f, "SEQ:")?;
                for el in val {
                    write!(f, "{el}")?;
                }
                Ok(())
            }
            Self::Mapping(val, _) => {
                write!(f, "MAP:")?;
                for entry in val {
                    write!(f, "{} = {}", entry.key, entry.value)?;
                }
                Ok(())
            }
        }
    }
}

impl<'a, TAG: Default> Default for YamlToken<'a, TAG> {
    fn default() -> Self {
        Scalar(Cow::default(), TAG::default())
    }
}

pub struct Entry<'a, TAG> {
    key: YamlToken<'a, TAG>,
    value: YamlToken<'a, TAG>,
}

impl<'a, TAG: Default> Default for Entry<'a, TAG> {
    fn default() -> Self {
        Entry {
            key: YamlToken::default(),
            value: YamlToken::default(),
        }
    }
}

pub struct YamlTokenError<'a, T> {
    _partial: YamlToken<'a, T>,
    _error: Vec<ErrorType>,
}