Enum json_syntax::Value

pub enum Value<M = ()> {
    Null,
    Boolean(bool),
    Number(NumberBuf),
    String(String),
    Array(Array<M>),
    Object(Object<M>),
}

Value.

The type parameter M is the type of metadata attached to each syntax node (values, sub values and object keys). The metadata is derived from the locspan::Span of the node in the source document using the metadata builder function passed to the parsing function (see the Parse trait for more details).

Parsing

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

Example

use json_syntax::{Value, Parse};
use locspan::{Meta, Span};

let value: Meta<Value<Span>, Span> = Value::parse_str("{ \"key\": \"value\" }", |span| span).unwrap();

You don’t need to specify the return type, here only shown to make it clear. Furthermore the MetaValue<Span> type alias can be used instead of Meta<Value<Span>, Span> to avoid repetition of the metadata type.

Comparison

This type implements the usual comparison traits PartialEq, Eq, PartialOrd and Ord. However these implementations will also compare the metadata. If you want to do comparisons while ignoring ths metadata, you can use the locspan::Stripped type (combined with the locspan::BorrowStripped trait).

Example

use json_syntax::{Value, Parse};
use locspan::BorrowStripped;

let a = Value::parse_str("null", |_| 0).unwrap();
let b = Value::parse_str("null", |_| 1).unwrap();

assert_ne!(a, b); // not equals because the metadata is different.
assert_eq!(a.stripped(), b.stripped()); // equals because the metadata is ignored.

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 ]", |span| span).unwrap();

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)

Number.

String(String)

String.

Array(Array<M>)

Array.

Object(Object<M>)

Object.

Implementations

impl<M> Value<M>

pub fn from_serde_json(
    value: Value,
    f: impl Clone + Fn(SerdeJsonFragment<'_>) -> M
) -> Meta<Self, M>

Converts a serde_json::Value into a Value.

The function f is used to annotate the output each sub value (passed as parameter).

Examples found in repository

src/convert/serde_json.rs (line 31)

	pub fn from_serde_json(
		value: serde_json::Value,
		f: impl Clone + Fn(SerdeJsonFragment) -> M,
	) -> Meta<Self, M> {
		let meta = f(SerdeJsonFragment::Value(&value));

		let v = match value {
			serde_json::Value::Null => Self::Null,
			serde_json::Value::Bool(b) => Self::Boolean(b),
			serde_json::Value::Number(n) => Self::Number(n.into()),
			serde_json::Value::String(s) => Self::String(s.into()),
			serde_json::Value::Array(a) => Self::Array(
				a.into_iter()
					.map(|i| Self::from_serde_json(i, f.clone()))
					.collect(),
			),
			serde_json::Value::Object(o) => Self::Object(
				o.into_iter()
					.map(|(k, v)| {
						let k_meta = f(SerdeJsonFragment::Key(&k));
						Entry::new(Meta(k.into(), k_meta), Self::from_serde_json(v, f.clone()))
					})
					.collect(),
			),
		};

		Meta(v, meta)
	}

	/// Converts a `Value` into a [`serde_json::Value`], stripping the metadata.
	pub fn into_serde_json(Meta(this, _): Meta<Self, M>) -> serde_json::Value {
		this.into()
	}
}

impl<M: Default> From<serde_json::Value> for Value<M> {
	#[inline(always)]
	fn from(value: serde_json::Value) -> Self {
		Value::from_serde_json(value, |_| M::default()).into_value()
	}

pub fn into_serde_json(Meta: Meta<Self, M>) -> Value

Converts a Value into a serde_json::Value, stripping the metadata.

Examples found in repository

src/convert/serde_json.rs (line 74)

	fn from(value: Value<M>) -> Self {
		match value {
			Value::Null => Self::Null,
			Value::Boolean(b) => Self::Bool(b),
			Value::Number(n) => Self::Number(n.into()),
			Value::String(s) => Self::String(s.into_string()),
			Value::Array(a) => Self::Array(a.into_iter().map(Value::into_serde_json).collect()),
			Value::Object(o) => Self::Object(
				o.into_iter()
					.map(
						|Entry {
						     key: Meta(key, _),
						     value,
						 }| { (key.into_string(), Value::into_serde_json(value)) },
					)
					.collect(),
			),
		}
	}

impl<M> Value<M>

pub fn kind(&self) -> Kind

Examples found in repository

src/lib.rs (line 233)

	pub fn is_kind(&self, kind: Kind) -> bool {
		self.kind() == 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>

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

Examples found in repository

src/lib.rs (line 319)

	pub fn as_str(&self) -> Option<&str> {
		self.as_string()
	}

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

Alias for as_string.

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

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

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

pub fn force_as_array(value: &Meta<Self, M>) -> Meta<&[Meta<Self, M>], &M>

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<M>>

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

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

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

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

pub fn into_array(self) -> Option<Array<M>>

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

pub fn traverse(&self) -> TraverseStripped<'_, M>

Examples found in repository

src/lib.rs (line 422)

	pub fn count(&self, mut f: impl FnMut(StrippedFragmentRef<M>) -> bool) -> usize {
		self.traverse().filter(|i| f(*i)).count()
	}

	/// 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(StrippedFragmentRef::is_value).count()`.
	pub fn volume(&self) -> usize {
		self.traverse()
			.filter(StrippedFragmentRef::is_value)
			.count()
	}

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

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

Examples found in repository

src/print.rs (line 799)

	fn fmt_with(&self, f: &mut fmt::Formatter, options: &Options, indent: usize) -> fmt::Result {
		match self {
			Self::Null => f.write_str("null"),
			Self::Boolean(b) => b.fmt_with(f, options, indent),
			Self::Number(n) => n.fmt_with(f, options, indent),
			Self::String(s) => s.fmt_with(f, options, indent),
			Self::Array(a) => {
				let mut sizes = Vec::with_capacity(self.count(|v| v.is_array() || v.is_object()));
				self.pre_compute_size(options, &mut sizes);
				let mut index = 0;
				a.fmt_with_size(f, options, indent, &sizes, &mut index)
			}
			Self::Object(o) => {
				let mut sizes = Vec::with_capacity(self.count(|v| v.is_array() || v.is_object()));
				self.pre_compute_size(options, &mut sizes);
				let mut index = 0;
				o.fmt_with_size(f, options, indent, &sizes, &mut index)
			}
		}
	}

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(StrippedFragmentRef::is_value).count().

pub fn map_metadata<N>(self, f: impl FnMut(M) -> N) -> Value<N>

Recursively maps the metadata inside the value.

Examples found in repository

src/lib.rs (line 446)

	pub fn map_metadata<N>(self, mut f: impl FnMut(M) -> N) -> Value<N> {
		match self {
			Self::Null => Value::Null,
			Self::Boolean(b) => Value::Boolean(b),
			Self::Number(n) => Value::Number(n),
			Self::String(s) => Value::String(s),
			Self::Array(a) => Value::Array(
				a.into_iter()
					.map(|Meta(item, meta)| Meta(item.map_metadata(&mut f), f(meta)))
					.collect(),
			),
			Self::Object(o) => Value::Object(o.map_metadata(f)),
		}
	}

	/// Tries to recursively maps the metadata inside the value.
	pub fn try_map_metadata<N, E>(
		self,
		mut f: impl FnMut(M) -> Result<N, E>,
	) -> Result<Value<N>, E> {
		match self {
			Self::Null => Ok(Value::Null),
			Self::Boolean(b) => Ok(Value::Boolean(b)),
			Self::Number(n) => Ok(Value::Number(n)),
			Self::String(s) => Ok(Value::String(s)),
			Self::Array(a) => {
				let mut items = Vec::with_capacity(a.len());
				for item in a {
					items.push(item.try_map_metadata_recursively(&mut f)?)
				}
				Ok(Value::Array(items))
			}
			Self::Object(o) => Ok(Value::Object(o.try_map_metadata(f)?)),
		}
	}

	/// Move and return the value, leaves `null` in its place.
	#[inline(always)]
	pub fn take(&mut self) -> Self {
		let mut result = Self::Null;
		std::mem::swap(&mut result, self);
		result
	}

	/// Puts this JSON value in canonical form according to
	/// [RFC 8785](https://www.rfc-editor.org/rfc/rfc8785).
	///
	/// The given `buffer` is used to canonicalize the number values.
	#[cfg(feature = "canonicalize")]
	pub fn canonicalize_with(&mut self, buffer: &mut ryu_js::Buffer) {
		match self {
			Self::Number(n) => *n = NumberBuf::from_number(n.canonical_with(buffer)),
			Self::Array(a) => {
				for item in a {
					item.canonicalize_with(buffer)
				}
			}
			Self::Object(o) => o.canonicalize_with(buffer),
			_ => (),
		}
	}

	/// Puts this JSON value in canonical form according to
	/// [RFC 8785](https://www.rfc-editor.org/rfc/rfc8785).
	#[cfg(feature = "canonicalize")]
	pub fn canonicalize(&mut self) {
		let mut buffer = ryu_js::Buffer::new();
		self.canonicalize_with(&mut buffer)
	}
}

pub trait Traversal<'a> {
	type Fragment;
	type Traverse: Iterator<Item = Self::Fragment>;

	fn traverse(&'a self) -> Self::Traverse;
}

impl<'a, M: 'a> Traversal<'a> for Meta<Value<M>, M> {
	type Fragment = FragmentRef<'a, M>;
	type Traverse = Traverse<'a, M>;

	fn traverse(&'a self) -> Self::Traverse {
		let mut stack = SmallVec::new();
		stack.push(FragmentRef::Value(self));
		Traverse { stack }
	}
}

impl<M, N> locspan::MapMetadataRecursively<M, N> for Value<M> {
	type Output = Value<N>;

	fn map_metadata_recursively<F: FnMut(M) -> N>(self, f: F) -> Value<N> {
		self.map_metadata(f)
	}

pub fn try_map_metadata<N, E>(
    self,
    f: impl FnMut(M) -> Result<N, E>
) -> Result<Value<N>, E>

Tries to recursively maps the metadata inside the value.

Examples found in repository

src/lib.rs (line 542)

	fn try_map_metadata_recursively<F: FnMut(M) -> Result<N, E>>(
		self,
		f: F,
	) -> Result<Value<N>, E> {
		self.try_map_metadata(f)
	}

pub fn take(&mut self) -> Self

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

Trait Implementations

impl<M: Clone> Clone for Value<M>

fn clone(&self) -> Value<M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for Value<M>

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

fn from(n: NumberBuf) -> Self

Converts to this type from the input type.

impl<M> From<Object<M>> for Value<M>

fn from(o: Object<M>) -> Self

Converts to this type from the input type.

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

fn from(s: String) -> Self

Converts to this type from the input type.

impl<M> From<String> for Value<M>

fn from(s: String) -> Self

Converts to this type from the input type.

impl<M> From<Value<M>> for Value

fn from(value: Value<M>) -> Self

Converts to this type from the input type.

impl<M: Default> From<Value> for Value<M>

fn from(value: Value) -> Self

Converts to this type from the input type.

impl<M> From<Vec<Meta<Value<M>, M>, Global>> for Value<M>

fn from(a: Array<M>) -> Self

Converts to this type from the input type.

impl<M> From<bool> for Value<M>

fn from(b: bool) -> Self

Converts to this type from the input type.

impl<M> From<i16> for Value<M>

fn from(n: i16) -> Self

Converts to this type from the input type.

impl<M> From<i32> for Value<M>

fn from(n: i32) -> Self

Converts to this type from the input type.

impl<M> From<i64> for Value<M>

fn from(n: i64) -> Self

Converts to this type from the input type.

impl<M> From<i8> for Value<M>

fn from(n: i8) -> Self

Converts to this type from the input type.

impl<M> From<u16> for Value<M>

fn from(n: u16) -> Self

Converts to this type from the input type.

impl<M> From<u32> for Value<M>

fn from(n: u32) -> Self

Converts to this type from the input type.

impl<M> From<u64> for Value<M>

fn from(n: u64) -> Self

Converts to this type from the input type.

impl<M> From<u8> for Value<M>

fn from(n: u8) -> Self

Converts to this type from the input type.

impl<M: Hash> Hash for Value<M>

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<M, N> MapMetadataRecursively<M, N> for Value<M>

type Output = Value<N>

fn map_metadata_recursively<F: FnMut(M) -> N>(self, f: F) -> Value<N>

Maps the metadata, recursively.

impl<M: Ord> Ord for Value<M>

fn cmp(&self, other: &Value<M>) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<M> Parse<M> for Value<M>

fn parse_spanned<C, F, E>(
    parser: &mut Parser<C, F, E>,
    context: Context
) -> Result<Meta<Self, Span>, Meta<Error<M, E>, M>>where
    C: Iterator<Item = Result<DecodedChar, E>>,
    F: FnMut(Span) -> M,

fn parse_str<F>(
    content: &str,
    metadata_builder: F
) -> Result<Meta<Self, M>, Meta<Error<M>, M>>where
    F: FnMut(Span) -> M,

fn parse_str_with<F>(
    content: &str,
    options: Options,
    metadata_builder: F
) -> Result<Meta<Self, M>, Meta<Error<M>, M>>where
    F: FnMut(Span) -> M,

fn parse_infallible_utf8<C, F>(
    chars: C,
    metadata_builder: F
) -> Result<Meta<Self, M>, Meta<Error<M>, M>>where
    C: Iterator<Item = char>,
    F: FnMut(Span) -> M,

fn parse_utf8_infallible_with<C, F>(
    chars: C,
    options: Options,
    metadata_builder: F
) -> Result<Meta<Self, M>, Meta<Error<M>, M>>where
    C: Iterator<Item = char>,
    F: FnMut(Span) -> M,

fn parse_utf8<C, F, E>(
    chars: C,
    metadata_builder: F
) -> Result<Meta<Self, M>, Meta<Error<M, E>, M>>where
    C: Iterator<Item = Result<char, E>>,
    F: FnMut(Span) -> M,

fn parse_utf8_with<C, F, E>(
    chars: C,
    options: Options,
    metadata_builder: F
) -> Result<Meta<Self, M>, Meta<Error<M, E>, M>>where
    C: Iterator<Item = Result<char, E>>,
    F: FnMut(Span) -> M,

fn parse_infallible<C, F>(
    chars: C,
    metadata_builder: F
) -> Result<Meta<Self, M>, Meta<Error<M>, M>>where
    C: Iterator<Item = DecodedChar>,
    F: FnMut(Span) -> M,

fn parse_infallible_with<C, F>(
    chars: C,
    options: Options,
    metadata_builder: F
) -> Result<Meta<Self, M>, Meta<Error<M>, M>>where
    C: Iterator<Item = DecodedChar>,
    F: FnMut(Span) -> M,

fn parse<C, F, E>(
    chars: C,
    metadata_builder: F
) -> Result<Meta<Self, M>, Meta<Error<M, E>, M>>where
    C: Iterator<Item = Result<DecodedChar, E>>,
    F: FnMut(Span) -> M,

fn parse_with<C, F, E>(
    chars: C,
    options: Options,
    metadata_builder: F
) -> Result<Meta<Self, M>, Meta<Error<M, E>, M>>where
    C: Iterator<Item = Result<DecodedChar, E>>,
    F: FnMut(Span) -> M,

fn parse_in<C, F, E>(
    parser: &mut Parser<C, F, E>,
    context: Context
) -> Result<Meta<Self, M>, Meta<Error<M, E>, M>>where
    C: Iterator<Item = Result<DecodedChar, E>>,
    F: FnMut(Span) -> M,

impl<M: PartialEq> PartialEq<Value<M>> for Value<M>

fn eq(&self, other: &Value<M>) -> 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<M: PartialOrd> PartialOrd<Value<M>> for Value<M>

fn partial_cmp(&self, other: &Value<M>) -> 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<M> PrecomputeSize for Value<M>

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

impl<M> Print for Value<M>

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

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<M> PrintWithSize for Value<M>

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

impl<M> StrippedHash for Value<M>

fn stripped_hash<H: Hasher>(&self, state: &mut H)

impl<M> StrippedOrd for Value<M>

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

impl<M, __M> StrippedPartialEq<Value<__M>> for Value<M>

fn stripped_eq(&self, other: &Value<__M>) -> bool

impl<M, __M> StrippedPartialOrd<Value<__M>> for Value<M>

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

impl<M> TryFrom<f32> for Value<M>

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<M> TryFrom<f64> for Value<M>

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.

impl<M, N, E> TryMapMetadataRecursively<M, N, E> for Value<M>

type Output = Value<N>

fn try_map_metadata_recursively<F: FnMut(M) -> Result<N, E>>(
    self,
    f: F
) -> Result<Value<N>, E>

Tries to map the metadata, recursively.

impl<M: Eq> Eq for Value<M>

impl<M> StrippedEq for Value<M>

impl<M> StructuralEq for Value<M>

impl<M> StructuralPartialEq for Value<M>