Enum JsonValue 

pub enum JsonValue {
    Null,
    Boolean(bool),
    Number(JsonNumberBuf),
    String(JsonString),
    Array(JsonArrayBuf),
    Object(JsonObject),
}

JSON Value.

Parsing

You can parse a Value by importing the JsonParse trait providing a collection of parsing functions.

Example

use json_syntax::{JsonValue, JsonParse, JsonCodeMap};
let (value, code_map) = JsonValue::parse_str("{ \"key\": \"value\" }").unwrap();

The code_map value of type JsonCodeMap contains code-mapping information about all the fragments of the JSON value (their location in the source text).

Comparison

The PartialEq and PartialOrd implementations will compare the JSON values semantically, without regard for the object entries indexes. The only exception is when one key has multiple values, in which cases the values are ordered by index. It is possible to compare the lexical representation of objects (where the entries indexes matter) by using the JsonBorrowLexical::as_lexical method on both ends and comparing the results.

Example

use json_syntax::{json, lexical::JsonBorrowLexical};

let a = json!({ "a": 0, "b": 1 });
let b = json!({ "b": 1, "a": 0 });

assert_eq!(a, b); // equals, because semantically equivalent.
assert_ne!(a.as_lexical(), b.as_lexical()); // not equals.

Printing

The JsonPrint trait provide a highly configurable printing method.

Example

use json_syntax::{JsonValue, JsonParse, JsonPrint};

let value = JsonValue::parse_str("[ 0, 1, { \"key\": \"value\" }, null ]").unwrap().0;

println!("{}", value.pretty_print()); // multi line, indent with 2 spaces
println!("{}", value.inline_print()); // single line, spaces
println!("{}", value.compact_print()); // single line, no spaces

let mut options = json_syntax::print::JsonPrintOptions::PRETTY;
options.indent = json_syntax::print::Indent::Tabs(1);
println!("{}", value.print_with(&options)); // multi line, indent with tabs

Variants

Null

null.

Boolean(bool)

Boolean true or false.

Number(JsonNumberBuf)

Number.

String(JsonString)

String.

Array(JsonArrayBuf)

Array.

Object(JsonObject)

Object.

Implementations

impl JsonValue

pub fn from_serde_json(value: Value) -> Self

Converts a serde_json::Value into a Value.

Example

use json_syntax::JsonValue;

// First we create a `serde_json` value.
let a = serde_json::json!({
  "foo": 1,
  "bar": [2, 3]
});

// We convert the `serde_json` value into a `json_syntax` value.
let b = JsonValue::from_serde_json(a);

// We convert it back into a `serde_json` value.
let _ = JsonValue::into_serde_json(b);

pub fn into_serde_json(self) -> Value

Converts a Value into a serde_json::Value.

Example

use json_syntax::JsonValue;

// First we create a `serde_json` value.
let a = serde_json::json!({
  "foo": 1,
  "bar": [2, 3]
});

// We convert the `serde_json` value into a `json_syntax` value.
let b = JsonValue::from_serde_json(a);

// We convert it back into a `serde_json` value.
let _ = JsonValue::into_serde_json(b);

impl JsonValue

pub fn locate_fragment( &self, code_map: &JsonCodeMap, path: &JsonFragmentPath, ) -> Option<usize>

Returns the JsonCodeMap index of the fragment described by path.

The returned index can be used to look up the byte span of the fragment in the code_map produced by parsing the same document.

Returns None if the path does not exist in this value (e.g., the key is missing, the array index is out of range, or a path segment tries to navigate into a fragment that has no sub-fragments).

Segment semantics

• [JsonFragmentPathSegment::ArrayIndex]: navigates into the i-th element of an array.
• [JsonFragmentPathSegment::ObjectKey]: navigates to the key string fragment of the n-th occurrence of the named key. This is a terminal step; further path segments after this will return None.
• [JsonFragmentPathSegment::ObjectValue]: navigates to the value of the n-th occurrence of the named key.

impl JsonValue

pub fn find_duplicate_key_recursive( &self, ) -> Option<(JsonFragmentPathBuf, &str)>

Recursively searches this value, including nested arrays and objects, for the first object containing a duplicate key.

Many JSON-based formats (such as JSON-LD) require object keys to be unique throughout a document, even though JSON itself only recommends it; this can be used to validate a whole document in one pass before processing it, rather than checking every object individually as it is encountered.

Returns the path to the first object found with a duplicate key (relative to self), together with the duplicated key itself, or None if no object anywhere in this value has a duplicate key. The returned path can be passed to JsonValue::locate_fragment (with an empty final segment, or combined with JsonBacktraceBuilder methods) to locate the offending object in a parsed document.

impl JsonValue

pub fn get_fragment(&self, index: usize) -> Result<JsonFragment<'_>, usize>

pub fn kind(&self) -> JsonKind

pub fn is_kind(&self, kind: JsonKind) -> bool

pub fn is_null(&self) -> bool

pub fn is_boolean(&self) -> bool

pub fn is_number(&self) -> bool

pub fn is_string(&self) -> bool

pub fn is_array(&self) -> bool

pub fn is_object(&self) -> bool

pub fn is_empty_array_or_object(&self) -> bool

Checks if the value is either an empty array or an empty object.

pub fn as_boolean(&self) -> Option<bool>

pub fn as_boolean_mut(&mut self) -> Option<&mut bool>

pub fn as_number(&self) -> Option<&JsonNumber>

pub fn as_number_mut(&mut self) -> Option<&mut JsonNumberBuf>

pub fn as_string(&self) -> Option<&str>

pub fn as_str(&self) -> Option<&str>

Alias for as_string.

pub fn as_string_mut(&mut self) -> Option<&mut JsonString>

pub fn as_array(&self) -> Option<&[Self]>

pub fn as_array_mut(&mut self) -> Option<&mut JsonArrayBuf>

pub fn force_as_array(&self) -> &[Self]

Return the given value as an array, even if it is not an array.

Returns the input value as is if it is already an array, or puts it in a slice with a single element if it is not.

pub fn as_object(&self) -> Option<&JsonObject>

pub fn as_object_mut(&mut self) -> Option<&mut JsonObject>

pub fn into_boolean(self) -> Option<bool>

pub fn into_number(self) -> Option<JsonNumberBuf>

pub fn into_string(self) -> Option<JsonString>

pub fn into_array(self) -> Option<JsonArrayBuf>

pub fn into_object(self) -> Option<JsonObject>

pub fn traverse(&self) -> Traverse<'_>

pub fn count(&self, f: impl FnMut(usize, JsonFragment<'_>) -> bool) -> usize

Recursively count the number of values for which f returns true.

pub fn volume(&self) -> usize

Returns the volume of the value.

The volume is the sum of all values and recursively nested values included in self, including self (the volume is at least 1).

This is equivalent to value.traverse().filter(|(_, f)| f.is_value()).count().

pub fn take(&mut self) -> Self

Move and return the value, leaves null in its place.

pub fn canonicalize_with(&mut self, buffer: &mut Buffer)

Puts this JSON value in canonical form according to RFC 8785.

The given buffer is used to canonicalize the number values.

pub fn canonicalize(&mut self)

Puts this JSON value in canonical form according to RFC 8785.

pub fn canonicalized(&self) -> Self

Returns the canonical form of this value according to RFC 8785.

Trait Implementations

impl Clone for JsonValue

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for JsonValue

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for JsonValue

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de> Deserializer<'de> for JsonValue

type Error = DeserializeError

The error type that can be returned if some error occurs during deserialization.

fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Require the Deserializer to figure out how to drive the visitor based on what data type is in the input.

fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i8 value.

fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i16 value.

fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i32 value.

fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i64 value.

fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i128 value.

fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u8 value.

fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u16 value.

fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u32 value.

fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u64 value.

fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an u128 value.

fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a f32 value.

fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a f64 value.

fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an optional value.

fn deserialize_enum<V>( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an enum value with a particular name and possible variants.

fn deserialize_newtype_struct<V>( self, _name: &'static str, visitor: V, ) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a newtype struct with a particular name.

fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a bool value.

fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a char value.

fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a string value and does not benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a string value and would benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a byte array and does not benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a byte array and would benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a unit value.

fn deserialize_unit_struct<V>( self, _name: &'static str, visitor: V, ) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a unit struct with a particular name.

fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a sequence of values.

fn deserialize_tuple<V>( self, _len: usize, visitor: V, ) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a sequence of values and knows how many values there are without looking at the serialized data.

fn deserialize_tuple_struct<V>( self, _name: &'static str, _len: usize, visitor: V, ) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a tuple struct with a particular name and number of fields.

fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a map of key-value pairs.

fn deserialize_struct<V>( self, _name: &'static str, _fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a struct with a particular name and fields.

fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting the name of a struct field or the discriminant of an enum variant.

fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type needs to deserialize a value whose type doesn’t matter because it is ignored.

fn is_human_readable(&self) -> bool

Determine whether Deserialize implementations should expect to deserialize their human-readable form.

impl Display for JsonValue

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for JsonValue

impl<'n> From<&'n JsonNumber> for JsonValue

fn from(n: &'n JsonNumber) -> Self

Converts to this type from the input type.

impl<'s> From<&'s str> for JsonValue

fn from(s: &'s str) -> Self

Converts to this type from the input type.

impl From<JsonNumberBuf> for JsonValue

fn from(n: JsonNumberBuf) -> Self

Converts to this type from the input type.

impl From<JsonObject> for JsonValue

fn from(o: JsonObject) -> Self

Converts to this type from the input type.

impl From<JsonValue> for Value

fn from(value: JsonValue) -> Self

Converts to this type from the input type.

impl From<JsonValue> for String

fn from(value: JsonValue) -> Self

Converts to this type from the input type.

impl From<SmallString<[u8; 16]>> for JsonValue

fn from(s: JsonString) -> Self

Converts to this type from the input type.

impl From<String> for JsonValue

fn from(s: String) -> Self

Converts to this type from the input type.

impl From<Value> for JsonValue

fn from(value: Value) -> Self

Converts to this type from the input type.

impl From<Vec<JsonValue>> for JsonValue

fn from(a: JsonArrayBuf) -> Self

Converts to this type from the input type.

impl From<bool> for JsonValue

fn from(b: bool) -> Self

Converts to this type from the input type.

impl From<i8> for JsonValue

fn from(n: i8) -> Self

Converts to this type from the input type.

impl From<i16> for JsonValue

fn from(n: i16) -> Self

Converts to this type from the input type.

impl From<i32> for JsonValue

fn from(n: i32) -> Self

Converts to this type from the input type.

impl From<i64> for JsonValue

fn from(n: i64) -> Self

Converts to this type from the input type.

impl From<u8> for JsonValue

fn from(n: u8) -> Self

Converts to this type from the input type.

impl From<u16> for JsonValue

fn from(n: u16) -> Self

Converts to this type from the input type.

impl From<u32> for JsonValue

fn from(n: u32) -> Self

Converts to this type from the input type.

impl From<u64> for JsonValue

fn from(n: u64) -> Self

Converts to this type from the input type.

impl FromStr for JsonValue

type Err = JsonParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for JsonValue

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'de> IntoDeserializer<'de, DeserializeError> for JsonValue

type Deserializer = JsonValue

The type of the deserializer being converted into.

fn into_deserializer(self) -> Self::Deserializer

Convert this value into a deserializer.

impl JsonBorrowLexical for JsonValue

fn as_lexical(&self) -> &JsonLexical<Self>

impl JsonLexicalEq for JsonValue

impl JsonLexicalPartialEq for JsonValue

fn lexical_eq(&self, other: &Self) -> bool

impl JsonParse for JsonValue

fn parse_in<C, E>( parser: &mut Parser<C, E>, context: JsonParsingContext, ) -> Result<(Self, usize), JsonParseError<E>>

where C: Iterator<Item = Result<DecodedChar, E>>,

fn parse_slice(content: &[u8]) -> Result<(Self, JsonCodeMap), JsonParseError>

fn parse_slice_with( content: &[u8], options: Options, ) -> Result<(Self, JsonCodeMap), JsonParseError>

fn parse_str(content: &str) -> Result<(Self, JsonCodeMap), JsonParseError>

fn parse_str_with( content: &str, options: Options, ) -> Result<(Self, JsonCodeMap), JsonParseError>

fn parse_infallible_utf8<C>( chars: C, ) -> Result<(Self, JsonCodeMap), JsonParseError>

where C: Iterator<Item = char>,

fn parse_utf8_infallible_with<C>( chars: C, options: Options, ) -> Result<(Self, JsonCodeMap), JsonParseError>

where C: Iterator<Item = char>,

fn parse_utf8<C, E>(chars: C) -> Result<(Self, JsonCodeMap), JsonParseError<E>>

where C: Iterator<Item = Result<char, E>>,

fn parse_utf8_with<C, E>( chars: C, options: Options, ) -> Result<(Self, JsonCodeMap), JsonParseError<E>>

where C: Iterator<Item = Result<char, E>>,

fn parse_infallible<C>(chars: C) -> Result<(Self, JsonCodeMap), JsonParseError>

where C: Iterator<Item = DecodedChar>,

fn parse_infallible_with<C>( chars: C, options: Options, ) -> Result<(Self, JsonCodeMap), JsonParseError>

where C: Iterator<Item = DecodedChar>,

fn parse<C, E>(chars: C) -> Result<(Self, JsonCodeMap), JsonParseError<E>>

where C: Iterator<Item = Result<DecodedChar, E>>,

fn parse_with<C, E>( chars: C, options: Options, ) -> Result<(Self, JsonCodeMap), JsonParseError<E>>

where C: Iterator<Item = Result<DecodedChar, E>>,

impl JsonVisit for JsonValue

fn visit<V: JsonVisitor>(&self, visitor: V) -> V::Output

impl Ord for JsonValue

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for JsonValue

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for JsonValue

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for JsonValue

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for JsonValue

impl TryFrom<f32> for JsonValue

type Error = TryFromFloatError

The type returned in the event of a conversion error.

fn try_from(n: f32) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<f64> for JsonValue

type Error = TryFromFloatError

The type returned in the event of a conversion error.

fn try_from(n: f64) -> Result<Self, Self::Error>

Performs the conversion.