RPM build fix (reverted CI changes which will need to be un-reverted or made conditional) and vendor Rust dependencies to make builds much faster in any CI system.
This commit is contained in:
Adam Ierymenko
1386
zeroidc/vendor/serde_json/src/value/de.rs
vendored
Normal file
1386
zeroidc/vendor/serde_json/src/value/de.rs
vendored
Normal file
File diff suppressed because it is too large
Load Diff
270
zeroidc/vendor/serde_json/src/value/from.rs
vendored
Normal file
270
zeroidc/vendor/serde_json/src/value/from.rs
vendored
Normal file
@@ -0,0 +1,270 @@
|
||||
use super::Value;
|
||||
use crate::map::Map;
|
||||
use crate::number::Number;
|
||||
use alloc::borrow::Cow;
|
||||
use alloc::string::{String, ToString};
|
||||
use alloc::vec::Vec;
|
||||
use core::iter::FromIterator;
|
||||
|
||||
#[cfg(feature = "arbitrary_precision")]
|
||||
use serde::serde_if_integer128;
|
||||
|
||||
macro_rules! from_integer {
|
||||
($($ty:ident)*) => {
|
||||
$(
|
||||
impl From<$ty> for Value {
|
||||
fn from(n: $ty) -> Self {
|
||||
Value::Number(n.into())
|
||||
}
|
||||
}
|
||||
)*
|
||||
};
|
||||
}
|
||||
|
||||
from_integer! {
|
||||
i8 i16 i32 i64 isize
|
||||
u8 u16 u32 u64 usize
|
||||
}
|
||||
|
||||
#[cfg(feature = "arbitrary_precision")]
|
||||
serde_if_integer128! {
|
||||
from_integer! {
|
||||
i128 u128
|
||||
}
|
||||
}
|
||||
|
||||
impl From<f32> for Value {
|
||||
/// Convert 32-bit floating point number to `Value`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::Value;
|
||||
///
|
||||
/// let f: f32 = 13.37;
|
||||
/// let x: Value = f.into();
|
||||
/// ```
|
||||
fn from(f: f32) -> Self {
|
||||
From::from(f as f64)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<f64> for Value {
|
||||
/// Convert 64-bit floating point number to `Value`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::Value;
|
||||
///
|
||||
/// let f: f64 = 13.37;
|
||||
/// let x: Value = f.into();
|
||||
/// ```
|
||||
fn from(f: f64) -> Self {
|
||||
Number::from_f64(f).map_or(Value::Null, Value::Number)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<bool> for Value {
|
||||
/// Convert boolean to `Value`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::Value;
|
||||
///
|
||||
/// let b = false;
|
||||
/// let x: Value = b.into();
|
||||
/// ```
|
||||
fn from(f: bool) -> Self {
|
||||
Value::Bool(f)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<String> for Value {
|
||||
/// Convert `String` to `Value`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::Value;
|
||||
///
|
||||
/// let s: String = "lorem".to_string();
|
||||
/// let x: Value = s.into();
|
||||
/// ```
|
||||
fn from(f: String) -> Self {
|
||||
Value::String(f)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<&'a str> for Value {
|
||||
/// Convert string slice to `Value`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::Value;
|
||||
///
|
||||
/// let s: &str = "lorem";
|
||||
/// let x: Value = s.into();
|
||||
/// ```
|
||||
fn from(f: &str) -> Self {
|
||||
Value::String(f.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<Cow<'a, str>> for Value {
|
||||
/// Convert copy-on-write string to `Value`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::Value;
|
||||
/// use std::borrow::Cow;
|
||||
///
|
||||
/// let s: Cow<str> = Cow::Borrowed("lorem");
|
||||
/// let x: Value = s.into();
|
||||
/// ```
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::Value;
|
||||
/// use std::borrow::Cow;
|
||||
///
|
||||
/// let s: Cow<str> = Cow::Owned("lorem".to_string());
|
||||
/// let x: Value = s.into();
|
||||
/// ```
|
||||
fn from(f: Cow<'a, str>) -> Self {
|
||||
Value::String(f.into_owned())
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Number> for Value {
|
||||
/// Convert `Number` to `Value`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::{Number, Value};
|
||||
///
|
||||
/// let n = Number::from(7);
|
||||
/// let x: Value = n.into();
|
||||
/// ```
|
||||
fn from(f: Number) -> Self {
|
||||
Value::Number(f)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Map<String, Value>> for Value {
|
||||
/// Convert map (with string keys) to `Value`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::{Map, Value};
|
||||
///
|
||||
/// let mut m = Map::new();
|
||||
/// m.insert("Lorem".to_string(), "ipsum".into());
|
||||
/// let x: Value = m.into();
|
||||
/// ```
|
||||
fn from(f: Map<String, Value>) -> Self {
|
||||
Value::Object(f)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Into<Value>> From<Vec<T>> for Value {
|
||||
/// Convert a `Vec` to `Value`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::Value;
|
||||
///
|
||||
/// let v = vec!["lorem", "ipsum", "dolor"];
|
||||
/// let x: Value = v.into();
|
||||
/// ```
|
||||
fn from(f: Vec<T>) -> Self {
|
||||
Value::Array(f.into_iter().map(Into::into).collect())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, T: Clone + Into<Value>> From<&'a [T]> for Value {
|
||||
/// Convert a slice to `Value`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::Value;
|
||||
///
|
||||
/// let v: &[&str] = &["lorem", "ipsum", "dolor"];
|
||||
/// let x: Value = v.into();
|
||||
/// ```
|
||||
fn from(f: &'a [T]) -> Self {
|
||||
Value::Array(f.iter().cloned().map(Into::into).collect())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Into<Value>> FromIterator<T> for Value {
|
||||
/// Convert an iteratable type to a `Value`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::Value;
|
||||
///
|
||||
/// let v = std::iter::repeat(42).take(5);
|
||||
/// let x: Value = v.collect();
|
||||
/// ```
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::Value;
|
||||
///
|
||||
/// let v: Vec<_> = vec!["lorem", "ipsum", "dolor"];
|
||||
/// let x: Value = v.into_iter().collect();
|
||||
/// ```
|
||||
///
|
||||
/// ```
|
||||
/// use std::iter::FromIterator;
|
||||
/// use serde_json::Value;
|
||||
///
|
||||
/// let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]);
|
||||
/// ```
|
||||
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
|
||||
Value::Array(iter.into_iter().map(Into::into).collect())
|
||||
}
|
||||
}
|
||||
|
||||
impl<K: Into<String>, V: Into<Value>> FromIterator<(K, V)> for Value {
|
||||
/// Convert an iteratable type to a `Value`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::Value;
|
||||
///
|
||||
/// let v: Vec<_> = vec![("lorem", 40), ("ipsum", 2)];
|
||||
/// let x: Value = v.into_iter().collect();
|
||||
/// ```
|
||||
fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
|
||||
Value::Object(
|
||||
iter.into_iter()
|
||||
.map(|(k, v)| (k.into(), v.into()))
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<()> for Value {
|
||||
/// Convert `()` to `Value`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::Value;
|
||||
///
|
||||
/// let u = ();
|
||||
/// let x: Value = u.into();
|
||||
/// ```
|
||||
fn from((): ()) -> Self {
|
||||
Value::Null
|
||||
}
|
||||
}
|
||||
258
zeroidc/vendor/serde_json/src/value/index.rs
vendored
Normal file
258
zeroidc/vendor/serde_json/src/value/index.rs
vendored
Normal file
@@ -0,0 +1,258 @@
|
||||
use super::Value;
|
||||
use crate::map::Map;
|
||||
use alloc::borrow::ToOwned;
|
||||
use alloc::string::String;
|
||||
use core::fmt::{self, Display};
|
||||
use core::ops;
|
||||
|
||||
/// A type that can be used to index into a `serde_json::Value`.
|
||||
///
|
||||
/// The [`get`] and [`get_mut`] methods of `Value` accept any type that
|
||||
/// implements `Index`, as does the [square-bracket indexing operator]. This
|
||||
/// trait is implemented for strings which are used as the index into a JSON
|
||||
/// map, and for `usize` which is used as the index into a JSON array.
|
||||
///
|
||||
/// [`get`]: ../enum.Value.html#method.get
|
||||
/// [`get_mut`]: ../enum.Value.html#method.get_mut
|
||||
/// [square-bracket indexing operator]: ../enum.Value.html#impl-Index%3CI%3E
|
||||
///
|
||||
/// This trait is sealed and cannot be implemented for types outside of
|
||||
/// `serde_json`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let data = json!({ "inner": [1, 2, 3] });
|
||||
///
|
||||
/// // Data is a JSON map so it can be indexed with a string.
|
||||
/// let inner = &data["inner"];
|
||||
///
|
||||
/// // Inner is a JSON array so it can be indexed with an integer.
|
||||
/// let first = &inner[0];
|
||||
///
|
||||
/// assert_eq!(first, 1);
|
||||
/// ```
|
||||
pub trait Index: private::Sealed {
|
||||
/// Return None if the key is not already in the array or object.
|
||||
#[doc(hidden)]
|
||||
fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value>;
|
||||
|
||||
/// Return None if the key is not already in the array or object.
|
||||
#[doc(hidden)]
|
||||
fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value>;
|
||||
|
||||
/// Panic if array index out of bounds. If key is not already in the object,
|
||||
/// insert it with a value of null. Panic if Value is a type that cannot be
|
||||
/// indexed into, except if Value is null then it can be treated as an empty
|
||||
/// object.
|
||||
#[doc(hidden)]
|
||||
fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value;
|
||||
}
|
||||
|
||||
impl Index for usize {
|
||||
fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
|
||||
match *v {
|
||||
Value::Array(ref vec) => vec.get(*self),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
|
||||
match *v {
|
||||
Value::Array(ref mut vec) => vec.get_mut(*self),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
|
||||
match *v {
|
||||
Value::Array(ref mut vec) => {
|
||||
let len = vec.len();
|
||||
vec.get_mut(*self).unwrap_or_else(|| {
|
||||
panic!(
|
||||
"cannot access index {} of JSON array of length {}",
|
||||
self, len
|
||||
)
|
||||
})
|
||||
}
|
||||
_ => panic!("cannot access index {} of JSON {}", self, Type(v)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Index for str {
|
||||
fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
|
||||
match *v {
|
||||
Value::Object(ref map) => map.get(self),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
|
||||
match *v {
|
||||
Value::Object(ref mut map) => map.get_mut(self),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
|
||||
if let Value::Null = *v {
|
||||
*v = Value::Object(Map::new());
|
||||
}
|
||||
match *v {
|
||||
Value::Object(ref mut map) => map.entry(self.to_owned()).or_insert(Value::Null),
|
||||
_ => panic!("cannot access key {:?} in JSON {}", self, Type(v)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Index for String {
|
||||
fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
|
||||
self[..].index_into(v)
|
||||
}
|
||||
fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
|
||||
self[..].index_into_mut(v)
|
||||
}
|
||||
fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
|
||||
self[..].index_or_insert(v)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, T> Index for &'a T
|
||||
where
|
||||
T: ?Sized + Index,
|
||||
{
|
||||
fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
|
||||
(**self).index_into(v)
|
||||
}
|
||||
fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
|
||||
(**self).index_into_mut(v)
|
||||
}
|
||||
fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
|
||||
(**self).index_or_insert(v)
|
||||
}
|
||||
}
|
||||
|
||||
// Prevent users from implementing the Index trait.
|
||||
mod private {
|
||||
pub trait Sealed {}
|
||||
impl Sealed for usize {}
|
||||
impl Sealed for str {}
|
||||
impl Sealed for alloc::string::String {}
|
||||
impl<'a, T> Sealed for &'a T where T: ?Sized + Sealed {}
|
||||
}
|
||||
|
||||
/// Used in panic messages.
|
||||
struct Type<'a>(&'a Value);
|
||||
|
||||
impl<'a> Display for Type<'a> {
|
||||
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
|
||||
match *self.0 {
|
||||
Value::Null => formatter.write_str("null"),
|
||||
Value::Bool(_) => formatter.write_str("boolean"),
|
||||
Value::Number(_) => formatter.write_str("number"),
|
||||
Value::String(_) => formatter.write_str("string"),
|
||||
Value::Array(_) => formatter.write_str("array"),
|
||||
Value::Object(_) => formatter.write_str("object"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The usual semantics of Index is to panic on invalid indexing.
|
||||
//
|
||||
// That said, the usual semantics are for things like Vec and BTreeMap which
|
||||
// have different use cases than Value. If you are working with a Vec, you know
|
||||
// that you are working with a Vec and you can get the len of the Vec and make
|
||||
// sure your indices are within bounds. The Value use cases are more
|
||||
// loosey-goosey. You got some JSON from an endpoint and you want to pull values
|
||||
// out of it. Outside of this Index impl, you already have the option of using
|
||||
// value.as_array() and working with the Vec directly, or matching on
|
||||
// Value::Array and getting the Vec directly. The Index impl means you can skip
|
||||
// that and index directly into the thing using a concise syntax. You don't have
|
||||
// to check the type, you don't have to check the len, it is all about what you
|
||||
// expect the Value to look like.
|
||||
//
|
||||
// Basically the use cases that would be well served by panicking here are
|
||||
// better served by using one of the other approaches: get and get_mut,
|
||||
// as_array, or match. The value of this impl is that it adds a way of working
|
||||
// with Value that is not well served by the existing approaches: concise and
|
||||
// careless and sometimes that is exactly what you want.
|
||||
impl<I> ops::Index<I> for Value
|
||||
where
|
||||
I: Index,
|
||||
{
|
||||
type Output = Value;
|
||||
|
||||
/// Index into a `serde_json::Value` using the syntax `value[0]` or
|
||||
/// `value["k"]`.
|
||||
///
|
||||
/// Returns `Value::Null` if the type of `self` does not match the type of
|
||||
/// the index, for example if the index is a string and `self` is an array
|
||||
/// or a number. Also returns `Value::Null` if the given key does not exist
|
||||
/// in the map or the given index is not within the bounds of the array.
|
||||
///
|
||||
/// For retrieving deeply nested values, you should have a look at the
|
||||
/// `Value::pointer` method.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let data = json!({
|
||||
/// "x": {
|
||||
/// "y": ["z", "zz"]
|
||||
/// }
|
||||
/// });
|
||||
///
|
||||
/// assert_eq!(data["x"]["y"], json!(["z", "zz"]));
|
||||
/// assert_eq!(data["x"]["y"][0], json!("z"));
|
||||
///
|
||||
/// assert_eq!(data["a"], json!(null)); // returns null for undefined values
|
||||
/// assert_eq!(data["a"]["b"], json!(null)); // does not panic
|
||||
/// ```
|
||||
fn index(&self, index: I) -> &Value {
|
||||
static NULL: Value = Value::Null;
|
||||
index.index_into(self).unwrap_or(&NULL)
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> ops::IndexMut<I> for Value
|
||||
where
|
||||
I: Index,
|
||||
{
|
||||
/// Write into a `serde_json::Value` using the syntax `value[0] = ...` or
|
||||
/// `value["k"] = ...`.
|
||||
///
|
||||
/// If the index is a number, the value must be an array of length bigger
|
||||
/// than the index. Indexing into a value that is not an array or an array
|
||||
/// that is too small will panic.
|
||||
///
|
||||
/// If the index is a string, the value must be an object or null which is
|
||||
/// treated like an empty object. If the key is not already present in the
|
||||
/// object, it will be inserted with a value of null. Indexing into a value
|
||||
/// that is neither an object nor null will panic.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let mut data = json!({ "x": 0 });
|
||||
///
|
||||
/// // replace an existing key
|
||||
/// data["x"] = json!(1);
|
||||
///
|
||||
/// // insert a new key
|
||||
/// data["y"] = json!([false, false, false]);
|
||||
///
|
||||
/// // replace an array value
|
||||
/// data["y"][0] = json!(true);
|
||||
///
|
||||
/// // inserted a deeply nested key
|
||||
/// data["a"]["b"]["c"]["d"] = json!(true);
|
||||
///
|
||||
/// println!("{}", data);
|
||||
/// ```
|
||||
fn index_mut(&mut self, index: I) -> &mut Value {
|
||||
index.index_or_insert(self)
|
||||
}
|
||||
}
|
||||
989
zeroidc/vendor/serde_json/src/value/mod.rs
vendored
Normal file
989
zeroidc/vendor/serde_json/src/value/mod.rs
vendored
Normal file
@@ -0,0 +1,989 @@
|
||||
//! The Value enum, a loosely typed way of representing any valid JSON value.
|
||||
//!
|
||||
//! # Constructing JSON
|
||||
//!
|
||||
//! Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value`
|
||||
//! objects with very natural JSON syntax.
|
||||
//!
|
||||
//! ```
|
||||
//! use serde_json::json;
|
||||
//!
|
||||
//! fn main() {
|
||||
//! // The type of `john` is `serde_json::Value`
|
||||
//! let john = json!({
|
||||
//! "name": "John Doe",
|
||||
//! "age": 43,
|
||||
//! "phones": [
|
||||
//! "+44 1234567",
|
||||
//! "+44 2345678"
|
||||
//! ]
|
||||
//! });
|
||||
//!
|
||||
//! println!("first phone number: {}", john["phones"][0]);
|
||||
//!
|
||||
//! // Convert to a string of JSON and print it out
|
||||
//! println!("{}", john.to_string());
|
||||
//! }
|
||||
//! ```
|
||||
//!
|
||||
//! The `Value::to_string()` function converts a `serde_json::Value` into a
|
||||
//! `String` of JSON text.
|
||||
//!
|
||||
//! One neat thing about the `json!` macro is that variables and expressions can
|
||||
//! be interpolated directly into the JSON value as you are building it. Serde
|
||||
//! will check at compile time that the value you are interpolating is able to
|
||||
//! be represented as JSON.
|
||||
//!
|
||||
//! ```
|
||||
//! # use serde_json::json;
|
||||
//! #
|
||||
//! # fn random_phone() -> u16 { 0 }
|
||||
//! #
|
||||
//! let full_name = "John Doe";
|
||||
//! let age_last_year = 42;
|
||||
//!
|
||||
//! // The type of `john` is `serde_json::Value`
|
||||
//! let john = json!({
|
||||
//! "name": full_name,
|
||||
//! "age": age_last_year + 1,
|
||||
//! "phones": [
|
||||
//! format!("+44 {}", random_phone())
|
||||
//! ]
|
||||
//! });
|
||||
//! ```
|
||||
//!
|
||||
//! A string of JSON data can be parsed into a `serde_json::Value` by the
|
||||
//! [`serde_json::from_str`][from_str] function. There is also
|
||||
//! [`from_slice`][from_slice] for parsing from a byte slice `&[u8]` and
|
||||
//! [`from_reader`][from_reader] for parsing from any `io::Read` like a File or
|
||||
//! a TCP stream.
|
||||
//!
|
||||
//! ```
|
||||
//! use serde_json::{json, Value, Error};
|
||||
//!
|
||||
//! fn untyped_example() -> Result<(), Error> {
|
||||
//! // Some JSON input data as a &str. Maybe this comes from the user.
|
||||
//! let data = r#"
|
||||
//! {
|
||||
//! "name": "John Doe",
|
||||
//! "age": 43,
|
||||
//! "phones": [
|
||||
//! "+44 1234567",
|
||||
//! "+44 2345678"
|
||||
//! ]
|
||||
//! }"#;
|
||||
//!
|
||||
//! // Parse the string of data into serde_json::Value.
|
||||
//! let v: Value = serde_json::from_str(data)?;
|
||||
//!
|
||||
//! // Access parts of the data by indexing with square brackets.
|
||||
//! println!("Please call {} at the number {}", v["name"], v["phones"][0]);
|
||||
//!
|
||||
//! Ok(())
|
||||
//! }
|
||||
//! #
|
||||
//! # untyped_example().unwrap();
|
||||
//! ```
|
||||
//!
|
||||
//! [macro]: https://docs.serde.rs/serde_json/macro.json.html
|
||||
//! [from_str]: https://docs.serde.rs/serde_json/de/fn.from_str.html
|
||||
//! [from_slice]: https://docs.serde.rs/serde_json/de/fn.from_slice.html
|
||||
//! [from_reader]: https://docs.serde.rs/serde_json/de/fn.from_reader.html
|
||||
|
||||
use crate::error::Error;
|
||||
use crate::io;
|
||||
use alloc::string::String;
|
||||
use alloc::vec::Vec;
|
||||
use core::fmt::{self, Debug, Display};
|
||||
use core::mem;
|
||||
use core::str;
|
||||
use serde::de::DeserializeOwned;
|
||||
use serde::ser::Serialize;
|
||||
|
||||
pub use self::index::Index;
|
||||
pub use self::ser::Serializer;
|
||||
pub use crate::map::Map;
|
||||
pub use crate::number::Number;
|
||||
|
||||
#[cfg(feature = "raw_value")]
|
||||
pub use crate::raw::{to_raw_value, RawValue};
|
||||
|
||||
/// Represents any valid JSON value.
|
||||
///
|
||||
/// See the [`serde_json::value` module documentation](self) for usage examples.
|
||||
#[derive(Clone, Eq, PartialEq)]
|
||||
pub enum Value {
|
||||
/// Represents a JSON null value.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!(null);
|
||||
/// ```
|
||||
Null,
|
||||
|
||||
/// Represents a JSON boolean.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!(true);
|
||||
/// ```
|
||||
Bool(bool),
|
||||
|
||||
/// Represents a JSON number, whether integer or floating point.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!(12.5);
|
||||
/// ```
|
||||
Number(Number),
|
||||
|
||||
/// Represents a JSON string.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!("a string");
|
||||
/// ```
|
||||
String(String),
|
||||
|
||||
/// Represents a JSON array.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!(["an", "array"]);
|
||||
/// ```
|
||||
Array(Vec<Value>),
|
||||
|
||||
/// Represents a JSON object.
|
||||
///
|
||||
/// By default the map is backed by a BTreeMap. Enable the `preserve_order`
|
||||
/// feature of serde_json to use IndexMap instead, which preserves
|
||||
/// entries in the order they are inserted into the map. In particular, this
|
||||
/// allows JSON data to be deserialized into a Value and serialized to a
|
||||
/// string while retaining the order of map keys in the input.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!({ "an": "object" });
|
||||
/// ```
|
||||
Object(Map<String, Value>),
|
||||
}
|
||||
|
||||
impl Debug for Value {
|
||||
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
|
||||
match *self {
|
||||
Value::Null => formatter.debug_tuple("Null").finish(),
|
||||
Value::Bool(v) => formatter.debug_tuple("Bool").field(&v).finish(),
|
||||
Value::Number(ref v) => Debug::fmt(v, formatter),
|
||||
Value::String(ref v) => formatter.debug_tuple("String").field(v).finish(),
|
||||
Value::Array(ref v) => {
|
||||
formatter.write_str("Array(")?;
|
||||
Debug::fmt(v, formatter)?;
|
||||
formatter.write_str(")")
|
||||
}
|
||||
Value::Object(ref v) => {
|
||||
formatter.write_str("Object(")?;
|
||||
Debug::fmt(v, formatter)?;
|
||||
formatter.write_str(")")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for Value {
|
||||
/// Display a JSON value as a string.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let json = json!({ "city": "London", "street": "10 Downing Street" });
|
||||
///
|
||||
/// // Compact format:
|
||||
/// //
|
||||
/// // {"city":"London","street":"10 Downing Street"}
|
||||
/// let compact = format!("{}", json);
|
||||
/// assert_eq!(compact,
|
||||
/// "{\"city\":\"London\",\"street\":\"10 Downing Street\"}");
|
||||
///
|
||||
/// // Pretty format:
|
||||
/// //
|
||||
/// // {
|
||||
/// // "city": "London",
|
||||
/// // "street": "10 Downing Street"
|
||||
/// // }
|
||||
/// let pretty = format!("{:#}", json);
|
||||
/// assert_eq!(pretty,
|
||||
/// "{\n \"city\": \"London\",\n \"street\": \"10 Downing Street\"\n}");
|
||||
/// ```
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
struct WriterFormatter<'a, 'b: 'a> {
|
||||
inner: &'a mut fmt::Formatter<'b>,
|
||||
}
|
||||
|
||||
impl<'a, 'b> io::Write for WriterFormatter<'a, 'b> {
|
||||
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||
// Safety: the serializer below only emits valid utf8 when using
|
||||
// the default formatter.
|
||||
let s = unsafe { str::from_utf8_unchecked(buf) };
|
||||
tri!(self.inner.write_str(s).map_err(io_error));
|
||||
Ok(buf.len())
|
||||
}
|
||||
|
||||
fn flush(&mut self) -> io::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn io_error(_: fmt::Error) -> io::Error {
|
||||
// Error value does not matter because Display impl just maps it
|
||||
// back to fmt::Error.
|
||||
io::Error::new(io::ErrorKind::Other, "fmt error")
|
||||
}
|
||||
|
||||
let alternate = f.alternate();
|
||||
let mut wr = WriterFormatter { inner: f };
|
||||
if alternate {
|
||||
// {:#}
|
||||
super::ser::to_writer_pretty(&mut wr, self).map_err(|_| fmt::Error)
|
||||
} else {
|
||||
// {}
|
||||
super::ser::to_writer(&mut wr, self).map_err(|_| fmt::Error)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_index(s: &str) -> Option<usize> {
|
||||
if s.starts_with('+') || (s.starts_with('0') && s.len() != 1) {
|
||||
return None;
|
||||
}
|
||||
s.parse().ok()
|
||||
}
|
||||
|
||||
impl Value {
|
||||
/// Index into a JSON array or map. A string index can be used to access a
|
||||
/// value in a map, and a usize index can be used to access an element of an
|
||||
/// array.
|
||||
///
|
||||
/// Returns `None` if the type of `self` does not match the type of the
|
||||
/// index, for example if the index is a string and `self` is an array or a
|
||||
/// number. Also returns `None` if the given key does not exist in the map
|
||||
/// or the given index is not within the bounds of the array.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let object = json!({ "A": 65, "B": 66, "C": 67 });
|
||||
/// assert_eq!(*object.get("A").unwrap(), json!(65));
|
||||
///
|
||||
/// let array = json!([ "A", "B", "C" ]);
|
||||
/// assert_eq!(*array.get(2).unwrap(), json!("C"));
|
||||
///
|
||||
/// assert_eq!(array.get("A"), None);
|
||||
/// ```
|
||||
///
|
||||
/// Square brackets can also be used to index into a value in a more concise
|
||||
/// way. This returns `Value::Null` in cases where `get` would have returned
|
||||
/// `None`.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let object = json!({
|
||||
/// "A": ["a", "á", "à"],
|
||||
/// "B": ["b", "b́"],
|
||||
/// "C": ["c", "ć", "ć̣", "ḉ"],
|
||||
/// });
|
||||
/// assert_eq!(object["B"][0], json!("b"));
|
||||
///
|
||||
/// assert_eq!(object["D"], json!(null));
|
||||
/// assert_eq!(object[0]["x"]["y"]["z"], json!(null));
|
||||
/// ```
|
||||
pub fn get<I: Index>(&self, index: I) -> Option<&Value> {
|
||||
index.index_into(self)
|
||||
}
|
||||
|
||||
/// Mutably index into a JSON array or map. A string index can be used to
|
||||
/// access a value in a map, and a usize index can be used to access an
|
||||
/// element of an array.
|
||||
///
|
||||
/// Returns `None` if the type of `self` does not match the type of the
|
||||
/// index, for example if the index is a string and `self` is an array or a
|
||||
/// number. Also returns `None` if the given key does not exist in the map
|
||||
/// or the given index is not within the bounds of the array.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let mut object = json!({ "A": 65, "B": 66, "C": 67 });
|
||||
/// *object.get_mut("A").unwrap() = json!(69);
|
||||
///
|
||||
/// let mut array = json!([ "A", "B", "C" ]);
|
||||
/// *array.get_mut(2).unwrap() = json!("D");
|
||||
/// ```
|
||||
pub fn get_mut<I: Index>(&mut self, index: I) -> Option<&mut Value> {
|
||||
index.index_into_mut(self)
|
||||
}
|
||||
|
||||
/// Returns true if the `Value` is an Object. Returns false otherwise.
|
||||
///
|
||||
/// For any Value on which `is_object` returns true, `as_object` and
|
||||
/// `as_object_mut` are guaranteed to return the map representation of the
|
||||
/// object.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let obj = json!({ "a": { "nested": true }, "b": ["an", "array"] });
|
||||
///
|
||||
/// assert!(obj.is_object());
|
||||
/// assert!(obj["a"].is_object());
|
||||
///
|
||||
/// // array, not an object
|
||||
/// assert!(!obj["b"].is_object());
|
||||
/// ```
|
||||
pub fn is_object(&self) -> bool {
|
||||
self.as_object().is_some()
|
||||
}
|
||||
|
||||
/// If the `Value` is an Object, returns the associated Map. Returns None
|
||||
/// otherwise.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!({ "a": { "nested": true }, "b": ["an", "array"] });
|
||||
///
|
||||
/// // The length of `{"nested": true}` is 1 entry.
|
||||
/// assert_eq!(v["a"].as_object().unwrap().len(), 1);
|
||||
///
|
||||
/// // The array `["an", "array"]` is not an object.
|
||||
/// assert_eq!(v["b"].as_object(), None);
|
||||
/// ```
|
||||
pub fn as_object(&self) -> Option<&Map<String, Value>> {
|
||||
match *self {
|
||||
Value::Object(ref map) => Some(map),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// If the `Value` is an Object, returns the associated mutable Map.
|
||||
/// Returns None otherwise.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let mut v = json!({ "a": { "nested": true } });
|
||||
///
|
||||
/// v["a"].as_object_mut().unwrap().clear();
|
||||
/// assert_eq!(v, json!({ "a": {} }));
|
||||
/// ```
|
||||
pub fn as_object_mut(&mut self) -> Option<&mut Map<String, Value>> {
|
||||
match *self {
|
||||
Value::Object(ref mut map) => Some(map),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if the `Value` is an Array. Returns false otherwise.
|
||||
///
|
||||
/// For any Value on which `is_array` returns true, `as_array` and
|
||||
/// `as_array_mut` are guaranteed to return the vector representing the
|
||||
/// array.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let obj = json!({ "a": ["an", "array"], "b": { "an": "object" } });
|
||||
///
|
||||
/// assert!(obj["a"].is_array());
|
||||
///
|
||||
/// // an object, not an array
|
||||
/// assert!(!obj["b"].is_array());
|
||||
/// ```
|
||||
pub fn is_array(&self) -> bool {
|
||||
self.as_array().is_some()
|
||||
}
|
||||
|
||||
/// If the `Value` is an Array, returns the associated vector. Returns None
|
||||
/// otherwise.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!({ "a": ["an", "array"], "b": { "an": "object" } });
|
||||
///
|
||||
/// // The length of `["an", "array"]` is 2 elements.
|
||||
/// assert_eq!(v["a"].as_array().unwrap().len(), 2);
|
||||
///
|
||||
/// // The object `{"an": "object"}` is not an array.
|
||||
/// assert_eq!(v["b"].as_array(), None);
|
||||
/// ```
|
||||
pub fn as_array(&self) -> Option<&Vec<Value>> {
|
||||
match *self {
|
||||
Value::Array(ref array) => Some(&*array),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// If the `Value` is an Array, returns the associated mutable vector.
|
||||
/// Returns None otherwise.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let mut v = json!({ "a": ["an", "array"] });
|
||||
///
|
||||
/// v["a"].as_array_mut().unwrap().clear();
|
||||
/// assert_eq!(v, json!({ "a": [] }));
|
||||
/// ```
|
||||
pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>> {
|
||||
match *self {
|
||||
Value::Array(ref mut list) => Some(list),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if the `Value` is a String. Returns false otherwise.
|
||||
///
|
||||
/// For any Value on which `is_string` returns true, `as_str` is guaranteed
|
||||
/// to return the string slice.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!({ "a": "some string", "b": false });
|
||||
///
|
||||
/// assert!(v["a"].is_string());
|
||||
///
|
||||
/// // The boolean `false` is not a string.
|
||||
/// assert!(!v["b"].is_string());
|
||||
/// ```
|
||||
pub fn is_string(&self) -> bool {
|
||||
self.as_str().is_some()
|
||||
}
|
||||
|
||||
/// If the `Value` is a String, returns the associated str. Returns None
|
||||
/// otherwise.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!({ "a": "some string", "b": false });
|
||||
///
|
||||
/// assert_eq!(v["a"].as_str(), Some("some string"));
|
||||
///
|
||||
/// // The boolean `false` is not a string.
|
||||
/// assert_eq!(v["b"].as_str(), None);
|
||||
///
|
||||
/// // JSON values are printed in JSON representation, so strings are in quotes.
|
||||
/// //
|
||||
/// // The value is: "some string"
|
||||
/// println!("The value is: {}", v["a"]);
|
||||
///
|
||||
/// // Rust strings are printed without quotes.
|
||||
/// //
|
||||
/// // The value is: some string
|
||||
/// println!("The value is: {}", v["a"].as_str().unwrap());
|
||||
/// ```
|
||||
pub fn as_str(&self) -> Option<&str> {
|
||||
match *self {
|
||||
Value::String(ref s) => Some(s),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if the `Value` is a Number. Returns false otherwise.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!({ "a": 1, "b": "2" });
|
||||
///
|
||||
/// assert!(v["a"].is_number());
|
||||
///
|
||||
/// // The string `"2"` is a string, not a number.
|
||||
/// assert!(!v["b"].is_number());
|
||||
/// ```
|
||||
pub fn is_number(&self) -> bool {
|
||||
match *self {
|
||||
Value::Number(_) => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if the `Value` is an integer between `i64::MIN` and
|
||||
/// `i64::MAX`.
|
||||
///
|
||||
/// For any Value on which `is_i64` returns true, `as_i64` is guaranteed to
|
||||
/// return the integer value.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let big = i64::max_value() as u64 + 10;
|
||||
/// let v = json!({ "a": 64, "b": big, "c": 256.0 });
|
||||
///
|
||||
/// assert!(v["a"].is_i64());
|
||||
///
|
||||
/// // Greater than i64::MAX.
|
||||
/// assert!(!v["b"].is_i64());
|
||||
///
|
||||
/// // Numbers with a decimal point are not considered integers.
|
||||
/// assert!(!v["c"].is_i64());
|
||||
/// ```
|
||||
pub fn is_i64(&self) -> bool {
|
||||
match *self {
|
||||
Value::Number(ref n) => n.is_i64(),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if the `Value` is an integer between zero and `u64::MAX`.
|
||||
///
|
||||
/// For any Value on which `is_u64` returns true, `as_u64` is guaranteed to
|
||||
/// return the integer value.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
|
||||
///
|
||||
/// assert!(v["a"].is_u64());
|
||||
///
|
||||
/// // Negative integer.
|
||||
/// assert!(!v["b"].is_u64());
|
||||
///
|
||||
/// // Numbers with a decimal point are not considered integers.
|
||||
/// assert!(!v["c"].is_u64());
|
||||
/// ```
|
||||
pub fn is_u64(&self) -> bool {
|
||||
match *self {
|
||||
Value::Number(ref n) => n.is_u64(),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if the `Value` is a number that can be represented by f64.
|
||||
///
|
||||
/// For any Value on which `is_f64` returns true, `as_f64` is guaranteed to
|
||||
/// return the floating point value.
|
||||
///
|
||||
/// Currently this function returns true if and only if both `is_i64` and
|
||||
/// `is_u64` return false but this is not a guarantee in the future.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
|
||||
///
|
||||
/// assert!(v["a"].is_f64());
|
||||
///
|
||||
/// // Integers.
|
||||
/// assert!(!v["b"].is_f64());
|
||||
/// assert!(!v["c"].is_f64());
|
||||
/// ```
|
||||
pub fn is_f64(&self) -> bool {
|
||||
match *self {
|
||||
Value::Number(ref n) => n.is_f64(),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// If the `Value` is an integer, represent it as i64 if possible. Returns
|
||||
/// None otherwise.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let big = i64::max_value() as u64 + 10;
|
||||
/// let v = json!({ "a": 64, "b": big, "c": 256.0 });
|
||||
///
|
||||
/// assert_eq!(v["a"].as_i64(), Some(64));
|
||||
/// assert_eq!(v["b"].as_i64(), None);
|
||||
/// assert_eq!(v["c"].as_i64(), None);
|
||||
/// ```
|
||||
pub fn as_i64(&self) -> Option<i64> {
|
||||
match *self {
|
||||
Value::Number(ref n) => n.as_i64(),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// If the `Value` is an integer, represent it as u64 if possible. Returns
|
||||
/// None otherwise.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
|
||||
///
|
||||
/// assert_eq!(v["a"].as_u64(), Some(64));
|
||||
/// assert_eq!(v["b"].as_u64(), None);
|
||||
/// assert_eq!(v["c"].as_u64(), None);
|
||||
/// ```
|
||||
pub fn as_u64(&self) -> Option<u64> {
|
||||
match *self {
|
||||
Value::Number(ref n) => n.as_u64(),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// If the `Value` is a number, represent it as f64 if possible. Returns
|
||||
/// None otherwise.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
|
||||
///
|
||||
/// assert_eq!(v["a"].as_f64(), Some(256.0));
|
||||
/// assert_eq!(v["b"].as_f64(), Some(64.0));
|
||||
/// assert_eq!(v["c"].as_f64(), Some(-64.0));
|
||||
/// ```
|
||||
pub fn as_f64(&self) -> Option<f64> {
|
||||
match *self {
|
||||
Value::Number(ref n) => n.as_f64(),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if the `Value` is a Boolean. Returns false otherwise.
|
||||
///
|
||||
/// For any Value on which `is_boolean` returns true, `as_bool` is
|
||||
/// guaranteed to return the boolean value.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!({ "a": false, "b": "false" });
|
||||
///
|
||||
/// assert!(v["a"].is_boolean());
|
||||
///
|
||||
/// // The string `"false"` is a string, not a boolean.
|
||||
/// assert!(!v["b"].is_boolean());
|
||||
/// ```
|
||||
pub fn is_boolean(&self) -> bool {
|
||||
self.as_bool().is_some()
|
||||
}
|
||||
|
||||
/// If the `Value` is a Boolean, returns the associated bool. Returns None
|
||||
/// otherwise.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!({ "a": false, "b": "false" });
|
||||
///
|
||||
/// assert_eq!(v["a"].as_bool(), Some(false));
|
||||
///
|
||||
/// // The string `"false"` is a string, not a boolean.
|
||||
/// assert_eq!(v["b"].as_bool(), None);
|
||||
/// ```
|
||||
pub fn as_bool(&self) -> Option<bool> {
|
||||
match *self {
|
||||
Value::Bool(b) => Some(b),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if the `Value` is a Null. Returns false otherwise.
|
||||
///
|
||||
/// For any Value on which `is_null` returns true, `as_null` is guaranteed
|
||||
/// to return `Some(())`.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!({ "a": null, "b": false });
|
||||
///
|
||||
/// assert!(v["a"].is_null());
|
||||
///
|
||||
/// // The boolean `false` is not null.
|
||||
/// assert!(!v["b"].is_null());
|
||||
/// ```
|
||||
pub fn is_null(&self) -> bool {
|
||||
self.as_null().is_some()
|
||||
}
|
||||
|
||||
/// If the `Value` is a Null, returns (). Returns None otherwise.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let v = json!({ "a": null, "b": false });
|
||||
///
|
||||
/// assert_eq!(v["a"].as_null(), Some(()));
|
||||
///
|
||||
/// // The boolean `false` is not null.
|
||||
/// assert_eq!(v["b"].as_null(), None);
|
||||
/// ```
|
||||
pub fn as_null(&self) -> Option<()> {
|
||||
match *self {
|
||||
Value::Null => Some(()),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Looks up a value by a JSON Pointer.
|
||||
///
|
||||
/// JSON Pointer defines a string syntax for identifying a specific value
|
||||
/// within a JavaScript Object Notation (JSON) document.
|
||||
///
|
||||
/// A Pointer is a Unicode string with the reference tokens separated by `/`.
|
||||
/// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The
|
||||
/// addressed value is returned and if there is no such value `None` is
|
||||
/// returned.
|
||||
///
|
||||
/// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901).
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let data = json!({
|
||||
/// "x": {
|
||||
/// "y": ["z", "zz"]
|
||||
/// }
|
||||
/// });
|
||||
///
|
||||
/// assert_eq!(data.pointer("/x/y/1").unwrap(), &json!("zz"));
|
||||
/// assert_eq!(data.pointer("/a/b/c"), None);
|
||||
/// ```
|
||||
pub fn pointer(&self, pointer: &str) -> Option<&Value> {
|
||||
if pointer.is_empty() {
|
||||
return Some(self);
|
||||
}
|
||||
if !pointer.starts_with('/') {
|
||||
return None;
|
||||
}
|
||||
pointer
|
||||
.split('/')
|
||||
.skip(1)
|
||||
.map(|x| x.replace("~1", "/").replace("~0", "~"))
|
||||
.try_fold(self, |target, token| match target {
|
||||
Value::Object(map) => map.get(&token),
|
||||
Value::Array(list) => parse_index(&token).and_then(|x| list.get(x)),
|
||||
_ => None,
|
||||
})
|
||||
}
|
||||
|
||||
/// Looks up a value by a JSON Pointer and returns a mutable reference to
|
||||
/// that value.
|
||||
///
|
||||
/// JSON Pointer defines a string syntax for identifying a specific value
|
||||
/// within a JavaScript Object Notation (JSON) document.
|
||||
///
|
||||
/// A Pointer is a Unicode string with the reference tokens separated by `/`.
|
||||
/// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The
|
||||
/// addressed value is returned and if there is no such value `None` is
|
||||
/// returned.
|
||||
///
|
||||
/// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901).
|
||||
///
|
||||
/// # Example of Use
|
||||
///
|
||||
/// ```
|
||||
/// use serde_json::Value;
|
||||
///
|
||||
/// fn main() {
|
||||
/// let s = r#"{"x": 1.0, "y": 2.0}"#;
|
||||
/// let mut value: Value = serde_json::from_str(s).unwrap();
|
||||
///
|
||||
/// // Check value using read-only pointer
|
||||
/// assert_eq!(value.pointer("/x"), Some(&1.0.into()));
|
||||
/// // Change value with direct assignment
|
||||
/// *value.pointer_mut("/x").unwrap() = 1.5.into();
|
||||
/// // Check that new value was written
|
||||
/// assert_eq!(value.pointer("/x"), Some(&1.5.into()));
|
||||
/// // Or change the value only if it exists
|
||||
/// value.pointer_mut("/x").map(|v| *v = 1.5.into());
|
||||
///
|
||||
/// // "Steal" ownership of a value. Can replace with any valid Value.
|
||||
/// let old_x = value.pointer_mut("/x").map(Value::take).unwrap();
|
||||
/// assert_eq!(old_x, 1.5);
|
||||
/// assert_eq!(value.pointer("/x").unwrap(), &Value::Null);
|
||||
/// }
|
||||
/// ```
|
||||
pub fn pointer_mut(&mut self, pointer: &str) -> Option<&mut Value> {
|
||||
if pointer.is_empty() {
|
||||
return Some(self);
|
||||
}
|
||||
if !pointer.starts_with('/') {
|
||||
return None;
|
||||
}
|
||||
pointer
|
||||
.split('/')
|
||||
.skip(1)
|
||||
.map(|x| x.replace("~1", "/").replace("~0", "~"))
|
||||
.try_fold(self, |target, token| match target {
|
||||
Value::Object(map) => map.get_mut(&token),
|
||||
Value::Array(list) => parse_index(&token).and_then(move |x| list.get_mut(x)),
|
||||
_ => None,
|
||||
})
|
||||
}
|
||||
|
||||
/// Takes the value out of the `Value`, leaving a `Null` in its place.
|
||||
///
|
||||
/// ```
|
||||
/// # use serde_json::json;
|
||||
/// #
|
||||
/// let mut v = json!({ "x": "y" });
|
||||
/// assert_eq!(v["x"].take(), json!("y"));
|
||||
/// assert_eq!(v, json!({ "x": null }));
|
||||
/// ```
|
||||
pub fn take(&mut self) -> Value {
|
||||
mem::replace(self, Value::Null)
|
||||
}
|
||||
}
|
||||
|
||||
/// The default value is `Value::Null`.
|
||||
///
|
||||
/// This is useful for handling omitted `Value` fields when deserializing.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use serde::Deserialize;
|
||||
/// use serde_json::Value;
|
||||
///
|
||||
/// #[derive(Deserialize)]
|
||||
/// struct Settings {
|
||||
/// level: i32,
|
||||
/// #[serde(default)]
|
||||
/// extras: Value,
|
||||
/// }
|
||||
///
|
||||
/// # fn try_main() -> Result<(), serde_json::Error> {
|
||||
/// let data = r#" { "level": 42 } "#;
|
||||
/// let s: Settings = serde_json::from_str(data)?;
|
||||
///
|
||||
/// assert_eq!(s.level, 42);
|
||||
/// assert_eq!(s.extras, Value::Null);
|
||||
/// #
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// #
|
||||
/// # try_main().unwrap()
|
||||
/// ```
|
||||
impl Default for Value {
|
||||
fn default() -> Value {
|
||||
Value::Null
|
||||
}
|
||||
}
|
||||
|
||||
mod de;
|
||||
mod from;
|
||||
mod index;
|
||||
mod partial_eq;
|
||||
mod ser;
|
||||
|
||||
/// Convert a `T` into `serde_json::Value` which is an enum that can represent
|
||||
/// any valid JSON data.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use serde::Serialize;
|
||||
/// use serde_json::json;
|
||||
///
|
||||
/// use std::error::Error;
|
||||
///
|
||||
/// #[derive(Serialize)]
|
||||
/// struct User {
|
||||
/// fingerprint: String,
|
||||
/// location: String,
|
||||
/// }
|
||||
///
|
||||
/// fn compare_json_values() -> Result<(), Box<Error>> {
|
||||
/// let u = User {
|
||||
/// fingerprint: "0xF9BA143B95FF6D82".to_owned(),
|
||||
/// location: "Menlo Park, CA".to_owned(),
|
||||
/// };
|
||||
///
|
||||
/// // The type of `expected` is `serde_json::Value`
|
||||
/// let expected = json!({
|
||||
/// "fingerprint": "0xF9BA143B95FF6D82",
|
||||
/// "location": "Menlo Park, CA",
|
||||
/// });
|
||||
///
|
||||
/// let v = serde_json::to_value(u).unwrap();
|
||||
/// assert_eq!(v, expected);
|
||||
///
|
||||
/// Ok(())
|
||||
/// }
|
||||
/// #
|
||||
/// # compare_json_values().unwrap();
|
||||
/// ```
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This conversion can fail if `T`'s implementation of `Serialize` decides to
|
||||
/// fail, or if `T` contains a map with non-string keys.
|
||||
///
|
||||
/// ```
|
||||
/// use std::collections::BTreeMap;
|
||||
///
|
||||
/// fn main() {
|
||||
/// // The keys in this map are vectors, not strings.
|
||||
/// let mut map = BTreeMap::new();
|
||||
/// map.insert(vec![32, 64], "x86");
|
||||
///
|
||||
/// println!("{}", serde_json::to_value(map).unwrap_err());
|
||||
/// }
|
||||
/// ```
|
||||
// Taking by value is more friendly to iterator adapters, option and result
|
||||
// consumers, etc. See https://github.com/serde-rs/json/pull/149.
|
||||
pub fn to_value<T>(value: T) -> Result<Value, Error>
|
||||
where
|
||||
T: Serialize,
|
||||
{
|
||||
value.serialize(Serializer)
|
||||
}
|
||||
|
||||
/// Interpret a `serde_json::Value` as an instance of type `T`.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use serde::Deserialize;
|
||||
/// use serde_json::json;
|
||||
///
|
||||
/// #[derive(Deserialize, Debug)]
|
||||
/// struct User {
|
||||
/// fingerprint: String,
|
||||
/// location: String,
|
||||
/// }
|
||||
///
|
||||
/// fn main() {
|
||||
/// // The type of `j` is `serde_json::Value`
|
||||
/// let j = json!({
|
||||
/// "fingerprint": "0xF9BA143B95FF6D82",
|
||||
/// "location": "Menlo Park, CA"
|
||||
/// });
|
||||
///
|
||||
/// let u: User = serde_json::from_value(j).unwrap();
|
||||
/// println!("{:#?}", u);
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This conversion can fail if the structure of the Value does not match the
|
||||
/// structure expected by `T`, for example if `T` is a struct type but the Value
|
||||
/// contains something other than a JSON map. It can also fail if the structure
|
||||
/// is correct but `T`'s implementation of `Deserialize` decides that something
|
||||
/// is wrong with the data, for example required struct fields are missing from
|
||||
/// the JSON map or some number is too big to fit in the expected primitive
|
||||
/// type.
|
||||
pub fn from_value<T>(value: Value) -> Result<T, Error>
|
||||
where
|
||||
T: DeserializeOwned,
|
||||
{
|
||||
T::deserialize(value)
|
||||
}
|
||||
95
zeroidc/vendor/serde_json/src/value/partial_eq.rs
vendored
Normal file
95
zeroidc/vendor/serde_json/src/value/partial_eq.rs
vendored
Normal file
@@ -0,0 +1,95 @@
|
||||
use super::Value;
|
||||
use alloc::string::String;
|
||||
|
||||
fn eq_i64(value: &Value, other: i64) -> bool {
|
||||
value.as_i64().map_or(false, |i| i == other)
|
||||
}
|
||||
|
||||
fn eq_u64(value: &Value, other: u64) -> bool {
|
||||
value.as_u64().map_or(false, |i| i == other)
|
||||
}
|
||||
|
||||
fn eq_f64(value: &Value, other: f64) -> bool {
|
||||
value.as_f64().map_or(false, |i| i == other)
|
||||
}
|
||||
|
||||
fn eq_bool(value: &Value, other: bool) -> bool {
|
||||
value.as_bool().map_or(false, |i| i == other)
|
||||
}
|
||||
|
||||
fn eq_str(value: &Value, other: &str) -> bool {
|
||||
value.as_str().map_or(false, |i| i == other)
|
||||
}
|
||||
|
||||
impl PartialEq<str> for Value {
|
||||
fn eq(&self, other: &str) -> bool {
|
||||
eq_str(self, other)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> PartialEq<&'a str> for Value {
|
||||
fn eq(&self, other: &&str) -> bool {
|
||||
eq_str(self, *other)
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq<Value> for str {
|
||||
fn eq(&self, other: &Value) -> bool {
|
||||
eq_str(other, self)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> PartialEq<Value> for &'a str {
|
||||
fn eq(&self, other: &Value) -> bool {
|
||||
eq_str(other, *self)
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq<String> for Value {
|
||||
fn eq(&self, other: &String) -> bool {
|
||||
eq_str(self, other.as_str())
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq<Value> for String {
|
||||
fn eq(&self, other: &Value) -> bool {
|
||||
eq_str(other, self.as_str())
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! partialeq_numeric {
|
||||
($($eq:ident [$($ty:ty)*])*) => {
|
||||
$($(
|
||||
impl PartialEq<$ty> for Value {
|
||||
fn eq(&self, other: &$ty) -> bool {
|
||||
$eq(self, *other as _)
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq<Value> for $ty {
|
||||
fn eq(&self, other: &Value) -> bool {
|
||||
$eq(other, *self as _)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> PartialEq<$ty> for &'a Value {
|
||||
fn eq(&self, other: &$ty) -> bool {
|
||||
$eq(*self, *other as _)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> PartialEq<$ty> for &'a mut Value {
|
||||
fn eq(&self, other: &$ty) -> bool {
|
||||
$eq(*self, *other as _)
|
||||
}
|
||||
}
|
||||
)*)*
|
||||
}
|
||||
}
|
||||
|
||||
partialeq_numeric! {
|
||||
eq_i64[i8 i16 i32 i64 isize]
|
||||
eq_u64[u8 u16 u32 u64 usize]
|
||||
eq_f64[f32 f64]
|
||||
eq_bool[bool]
|
||||
}
|
||||
1030
zeroidc/vendor/serde_json/src/value/ser.rs
vendored
Normal file
1030
zeroidc/vendor/serde_json/src/value/ser.rs
vendored
Normal file
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user