1 //! The Value enum, a loosely typed way of representing any valid JSON value.
3 //! # Constructing JSON
5 //! Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value`
6 //! objects with very natural JSON syntax. In order to use this macro,
7 //! `serde_json` needs to be imported with the `#[macro_use]` attribute.
11 //! extern crate serde_json;
14 //! // The type of `john` is `serde_json::Value`
15 //! let john = json!({
16 //! "name": "John Doe",
24 //! println!("first phone number: {}", john["phones"][0]);
26 //! // Convert to a string of JSON and print it out
27 //! println!("{}", john.to_string());
31 //! The `Value::to_string()` function converts a `serde_json::Value` into a
32 //! `String` of JSON text.
34 //! One neat thing about the `json!` macro is that variables and expressions can
35 //! be interpolated directly into the JSON value as you are building it. Serde
36 //! will check at compile time that the value you are interpolating is able to
37 //! be represented as JSON.
40 //! # #[macro_use] extern crate serde_json;
41 //! # fn random_phone() -> u16 { 0 }
43 //! let full_name = "John Doe";
44 //! let age_last_year = 42;
46 //! // The type of `john` is `serde_json::Value`
47 //! let john = json!({
48 //! "name": full_name,
49 //! "age": age_last_year + 1,
51 //! format!("+44 {}", random_phone())
58 //! A string of JSON data can be parsed into a `serde_json::Value` by the
59 //! [`serde_json::from_str`][from_str] function. There is also
60 //! [`from_slice`][from_slice] for parsing from a byte slice &[u8],
61 //! [`from_iter`][from_iter] for parsing from an iterator of bytes, and
62 //! [`from_reader`][from_reader] for parsing from any `io::Read` like a File or
66 //! # extern crate serde_json;
67 //! # use serde_json::Error;
68 //! # pub fn example() -> Result<(), Error> {
69 //! use serde_json::Value;
71 //! let data = r#" { "name": "John Doe", "age": 43, ... } "#;
72 //! let v: Value = serde_json::from_str(data)?;
73 //! println!("Please call {} at the number {}", v["name"], v["phones"][0]);
78 //! [macro]: https://docs.serde.rs/serde_json/macro.json.html
79 //! [from_str]: https://docs.serde.rs/serde_json/de/fn.from_str.html
80 //! [from_slice]: https://docs.serde.rs/serde_json/de/fn.from_slice.html
81 //! [from_iter]: https://docs.serde.rs/serde_json/de/fn.from_iter.html
82 //! [from_reader]: https://docs.serde.rs/serde_json/de/fn.from_reader.html
93 use serde
::de
::{self, Unexpected}
;
95 use serde
::de
::value
::ValueDeserializer
;
97 use error
::{Error, ErrorCode}
;
100 pub use number
::Number
;
102 /// Represents any valid JSON value.
103 #[derive(Debug, Clone, PartialEq)]
105 /// Represents a JSON null value.
108 /// Represents a JSON boolean.
111 /// Represents a JSON number, whether integer or floating point.
114 /// Represents a JSON string.
117 /// Represents a JSON array.
120 /// Represents a JSON object.
121 Object(Map
<String
, Value
>),
124 fn parse_index(s
: &str) -> Option
<usize> {
125 if s
.starts_with('
+'
) || (s
.starts_with('
0'
) && s
.len() != 1) {
132 /// Index into a JSON array or map. A string index can be used to access a
133 /// value in a map, and a usize index can be used to access an element of an
136 /// Returns `None` if the type of `self` does not match the type of the
137 /// index, for example if the index is a string and `self` is an array or a
138 /// number. Also returns `None` if the given key does not exist in the map
139 /// or the given index is not within the bounds of the array.
142 /// # #[macro_use] extern crate serde_json;
144 /// let object = json!({ "A": 65, "B": 66, "C": 67 });
145 /// assert_eq!(*object.get("A").unwrap(), json!(65));
147 /// let array = json!([ "A", "B", "C" ]);
148 /// assert_eq!(*array.get(2).unwrap(), json!("C"));
150 /// assert_eq!(array.get("A"), None);
154 /// Square brackets can also be used to index into a value in a more concise
155 /// way. This returns `Value::Null` in cases where `get` would have returned
159 /// # #[macro_use] extern crate serde_json;
161 /// let object = json!({
162 /// "A": ["a", "á", "à"],
163 /// "B": ["b", "b́"],
164 /// "C": ["c", "ć", "ć̣", "ḉ"],
166 /// assert_eq!(object["B"][0], json!("b"));
168 /// assert_eq!(object["D"], json!(null));
169 /// assert_eq!(object[0]["x"]["y"]["z"], json!(null));
172 pub fn get
<I
: Index
>(&self, index
: I
) -> Option
<&Value
> {
173 index
.index_into(self)
176 /// Mutably index into a JSON array or map. A string index can be used to
177 /// access a value in a map, and a usize index can be used to access an
178 /// element of an array.
180 /// Returns `None` if the type of `self` does not match the type of the
181 /// index, for example if the index is a string and `self` is an array or a
182 /// number. Also returns `None` if the given key does not exist in the map
183 /// or the given index is not within the bounds of the array.
186 /// # #[macro_use] extern crate serde_json;
188 /// let mut object = json!({ "A": 65, "B": 66, "C": 67 });
189 /// *object.get_mut("A").unwrap() = json!(69);
191 /// let mut array = json!([ "A", "B", "C" ]);
192 /// *array.get_mut(2).unwrap() = json!("D");
195 pub fn get_mut
<I
: Index
>(&mut self, index
: I
) -> Option
<&mut Value
> {
196 index
.index_into_mut(self)
199 /// Returns true if the `Value` is an Object. Returns false otherwise.
200 pub fn is_object(&self) -> bool
{
201 self.as_object().is_some()
204 /// If the `Value` is an Object, returns the associated Map.
205 /// Returns None otherwise.
206 pub fn as_object(&self) -> Option
<&Map
<String
, Value
>> {
208 Value
::Object(ref map
) => Some(map
),
213 /// If the `Value` is an Object, returns the associated mutable Map.
214 /// Returns None otherwise.
215 pub fn as_object_mut(&mut self) -> Option
<&mut Map
<String
, Value
>> {
217 Value
::Object(ref mut map
) => Some(map
),
222 /// Returns true if the `Value` is an Array. Returns false otherwise.
223 pub fn is_array(&self) -> bool
{
224 self.as_array().is_some()
227 /// If the `Value` is an Array, returns the associated vector.
228 /// Returns None otherwise.
229 pub fn as_array(&self) -> Option
<&Vec
<Value
>> {
231 Value
::Array(ref array
) => Some(&*array
),
236 /// If the `Value` is an Array, returns the associated mutable vector.
237 /// Returns None otherwise.
238 pub fn as_array_mut(&mut self) -> Option
<&mut Vec
<Value
>> {
240 Value
::Array(ref mut list
) => Some(list
),
245 /// Returns true if the `Value` is a String. Returns false otherwise.
246 pub fn is_string(&self) -> bool
{
247 self.as_str().is_some()
250 /// If the `Value` is a String, returns the associated str.
251 /// Returns None otherwise.
252 pub fn as_str(&self) -> Option
<&str> {
254 Value
::String(ref s
) => Some(s
),
259 /// Returns true if the `Value` is a Number. Returns false otherwise.
260 pub fn is_number(&self) -> bool
{
262 Value
::Number(_
) => true,
267 /// Returns true if the `Value` is a number that can be represented by i64.
268 pub fn is_i64(&self) -> bool
{
270 Value
::Number(ref n
) => n
.is_i64(),
275 /// Returns true if the `Value` is a number that can be represented by u64.
276 pub fn is_u64(&self) -> bool
{
278 Value
::Number(ref n
) => n
.is_u64(),
283 /// Returns true if the `Value` is a number that can be represented by f64.
284 pub fn is_f64(&self) -> bool
{
286 Value
::Number(ref n
) => n
.is_f64(),
291 /// If the `Value` is a number, represent it as i64 if possible.
292 /// Returns None otherwise.
293 pub fn as_i64(&self) -> Option
<i64> {
295 Value
::Number(ref n
) => n
.as_i64(),
300 /// If the `Value` is a number, represent it as u64 if possible.
301 /// Returns None otherwise.
302 pub fn as_u64(&self) -> Option
<u64> {
304 Value
::Number(ref n
) => n
.as_u64(),
309 /// If the `Value` is a number, represent it as f64 if possible.
310 /// Returns None otherwise.
311 pub fn as_f64(&self) -> Option
<f64> {
313 Value
::Number(ref n
) => n
.as_f64(),
318 /// Returns true if the `Value` is a Boolean. Returns false otherwise.
319 pub fn is_boolean(&self) -> bool
{
320 self.as_bool().is_some()
323 /// If the `Value` is a Boolean, returns the associated bool.
324 /// Returns None otherwise.
325 pub fn as_bool(&self) -> Option
<bool
> {
327 Value
::Bool(b
) => Some(b
),
332 /// Returns true if the `Value` is a Null. Returns false otherwise.
333 pub fn is_null(&self) -> bool
{
334 self.as_null().is_some()
337 /// If the `Value` is a Null, returns ().
338 /// Returns None otherwise.
339 pub fn as_null(&self) -> Option
<()> {
341 Value
::Null
=> Some(()),
346 /// Looks up a value by a JSON Pointer.
348 /// JSON Pointer defines a string syntax for identifying a specific value
349 /// within a JavaScript Object Notation (JSON) document.
351 /// A Pointer is a Unicode string with the reference tokens separated by `/`.
352 /// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The
353 /// addressed value is returned and if there is no such value `None` is
356 /// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901).
361 /// # #[macro_use] extern crate serde_json;
363 /// let data = json!({
369 /// assert_eq!(data.pointer("/x/y/1").unwrap(), &json!("zz"));
370 /// assert_eq!(data.pointer("/a/b/c"), None);
373 pub fn pointer
<'a
>(&'a
self, pointer
: &str) -> Option
<&'a Value
> {
377 if !pointer
.starts_with('
/'
) {
380 let tokens
= pointer
.split('
/'
).skip(1).map(|x
| x
.replace("~1", "/").replace("~0", "~"));
381 let mut target
= self;
383 for token
in tokens
{
384 let target_opt
= match *target
{
385 Value
::Object(ref map
) => map
.get(&token
),
386 Value
::Array(ref list
) => parse_index(&token
).and_then(|x
| list
.get(x
)),
389 if let Some(t
) = target_opt
{
398 /// Looks up a value by a JSON Pointer and returns a mutable reference to
401 /// JSON Pointer defines a string syntax for identifying a specific value
402 /// within a JavaScript Object Notation (JSON) document.
404 /// A Pointer is a Unicode string with the reference tokens separated by `/`.
405 /// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The
406 /// addressed value is returned and if there is no such value `None` is
409 /// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901).
414 /// extern crate serde_json;
416 /// use serde_json::Value;
420 /// let s = r#"{"x": 1.0, "y": 2.0}"#;
421 /// let mut value: Value = serde_json::from_str(s).unwrap();
423 /// // Check value using read-only pointer
424 /// assert_eq!(value.pointer("/x"), Some(&1.0.into()));
425 /// // Change value with direct assignment
426 /// *value.pointer_mut("/x").unwrap() = 1.5.into();
427 /// // Check that new value was written
428 /// assert_eq!(value.pointer("/x"), Some(&1.5.into()));
430 /// // "Steal" ownership of a value. Can replace with any valid Value.
431 /// let old_x = value.pointer_mut("/x").map(|x| mem::replace(x, Value::Null)).unwrap();
432 /// assert_eq!(old_x, 1.5);
433 /// assert_eq!(value.pointer("/x").unwrap(), &Value::Null);
436 pub fn pointer_mut
<'a
>(&'a
mut self, pointer
: &str) -> Option
<&'a
mut Value
> {
440 if !pointer
.starts_with('
/'
) {
443 let tokens
= pointer
.split('
/'
).skip(1).map(|x
| x
.replace("~1", "/").replace("~0", "~"));
444 let mut target
= self;
446 for token
in tokens
{
447 // borrow checker gets confused about `target` being mutably borrowed too many times because of the loop
448 // this once-per-loop binding makes the scope clearer and circumvents the error
449 let target_once
= target
;
450 let target_opt
= match *target_once
{
451 Value
::Object(ref mut map
) => map
.get_mut(&token
),
452 Value
::Array(ref mut list
) => parse_index(&token
).and_then(move |x
| list
.get_mut(x
)),
455 if let Some(t
) = target_opt
{
465 /// The default value is `Value::Null`.
467 /// This is useful for handling omitted `Value` fields when deserializing.
472 /// # extern crate serde_json;
473 /// # #[macro_use] extern crate serde_derive;
474 /// use serde_json::Value;
476 /// #[derive(Deserialize)]
477 /// struct Settings {
479 /// #[serde(default)]
483 /// # pub fn try_main() -> Result<(), serde_json::Error> {
484 /// let data = r#" { "level": 42 } "#;
485 /// let s: Settings = serde_json::from_str(data)?;
487 /// assert_eq!(s.level, 42);
488 /// assert_eq!(s.extras, Value::Null);
490 /// # fn main() { try_main().unwrap() }
492 impl Default
for Value
{
493 fn default() -> Value
{
498 /// A type that can be used to index into a `serde_json::Value`. See the `get`
499 /// and `get_mut` methods of `Value`.
501 /// This trait is sealed and cannot be implemented for types outside of
503 pub trait Index
: private
::Sealed
{
504 /// Return None if the key is not already in the array or object.
506 fn index_into
<'v
>(&self, v
: &'v Value
) -> Option
<&'v Value
>;
508 /// Return None if the key is not already in the array or object.
510 fn index_into_mut
<'v
>(&self, v
: &'v
mut Value
) -> Option
<&'v
mut Value
>;
512 /// Panic if array index out of bounds. If key is not already in the object,
513 /// insert it with a value of null. Panic if Value is a type that cannot be
514 /// indexed into, except if Value is null then it can be treated as an empty
517 fn index_or_insert
<'v
>(&self, v
: &'v
mut Value
) -> &'v
mut Value
;
520 impl Index
for usize {
521 fn index_into
<'v
>(&self, v
: &'v Value
) -> Option
<&'v Value
> {
523 Value
::Array(ref vec
) => vec
.get(*self),
527 fn index_into_mut
<'v
>(&self, v
: &'v
mut Value
) -> Option
<&'v
mut Value
> {
529 Value
::Array(ref mut vec
) => vec
.get_mut(*self),
533 fn index_or_insert
<'v
>(&self, v
: &'v
mut Value
) -> &'v
mut Value
{
535 Value
::Array(ref mut vec
) => {
537 vec
.get_mut(*self).unwrap_or_else(|| {
538 panic
!("cannot access index {} of JSON array of length {}",
542 _
=> panic
!("cannot access index {} of JSON {}", self, Type(v
)),
548 fn index_into
<'v
>(&self, v
: &'v Value
) -> Option
<&'v Value
> {
550 Value
::Object(ref map
) => map
.get(self),
554 fn index_into_mut
<'v
>(&self, v
: &'v
mut Value
) -> Option
<&'v
mut Value
> {
556 Value
::Object(ref mut map
) => map
.get_mut(self),
560 fn index_or_insert
<'v
>(&self, v
: &'v
mut Value
) -> &'v
mut Value
{
561 if let Value
::Null
= *v
{
562 let mut map
= Map
::new();
563 map
.insert(self.to_owned(), Value
::Null
);
564 *v
= Value
::Object(map
);
567 Value
::Object(ref mut map
) => {
568 // TODO: use entry() once LinkedHashMap supports entry()
569 // https://github.com/contain-rs/linked-hash-map/issues/5
570 if !map
.contains_key(self) {
571 map
.insert(self.to_owned(), Value
::Null
);
573 map
.get_mut(self).unwrap()
575 _
=> panic
!("cannot access key {:?} in JSON {}", self, Type(v
)),
580 impl Index
for String
{
581 fn index_into
<'v
>(&self, v
: &'v Value
) -> Option
<&'v Value
> {
582 self[..].index_into(v
)
584 fn index_into_mut
<'v
>(&self, v
: &'v
mut Value
) -> Option
<&'v
mut Value
> {
585 self[..].index_into_mut(v
)
587 fn index_or_insert
<'v
>(&self, v
: &'v
mut Value
) -> &'v
mut Value
{
588 self[..].index_or_insert(v
)
592 impl<'a
, T
: ?Sized
> Index
for &'a T
where T
: Index
{
593 fn index_into
<'v
>(&self, v
: &'v Value
) -> Option
<&'v Value
> {
594 (**self).index_into(v
)
596 fn index_into_mut
<'v
>(&self, v
: &'v
mut Value
) -> Option
<&'v
mut Value
> {
597 (**self).index_into_mut(v
)
599 fn index_or_insert
<'v
>(&self, v
: &'v
mut Value
) -> &'v
mut Value
{
600 (**self).index_or_insert(v
)
604 // Prevent users from implementing the Index trait.
607 impl Sealed
for usize {}
608 impl Sealed
for str {}
609 impl Sealed
for String {}
610 impl<'a
, T
: ?Sized
> Sealed
for &'a T
where T
: Sealed {}
613 /// Used in panic messages.
614 struct Type
<'a
>(&'a Value
);
616 impl<'a
> fmt
::Display
for Type
<'a
> {
617 fn fmt(&self, formatter
: &mut fmt
::Formatter
) -> fmt
::Result
{
619 Value
::Null
=> formatter
.write_str("null"),
620 Value
::Bool(_
) => formatter
.write_str("boolean"),
621 Value
::Number(_
) => formatter
.write_str("number"),
622 Value
::String(_
) => formatter
.write_str("string"),
623 Value
::Array(_
) => formatter
.write_str("array"),
624 Value
::Object(_
) => formatter
.write_str("object"),
629 // The usual semantics of Index is to panic on invalid indexing.
631 // That said, the usual semantics are for things like Vec and BTreeMap which
632 // have different use cases than Value. If you are working with a Vec, you know
633 // that you are working with a Vec and you can get the len of the Vec and make
634 // sure your indices are within bounds. The Value use cases are more
635 // loosey-goosey. You got some JSON from an endpoint and you want to pull values
636 // out of it. Outside of this Index impl, you already have the option of using
637 // value.as_array() and working with the Vec directly, or matching on
638 // Value::Array and getting the Vec directly. The Index impl means you can skip
639 // that and index directly into the thing using a concise syntax. You don't have
640 // to check the type, you don't have to check the len, it is all about what you
641 // expect the Value to look like.
643 // Basically the use cases that would be well served by panicking here are
644 // better served by using one of the other approaches: get and get_mut,
645 // as_array, or match. The value of this impl is that it adds a way of working
646 // with Value that is not well served by the existing approaches: concise and
647 // careless and sometimes that is exactly what you want.
648 impl<I
> ops
::Index
<I
> for Value
where I
: Index
{
651 /// Index into a `serde_json::Value` using the syntax `value[0]` or
654 /// Returns `Value::Null` if the type of `self` does not match the type of
655 /// the index, for example if the index is a string and `self` is an array
656 /// or a number. Also returns `Value::Null` if the given key does not exist
657 /// in the map or the given index is not within the bounds of the array.
659 /// For retrieving deeply nested values, you should have a look at the
660 /// `Value::pointer` method.
665 /// # #[macro_use] extern crate serde_json;
667 /// let data = json!({
673 /// assert_eq!(data["x"]["y"], json!(["z", "zz"]));
674 /// assert_eq!(data["x"]["y"][0], json!("z"));
676 /// assert_eq!(data["a"], json!(null)); // returns null for undefined values
677 /// assert_eq!(data["a"]["b"], json!(null)); // does not panic
680 fn index(&self, index
: I
) -> &Value
{
681 static NULL
: Value
= Value
::Null
;
682 index
.index_into(self).unwrap_or(&NULL
)
686 impl<I
> ops
::IndexMut
<I
> for Value
where I
: Index
{
687 /// Write into a `serde_json::Value` using the syntax `value[0] = ...` or
688 /// `value["k"] = ...`.
690 /// If the index is a number, the value must be an array of length bigger
691 /// than the index. Indexing into a value that is not an array or an array
692 /// that is too small will panic.
694 /// If the index is a string, the value must be an object or null which is
695 /// treated like an empty object. If the key is not already present in the
696 /// object, it will be inserted with a value of null. Indexing into a value
697 /// that is neither an object nor null will panic.
702 /// # #[macro_use] extern crate serde_json;
704 /// let mut data = json!({ "x": 0 });
706 /// // replace an existing key
707 /// data["x"] = json!(1);
709 /// // insert a new key
710 /// data["y"] = json!([false, false, false]);
712 /// // replace an array value
713 /// data["y"][0] = json!(true);
715 /// // inserted a deeply nested key
716 /// data["a"]["b"]["c"]["d"] = json!(true);
718 /// println!("{}", data);
721 fn index_mut(&mut self, index
: I
) -> &mut Value
{
722 index
.index_or_insert(self)
726 impl PartialEq
<str> for Value
{
727 fn eq(&self, other
: &str) -> bool
{
728 self.as_str().map_or(false, |s
| s
== other
)
732 impl<'a
> PartialEq
<&'a
str> for Value
{
733 fn eq(&self, other
: &&str) -> bool
{
734 self.as_str().map_or(false, |s
| s
== *other
)
738 impl PartialEq
<Value
> for str {
739 fn eq(&self, other
: &Value
) -> bool
{
740 other
.as_str().map_or(false, |s
| s
== self)
744 impl<'a
> PartialEq
<Value
> for &'a
str {
745 fn eq(&self, other
: &Value
) -> bool
{
746 other
.as_str().map_or(false, |s
| s
== *self)
750 impl PartialEq
<String
> for Value
{
751 fn eq(&self, other
: &String
) -> bool
{
752 self.as_str().map_or(false, |s
| s
== other
)
757 impl PartialEq
<Value
> for String
{
758 fn eq(&self, other
: &Value
) -> bool
{
759 other
.as_str().map_or(false, |s
| s
== self)
763 macro_rules
! partialeq_numeric
{
764 ($
([$
($ty
:ty
)*], $conversion
:ident
, $base
:ty
)*) => {
766 impl PartialEq
<$ty
> for Value
{
767 fn eq(&self, other
: &$ty
) -> bool
{
768 self.$
conversion().map_or(false, |i
| i
== (*other
as $base
))
772 impl PartialEq
<Value
> for $ty
{
773 fn eq(&self, other
: &Value
) -> bool
{
774 other
.$
conversion().map_or(false, |i
| i
== (*self as $base
))
778 impl<'a
> PartialEq
<$ty
> for &'a Value
{
779 fn eq(&self, other
: &$ty
) -> bool
{
780 self.$
conversion().map_or(false, |i
| i
== (*other
as $base
))
784 impl<'a
> PartialEq
<$ty
> for &'a
mut Value
{
785 fn eq(&self, other
: &$ty
) -> bool
{
786 self.$
conversion().map_or(false, |i
| i
== (*other
as $base
))
794 [i8 i16 i32 i64 isize], as_i64
, i64
795 [u8 u16 u32 u64 usize], as_u64
, u64
796 [f32 f64], as_f64
, f64
799 macro_rules
! from_integer
{
802 impl From
<$ty
> for Value
{
803 fn from(n
: $ty
) -> Self {
804 Value
::Number(n
.into())
816 impl From
<f32> for Value
{
817 /// Convert 32-bit floating point number to `Value`
822 /// # extern crate serde_json;
823 /// use serde_json::Value;
826 /// let f: f32 = 13.37;
827 /// let x: Value = f.into();
830 fn from(f
: f32) -> Self {
835 impl From
<f64> for Value
{
836 /// Convert 64-bit floating point number to `Value`
841 /// # extern crate serde_json;
842 /// use serde_json::Value;
845 /// let f: f64 = 13.37;
846 /// let x: Value = f.into();
849 fn from(f
: f64) -> Self {
850 Number
::from_f64(f
).map_or(Value
::Null
, Value
::Number
)
854 impl From
<bool
> for Value
{
855 /// Convert boolean to `Value`
860 /// # extern crate serde_json;
861 /// use serde_json::Value;
865 /// let x: Value = b.into();
868 fn from(f
: bool
) -> Self {
873 impl From
<String
> for Value
{
874 /// Convert `String` to `Value`
879 /// # extern crate serde_json;
880 /// use serde_json::Value;
883 /// let s: String = "lorem".to_string();
884 /// let x: Value = s.into();
887 fn from(f
: String
) -> Self {
892 impl<'a
> From
<&'a
str> for Value
{
893 /// Convert string slice to `Value`
898 /// # extern crate serde_json;
899 /// use serde_json::Value;
902 /// let s: &str = "lorem";
903 /// let x: Value = s.into();
906 fn from(f
: &str) -> Self {
907 Value
::String(f
.to_string())
911 impl<'a
> From
<Cow
<'a
, str>> for Value
{
912 /// Convert copy-on-write string to `Value`
917 /// # extern crate serde_json;
918 /// use serde_json::Value;
919 /// use std::borrow::Cow;
922 /// let s: Cow<str> = Cow::Borrowed("lorem");
923 /// let x: Value = s.into();
928 /// # extern crate serde_json;
929 /// use serde_json::Value;
930 /// use std::borrow::Cow;
933 /// let s: Cow<str> = Cow::Owned("lorem".to_string());
934 /// let x: Value = s.into();
937 fn from(f
: Cow
<'a
, str>) -> Self {
938 Value
::String(f
.to_string())
942 impl From
<Map
<String
, Value
>> for Value
{
943 /// Convert map (with string keys) to `Value`
948 /// # extern crate serde_json;
949 /// use serde_json::{Map, Value};
952 /// let mut m = Map::new();
953 /// m.insert("Lorem".to_string(), "ipsum".into());
954 /// let x: Value = m.into();
957 fn from(f
: Map
<String
, Value
>) -> Self {
962 impl<T
: Into
<Value
>> From
<Vec
<T
>> for Value
{
963 /// Convert a `Vec` to `Value`
968 /// # extern crate serde_json;
969 /// use serde_json::Value;
972 /// let v = vec!["lorem", "ipsum", "dolor"];
973 /// let x: Value = v.into();
976 fn from(f
: Vec
<T
>) -> Self {
977 Value
::Array(f
.into_iter().map(Into
::into
).collect())
981 impl<'a
, T
: Clone
+ Into
<Value
>> From
<&'a
[T
]> for Value
{
982 /// Convert a slice to `Value`
987 /// # extern crate serde_json;
988 /// use serde_json::Value;
991 /// let v: &[&str] = &["lorem", "ipsum", "dolor"];
992 /// let x: Value = v.into();
995 fn from(f
: &'a
[T
]) -> Self {
996 Value
::Array(f
.into_iter().cloned().map(Into
::into
).collect())
1000 impl<T
: Into
<Value
>> ::std
::iter
::FromIterator
<T
> for Value
{
1001 /// Convert an iteratable type to a `Value`
1006 /// # extern crate serde_json;
1007 /// use serde_json::Value;
1010 /// let v = std::iter::repeat(42).take(5);
1011 /// let x: Value = v.collect();
1016 /// # extern crate serde_json;
1017 /// use serde_json::Value;
1020 /// let v: Vec<_> = vec!["lorem", "ipsum", "dolor"];
1021 /// let x: Value = v.into_iter().collect();
1026 /// # extern crate serde_json;
1027 /// use std::iter::FromIterator;
1028 /// use serde_json::Value;
1031 /// let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]);
1034 fn from_iter
<I
: IntoIterator
<Item
=T
>>(iter
: I
) -> Self {
1035 let vec
: Vec
<Value
> = iter
.into_iter().map(|x
| x
.into()).collect();
1041 impl ser
::Serialize
for Value
{
1043 fn serialize
<S
>(&self, serializer
: S
) -> Result
<S
::Ok
, S
::Error
>
1044 where S
: ser
::Serializer
,
1047 Value
::Null
=> serializer
.serialize_unit(),
1048 Value
::Bool(b
) => serializer
.serialize_bool(b
),
1049 Value
::Number(ref n
) => n
.serialize(serializer
),
1050 Value
::String(ref s
) => serializer
.serialize_str(s
),
1051 Value
::Array(ref v
) => v
.serialize(serializer
),
1052 Value
::Object(ref m
) => {
1053 use serde
::ser
::SerializeMap
;
1054 let mut map
= try
!(serializer
.serialize_map(Some(m
.len())));
1056 try
!(map
.serialize_key(k
));
1057 try
!(map
.serialize_value(v
));
1065 impl de
::Deserialize
for Value
{
1067 fn deserialize
<D
>(deserializer
: D
) -> Result
<Value
, D
::Error
>
1068 where D
: de
::Deserializer
,
1070 struct ValueVisitor
;
1072 impl de
::Visitor
for ValueVisitor
{
1075 fn expecting(&self, formatter
: &mut fmt
::Formatter
) -> fmt
::Result
{
1076 formatter
.write_str("any valid JSON value")
1080 fn visit_bool
<E
>(self, value
: bool
) -> Result
<Value
, E
> {
1081 Ok(Value
::Bool(value
))
1085 fn visit_i64
<E
>(self, value
: i64) -> Result
<Value
, E
> {
1086 Ok(Value
::Number(value
.into()))
1090 fn visit_u64
<E
>(self, value
: u64) -> Result
<Value
, E
> {
1091 Ok(Value
::Number(value
.into()))
1095 fn visit_f64
<E
>(self, value
: f64) -> Result
<Value
, E
> {
1096 Ok(Number
::from_f64(value
).map_or(Value
::Null
, Value
::Number
))
1100 fn visit_str
<E
>(self, value
: &str) -> Result
<Value
, E
>
1103 self.visit_string(String
::from(value
))
1107 fn visit_string
<E
>(self, value
: String
) -> Result
<Value
, E
> {
1108 Ok(Value
::String(value
))
1112 fn visit_none
<E
>(self) -> Result
<Value
, E
> {
1120 ) -> Result
<Value
, D
::Error
>
1121 where D
: de
::Deserializer
,
1123 de
::Deserialize
::deserialize(deserializer
)
1127 fn visit_unit
<E
>(self) -> Result
<Value
, E
> {
1132 fn visit_seq
<V
>(self, visitor
: V
) -> Result
<Value
, V
::Error
>
1133 where V
: de
::SeqVisitor
,
1135 let values
= try
!(de
::impls
::VecVisitor
::new()
1136 .visit_seq(visitor
));
1137 Ok(Value
::Array(values
))
1140 fn visit_map
<V
>(self, mut visitor
: V
) -> Result
<Value
, V
::Error
>
1141 where V
: de
::MapVisitor
,
1143 let mut values
= Map
::with_capacity(visitor
.size_hint().0);
1145 while let Some((key
, value
)) = try
!(visitor
.visit()) {
1146 values
.insert(key
, value
);
1149 Ok(Value
::Object(values
))
1153 deserializer
.deserialize(ValueVisitor
)
1157 struct WriterFormatter
<'a
, 'b
: 'a
> {
1158 inner
: &'a
mut fmt
::Formatter
<'b
>,
1161 impl<'a
, 'b
> io
::Write
for WriterFormatter
<'a
, 'b
> {
1162 fn write(&mut self, buf
: &[u8]) -> io
::Result
<usize> {
1163 fn io_error
<E
>(_
: E
) -> io
::Error
{
1164 // Value does not matter because fmt::Debug and fmt::Display impls
1165 // below just map it to fmt::Error
1166 io
::Error
::new(io
::ErrorKind
::Other
, "fmt error")
1168 let s
= try
!(str::from_utf8(buf
).map_err(io_error
));
1169 try
!(self.inner
.write_str(s
).map_err(io_error
));
1173 fn flush(&mut self) -> io
::Result
<()> {
1178 impl fmt
::Display
for Value
{
1179 /// Serializes a json value into a string
1180 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
1181 let mut wr
= WriterFormatter
{
1184 super::ser
::to_writer(&mut wr
, self).map_err(|_
| fmt
::Error
)
1188 impl str::FromStr
for Value
{
1190 fn from_str(s
: &str) -> Result
<Value
, Error
> {
1191 super::de
::from_str(s
)
1197 impl ser
::Serializer
for Serializer
{
1201 type SerializeSeq
= SerializeVec
;
1202 type SerializeTuple
= SerializeVec
;
1203 type SerializeTupleStruct
= SerializeVec
;
1204 type SerializeTupleVariant
= SerializeTupleVariant
;
1205 type SerializeMap
= SerializeMap
;
1206 type SerializeStruct
= SerializeMap
;
1207 type SerializeStructVariant
= SerializeStructVariant
;
1210 fn serialize_bool(self, value
: bool
) -> Result
<Value
, Error
> {
1211 Ok(Value
::Bool(value
))
1215 fn serialize_i8(self, value
: i8) -> Result
<Value
, Error
> {
1216 self.serialize_i64(value
as i64)
1220 fn serialize_i16(self, value
: i16) -> Result
<Value
, Error
> {
1221 self.serialize_i64(value
as i64)
1225 fn serialize_i32(self, value
: i32) -> Result
<Value
, Error
> {
1226 self.serialize_i64(value
as i64)
1229 fn serialize_i64(self, value
: i64) -> Result
<Value
, Error
> {
1230 Ok(Value
::Number(value
.into()))
1234 fn serialize_u8(self, value
: u8) -> Result
<Value
, Error
> {
1235 self.serialize_u64(value
as u64)
1239 fn serialize_u16(self, value
: u16) -> Result
<Value
, Error
> {
1240 self.serialize_u64(value
as u64)
1244 fn serialize_u32(self, value
: u32) -> Result
<Value
, Error
> {
1245 self.serialize_u64(value
as u64)
1249 fn serialize_u64(self, value
: u64) -> Result
<Value
, Error
> {
1250 Ok(Value
::Number(value
.into()))
1254 fn serialize_f32(self, value
: f32) -> Result
<Value
, Error
> {
1255 self.serialize_f64(value
as f64)
1259 fn serialize_f64(self, value
: f64) -> Result
<Value
, Error
> {
1260 Ok(Number
::from_f64(value
).map_or(Value
::Null
, Value
::Number
))
1264 fn serialize_char(self, value
: char) -> Result
<Value
, Error
> {
1265 let mut s
= String
::new();
1267 self.serialize_str(&s
)
1271 fn serialize_str(self, value
: &str) -> Result
<Value
, Error
> {
1272 Ok(Value
::String(value
.to_owned()))
1275 fn serialize_bytes(self, value
: &[u8]) -> Result
<Value
, Error
> {
1276 let vec
= value
.iter().map(|&b
| Value
::Number(b
.into())).collect();
1277 Ok(Value
::Array(vec
))
1281 fn serialize_unit(self) -> Result
<Value
, Error
> {
1286 fn serialize_unit_struct(
1289 ) -> Result
<Value
, Error
> {
1290 self.serialize_unit()
1294 fn serialize_unit_variant(
1296 _name
: &'
static str,
1297 _variant_index
: usize,
1298 variant
: &'
static str
1299 ) -> Result
<Value
, Error
> {
1300 self.serialize_str(variant
)
1304 fn serialize_newtype_struct
<T
: ?Sized
>(
1306 _name
: &'
static str,
1308 ) -> Result
<Value
, Error
>
1309 where T
: ser
::Serialize
,
1311 value
.serialize(self)
1314 fn serialize_newtype_variant
<T
: ?Sized
>(
1316 _name
: &'
static str,
1317 _variant_index
: usize,
1318 variant
: &'
static str,
1320 ) -> Result
<Value
, Error
>
1321 where T
: ser
::Serialize
,
1323 let mut values
= Map
::new();
1324 values
.insert(String
::from(variant
), try
!(to_value(&value
)));
1325 Ok(Value
::Object(values
))
1329 fn serialize_none(self) -> Result
<Value
, Error
> {
1330 self.serialize_unit()
1334 fn serialize_some
<T
: ?Sized
>(self, value
: &T
) -> Result
<Value
, Error
>
1335 where T
: ser
::Serialize
,
1337 value
.serialize(self)
1343 ) -> Result
<Self::SerializeSeq
, Error
> {
1345 vec
: Vec
::with_capacity(len
.unwrap_or(0))
1349 fn serialize_seq_fixed_size(
1352 ) -> Result
<Self::SerializeSeq
, Error
> {
1353 self.serialize_seq(Some(size
))
1356 fn serialize_tuple(self, len
: usize) -> Result
<Self::SerializeTuple
, Error
> {
1357 self.serialize_seq(Some(len
))
1360 fn serialize_tuple_struct(
1362 _name
: &'
static str,
1364 ) -> Result
<Self::SerializeTupleStruct
, Error
> {
1365 self.serialize_seq(Some(len
))
1368 fn serialize_tuple_variant(
1370 _name
: &'
static str,
1371 _variant_index
: usize,
1372 variant
: &'
static str,
1374 ) -> Result
<Self::SerializeTupleVariant
, Error
> {
1375 Ok(SerializeTupleVariant
{
1376 name
: String
::from(variant
),
1377 vec
: Vec
::with_capacity(len
),
1384 ) -> Result
<Self::SerializeMap
, Error
> {
1391 fn serialize_struct(
1393 _name
: &'
static str,
1395 ) -> Result
<Self::SerializeStruct
, Error
> {
1396 self.serialize_map(Some(len
))
1399 fn serialize_struct_variant(
1401 _name
: &'
static str,
1402 _variant_index
: usize,
1403 variant
: &'
static str,
1405 ) -> Result
<Self::SerializeStructVariant
, Error
> {
1406 Ok(SerializeStructVariant
{
1407 name
: String
::from(variant
),
1414 pub struct SerializeVec
{
1419 pub struct SerializeTupleVariant
{
1425 pub struct SerializeMap
{
1426 map
: Map
<String
, Value
>,
1427 next_key
: Option
<String
>,
1431 pub struct SerializeStructVariant
{
1433 map
: Map
<String
, Value
>,
1436 impl ser
::SerializeSeq
for SerializeVec
{
1440 fn serialize_element
<T
: ?Sized
>(&mut self, value
: &T
) -> Result
<(), Error
>
1441 where T
: ser
::Serialize
1443 self.vec
.push(try
!(to_value(&value
)));
1447 fn end(self) -> Result
<Value
, Error
> {
1448 Ok(Value
::Array(self.vec
))
1452 impl ser
::SerializeTuple
for SerializeVec
{
1456 fn serialize_element
<T
: ?Sized
>(&mut self, value
: &T
) -> Result
<(), Error
>
1457 where T
: ser
::Serialize
1459 ser
::SerializeSeq
::serialize_element(self, value
)
1462 fn end(self) -> Result
<Value
, Error
> {
1463 ser
::SerializeSeq
::end(self)
1467 impl ser
::SerializeTupleStruct
for SerializeVec
{
1471 fn serialize_field
<T
: ?Sized
>(&mut self, value
: &T
) -> Result
<(), Error
>
1472 where T
: ser
::Serialize
1474 ser
::SerializeSeq
::serialize_element(self, value
)
1477 fn end(self) -> Result
<Value
, Error
> {
1478 ser
::SerializeSeq
::end(self)
1482 impl ser
::SerializeTupleVariant
for SerializeTupleVariant
{
1486 fn serialize_field
<T
: ?Sized
>(&mut self, value
: &T
) -> Result
<(), Error
>
1487 where T
: ser
::Serialize
1489 self.vec
.push(try
!(to_value(&value
)));
1493 fn end(self) -> Result
<Value
, Error
> {
1494 let mut object
= Map
::new();
1496 object
.insert(self.name
, Value
::Array(self.vec
));
1498 Ok(Value
::Object(object
))
1502 impl ser
::SerializeMap
for SerializeMap
{
1506 fn serialize_key
<T
: ?Sized
>(&mut self, key
: &T
) -> Result
<(), Error
>
1507 where T
: ser
::Serialize
1509 match try
!(to_value(&key
)) {
1510 Value
::String(s
) => self.next_key
= Some(s
),
1511 Value
::Number(n
) => {
1512 if n
.is_u64() || n
.is_i64() {
1513 self.next_key
= Some(n
.to_string())
1515 return Err(Error
::syntax(ErrorCode
::KeyMustBeAString
, 0, 0))
1518 _
=> return Err(Error
::syntax(ErrorCode
::KeyMustBeAString
, 0, 0)),
1523 fn serialize_value
<T
: ?Sized
>(&mut self, value
: &T
) -> Result
<(), Error
>
1524 where T
: ser
::Serialize
1526 let key
= self.next_key
.take();
1527 // Panic because this indicates a bug in the program rather than an
1528 // expected failure.
1529 let key
= key
.expect("serialize_value called before serialize_key");
1530 self.map
.insert(key
, try
!(to_value(&value
)));
1534 fn end(self) -> Result
<Value
, Error
> {
1535 Ok(Value
::Object(self.map
))
1539 impl ser
::SerializeStruct
for SerializeMap
{
1543 fn serialize_field
<T
: ?Sized
>(&mut self, key
: &'
static str, value
: &T
) -> Result
<(), Error
>
1544 where T
: ser
::Serialize
1546 try
!(ser
::SerializeMap
::serialize_key(self, key
));
1547 ser
::SerializeMap
::serialize_value(self, value
)
1550 fn end(self) -> Result
<Value
, Error
> {
1551 ser
::SerializeMap
::end(self)
1555 impl ser
::SerializeStructVariant
for SerializeStructVariant
{
1559 fn serialize_field
<T
: ?Sized
>(&mut self, key
: &'
static str, value
: &T
) -> Result
<(), Error
>
1560 where T
: ser
::Serialize
1562 self.map
.insert(String
::from(key
), try
!(to_value(&value
)));
1566 fn end(self) -> Result
<Value
, Error
> {
1567 let mut object
= Map
::new();
1569 object
.insert(self.name
, Value
::Object(self.map
));
1571 Ok(Value
::Object(object
))
1575 impl de
::Deserializer
for Value
{
1579 fn deserialize
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
1580 where V
: de
::Visitor
,
1583 Value
::Null
=> visitor
.visit_unit(),
1584 Value
::Bool(v
) => visitor
.visit_bool(v
),
1585 Value
::Number(n
) => n
.deserialize(visitor
),
1586 Value
::String(v
) => visitor
.visit_string(v
),
1587 Value
::Array(v
) => {
1589 let mut deserializer
= SeqDeserializer
::new(v
);
1590 let seq
= try
!(visitor
.visit_seq(&mut deserializer
));
1591 let remaining
= deserializer
.iter
.len();
1595 Err(de
::Error
::invalid_length(len
, &"fewer elements in array"))
1598 Value
::Object(v
) => {
1600 let mut deserializer
= MapDeserializer
::new(v
);
1601 let map
= try
!(visitor
.visit_map(&mut deserializer
));
1602 let remaining
= deserializer
.iter
.len();
1606 Err(de
::Error
::invalid_length(len
, &"fewer elements in map"))
1613 fn deserialize_option
<V
>(
1616 ) -> Result
<V
::Value
, Error
>
1617 where V
: de
::Visitor
,
1620 Value
::Null
=> visitor
.visit_none(),
1621 _
=> visitor
.visit_some(self),
1626 fn deserialize_enum
<V
>(
1629 _variants
: &'
static [&'
static str],
1631 ) -> Result
<V
::Value
, Error
>
1632 where V
: de
::Visitor
,
1634 let (variant
, value
) = match self {
1635 Value
::Object(value
) => {
1636 let mut iter
= value
.into_iter();
1637 let (variant
, value
) = match iter
.next() {
1640 return Err(de
::Error
::invalid_value(Unexpected
::Map
, &"map with a single key"));
1643 // enums are encoded in json as maps with a single key:value pair
1644 if iter
.next().is_some() {
1645 return Err(de
::Error
::invalid_value(Unexpected
::Map
, &"map with a single key"));
1647 (variant
, Some(value
))
1649 Value
::String(variant
) => (variant
, None
),
1651 return Err(de
::Error
::invalid_type(other
.unexpected(), &"string or map"));
1655 visitor
.visit_enum(EnumDeserializer
{
1662 fn deserialize_newtype_struct
<V
>(
1664 _name
: &'
static str,
1666 ) -> Result
<V
::Value
, Self::Error
>
1667 where V
: de
::Visitor
,
1669 visitor
.visit_newtype_struct(self)
1672 forward_to_deserialize
! {
1673 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
1674 seq_fixed_size bytes byte_buf map unit_struct tuple_struct
struct
1675 struct_field tuple ignored_any
1679 struct EnumDeserializer
{
1681 value
: Option
<Value
>,
1684 impl de
::EnumVisitor
for EnumDeserializer
{
1686 type Variant
= VariantDeserializer
;
1688 fn visit_variant_seed
<V
>(self, seed
: V
) -> Result
<(V
::Value
, VariantDeserializer
), Error
>
1689 where V
: de
::DeserializeSeed
,
1691 let variant
= self.variant
.into_deserializer();
1692 let visitor
= VariantDeserializer { value: self.value }
;
1693 seed
.deserialize(variant
).map(|v
| (v
, visitor
))
1697 struct VariantDeserializer
{
1698 value
: Option
<Value
>,
1701 impl de
::VariantVisitor
for VariantDeserializer
{
1704 fn visit_unit(self) -> Result
<(), Error
> {
1706 Some(value
) => de
::Deserialize
::deserialize(value
),
1711 fn visit_newtype_seed
<T
>(self, seed
: T
) -> Result
<T
::Value
, Error
>
1712 where T
: de
::DeserializeSeed
,
1715 Some(value
) => seed
.deserialize(value
),
1716 None
=> Err(de
::Error
::invalid_type(Unexpected
::UnitVariant
, &"newtype variant")),
1724 ) -> Result
<V
::Value
, Error
>
1725 where V
: de
::Visitor
,
1728 Some(Value
::Array(v
)) => {
1729 de
::Deserializer
::deserialize(SeqDeserializer
::new(v
), visitor
)
1731 Some(other
) => Err(de
::Error
::invalid_type(other
.unexpected(), &"tuple variant")),
1732 None
=> Err(de
::Error
::invalid_type(Unexpected
::UnitVariant
, &"tuple variant"))
1738 _fields
: &'
static [&'
static str],
1740 ) -> Result
<V
::Value
, Error
>
1741 where V
: de
::Visitor
,
1744 Some(Value
::Object(v
)) => {
1745 de
::Deserializer
::deserialize(MapDeserializer
::new(v
), visitor
)
1747 Some(other
) => Err(de
::Error
::invalid_type(other
.unexpected(), &"struct variant")),
1748 _
=> Err(de
::Error
::invalid_type(Unexpected
::UnitVariant
, &"struct variant"))
1753 struct SeqDeserializer
{
1754 iter
: vec
::IntoIter
<Value
>,
1757 impl SeqDeserializer
{
1758 fn new(vec
: Vec
<Value
>) -> Self {
1760 iter
: vec
.into_iter(),
1765 impl de
::Deserializer
for SeqDeserializer
{
1769 fn deserialize
<V
>(mut self, visitor
: V
) -> Result
<V
::Value
, Error
>
1770 where V
: de
::Visitor
,
1772 let len
= self.iter
.len();
1774 visitor
.visit_unit()
1776 let ret
= try
!(visitor
.visit_seq(&mut self));
1777 let remaining
= self.iter
.len();
1781 Err(de
::Error
::invalid_length(len
, &"fewer elements in array"))
1786 forward_to_deserialize
! {
1787 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
1788 seq seq_fixed_size bytes byte_buf map unit_struct newtype_struct
1789 tuple_struct
struct struct_field tuple
enum ignored_any
1793 impl de
::SeqVisitor
for SeqDeserializer
{
1796 fn visit_seed
<T
>(&mut self, seed
: T
) -> Result
<Option
<T
::Value
>, Error
>
1797 where T
: de
::DeserializeSeed
,
1799 match self.iter
.next() {
1800 Some(value
) => seed
.deserialize(value
).map(Some
),
1805 fn size_hint(&self) -> (usize, Option
<usize>) {
1806 self.iter
.size_hint()
1810 struct MapDeserializer
{
1811 iter
: <Map
<String
, Value
> as IntoIterator
>::IntoIter
,
1812 value
: Option
<Value
>,
1815 impl MapDeserializer
{
1816 fn new(map
: Map
<String
, Value
>) -> Self {
1818 iter
: map
.into_iter(),
1824 impl de
::MapVisitor
for MapDeserializer
{
1827 fn visit_key_seed
<T
>(&mut self, seed
: T
) -> Result
<Option
<T
::Value
>, Error
>
1828 where T
: de
::DeserializeSeed
,
1830 match self.iter
.next() {
1831 Some((key
, value
)) => {
1832 self.value
= Some(value
);
1833 seed
.deserialize(key
.into_deserializer()).map(Some
)
1839 fn visit_value_seed
<T
>(&mut self, seed
: T
) -> Result
<T
::Value
, Error
>
1840 where T
: de
::DeserializeSeed
,
1842 match self.value
.take() {
1843 Some(value
) => seed
.deserialize(value
),
1844 None
=> Err(de
::Error
::custom("value is missing")),
1848 fn size_hint(&self) -> (usize, Option
<usize>) {
1849 self.iter
.size_hint()
1853 impl de
::Deserializer
for MapDeserializer
{
1857 fn deserialize
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
1858 where V
: de
::Visitor
,
1860 visitor
.visit_map(self)
1863 forward_to_deserialize
! {
1864 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
1865 seq seq_fixed_size bytes byte_buf map unit_struct newtype_struct
1866 tuple_struct
struct struct_field tuple
enum ignored_any
1870 impl<'a
> de
::Deserializer
for &'a Value
{
1873 fn deserialize
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
1874 where V
: de
::Visitor
,
1877 Value
::Null
=> visitor
.visit_unit(),
1878 Value
::Bool(v
) => visitor
.visit_bool(v
),
1879 Value
::Number(ref n
) => n
.deserialize(visitor
),
1880 Value
::String(ref v
) => visitor
.visit_str(v
),
1881 Value
::Array(ref v
) => {
1883 let mut deserializer
= SeqRefDeserializer
::new(v
);
1884 let seq
= try
!(visitor
.visit_seq(&mut deserializer
));
1885 let remaining
= deserializer
.iter
.len();
1889 Err(de
::Error
::invalid_length(len
, &"fewer elements in array"))
1892 Value
::Object(ref v
) => {
1894 let mut deserializer
= MapRefDeserializer
::new(v
);
1895 let map
= try
!(visitor
.visit_map(&mut deserializer
));
1896 let remaining
= deserializer
.iter
.len();
1900 Err(de
::Error
::invalid_length(len
, &"fewer elements in map"))
1906 fn deserialize_option
<V
>(
1909 ) -> Result
<V
::Value
, Error
>
1910 where V
: de
::Visitor
,
1913 Value
::Null
=> visitor
.visit_none(),
1914 _
=> visitor
.visit_some(self),
1918 fn deserialize_enum
<V
>(
1921 _variants
: &'
static [&'
static str],
1923 ) -> Result
<V
::Value
, Error
>
1924 where V
: de
::Visitor
,
1926 let (variant
, value
) = match *self {
1927 Value
::Object(ref value
) => {
1928 let mut iter
= value
.into_iter();
1929 let (variant
, value
) = match iter
.next() {
1932 return Err(de
::Error
::invalid_value(Unexpected
::Map
, &"map with a single key"));
1935 // enums are encoded in json as maps with a single key:value pair
1936 if iter
.next().is_some() {
1937 return Err(de
::Error
::invalid_value(Unexpected
::Map
, &"map with a single key"));
1939 (variant
, Some(value
))
1941 Value
::String(ref variant
) => (variant
, None
),
1943 return Err(de
::Error
::invalid_type(other
.unexpected(), &"string or map"));
1947 visitor
.visit_enum(EnumRefDeserializer
{
1954 fn deserialize_newtype_struct
<V
>(
1956 _name
: &'
static str,
1958 ) -> Result
<V
::Value
, Self::Error
>
1959 where V
: de
::Visitor
,
1961 visitor
.visit_newtype_struct(self)
1964 forward_to_deserialize
! {
1965 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
1966 seq_fixed_size bytes byte_buf map unit_struct tuple_struct
struct
1967 struct_field tuple ignored_any
1971 struct EnumRefDeserializer
<'a
> {
1973 value
: Option
<&'a Value
>,
1976 impl<'a
> de
::EnumVisitor
for EnumRefDeserializer
<'a
> {
1978 type Variant
= VariantRefDeserializer
<'a
>;
1980 fn visit_variant_seed
<V
>(self, seed
: V
) -> Result
<(V
::Value
, Self::Variant
), Error
>
1981 where V
: de
::DeserializeSeed
,
1983 let variant
= self.variant
.into_deserializer();
1984 let visitor
= VariantRefDeserializer { value: self.value }
;
1985 seed
.deserialize(variant
).map(|v
| (v
, visitor
))
1989 struct VariantRefDeserializer
<'a
> {
1990 value
: Option
<&'a Value
>,
1993 impl<'a
> de
::VariantVisitor
for VariantRefDeserializer
<'a
> {
1996 fn visit_unit(self) -> Result
<(), Error
> {
1998 Some(value
) => de
::Deserialize
::deserialize(value
),
2003 fn visit_newtype_seed
<T
>(self, seed
: T
) -> Result
<T
::Value
, Error
>
2004 where T
: de
::DeserializeSeed
,
2007 Some(value
) => seed
.deserialize(value
),
2008 None
=> Err(de
::Error
::invalid_type(Unexpected
::UnitVariant
, &"newtype variant")),
2016 ) -> Result
<V
::Value
, Error
>
2017 where V
: de
::Visitor
,
2020 Some(&Value
::Array(ref v
)) => {
2021 de
::Deserializer
::deserialize(SeqRefDeserializer
::new(v
), visitor
)
2023 Some(other
) => Err(de
::Error
::invalid_type(other
.unexpected(), &"tuple variant")),
2024 None
=> Err(de
::Error
::invalid_type(Unexpected
::UnitVariant
, &"tuple variant"))
2030 _fields
: &'
static [&'
static str],
2032 ) -> Result
<V
::Value
, Error
>
2033 where V
: de
::Visitor
,
2036 Some(&Value
::Object(ref v
)) => {
2037 de
::Deserializer
::deserialize(MapRefDeserializer
::new(v
), visitor
)
2039 Some(other
) => Err(de
::Error
::invalid_type(other
.unexpected(), &"struct variant")),
2040 _
=> Err(de
::Error
::invalid_type(Unexpected
::UnitVariant
, &"struct variant"))
2045 struct SeqRefDeserializer
<'a
> {
2046 iter
: slice
::Iter
<'a
, Value
>,
2049 impl<'a
> SeqRefDeserializer
<'a
> {
2050 fn new(slice
: &'a
[Value
]) -> Self {
2051 SeqRefDeserializer
{
2057 impl<'a
> de
::Deserializer
for SeqRefDeserializer
<'a
> {
2061 fn deserialize
<V
>(mut self, visitor
: V
) -> Result
<V
::Value
, Error
>
2062 where V
: de
::Visitor
,
2064 let len
= self.iter
.len();
2066 visitor
.visit_unit()
2068 let ret
= try
!(visitor
.visit_seq(&mut self));
2069 let remaining
= self.iter
.len();
2073 Err(de
::Error
::invalid_length(len
, &"fewer elements in array"))
2078 forward_to_deserialize
! {
2079 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
2080 seq seq_fixed_size bytes byte_buf map unit_struct newtype_struct
2081 tuple_struct
struct struct_field tuple
enum ignored_any
2085 impl<'a
> de
::SeqVisitor
for SeqRefDeserializer
<'a
> {
2088 fn visit_seed
<T
>(&mut self, seed
: T
) -> Result
<Option
<T
::Value
>, Error
>
2089 where T
: de
::DeserializeSeed
,
2091 match self.iter
.next() {
2092 Some(value
) => seed
.deserialize(value
).map(Some
),
2097 fn size_hint(&self) -> (usize, Option
<usize>) {
2098 self.iter
.size_hint()
2102 struct MapRefDeserializer
<'a
> {
2103 iter
: <&'a Map
<String
, Value
> as IntoIterator
>::IntoIter
,
2104 value
: Option
<&'a Value
>,
2107 impl<'a
> MapRefDeserializer
<'a
> {
2108 fn new(map
: &'a Map
<String
, Value
>) -> Self {
2109 MapRefDeserializer
{
2110 iter
: map
.into_iter(),
2116 impl<'a
> de
::MapVisitor
for MapRefDeserializer
<'a
> {
2119 fn visit_key_seed
<T
>(&mut self, seed
: T
) -> Result
<Option
<T
::Value
>, Error
>
2120 where T
: de
::DeserializeSeed
,
2122 match self.iter
.next() {
2123 Some((key
, value
)) => {
2124 self.value
= Some(value
);
2125 seed
.deserialize((&**key
).into_deserializer()).map(Some
)
2131 fn visit_value_seed
<T
>(&mut self, seed
: T
) -> Result
<T
::Value
, Error
>
2132 where T
: de
::DeserializeSeed
,
2134 match self.value
.take() {
2135 Some(value
) => seed
.deserialize(value
),
2136 None
=> Err(de
::Error
::custom("value is missing")),
2140 fn size_hint(&self) -> (usize, Option
<usize>) {
2141 self.iter
.size_hint()
2145 impl<'a
> de
::Deserializer
for MapRefDeserializer
<'a
> {
2149 fn deserialize
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
2150 where V
: de
::Visitor
,
2152 visitor
.visit_map(self)
2155 forward_to_deserialize
! {
2156 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
2157 seq seq_fixed_size bytes byte_buf map unit_struct newtype_struct
2158 tuple_struct
struct struct_field tuple
enum ignored_any
2163 fn unexpected(&self) -> Unexpected
{
2165 Value
::Null
=> Unexpected
::Unit
,
2166 Value
::Bool(b
) => Unexpected
::Bool(b
),
2167 Value
::Number(ref n
) => {
2168 if let Some(u
) = n
.as_u64() {
2169 Unexpected
::Unsigned(u
)
2170 } else if let Some(i
) = n
.as_i64() {
2171 Unexpected
::Signed(i
)
2172 } else if let Some(f
) = n
.as_f64() {
2173 Unexpected
::Float(f
)
2175 panic
!("unexpected number")
2178 Value
::String(ref s
) => Unexpected
::Str(s
),
2179 Value
::Array(_
) => Unexpected
::Seq
,
2180 Value
::Object(_
) => Unexpected
::Map
,
2185 /// Convert a `T` into `serde_json::Value` which is an enum that can represent
2186 /// any valid JSON data.
2188 /// This conversion can fail if `T`'s implementation of `Serialize` decides to
2189 /// fail, or if `T` contains a map with non-string keys.
2192 /// # use serde_json::Value;
2193 /// let val = serde_json::to_value("s").unwrap();
2194 /// assert_eq!(val, Value::String("s".to_owned()));
2196 #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
2197 // Taking by value is more friendly to iterator adapters, option and result
2198 // consumers, etc. See https://github.com/serde-rs/json/pull/149.
2199 pub fn to_value
<T
>(value
: T
) -> Result
<Value
, Error
>
2200 where T
: ser
::Serialize
,
2202 value
.serialize(Serializer
)
2205 /// Interpret a `serde_json::Value` as an instance of type `T`.
2207 /// This conversion can fail if the structure of the Value does not match the
2208 /// structure expected by `T`, for example if `T` is a struct type but the Value
2209 /// contains something other than a JSON map. It can also fail if the structure
2210 /// is correct but `T`'s implementation of `Deserialize` decides that something
2211 /// is wrong with the data, for example required struct fields are missing from
2212 /// the JSON map or some number is too big to fit in the expected primitive
2214 pub fn from_value
<T
>(value
: Value
) -> Result
<T
, Error
>
2215 where T
: de
::Deserialize
,
2217 de
::Deserialize
::deserialize(value
)
2220 /// Representation of any serializable data as a `serde_json::Value`.
2222 /// Represent `self` as a `serde_json::Value`. Note that `Value` is not a
2223 /// JSON string. If you need a string, use `serde_json::to_string` instead.
2225 /// This conversion can fail if `T`'s implementation of `Serialize` decides
2226 /// to fail, or if `T` contains a map with non-string keys.
2227 fn to_json(&self) -> Result
<Value
, Error
>;
2230 impl<T
: ?Sized
> ToJson
for T
2231 where T
: ser
::Serialize
,
2233 fn to_json(&self) -> Result
<Value
, Error
> {