jsonb_rs/
from.rs

1// Copyright 2023 Datafuse Labs.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use core::iter::FromIterator;
16use std::borrow::Cow;
17
18use ordered_float::OrderedFloat;
19use serde_json::Map as JsonMap;
20use serde_json::Number as JsonNumber;
21use serde_json::Value as JsonValue;
22
23use super::number::Number;
24use super::value::Object;
25use super::value::Value;
26
27macro_rules! from_signed_integer {
28    ($($ty:ident)*) => {
29        $(
30            impl<'a> From<$ty> for Value<'a> {
31                fn from(n: $ty) -> Self {
32                    Value::Number(Number::Int64(n as i64))
33                }
34            }
35        )*
36    };
37}
38
39macro_rules! from_unsigned_integer {
40    ($($ty:ident)*) => {
41        $(
42            impl<'a> From<$ty> for Value<'a> {
43                fn from(n: $ty) -> Self {
44                    Value::Number(Number::UInt64(n as u64))
45                }
46            }
47        )*
48    };
49}
50
51macro_rules! from_float {
52    ($($ty:ident)*) => {
53        $(
54            impl<'a> From<$ty> for Value<'a> {
55                fn from(n: $ty) -> Self {
56                    Value::Number(Number::Float64(n as f64))
57                }
58            }
59        )*
60    };
61}
62
63from_signed_integer! {
64    i8 i16 i32 i64 isize
65}
66
67from_unsigned_integer! {
68    u8 u16 u32 u64 usize
69}
70
71from_float! {
72    f32 f64
73}
74
75impl<'a> From<OrderedFloat<f32>> for Value<'a> {
76    fn from(f: OrderedFloat<f32>) -> Self {
77        Value::Number(Number::Float64(f.0 as f64))
78    }
79}
80
81impl<'a> From<OrderedFloat<f64>> for Value<'a> {
82    fn from(f: OrderedFloat<f64>) -> Self {
83        Value::Number(Number::Float64(f.0))
84    }
85}
86
87impl<'a> From<bool> for Value<'a> {
88    fn from(f: bool) -> Self {
89        Value::Bool(f)
90    }
91}
92
93impl<'a> From<String> for Value<'a> {
94    fn from(f: String) -> Self {
95        Value::String(f.into())
96    }
97}
98
99impl<'a> From<&'a str> for Value<'a> {
100    fn from(f: &'a str) -> Self {
101        Value::String(Cow::from(f))
102    }
103}
104
105impl<'a> From<Cow<'a, str>> for Value<'a> {
106    fn from(f: Cow<'a, str>) -> Self {
107        Value::String(f)
108    }
109}
110
111impl<'a> From<Object<'a>> for Value<'a> {
112    fn from(o: Object<'a>) -> Self {
113        Value::Object(o)
114    }
115}
116
117impl<'a, T: Into<Value<'a>>> From<Vec<T>> for Value<'a> {
118    fn from(f: Vec<T>) -> Self {
119        Value::Array(f.into_iter().map(Into::into).collect())
120    }
121}
122
123impl<'a, T: Clone + Into<Value<'a>>> From<&'a [T]> for Value<'a> {
124    fn from(f: &'a [T]) -> Self {
125        Value::Array(f.iter().cloned().map(Into::into).collect())
126    }
127}
128
129impl<'a, T: Into<Value<'a>>> FromIterator<T> for Value<'a> {
130    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
131        Value::Array(iter.into_iter().map(Into::into).collect())
132    }
133}
134
135impl<'a, K: Into<String>, V: Into<Value<'a>>> FromIterator<(K, V)> for Value<'a> {
136    fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
137        Value::Object(
138            iter.into_iter()
139                .map(|(k, v)| (k.into(), v.into()))
140                .collect(),
141        )
142    }
143}
144
145impl<'a> From<()> for Value<'a> {
146    fn from((): ()) -> Self {
147        Value::Null
148    }
149}
150
151impl<'a> From<&JsonValue> for Value<'a> {
152    fn from(value: &JsonValue) -> Self {
153        match value {
154            JsonValue::Null => Value::Null,
155            JsonValue::Bool(v) => Value::Bool(*v),
156            JsonValue::Number(v) => {
157                if v.is_u64() {
158                    Value::Number(Number::UInt64(v.as_u64().unwrap()))
159                } else if v.is_i64() {
160                    Value::Number(Number::Int64(v.as_i64().unwrap()))
161                } else {
162                    Value::Number(Number::Float64(v.as_f64().unwrap()))
163                }
164            }
165            JsonValue::String(v) => Value::String(v.clone().into()),
166            JsonValue::Array(arr) => {
167                let mut vals: Vec<Value> = Vec::with_capacity(arr.len());
168                for val in arr {
169                    vals.push(val.into());
170                }
171                Value::Array(vals)
172            }
173            JsonValue::Object(obj) => {
174                let mut map = Object::new();
175                for (k, v) in obj.iter() {
176                    let val: Value = v.into();
177                    map.insert(k.to_string(), val);
178                }
179                Value::Object(map)
180            }
181        }
182    }
183}
184
185impl<'a> From<Value<'a>> for JsonValue {
186    fn from(value: Value<'a>) -> Self {
187        match value {
188            Value::Null => JsonValue::Null,
189            Value::Bool(v) => JsonValue::Bool(v),
190            Value::Number(v) => match v {
191                Number::Int64(v) => JsonValue::Number(v.into()),
192                Number::UInt64(v) => JsonValue::Number(v.into()),
193                Number::Float64(v) => JsonValue::Number(JsonNumber::from_f64(v).unwrap()),
194            },
195            Value::String(v) => JsonValue::String(v.to_string()),
196            Value::Array(arr) => {
197                let mut vals: Vec<JsonValue> = Vec::with_capacity(arr.len());
198                for val in arr {
199                    vals.push(val.into());
200                }
201                JsonValue::Array(vals)
202            }
203            Value::Object(obj) => {
204                let mut map = JsonMap::new();
205                for (k, v) in obj.iter() {
206                    let val: JsonValue = v.clone().into();
207                    map.insert(k.to_string(), val);
208                }
209                JsonValue::Object(map)
210            }
211        }
212    }
213}
jsonb_rs/from.rs

jsonb_rs/
from.rs
