Enum json_ld_syntax::Value

pub enum Value {
    Null,
    Boolean(bool),
    Number(NumberBuf<SmallVec<[u8; 16]>>),
    String(SmallString<[u8; 16]>),
    Array(Vec<Value>),
    Object(Object),
}

JSON Value.

Parsing

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

Example

use json_syntax::{Value, Parse, CodeMap};
let (value, code_map) = Value::parse_str("{ \"key\": \"value\" }").unwrap();

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

Comparison

This type implements the usual comparison traits PartialEq, Eq, PartialOrd and Ord. However by default JSON object entries ordering matters, meaning that { "a": 0, "b": 1 } is not equal to { "b": 1, "a": 0 }. If you want to do comparisons while ignoring entries ordering, you can use the Unordered type (combined with the UnorderedPartialEq trait). Any T reference can be turned into an Unordered<T> reference at will using the BorrowUnordered::as_unordered method.

Example

use json_syntax::{json, Unordered, BorrowUnordered};

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

assert_ne!(a, b); // not equals entries are in a different order.
assert_eq!(a.as_unordered(), b.as_unordered()); // equals modulo entry order.
assert_eq!(Unordered(a), Unordered(b)); // equals modulo entry order.

Printing

The Print trait provide a highly configurable printing method.

Example

use json_syntax::{Value, Parse, Print};

let value = Value::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::Options::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(NumberBuf<SmallVec<[u8; 16]>>)

Number.

String(SmallString<[u8; 16]>)

String.

Array(Vec<Value>)

Array.

Object(Object)

Object.

Implementations

impl Value

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

pub fn kind(&self) -> Kind

pub fn is_kind(&self, kind: Kind) -> 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<&Number>

pub fn as_number_mut(&mut self) -> Option<&mut NumberBuf<SmallVec<[u8; 16]>>>

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 SmallString<[u8; 16]>>

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

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

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

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<&Object>

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

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

pub fn into_number(self) -> Option<NumberBuf<SmallVec<[u8; 16]>>>

pub fn into_string(self) -> Option<SmallString<[u8; 16]>>

pub fn into_array(self) -> Option<Vec<Value>>

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

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

pub fn count(&self, f: impl FnMut(usize, FragmentRef<'_>) -> 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) -> Value

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

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Compare for Value

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

impl Debug for Value

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

Formats the value using the given formatter.

impl Display for Value

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

Formats the value using the given formatter.

impl<'n> From<&'n Number> for Value

fn from(n: &'n Number) -> Value

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl From<NumberBuf<SmallVec<[u8; 16]>>> for Value

fn from(n: NumberBuf<SmallVec<[u8; 16]>>) -> Value

Converts to this type from the input type.

impl From<Object> for Value

fn from(o: Object) -> Value

Converts to this type from the input type.

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

fn from(s: SmallString<[u8; 16]>) -> Value

Converts to this type from the input type.

impl From<String> for Value

fn from(s: String) -> Value

Converts to this type from the input type.

impl From<Vec<Value>> for Value

fn from(a: Vec<Value>) -> Value

Converts to this type from the input type.

impl From<bool> for Value

fn from(b: bool) -> Value

Converts to this type from the input type.

impl From<i16> for Value

fn from(n: i16) -> Value

Converts to this type from the input type.

impl From<i32> for Value

fn from(n: i32) -> Value

Converts to this type from the input type.

impl From<i64> for Value

fn from(n: i64) -> Value

Converts to this type from the input type.

impl From<i8> for Value

fn from(n: i8) -> Value

Converts to this type from the input type.

impl From<u16> for Value

fn from(n: u16) -> Value

Converts to this type from the input type.

impl From<u32> for Value

fn from(n: u32) -> Value

Converts to this type from the input type.

impl From<u64> for Value

fn from(n: u64) -> Value

Converts to this type from the input type.

impl From<u8> for Value

fn from(n: u8) -> Value

Converts to this type from the input type.

impl FromStr for Value

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Value, <Value as FromStr>::Err>

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

impl Hash for Value

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

where __H: Hasher,

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 Ord for Value

fn cmp(&self, other: &Value) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl Parse for Value

fn parse_in<C, E>( parser: &mut Parser<C, E>, context: Context ) -> Result<Meta<Value, usize>, Error<E>>

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

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

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

fn parse_str(content: &str) -> Result<(Self, CodeMap), Error>

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

fn parse_infallible_utf8<C>(chars: C) -> Result<(Self, CodeMap), Error>

where C: Iterator<Item = char>,

fn parse_utf8_infallible_with<C>( chars: C, options: Options ) -> Result<(Self, CodeMap), Error>

where C: Iterator<Item = char>,

fn parse_utf8<C, E>(chars: C) -> Result<(Self, CodeMap), Error<E>>

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

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

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

fn parse_infallible<C>(chars: C) -> Result<(Self, CodeMap), Error>

where C: Iterator<Item = DecodedChar>,

fn parse_infallible_with<C>( chars: C, options: Options ) -> Result<(Self, CodeMap), Error>

where C: Iterator<Item = DecodedChar>,

fn parse<C, E>(chars: C) -> Result<(Self, CodeMap), Error<E>>

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

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

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

impl PartialEq for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Value

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PrecomputeSize for Value

fn pre_compute_size(&self, options: &Options, sizes: &mut Vec<Size>) -> Size

impl Print for Value

fn fmt_with( &self, f: &mut Formatter<'_>, options: &Options, indent: usize ) -> Result<(), Error>

fn pretty_print(&self) -> Printed<'_, Self>

Print the value with Options::pretty options.

fn compact_print(&self) -> Printed<'_, Self>

Print the value with Options::compact options.

fn inline_print(&self) -> Printed<'_, Self>

Print the value with Options::inline options.

fn print_with(&self, options: Options) -> Printed<'_, Self>

Print the value with the given options.

impl PrintWithSize for Value

fn fmt_with_size( &self, f: &mut Formatter<'_>, options: &Options, indent: usize, sizes: &[Size], index: &mut usize ) -> Result<(), Error>

impl TryFrom<f32> for Value

type Error = TryFromFloatError

The type returned in the event of a conversion error.

fn try_from(n: f32) -> Result<Value, <Value as TryFrom<f32>>::Error>

Performs the conversion.

impl TryFrom<f64> for Value

type Error = TryFromFloatError

The type returned in the event of a conversion error.

fn try_from(n: f64) -> Result<Value, <Value as TryFrom<f64>>::Error>

Performs the conversion.

impl UnorderedPartialEq for Value

fn unordered_eq(&self, other: &Value) -> bool

impl Eq for Value

impl StructuralPartialEq for Value

impl UnorderedEq for Value