serde_json/value/
from.rs

1use std::borrow::Cow;
2
3use super::Value;
4use map::Map;
5use number::Number;
6
7macro_rules! from_integer {
8    ($($ty:ident)*) => {
9        $(
10            impl From<$ty> for Value {
11                fn from(n: $ty) -> Self {
12                    Value::Number(n.into())
13                }
14            }
15        )*
16    };
17}
18
19from_integer! {
20    i8 i16 i32 i64 isize
21    u8 u16 u32 u64 usize
22}
23
24#[cfg(feature = "arbitrary_precision")]
25serde_if_integer128! {
26    from_integer! {
27        i128 u128
28    }
29}
30
31impl From<f32> for Value {
32    /// Convert 32-bit floating point number to `Value`
33    ///
34    /// # Examples
35    ///
36    /// ```edition2018
37    /// use serde_json::Value;
38    ///
39    /// let f: f32 = 13.37;
40    /// let x: Value = f.into();
41    /// ```
42    fn from(f: f32) -> Self {
43        From::from(f as f64)
44    }
45}
46
47impl From<f64> for Value {
48    /// Convert 64-bit floating point number to `Value`
49    ///
50    /// # Examples
51    ///
52    /// ```edition2018
53    /// use serde_json::Value;
54    ///
55    /// let f: f64 = 13.37;
56    /// let x: Value = f.into();
57    /// ```
58    fn from(f: f64) -> Self {
59        Number::from_f64(f).map_or(Value::Null, Value::Number)
60    }
61}
62
63impl From<bool> for Value {
64    /// Convert boolean to `Value`
65    ///
66    /// # Examples
67    ///
68    /// ```edition2018
69    /// use serde_json::Value;
70    ///
71    /// let b = false;
72    /// let x: Value = b.into();
73    /// ```
74    fn from(f: bool) -> Self {
75        Value::Bool(f)
76    }
77}
78
79impl From<String> for Value {
80    /// Convert `String` to `Value`
81    ///
82    /// # Examples
83    ///
84    /// ```edition2018
85    /// use serde_json::Value;
86    ///
87    /// let s: String = "lorem".to_string();
88    /// let x: Value = s.into();
89    /// ```
90    fn from(f: String) -> Self {
91        Value::String(f)
92    }
93}
94
95impl<'a> From<&'a str> for Value {
96    /// Convert string slice to `Value`
97    ///
98    /// # Examples
99    ///
100    /// ```edition2018
101    /// use serde_json::Value;
102    ///
103    /// let s: &str = "lorem";
104    /// let x: Value = s.into();
105    /// ```
106    fn from(f: &str) -> Self {
107        Value::String(f.to_string())
108    }
109}
110
111impl<'a> From<Cow<'a, str>> for Value {
112    /// Convert copy-on-write string to `Value`
113    ///
114    /// # Examples
115    ///
116    /// ```edition2018
117    /// use serde_json::Value;
118    /// use std::borrow::Cow;
119    ///
120    /// let s: Cow<str> = Cow::Borrowed("lorem");
121    /// let x: Value = s.into();
122    /// ```
123    ///
124    /// ```edition2018
125    /// use serde_json::Value;
126    /// use std::borrow::Cow;
127    ///
128    /// let s: Cow<str> = Cow::Owned("lorem".to_string());
129    /// let x: Value = s.into();
130    /// ```
131    fn from(f: Cow<'a, str>) -> Self {
132        Value::String(f.into_owned())
133    }
134}
135
136impl From<Map<String, Value>> for Value {
137    /// Convert map (with string keys) to `Value`
138    ///
139    /// # Examples
140    ///
141    /// ```edition2018
142    /// use serde_json::{Map, Value};
143    ///
144    /// let mut m = Map::new();
145    /// m.insert("Lorem".to_string(), "ipsum".into());
146    /// let x: Value = m.into();
147    /// ```
148    fn from(f: Map<String, Value>) -> Self {
149        Value::Object(f)
150    }
151}
152
153impl<T: Into<Value>> From<Vec<T>> for Value {
154    /// Convert a `Vec` to `Value`
155    ///
156    /// # Examples
157    ///
158    /// ```edition2018
159    /// use serde_json::Value;
160    ///
161    /// let v = vec!["lorem", "ipsum", "dolor"];
162    /// let x: Value = v.into();
163    /// ```
164    fn from(f: Vec<T>) -> Self {
165        Value::Array(f.into_iter().map(Into::into).collect())
166    }
167}
168
169impl<'a, T: Clone + Into<Value>> From<&'a [T]> for Value {
170    /// Convert a slice to `Value`
171    ///
172    /// # Examples
173    ///
174    /// ```edition2018
175    /// use serde_json::Value;
176    ///
177    /// let v: &[&str] = &["lorem", "ipsum", "dolor"];
178    /// let x: Value = v.into();
179    /// ```
180    fn from(f: &'a [T]) -> Self {
181        Value::Array(f.iter().cloned().map(Into::into).collect())
182    }
183}
184
185impl<T: Into<Value>> ::std::iter::FromIterator<T> for Value {
186    /// Convert an iteratable type to a `Value`
187    ///
188    /// # Examples
189    ///
190    /// ```edition2018
191    /// use serde_json::Value;
192    ///
193    /// let v = std::iter::repeat(42).take(5);
194    /// let x: Value = v.collect();
195    /// ```
196    ///
197    /// ```edition2018
198    /// use serde_json::Value;
199    ///
200    /// let v: Vec<_> = vec!["lorem", "ipsum", "dolor"];
201    /// let x: Value = v.into_iter().collect();
202    /// ```
203    ///
204    /// ```edition2018
205    /// use std::iter::FromIterator;
206    /// use serde_json::Value;
207    ///
208    /// let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]);
209    /// ```
210    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
211        Value::Array(iter.into_iter().map(Into::into).collect())
212    }
213}
214
215impl From<()> for Value {
216    /// Convert `()` to `Value`
217    ///
218    /// # Examples
219    ///
220    /// ```edition2018
221    /// use serde_json::Value;
222    ///
223    /// let u = ();
224    /// let x: Value = u.into();
225    /// ```
226    fn from((): ()) -> Self {
227        Value::Null
228    }
229}