hocon-rs 0.2.0

Rust implementation of HOCON
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

use crate::value::Value;
use serde_json::Number;
use std::{collections::HashMap, iter::once};

impl From<i64> for Value {
    fn from(value: i64) -> Self {
        Value::Number(value.into())
    }
}

impl From<i32> for Value {
    fn from(value: i32) -> Self {
        Value::Number(value.into())
    }
}

impl From<String> for Value {
    fn from(value: String) -> Self {
        Value::String(value)
    }
}

impl From<&str> for Value {
    fn from(value: &str) -> Self {
        Value::String(value.to_string())
    }
}

impl From<bool> for Value {
    fn from(value: bool) -> Self {
        Value::Boolean(value)
    }
}

impl From<f64> for Value {
    fn from(value: f64) -> Self {
        Number::from_f64(value).map_or(Value::Null, Value::Number)
    }
}

impl From<HashMap<String, Value>> for Value {
    fn from(value: HashMap<String, Value>) -> Self {
        Value::Object(value)
    }
}

impl From<(String, Value)> for Value {
    fn from(value: (String, Value)) -> Self {
        Value::Object(HashMap::from_iter(once(value)))
    }
}

impl From<(&str, Value)> for Value {
    fn from(value: (&str, Value)) -> Self {
        let (k, v) = value;
        Value::Object(HashMap::from_iter(once((k.to_string(), v))))
    }
}

impl From<Vec<(String, Value)>> for Value {
    fn from(value: Vec<(String, Value)>) -> Self {
        Value::Object(HashMap::from_iter(value))
    }
}

impl From<Vec<(&str, Value)>> for Value {
    fn from(value: Vec<(&str, Value)>) -> Self {
        Value::Object(value.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
    }
}

impl From<Vec<Value>> for Value {
    fn from(value: Vec<Value>) -> Self {
        Value::Array(value)
    }
}

impl From<Number> for Value {
    fn from(value: Number) -> Self {
        Value::Number(value)
    }
}

impl From<serde_json::Value> for Value {
    fn from(val: serde_json::Value) -> Self {
        match val {
            serde_json::Value::Null => Value::Null,
            serde_json::Value::Bool(boolean) => Value::Boolean(boolean),
            serde_json::Value::Number(number) => Value::Number(number),
            serde_json::Value::String(string) => Value::String(string),
            serde_json::Value::Array(array) => {
                Value::array_from_iter(array.into_iter().map(Into::into))
            }
            serde_json::Value::Object(object) => {
                Value::object_from_iter(object.into_iter().map(|(key, value)| (key, value.into())))
            }
        }
    }
}

impl From<Value> for serde_json::Value {
    fn from(val: Value) -> Self {
        match val {
            Value::Object(object) => {
                let map = serde_json::Map::from_iter(
                    object.into_iter().map(|(key, value)| (key, value.into())),
                );
                serde_json::Value::Object(map)
            }
            Value::Array(array) => {
                serde_json::Value::Array(array.into_iter().map(Into::into).collect())
            }
            Value::Boolean(boolean) => serde_json::Value::Bool(boolean),
            Value::Null => serde_json::Value::Null,
            Value::String(string) => serde_json::Value::String(string),
            Value::Number(number) => serde_json::Value::Number(number),
        }
    }
}