src/json_value.rs - platform/external/rust/crates/tinyjson - Git at Google

 use crate::generator::{format, stringify, JsonGenerateResult, JsonGenerator};
 use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::fmt;
 use std::io;
 use std::ops::{Index, IndexMut};

 const NULL: () = ();

 /// Enum to represent one JSON value. Each variant represents corresponding JSON types.
 /// ```
 /// use tinyjson::JsonValue;
 /// use std::convert::TryInto;
 ///
 /// // Convert from raw values using `From` trait
 /// let value = JsonValue::from("this is string".to_string());
 ///
 /// // Get reference to inner value
 /// let maybe_number: Option<&f64> = value.get();
 /// assert!(maybe_number.is_none());
 /// let maybe_string: Option<&String> = value.get();
 /// assert!(maybe_string.is_some());
 ///
 /// // Check type of JSON value
 /// assert!(matches!(value, JsonValue::String(_)));
 /// assert!(value.is_string());
 ///
 /// // Convert into raw values using `TryInto` trait
 /// let original_value: String = value.try_into().unwrap();
 /// ```
 #[derive(Debug, Clone, PartialEq)]
 pub enum JsonValue {
     /// Number type value.
     Number(f64),
     /// Boolean type value.
     Boolean(bool),
     /// String type value.
     String(String),
     /// Null type value.
     Null,
     /// Array type value.
     Array(Vec<JsonValue>),
     /// Object type value.
     Object(HashMap<String, JsonValue>),
 }

 /// Trait to access to inner value of `JsonValue` as reference.
 ///
 /// This is used by several APIs like [`JsonValue::get`] to represent any inner values of [`JsonValue`].
 pub trait InnerAsRef {
     fn json_value_as(v: &JsonValue) -> Option<&Self>;
 }

 macro_rules! impl_inner_ref {
     ($to:ty, $pat:pat => $val:expr) => {
         impl InnerAsRef for $to {
             fn json_value_as(v: &JsonValue) -> Option<&$to> {
                 use JsonValue::*;
                 match v {
                     $pat => Some($val),
                     _ => None,
                 }
             }
         }
     };
 }

 impl_inner_ref!(f64, Number(n) => n);
 impl_inner_ref!(bool, Boolean(b) => b);
 impl_inner_ref!(String, String(s) => s);
 impl_inner_ref!((), Null => &NULL);
 impl_inner_ref!(Vec<JsonValue>, Array(a) => a);
 impl_inner_ref!(HashMap<String, JsonValue>, Object(h) => h);

 /// Trait to access to inner value of `JsonValue` as mutable reference.
 ///
 /// This is a mutable version of [`InnerAsRef`].
 pub trait InnerAsRefMut {
     fn json_value_as_mut(v: &mut JsonValue) -> Option<&mut Self>;
 }

 macro_rules! impl_inner_ref_mut {
     ($to:ty, $pat:pat => $val:expr) => {
         impl InnerAsRefMut for $to {
             fn json_value_as_mut(v: &mut JsonValue) -> Option<&mut $to> {
                 use JsonValue::*;
                 match v {
                     $pat => Some($val),
                     _ => None,
                 }
             }
         }
     };
 }

 impl_inner_ref_mut!(f64, Number(n) => n);
 impl_inner_ref_mut!(bool, Boolean(b) => b);
 impl_inner_ref_mut!(String, String(s) => s);
 impl_inner_ref_mut!(Vec<JsonValue>, Array(a) => a);
 impl_inner_ref_mut!(HashMap<String, JsonValue>, Object(h) => h);

 // Note: matches! is available from Rust 1.42
 macro_rules! is_xxx {
     (
         $(#[$meta:meta])*
         $name:ident,
         $variant:pat,
     ) => {
         $(#[$meta])*
         pub fn $name(&self) -> bool {
             match self {
                 $variant => true,
                 _ => false,
             }
         }
     };
 }

 impl JsonValue {
     /// Get immutable reference to the inner value.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     ///
     /// let value: JsonValue = "[1, 2, 3]".parse().unwrap();
     /// let vec: &Vec<_> = value.get().unwrap();
     /// assert_eq!(vec[0], JsonValue::from(1.0));
     ///
     /// // Try to convert with incorrect type
     /// assert!(value.get::<f64>().is_none());
     /// ```
     pub fn get<T: InnerAsRef>(&self) -> Option<&T> {
         T::json_value_as(self)
     }

     /// Get mutable reference to the inner value.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     ///
     /// let mut value: JsonValue = "[1, 2, 3]".parse().unwrap();
     /// let vec: &mut Vec<_> = value.get_mut().unwrap();
     /// vec[0] = JsonValue::from(false);
     /// assert_eq!(value.stringify().unwrap(), "[false,2,3]");
     ///
     /// // Try to convert with incorrect type
     /// assert!(value.get_mut::<f64>().is_none());
     /// ```
     pub fn get_mut<T: InnerAsRefMut>(&mut self) -> Option<&mut T> {
         T::json_value_as_mut(self)
     }

     is_xxx!(
         /// Check if the inner value is a boolean.
         ///
         /// ```
         /// use tinyjson::JsonValue;
         ///
         /// let v = JsonValue::from(true);
         /// assert!(v.is_bool());
         /// let v = JsonValue::from(1.0);
         /// assert!(!v.is_bool());
         /// ```
         is_bool,
         JsonValue::Boolean(_),
     );
     is_xxx!(
         /// Check if the inner value is a number.
         ///
         /// ```
         /// use tinyjson::JsonValue;
         ///
         /// let v = JsonValue::from(1.0);
         /// assert!(v.is_number());
         /// let v = JsonValue::from(false);
         /// assert!(!v.is_number());
         /// ```
         is_number,
         JsonValue::Number(_),
     );
     is_xxx!(
         /// Check if the inner value is a string.
         ///
         /// ```
         /// use tinyjson::JsonValue;
         ///
         /// let v = JsonValue::from("foo".to_string());
         /// assert!(v.is_string());
         /// let v = JsonValue::from(1.0);
         /// assert!(!v.is_string());
         /// ```
         is_string,
         JsonValue::String(_),
     );
     is_xxx!(
         /// Check if the inner value is null.
         ///
         /// ```
         /// use tinyjson::JsonValue;
         ///
         /// let v = JsonValue::from(()); // () is inner representation of null value
         /// assert!(v.is_null());
         /// let v = JsonValue::from(false);
         /// assert!(!v.is_null());
         /// ```
         is_null,
         JsonValue::Null,
     );
     is_xxx!(
         /// Check if the inner value is an array.
         ///
         /// ```
         /// use tinyjson::JsonValue;
         ///
         /// let v = JsonValue::from(vec![]);
         /// assert!(v.is_array());
         /// let v = JsonValue::from(1.0);
         /// assert!(!v.is_array());
         /// ```
         is_array,
         JsonValue::Array(_),
     );
     is_xxx!(
         /// Check if the inner value is an object.
         ///
         /// ```
         /// use tinyjson::JsonValue;
         /// use std::collections::HashMap;
         ///
         /// let v = JsonValue::from(HashMap::new());
         /// assert!(v.is_object());
         /// let v = JsonValue::from(vec![]);
         /// assert!(!v.is_object());
         /// ```
         is_object,
         JsonValue::Object(_),
     );

     /// Convert this JSON value to `String` value.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     ///
     /// let v = JsonValue::from(vec![1.0.into(), true.into(), "str".to_string().into()]);
     /// let s = v.stringify().unwrap();
     /// assert_eq!(&s, "[1,true,\"str\"]");
     /// ```
     pub fn stringify(&self) -> JsonGenerateResult {
         stringify(self)
     }

     /// Write this JSON value to the given `io::Write` object as UTF-8 byte sequence.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     /// use std::io::Write;
     ///
     /// let v = JsonValue::from(vec![1.0.into(), true.into(), "str".to_string().into()]);
     /// let mut bytes = vec![];
     /// v.write_to(&mut bytes).unwrap();
     /// assert_eq!(&String::from_utf8(bytes).unwrap(), "[1,true,\"str\"]");
     /// ```
     pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
         JsonGenerator::new(w).generate(self)
     }

     /// Convert this JSON value to `String` value with 2-spaces indentation.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     ///
     /// let v = JsonValue::from(vec![1.0.into(), true.into(), "str".to_string().into()]);
     /// let s = v.format().unwrap();
     /// assert_eq!(&s,
     /// "[
     ///   1,
     ///   true,
     ///   \"str\"
     /// ]");
     /// ```
     pub fn format(&self) -> JsonGenerateResult {
         format(self)
     }

     /// Write this JSON value to the given `io::Write` object as UTF-8 byte sequence with 2-spaces indentation.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     ///
     /// let v = JsonValue::from(vec![1.0.into(), true.into(), "str".to_string().into()]);
     /// let mut bytes = vec![];
     /// v.format_to(&mut bytes).unwrap();
     /// assert_eq!(&String::from_utf8(bytes).unwrap(),
     /// "[
     ///   1,
     ///   true,
     ///   \"str\"
     /// ]");
     /// ```
     pub fn format_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
         JsonGenerator::new(w).indent("  ").generate(self)
     }
 }

 /// Access to value of the key of object.
 ///
 /// ```
 /// use tinyjson::JsonValue;
 /// use std::collections::HashMap;
 ///
 /// let mut m = HashMap::new();
 /// m.insert("foo".to_string(), 1.0.into());
 /// let v = JsonValue::from(m);
 /// let i = &v["foo"];
 /// assert_eq!(i, &JsonValue::Number(1.0));
 /// ```
 ///
 ///  This will panic when the given `JsonValue` value is not an object
 ///
 /// ```should_panic
 /// # use tinyjson::JsonValue;
 /// let v = JsonValue::from(vec![]);
 /// let _ = &v["foo"]; // Panic
 /// ```
 ///
 /// or when the key does not exist in the object.
 ///
 /// ```should_panic
 /// # use tinyjson::JsonValue;
 /// # use std::collections::HashMap;
 /// let v = JsonValue::from(HashMap::new());
 /// let _ = &v["foo"]; // Panic
 /// ```
 ///
 /// Using this operator, you can access the nested elements quickly
 ///
 /// ```
 /// # use tinyjson::JsonValue;
 /// let mut json: JsonValue = r#"
 /// {
 ///   "foo": {
 ///     "bar": [
 ///       { "target": 42 }
 ///     ]
 ///   }
 /// }
 /// "#.parse().unwrap();
 ///
 /// // Access with index operator
 /// let target_value: f64 = *json["foo"]["bar"][0]["target"].get().unwrap();
 /// assert_eq!(target_value, 42.0);
 /// ```

 impl<'a> Index<&'a str> for JsonValue {
     type Output = JsonValue;

     fn index(&self, key: &'a str) -> &Self::Output {
         let obj = match self {
             JsonValue::Object(o) => o,
             _ => panic!(
                 "Attempted to access to an object with key '{}' but actually it was {:?}",
                 key, self
             ),
         };

         match obj.get(key) {
             Some(json) => json,
             None => panic!("Key '{}' was not found in {:?}", key, self),
         }
     }
 }

 /// Access to value of the index of array.
 ///
 /// ```
 /// use tinyjson::JsonValue;
 ///
 /// let v = JsonValue::from(vec![1.0.into(), true.into()]);
 /// let b = &v[1];
 /// assert_eq!(b, &JsonValue::Boolean(true));
 /// ```
 ///
 ///  This will panic when the given `JsonValue` value is not an array
 ///
 /// ```should_panic
 /// # use tinyjson::JsonValue;
 /// use std::collections::HashMap;
 /// let v = JsonValue::from(HashMap::new());
 /// let _ = &v[0]; // Panic
 /// ```
 ///
 /// or when the index is out of bounds.
 ///
 /// ```should_panic
 /// # use tinyjson::JsonValue;
 /// let v = JsonValue::from(vec![]);
 /// let _ = &v[0]; // Panic
 /// ```
 impl Index<usize> for JsonValue {
     type Output = JsonValue;

     fn index(&self, index: usize) -> &'_ Self::Output {
         let array = match self {
             JsonValue::Array(a) => a,
             _ => panic!(
                 "Attempted to access to an array with index {} but actually the value was {:?}",
                 index, self,
             ),
         };
         &array[index]
     }
 }

 /// Access to value of the key of mutable object.
 ///
 /// ```
 /// use tinyjson::JsonValue;
 /// use std::collections::HashMap;
 ///
 /// let mut m = HashMap::new();
 /// m.insert("foo".to_string(), 1.0.into());
 /// let mut v = JsonValue::from(m);
 /// v["foo"] = JsonValue::Number(3.14);
 /// assert_eq!(v["foo"], JsonValue::Number(3.14));
 /// ```
 ///
 ///  This will panic when the given `JsonValue` value is not an object
 ///
 /// ```should_panic
 /// # use tinyjson::JsonValue;
 /// let mut v = JsonValue::from(vec![]);
 /// let _ = &mut v["foo"]; // Panic
 /// ```
 ///
 /// or when the key does not exist in the object.
 ///
 /// ```should_panic
 /// # use tinyjson::JsonValue;
 /// # use std::collections::HashMap;
 /// let mut v = JsonValue::from(HashMap::new());
 /// let _ = &mut v["foo"]; // Panic
 /// ```
 ///
 /// Using this operator, you can modify the nested elements quickly
 ///
 /// ```
 /// # use tinyjson::JsonValue;
 /// let mut json: JsonValue = r#"
 /// {
 ///   "foo": {
 ///     "bar": [
 ///       { "target": 42 }
 ///     ]
 ///   }
 /// }
 /// "#.parse().unwrap();
 ///
 /// // Modify with index operator
 /// json["foo"]["bar"][0]["target"] = JsonValue::Boolean(false);
 /// assert_eq!(json["foo"]["bar"][0]["target"], JsonValue::Boolean(false));
 /// ```
 impl<'a> IndexMut<&'a str> for JsonValue {
     fn index_mut(&mut self, key: &'a str) -> &mut Self::Output {
         let obj = match self {
             JsonValue::Object(o) => o,
             _ => panic!(
                 "Attempted to access to an object with key '{}' but actually it was {:?}",
                 key, self
             ),
         };

         if let Some(json) = obj.get_mut(key) {
             json
         } else {
             panic!("Key '{}' was not found in object", key)
         }
     }
 }

 /// Access to value of the index of mutable array.
 ///
 /// ```
 /// use tinyjson::JsonValue;
 ///
 /// let mut v = JsonValue::from(vec![1.0.into(), true.into()]);
 /// let b = &mut v[1];
 /// assert_eq!(b, &JsonValue::Boolean(true));
 /// ```
 ///
 ///  This will panic when the given `JsonValue` value is not an array
 ///
 /// ```should_panic
 /// # use tinyjson::JsonValue;
 /// use std::collections::HashMap;
 /// let mut v = JsonValue::from(HashMap::new());
 /// let _ = &mut v[0]; // Panic
 /// ```
 ///
 /// or when the index is out of bounds.
 ///
 /// ```should_panic
 /// # use tinyjson::JsonValue;
 /// let mut v = JsonValue::from(vec![]);
 /// let _ = &mut v[0]; // Panic
 /// ```
 impl IndexMut<usize> for JsonValue {
     fn index_mut(&mut self, index: usize) -> &mut Self::Output {
         let array = match self {
             JsonValue::Array(a) => a,
             _ => panic!(
                 "Attempted to access to an array with index {} but actually the value was {:?}",
                 index, self,
             ),
         };

         &mut array[index]
     }
 }

 macro_rules! impl_from {
     (
         $(#[$meta:meta])*
         $v:ident: $t:ty => $e:expr
     ) => {
         $(#[$meta])*
         impl From<$t> for JsonValue {
             fn from($v: $t) -> JsonValue {
                 use JsonValue::*;
                 $e
             }
         }
     };
 }

 impl_from!(
     /// Convert `f64` value into `JsonValue`.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     /// let v = JsonValue::from(1.0);
     /// assert!(v.is_number());
     /// ```
     n: f64 => Number(n)
 );
 impl_from!(
     /// Convert `bool` value into `JsonValue`.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     /// let v = JsonValue::from(true);
     /// assert!(v.is_bool());
     /// ```
     b: bool => Boolean(b)
 );
 impl_from!(
     /// Convert `bool` value into `JsonValue`. Note that `&str` is not available. Explicitly allocate `String` object
     /// and pass it.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     /// let v = JsonValue::from("foo".to_string());
     /// assert!(v.is_string());
     /// ```
     s: String => String(s)
 );
 impl_from!(
     /// Convert `()` into `JsonValue`. `()` is an inner representation of null JSON value.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     /// let v = JsonValue::from(());
     /// assert!(v.is_null());
     /// ```
     _x: () => Null
 );
 impl_from!(
     /// Convert `Vec` value into `JsonValue`.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     /// let v = JsonValue::from(vec![1.0.into(), true.into()]);
     /// assert!(v.is_array());
     /// ```
     a: Vec<JsonValue> => Array(a)
 );
 impl_from!(
     /// Convert `HashMap` value into `JsonValue`.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     /// use std::collections::HashMap;
     /// let mut m = HashMap::new();
     /// m.insert("foo".to_string(), 1.0.into());
     /// let v = JsonValue::from(m);
     /// assert!(v.is_object());
     /// ```
     o: HashMap<String, JsonValue> => Object(o)
 );

 /// Error caused when trying to convert `JsonValue` into some wrong type value.
 ///
 /// ```
 /// use tinyjson::{JsonValue, UnexpectedValue};
 /// use std::convert::TryFrom;
 ///
 /// let error = String::try_from(JsonValue::from(1.0)).unwrap_err();
 /// assert!(matches!(error, UnexpectedValue{..}));
 /// ```
 #[derive(Debug)]
 pub struct UnexpectedValue {
     value: JsonValue,
     expected: &'static str,
 }

 impl UnexpectedValue {
     /// Get reference to the value which failed to be converted.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     /// use std::convert::TryFrom;
     ///
     /// let error = String::try_from(JsonValue::from(1.0)).unwrap_err();
     /// assert_eq!(error.value(), &JsonValue::Number(1.0));
     /// ```
     pub fn value(&self) -> &JsonValue {
         &self.value
     }
 }

 impl fmt::Display for UnexpectedValue {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
             "Unexpected JSON value: {:?}. Expected {} value",
             self.value, self.expected
         )
     }
 }

 impl std::error::Error for UnexpectedValue {}

 /// Convert this error into the value which failed to be converted.
 ///
 /// ```
 /// use tinyjson::JsonValue;
 /// use std::convert::TryFrom;
 ///
 /// let error = String::try_from(JsonValue::from(1.0)).unwrap_err();
 /// assert_eq!(JsonValue::from(error), JsonValue::Number(1.0));
 /// ```
 impl From<UnexpectedValue> for JsonValue {
     fn from(err: UnexpectedValue) -> Self {
         err.value
     }
 }

 macro_rules! impl_try_from {
     (
         $(#[$meta:meta])*
         $pat:pat => $val:expr,
         $ty:ty,
     ) => {
         $(#[$meta])*
         impl TryFrom<JsonValue> for $ty {
             type Error = UnexpectedValue;

             fn try_from(v: JsonValue) -> Result<Self, UnexpectedValue> {
                 match v {
                     $pat => Ok($val),
                     v => Err(UnexpectedValue {
                         value: v,
                         expected: stringify!($ty),
                     }),
                 }
             }
         }
     };
 }

 impl_try_from!(
     /// Try to convert the `JsonValue` value into `f64`. `UnexpectedValue` error happens when trying to convert an
     /// incorrect type value.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     /// use std::convert::TryFrom;
     ///
     /// let v = JsonValue::from(1.0);
     /// let r = f64::try_from(v);
     /// assert!(r.is_ok());
     ///
     /// let v = JsonValue::from(true);
     /// let r = f64::try_from(v);
     /// assert!(r.is_err());
     /// ```
     JsonValue::Number(n) => n,
     f64,
 );
 impl_try_from!(
     /// Try to convert the `JsonValue` value into `bool`. `UnexpectedValue` error happens when trying to convert an
     /// incorrect type value.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     /// use std::convert::TryFrom;
     ///
     /// let v = JsonValue::from(true);
     /// let r = bool::try_from(v);
     /// assert!(r.is_ok());
     ///
     /// let v = JsonValue::from(1.0);
     /// let r = bool::try_from(v);
     /// assert!(r.is_err());
     /// ```
     JsonValue::Boolean(b) => b,
     bool,
 );
 impl_try_from!(
     /// Try to convert the `JsonValue` value into `String`. `UnexpectedValue` error happens when trying to convert an
     /// incorrect type value.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     /// use std::convert::TryFrom;
     ///
     /// let v = JsonValue::from("foo".to_string());
     /// let r = String::try_from(v);
     /// assert!(r.is_ok());
     ///
     /// let v = JsonValue::from(1.0);
     /// let r = String::try_from(v);
     /// assert!(r.is_err());
     /// ```
     JsonValue::String(s) => s,
     String,
 );
 impl_try_from!(
     /// Try to convert the `JsonValue` value into `()`. Note that `()` is an inner representation of null JSON value.
     /// `UnexpectedValue` error happens when trying to convert an incorrect type value.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     /// use std::convert::TryFrom;
     ///
     /// let v = JsonValue::from(());
     /// let r = <()>::try_from(v);
     /// assert!(r.is_ok());
     ///
     /// let v = JsonValue::from(1.0);
     /// let r = <()>::try_from(v);
     /// assert!(r.is_err());
     /// ```
     JsonValue::Null => (),
     (),
 );
 impl_try_from!(
     /// Try to convert the `JsonValue` value into `Vec<JsonValue>`. `UnexpectedValue` error happens when trying to
     /// convert an incorrect type value.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     /// use std::convert::TryFrom;
     ///
     /// let v = JsonValue::from(vec![true.into()]);
     /// let r = <Vec<_>>::try_from(v);
     /// assert!(r.is_ok());
     ///
     /// let v = JsonValue::from(1.0);
     /// let r = <Vec<_>>::try_from(v);
     /// assert!(r.is_err());
     /// ```
     JsonValue::Array(a) => a,
     Vec<JsonValue>,
 );
 impl_try_from!(
     /// Try to convert the `JsonValue` value into `HashMap<String, JsonValue>`. `UnexpectedValue` error happens when
     /// trying to convert an incorrect type value.
     ///
     /// ```
     /// use tinyjson::JsonValue;
     /// use std::convert::TryFrom;
     /// use std::collections::HashMap;
     ///
     /// let mut m = HashMap::new();
     /// m.insert("foo".to_string(), 42.0.into());
     /// let v = JsonValue::from(m);
     /// let r = <HashMap<_, _>>::try_from(v);
     /// assert!(r.is_ok());
     ///
     /// let v = JsonValue::from(1.0);
     /// let r = <HashMap<_, _>>::try_from(v);
     /// assert!(r.is_err());
     /// ```
     JsonValue::Object(o) => o,
     HashMap<String, JsonValue>,
 );
	use crate::generator::{format, stringify, JsonGenerateResult, JsonGenerator};
	use std::collections::HashMap;
	use std::convert::TryFrom;
	use std::fmt;
	use std::io;
	use std::ops::{Index, IndexMut};

	const NULL: () = ();

	/// Enum to represent one JSON value. Each variant represents corresponding JSON types.
	/// ```
	/// use tinyjson::JsonValue;
	/// use std::convert::TryInto;
	///
	/// // Convert from raw values using `From` trait
	/// let value = JsonValue::from("this is string".to_string());
	///
	/// // Get reference to inner value
	/// let maybe_number: Option<&f64> = value.get();
	/// assert!(maybe_number.is_none());
	/// let maybe_string: Option<&String> = value.get();
	/// assert!(maybe_string.is_some());
	///
	/// // Check type of JSON value
	/// assert!(matches!(value, JsonValue::String(_)));
	/// assert!(value.is_string());
	///
	/// // Convert into raw values using `TryInto` trait
	/// let original_value: String = value.try_into().unwrap();
	/// ```
	#[derive(Debug, Clone, PartialEq)]
	pub enum JsonValue {
	/// Number type value.
	Number(f64),
	/// Boolean type value.
	Boolean(bool),
	/// String type value.
	String(String),
	/// Null type value.
	Null,
	/// Array type value.
	Array(Vec<JsonValue>),
	/// Object type value.
	Object(HashMap<String, JsonValue>),
	}

	/// Trait to access to inner value of `JsonValue` as reference.
	///
	/// This is used by several APIs like [`JsonValue::get`] to represent any inner values of [`JsonValue`].
	pub trait InnerAsRef {
	fn json_value_as(v: &JsonValue) -> Option<&Self>;
	}

	macro_rules! impl_inner_ref {
	($to:ty, $pat:pat => $val:expr) => {
	impl InnerAsRef for $to {
	fn json_value_as(v: &JsonValue) -> Option<&$to> {
	use JsonValue::*;
	match v {
	$pat => Some($val),
	_ => None,
	}
	}
	}
	};
	}

	impl_inner_ref!(f64, Number(n) => n);
	impl_inner_ref!(bool, Boolean(b) => b);
	impl_inner_ref!(String, String(s) => s);
	impl_inner_ref!((), Null => &NULL);
	impl_inner_ref!(Vec<JsonValue>, Array(a) => a);
	impl_inner_ref!(HashMap<String, JsonValue>, Object(h) => h);

	/// Trait to access to inner value of `JsonValue` as mutable reference.
	///
	/// This is a mutable version of [`InnerAsRef`].
	pub trait InnerAsRefMut {
	fn json_value_as_mut(v: &mut JsonValue) -> Option<&mut Self>;
	}

	macro_rules! impl_inner_ref_mut {
	($to:ty, $pat:pat => $val:expr) => {
	impl InnerAsRefMut for $to {
	fn json_value_as_mut(v: &mut JsonValue) -> Option<&mut $to> {
	use JsonValue::*;
	match v {
	$pat => Some($val),
	_ => None,
	}
	}
	}
	};
	}

	impl_inner_ref_mut!(f64, Number(n) => n);
	impl_inner_ref_mut!(bool, Boolean(b) => b);
	impl_inner_ref_mut!(String, String(s) => s);
	impl_inner_ref_mut!(Vec<JsonValue>, Array(a) => a);
	impl_inner_ref_mut!(HashMap<String, JsonValue>, Object(h) => h);

	// Note: matches! is available from Rust 1.42
	macro_rules! is_xxx {
	(
	$(#[$meta:meta])*
	$name:ident,
	$variant:pat,
	) => {
	$(#[$meta])*
	pub fn $name(&self) -> bool {
	match self {
	$variant => true,
	_ => false,
	}
	}
	};
	}

	impl JsonValue {
	/// Get immutable reference to the inner value.
	///
	/// ```
	/// use tinyjson::JsonValue;
	///
	/// let value: JsonValue = "[1, 2, 3]".parse().unwrap();
	/// let vec: &Vec<_> = value.get().unwrap();
	/// assert_eq!(vec[0], JsonValue::from(1.0));
	///
	/// // Try to convert with incorrect type
	/// assert!(value.get::<f64>().is_none());
	/// ```
	pub fn get<T: InnerAsRef>(&self) -> Option<&T> {
	T::json_value_as(self)
	}

	/// Get mutable reference to the inner value.
	///
	/// ```
	/// use tinyjson::JsonValue;
	///
	/// let mut value: JsonValue = "[1, 2, 3]".parse().unwrap();
	/// let vec: &mut Vec<_> = value.get_mut().unwrap();
	/// vec[0] = JsonValue::from(false);
	/// assert_eq!(value.stringify().unwrap(), "[false,2,3]");
	///
	/// // Try to convert with incorrect type
	/// assert!(value.get_mut::<f64>().is_none());
	/// ```
	pub fn get_mut<T: InnerAsRefMut>(&mut self) -> Option<&mut T> {
	T::json_value_as_mut(self)
	}

	is_xxx!(
	/// Check if the inner value is a boolean.
	///
	/// ```
	/// use tinyjson::JsonValue;
	///
	/// let v = JsonValue::from(true);
	/// assert!(v.is_bool());
	/// let v = JsonValue::from(1.0);
	/// assert!(!v.is_bool());
	/// ```
	is_bool,
	JsonValue::Boolean(_),
	);
	is_xxx!(
	/// Check if the inner value is a number.
	///
	/// ```
	/// use tinyjson::JsonValue;
	///
	/// let v = JsonValue::from(1.0);
	/// assert!(v.is_number());
	/// let v = JsonValue::from(false);
	/// assert!(!v.is_number());
	/// ```
	is_number,
	JsonValue::Number(_),
	);
	is_xxx!(
	/// Check if the inner value is a string.
	///
	/// ```
	/// use tinyjson::JsonValue;
	///
	/// let v = JsonValue::from("foo".to_string());
	/// assert!(v.is_string());
	/// let v = JsonValue::from(1.0);
	/// assert!(!v.is_string());
	/// ```
	is_string,
	JsonValue::String(_),
	);
	is_xxx!(
	/// Check if the inner value is null.
	///
	/// ```
	/// use tinyjson::JsonValue;
	///
	/// let v = JsonValue::from(()); // () is inner representation of null value
	/// assert!(v.is_null());
	/// let v = JsonValue::from(false);
	/// assert!(!v.is_null());
	/// ```
	is_null,
	JsonValue::Null,
	);
	is_xxx!(
	/// Check if the inner value is an array.
	///
	/// ```
	/// use tinyjson::JsonValue;
	///
	/// let v = JsonValue::from(vec![]);
	/// assert!(v.is_array());
	/// let v = JsonValue::from(1.0);
	/// assert!(!v.is_array());
	/// ```
	is_array,
	JsonValue::Array(_),
	);
	is_xxx!(
	/// Check if the inner value is an object.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// use std::collections::HashMap;
	///
	/// let v = JsonValue::from(HashMap::new());
	/// assert!(v.is_object());
	/// let v = JsonValue::from(vec![]);
	/// assert!(!v.is_object());
	/// ```
	is_object,
	JsonValue::Object(_),
	);

	/// Convert this JSON value to `String` value.
	///
	/// ```
	/// use tinyjson::JsonValue;
	///
	/// let v = JsonValue::from(vec![1.0.into(), true.into(), "str".to_string().into()]);
	/// let s = v.stringify().unwrap();
	/// assert_eq!(&s, "[1,true,\"str\"]");
	/// ```
	pub fn stringify(&self) -> JsonGenerateResult {
	stringify(self)
	}

	/// Write this JSON value to the given `io::Write` object as UTF-8 byte sequence.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// use std::io::Write;
	///
	/// let v = JsonValue::from(vec![1.0.into(), true.into(), "str".to_string().into()]);
	/// let mut bytes = vec![];
	/// v.write_to(&mut bytes).unwrap();
	/// assert_eq!(&String::from_utf8(bytes).unwrap(), "[1,true,\"str\"]");
	/// ```
	pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
	JsonGenerator::new(w).generate(self)
	}

	/// Convert this JSON value to `String` value with 2-spaces indentation.
	///
	/// ```
	/// use tinyjson::JsonValue;
	///
	/// let v = JsonValue::from(vec![1.0.into(), true.into(), "str".to_string().into()]);
	/// let s = v.format().unwrap();
	/// assert_eq!(&s,
	/// "[
	/// 1,
	/// true,
	/// \"str\"
	/// ]");
	/// ```
	pub fn format(&self) -> JsonGenerateResult {
	format(self)
	}

	/// Write this JSON value to the given `io::Write` object as UTF-8 byte sequence with 2-spaces indentation.
	///
	/// ```
	/// use tinyjson::JsonValue;
	///
	/// let v = JsonValue::from(vec![1.0.into(), true.into(), "str".to_string().into()]);
	/// let mut bytes = vec![];
	/// v.format_to(&mut bytes).unwrap();
	/// assert_eq!(&String::from_utf8(bytes).unwrap(),
	/// "[
	/// 1,
	/// true,
	/// \"str\"
	/// ]");
	/// ```
	pub fn format_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
	JsonGenerator::new(w).indent(" ").generate(self)
	}
	}

	/// Access to value of the key of object.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// use std::collections::HashMap;
	///
	/// let mut m = HashMap::new();
	/// m.insert("foo".to_string(), 1.0.into());
	/// let v = JsonValue::from(m);
	/// let i = &v["foo"];
	/// assert_eq!(i, &JsonValue::Number(1.0));
	/// ```
	///
	/// This will panic when the given `JsonValue` value is not an object
	///
	/// ```should_panic
	/// # use tinyjson::JsonValue;
	/// let v = JsonValue::from(vec![]);
	/// let _ = &v["foo"]; // Panic
	/// ```
	///
	/// or when the key does not exist in the object.
	///
	/// ```should_panic
	/// # use tinyjson::JsonValue;
	/// # use std::collections::HashMap;
	/// let v = JsonValue::from(HashMap::new());
	/// let _ = &v["foo"]; // Panic
	/// ```
	///
	/// Using this operator, you can access the nested elements quickly
	///
	/// ```
	/// # use tinyjson::JsonValue;
	/// let mut json: JsonValue = r#"
	/// {
	/// "foo": {
	/// "bar": [
	/// { "target": 42 }
	/// ]
	/// }
	/// }
	/// "#.parse().unwrap();
	///
	/// // Access with index operator
	/// let target_value: f64 = *json["foo"]["bar"][0]["target"].get().unwrap();
	/// assert_eq!(target_value, 42.0);
	/// ```

	impl<'a> Index<&'a str> for JsonValue {
	type Output = JsonValue;

	fn index(&self, key: &'a str) -> &Self::Output {
	let obj = match self {
	JsonValue::Object(o) => o,
	_ => panic!(
	"Attempted to access to an object with key '{}' but actually it was {:?}",
	key, self
	),
	};

	match obj.get(key) {
	Some(json) => json,
	None => panic!("Key '{}' was not found in {:?}", key, self),
	}
	}
	}

	/// Access to value of the index of array.
	///
	/// ```
	/// use tinyjson::JsonValue;
	///
	/// let v = JsonValue::from(vec![1.0.into(), true.into()]);
	/// let b = &v[1];
	/// assert_eq!(b, &JsonValue::Boolean(true));
	/// ```
	///
	/// This will panic when the given `JsonValue` value is not an array
	///
	/// ```should_panic
	/// # use tinyjson::JsonValue;
	/// use std::collections::HashMap;
	/// let v = JsonValue::from(HashMap::new());
	/// let _ = &v[0]; // Panic
	/// ```
	///
	/// or when the index is out of bounds.
	///
	/// ```should_panic
	/// # use tinyjson::JsonValue;
	/// let v = JsonValue::from(vec![]);
	/// let _ = &v[0]; // Panic
	/// ```
	impl Index<usize> for JsonValue {
	type Output = JsonValue;

	fn index(&self, index: usize) -> &'_ Self::Output {
	let array = match self {
	JsonValue::Array(a) => a,
	_ => panic!(
	"Attempted to access to an array with index {} but actually the value was {:?}",
	index, self,
	),
	};
	&array[index]
	}
	}

	/// Access to value of the key of mutable object.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// use std::collections::HashMap;
	///
	/// let mut m = HashMap::new();
	/// m.insert("foo".to_string(), 1.0.into());
	/// let mut v = JsonValue::from(m);
	/// v["foo"] = JsonValue::Number(3.14);
	/// assert_eq!(v["foo"], JsonValue::Number(3.14));
	/// ```
	///
	/// This will panic when the given `JsonValue` value is not an object
	///
	/// ```should_panic
	/// # use tinyjson::JsonValue;
	/// let mut v = JsonValue::from(vec![]);
	/// let _ = &mut v["foo"]; // Panic
	/// ```
	///
	/// or when the key does not exist in the object.
	///
	/// ```should_panic
	/// # use tinyjson::JsonValue;
	/// # use std::collections::HashMap;
	/// let mut v = JsonValue::from(HashMap::new());
	/// let _ = &mut v["foo"]; // Panic
	/// ```
	///
	/// Using this operator, you can modify the nested elements quickly
	///
	/// ```
	/// # use tinyjson::JsonValue;
	/// let mut json: JsonValue = r#"
	/// {
	/// "foo": {
	/// "bar": [
	/// { "target": 42 }
	/// ]
	/// }
	/// }
	/// "#.parse().unwrap();
	///
	/// // Modify with index operator
	/// json["foo"]["bar"][0]["target"] = JsonValue::Boolean(false);
	/// assert_eq!(json["foo"]["bar"][0]["target"], JsonValue::Boolean(false));
	/// ```
	impl<'a> IndexMut<&'a str> for JsonValue {
	fn index_mut(&mut self, key: &'a str) -> &mut Self::Output {
	let obj = match self {
	JsonValue::Object(o) => o,
	_ => panic!(
	"Attempted to access to an object with key '{}' but actually it was {:?}",
	key, self
	),
	};

	if let Some(json) = obj.get_mut(key) {
	json
	} else {
	panic!("Key '{}' was not found in object", key)
	}
	}
	}

	/// Access to value of the index of mutable array.
	///
	/// ```
	/// use tinyjson::JsonValue;
	///
	/// let mut v = JsonValue::from(vec![1.0.into(), true.into()]);
	/// let b = &mut v[1];
	/// assert_eq!(b, &JsonValue::Boolean(true));
	/// ```
	///
	/// This will panic when the given `JsonValue` value is not an array
	///
	/// ```should_panic
	/// # use tinyjson::JsonValue;
	/// use std::collections::HashMap;
	/// let mut v = JsonValue::from(HashMap::new());
	/// let _ = &mut v[0]; // Panic
	/// ```
	///
	/// or when the index is out of bounds.
	///
	/// ```should_panic
	/// # use tinyjson::JsonValue;
	/// let mut v = JsonValue::from(vec![]);
	/// let _ = &mut v[0]; // Panic
	/// ```
	impl IndexMut<usize> for JsonValue {
	fn index_mut(&mut self, index: usize) -> &mut Self::Output {
	let array = match self {
	JsonValue::Array(a) => a,
	_ => panic!(
	"Attempted to access to an array with index {} but actually the value was {:?}",
	index, self,
	),
	};

	&mut array[index]
	}
	}

	macro_rules! impl_from {
	(
	$(#[$meta:meta])*
	$v:ident: $t:ty => $e:expr
	) => {
	$(#[$meta])*
	impl From<$t> for JsonValue {
	fn from($v: $t) -> JsonValue {
	use JsonValue::*;
	$e
	}
	}
	};
	}

	impl_from!(
	/// Convert `f64` value into `JsonValue`.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// let v = JsonValue::from(1.0);
	/// assert!(v.is_number());
	/// ```
	n: f64 => Number(n)
	);
	impl_from!(
	/// Convert `bool` value into `JsonValue`.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// let v = JsonValue::from(true);
	/// assert!(v.is_bool());
	/// ```
	b: bool => Boolean(b)
	);
	impl_from!(
	/// Convert `bool` value into `JsonValue`. Note that `&str` is not available. Explicitly allocate `String` object
	/// and pass it.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// let v = JsonValue::from("foo".to_string());
	/// assert!(v.is_string());
	/// ```
	s: String => String(s)
	);
	impl_from!(
	/// Convert `()` into `JsonValue`. `()` is an inner representation of null JSON value.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// let v = JsonValue::from(());
	/// assert!(v.is_null());
	/// ```
	_x: () => Null
	);
	impl_from!(
	/// Convert `Vec` value into `JsonValue`.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// let v = JsonValue::from(vec![1.0.into(), true.into()]);
	/// assert!(v.is_array());
	/// ```
	a: Vec<JsonValue> => Array(a)
	);
	impl_from!(
	/// Convert `HashMap` value into `JsonValue`.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// use std::collections::HashMap;
	/// let mut m = HashMap::new();
	/// m.insert("foo".to_string(), 1.0.into());
	/// let v = JsonValue::from(m);
	/// assert!(v.is_object());
	/// ```
	o: HashMap<String, JsonValue> => Object(o)
	);

	/// Error caused when trying to convert `JsonValue` into some wrong type value.
	///
	/// ```
	/// use tinyjson::{JsonValue, UnexpectedValue};
	/// use std::convert::TryFrom;
	///
	/// let error = String::try_from(JsonValue::from(1.0)).unwrap_err();
	/// assert!(matches!(error, UnexpectedValue{..}));
	/// ```
	#[derive(Debug)]
	pub struct UnexpectedValue {
	value: JsonValue,
	expected: &'static str,
	}

	impl UnexpectedValue {
	/// Get reference to the value which failed to be converted.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// use std::convert::TryFrom;
	///
	/// let error = String::try_from(JsonValue::from(1.0)).unwrap_err();
	/// assert_eq!(error.value(), &JsonValue::Number(1.0));
	/// ```
	pub fn value(&self) -> &JsonValue {
	&self.value
	}
	}

	impl fmt::Display for UnexpectedValue {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	write!(
	f,
	"Unexpected JSON value: {:?}. Expected {} value",
	self.value, self.expected
	)
	}
	}

	impl std::error::Error for UnexpectedValue {}

	/// Convert this error into the value which failed to be converted.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// use std::convert::TryFrom;
	///
	/// let error = String::try_from(JsonValue::from(1.0)).unwrap_err();
	/// assert_eq!(JsonValue::from(error), JsonValue::Number(1.0));
	/// ```
	impl From<UnexpectedValue> for JsonValue {
	fn from(err: UnexpectedValue) -> Self {
	err.value
	}
	}

	macro_rules! impl_try_from {
	(
	$(#[$meta:meta])*
	$pat:pat => $val:expr,
	$ty:ty,
	) => {
	$(#[$meta])*
	impl TryFrom<JsonValue> for $ty {
	type Error = UnexpectedValue;

	fn try_from(v: JsonValue) -> Result<Self, UnexpectedValue> {
	match v {
	$pat => Ok($val),
	v => Err(UnexpectedValue {
	value: v,
	expected: stringify!($ty),
	}),
	}
	}
	}
	};
	}

	impl_try_from!(
	/// Try to convert the `JsonValue` value into `f64`. `UnexpectedValue` error happens when trying to convert an
	/// incorrect type value.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// use std::convert::TryFrom;
	///
	/// let v = JsonValue::from(1.0);
	/// let r = f64::try_from(v);
	/// assert!(r.is_ok());
	///
	/// let v = JsonValue::from(true);
	/// let r = f64::try_from(v);
	/// assert!(r.is_err());
	/// ```
	JsonValue::Number(n) => n,
	f64,
	);
	impl_try_from!(
	/// Try to convert the `JsonValue` value into `bool`. `UnexpectedValue` error happens when trying to convert an
	/// incorrect type value.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// use std::convert::TryFrom;
	///
	/// let v = JsonValue::from(true);
	/// let r = bool::try_from(v);
	/// assert!(r.is_ok());
	///
	/// let v = JsonValue::from(1.0);
	/// let r = bool::try_from(v);
	/// assert!(r.is_err());
	/// ```
	JsonValue::Boolean(b) => b,
	bool,
	);
	impl_try_from!(
	/// Try to convert the `JsonValue` value into `String`. `UnexpectedValue` error happens when trying to convert an
	/// incorrect type value.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// use std::convert::TryFrom;
	///
	/// let v = JsonValue::from("foo".to_string());
	/// let r = String::try_from(v);
	/// assert!(r.is_ok());
	///
	/// let v = JsonValue::from(1.0);
	/// let r = String::try_from(v);
	/// assert!(r.is_err());
	/// ```
	JsonValue::String(s) => s,
	String,
	);
	impl_try_from!(
	/// Try to convert the `JsonValue` value into `()`. Note that `()` is an inner representation of null JSON value.
	/// `UnexpectedValue` error happens when trying to convert an incorrect type value.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// use std::convert::TryFrom;
	///
	/// let v = JsonValue::from(());
	/// let r = <()>::try_from(v);
	/// assert!(r.is_ok());
	///
	/// let v = JsonValue::from(1.0);
	/// let r = <()>::try_from(v);
	/// assert!(r.is_err());
	/// ```
	JsonValue::Null => (),
	(),
	);
	impl_try_from!(
	/// Try to convert the `JsonValue` value into `Vec<JsonValue>`. `UnexpectedValue` error happens when trying to
	/// convert an incorrect type value.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// use std::convert::TryFrom;
	///
	/// let v = JsonValue::from(vec![true.into()]);
	/// let r = <Vec<_>>::try_from(v);
	/// assert!(r.is_ok());
	///
	/// let v = JsonValue::from(1.0);
	/// let r = <Vec<_>>::try_from(v);
	/// assert!(r.is_err());
	/// ```
	JsonValue::Array(a) => a,
	Vec<JsonValue>,
	);
	impl_try_from!(
	/// Try to convert the `JsonValue` value into `HashMap<String, JsonValue>`. `UnexpectedValue` error happens when
	/// trying to convert an incorrect type value.
	///
	/// ```
	/// use tinyjson::JsonValue;
	/// use std::convert::TryFrom;
	/// use std::collections::HashMap;
	///
	/// let mut m = HashMap::new();
	/// m.insert("foo".to_string(), 42.0.into());
	/// let v = JsonValue::from(m);
	/// let r = <HashMap<_, _>>::try_from(v);
	/// assert!(r.is_ok());
	///
	/// let v = JsonValue::from(1.0);
	/// let r = <HashMap<_, _>>::try_from(v);
	/// assert!(r.is_err());
	/// ```
	JsonValue::Object(o) => o,
	HashMap<String, JsonValue>,
	);