fson 1.0.0

Flexible Serialized Object Notation
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

pub use crate::parser::Rule;
pub use pest::iterators::{Pair, Pairs};
pub use std::collections::HashMap;

#[derive(Debug, Clone, PartialEq)]
pub enum TemplateValue {
    String(String),
    Interpolation(Value),
}

#[derive(Debug, Clone, PartialEq)]
pub enum ReferenceAsValue {
    Id(String),
    Path(Vec<String>),
}

#[derive(Debug, Clone, PartialEq)]
pub enum Value {
    /// `inf` in js
    Infinity,
    /// `-inf` in js
    NegativeInfinity,
    /// `null` in js
    Null,
    /// `NaN` in js
    NaN,

    /// ## Example:
    /// ```
    /// Value::String(String::from("string"))
    /// ```
    String(String),

    /// ## Example:
    /// ```
    /// Value::Number(1.0)
    /// ```
    Number(f64),

    /// ## Example:
    /// ```
    /// Value::Boolean(true)
    /// Value::Boolean(false)
    /// ```
    Boolean(bool),

    /// ## Example:
    /// ```
    /// Value::Identifier(String::from("identifier"))
    /// ```
    Identifier(String),

    /// Object: `{ k: v, ... }`
    /// ## Example:
    /// ```
    /// Value::Object(object!(
    ///     String::from("one") => Value::Number(1.0),
    ///     String::from("two") => Value::Number(2.0))
    /// ))
    /// ```
    Object(HashMap<String, Value>),

    /// Array: `[..., ...]`
    /// ## Example:
    /// ```
    /// Value::Array(vec![ Value::Number(1.0), Value::Array(vec![ Value::Boolean(true) ]) ])
    /// ```
    Array(Vec<Value>),

    /// Template string: `${...}`
    /// ## Example:
    /// ```
    /// Value::TemplateString(vec![ TemplateValue::String("2 + 2 = ".to_string()), TemplateValue::Interpolation(Value::Number(4.0)) ]) // 2 + 2 = 4
    /// ```
    TemplateString(Vec<TemplateValue>),

    /// Reference as value: `#id | #"id"` or `#/path/to/object | #"path"/"to"/"object"`
    /// ## Example:
    /// ```
    /// Value::Reference(ReferenceAsValue::Id("id".to_string()))
    /// Value::Reference(ReferenceAsValue::Path(vec![ String::from("path"), String::from("to"), String::from("object") ]))
    /// ```
    Reference(ReferenceAsValue),

    /// Reference declaration:
    /// ```
    /// #{
    ///     #id: "id",
    ///     #value: "any value"
    /// }
    /// ```
    /// ## Example:
    /// ```
    /// Value::ReferenceDeclaration { id: "id".to_string(), value: Box::new("any value".to_string()) }
    /// ```
    ReferenceDeclaration { id: String, value: Box<Value> },
}

#[derive(Debug, Clone)]
pub struct ReferencesManager {
    pub refs: HashMap<String, Value>,
    pub ref_paths: HashMap<String, Value>,
}

impl ReferencesManager {
    pub fn get_by_path(self, path: String) -> Option<Value> {
        if self.ref_paths.contains_key(&path.clone()) {
            let value = &self.ref_paths[&path];
            Some(value.clone())
        } else {
            None
        }
    }
    pub fn get_by_id(self, id: String) -> Option<Value> {
        if self.refs.contains_key(&id.clone()) {
            let value = &self.refs[&id];
            Some(value.clone())
        } else {
            None
        }
    }
}