litl-val 0.2.0

A memory efficient representation of JSON values
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

mod conversions;
mod key;
mod key_e;
mod map;
mod map_ref;
mod val;
mod val_e;
mod val_ref;
pub use key::Key;
pub use map::{Map, ValMapEntries};
pub use val::Val;
pub use val_e::ValE;
pub use val_ref::ValRef;

mod slim_boxed_slice;
mod tiny_string;

mod from_other;
mod to_other;

pub use from_other::to_val;
pub use to_other::{deserializer::ValDeserializerError, from_val};

#[cfg(test)]
mod test {
    use ordered_float::NotNan;

    use crate::{
        key_e::KeyE,
        map_ref::MapRef,
        slim_boxed_slice::{SlimBoxedSlice, SlimBoxedString},
        tiny_string::TinyString,
        Val, ValE, ValRef,
    };

    #[test]
    fn primtives_roundtrip() {
        let val: Val = ValE::Null.into();
        println!("{:?}", val);
        assert_eq!(val.direct_ref(), ValRef::Null);
        assert_eq!(Into::<ValE>::into(val), ValE::Null);

        let val: Val = ValE::Bool(true).into();
        println!("{:?}", val);
        assert_eq!(val.direct_ref(), ValRef::Bool(true));
        assert_eq!(Into::<ValE>::into(val), ValE::Bool(true));

        let val: Val = ValE::Bool(false).into();
        println!("{:?}", val);
        assert_eq!(val.direct_ref(), ValRef::Bool(false));
        assert_eq!(Into::<ValE>::into(val), ValE::Bool(false));

        let val: Val = ValE::Number(NotNan::new(0.0).unwrap()).into();
        println!("{:?}", val);
        assert_eq!(val.direct_ref(), ValRef::Number(NotNan::new(0.0).unwrap()));
        assert_eq!(
            Into::<ValE>::into(val),
            ValE::Number(NotNan::new(0.0).unwrap())
        );

        let val: Val = ValE::ShortString(TinyString::try_from("Hello").unwrap()).into();
        println!("{:?}", val);
        assert_eq!(val.direct_ref(), ValRef::String("Hello"));
        assert_eq!(
            Into::<ValE>::into(val),
            ValE::ShortString(TinyString::try_from("Hello").unwrap())
        );

        let val: Val = ValE::LongString(SlimBoxedString::from_str("Hello, world")).into();
        println!("{:?}", val);
        assert_eq!(val.direct_ref(), ValRef::String("Hello, world"));
        assert_eq!(
            Into::<ValE>::into(val),
            ValE::LongString(SlimBoxedString::from_str("Hello, world"))
        );

        let val: Val = ValE::Array(SlimBoxedSlice::from_vec(vec![
            ValE::Bool(true).into(),
            ValE::Number(NotNan::new(42.0).unwrap()).into(),
        ]))
        .into();
        println!("{:?}", val);
        assert_eq!(
            val.direct_ref(),
            ValRef::Array(&[
                ValE::Bool(true).into(),
                ValE::Number(NotNan::new(42.0).unwrap()).into(),
            ])
        );
        assert_eq!(
            Into::<ValE>::into(val),
            ValE::Array(SlimBoxedSlice::from_vec(vec![
                ValE::Bool(true).into(),
                ValE::Number(NotNan::new(42.0).unwrap()).into(),
            ]))
        );

        let val: Val = Val::object(vec![
            ("a", ValE::Bool(true)),
            ("b", ValE::Number(NotNan::new(42.0).unwrap())),
        ]);
        println!("{:?}", val);
        assert_eq!(
            val.direct_ref(),
            ValRef::Object(MapRef(&[
                (KeyE::str("a").into(), ValE::Bool(true).into()),
                (
                    KeyE::str("b").into(),
                    ValE::Number(NotNan::new(42.0).unwrap()).into(),
                ),
            ]))
        );
        assert_eq!(
            Into::<ValE>::into(val),
            Val::object(vec![
                ("a", ValE::Bool(true)),
                ("b", ValE::Number(NotNan::new(42.0).unwrap()),),
            ])
            .into()
        );
    }
}