luminos-config 0.1.0

luminos config
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
71
72
73
74
75
76
77
78
79

use std::collections::HashMap;

#[derive(Debug, Clone)]
pub enum Node {
    Null,
    Bool(bool),
    Number(i64),
    Text(String),
    Object(HashMap<String, Node>),
}

impl Default for Node {
    fn default() -> Self {
        Node::Object(HashMap::new())
    }
}

impl From<&[(&str, Node)]> for Node {
    fn from(slice: &[(&str, Node)]) -> Node {
        Node::Object(
            slice
                .iter()
                .map(|(k, v)| (k.to_string(), v.clone()))
                .collect(),
        )
    }
}

impl<T> From<Vec<(&str, T)>> for Node
where
    T: Into<Node>,
{
    fn from(v: Vec<(&str, T)>) -> Self {
        Node::Object(
            v.into_iter()
                .map(|(k, val)| (k.to_string(), val.into()))
                .collect(),
        )
    }
}

impl From<bool> for Node {
    fn from(b: bool) -> Self {
        Node::Bool(b)
    }
}

impl From<i64> for Node {
    fn from(n: i64) -> Self {
        Node::Number(n)
    }
}

impl From<String> for Node {
    fn from(s: String) -> Self {
        Node::Text(s)
    }
}

impl From<&str> for Node {
    fn from(s: &str) -> Self {
        Node::Text(s.to_string())
    }
}

#[macro_export]
macro_rules! node {
    // Match: [ (key, value), ... ]
    [ $( ($key:expr, $value:expr) ),* $(,)? ] => {{
        let v: Vec<(&str, $crate::Node)> = vec![
            $(($key, {
                let val: $crate::Node = $value.into();
                val
            })),*
        ];
        let result: $crate::Node = v.into();
        result
    }};
}