[−][src]Enum jsondata::Json

pub enum Json {
    Null,
    Bool(bool),
    Integer(Integral),
    Float(Floating),
    String(String),
    Array(Vec<Json>),
    Object(Vec<Property>),
    // some variants omitted
}

Json type implements JavaScript Object Notation as per specification RFC-8259.

JSON scalar types - Null, Number, Boolean, String, are supported.
JSON container types - Array, Object, are supported.
JSON numbers can be 128-bit integers or 64-bit floating point.
When document is known to contain lot of numbers and only one of them needs to be extracted, parsing the entire document can be inefficient just to get that one field. Numbers are implemented with deferred conversion, using Integral and Floating types.
Arrays are implemented as vector of Json values Vec<Json>.
Objects are implemented as vector of properties, Vec<Property>, where each property is a tuple of (key, value). Here key is String type and value is Json type.

Json enum type has documented variants and undocumented variants. Applications, when matching with Json, must use the catch-all variant:

match json {
    Json::Null => // handle null,
    Json::Bool(b) => // handle bool,
    Json::Integer(i) => // handle integer,
    Json::Float(f) => // handle float,
    Json::String(s) => // handle string,
    Json::Array(a) => // handle array,
    Json::Object(o) => // handle object,
    _ => // catch all.
}

Parsing JSON text:

let json: jsondata::Json = "10".parse().unwrap();

return a Json enum type.

Converting Rust native types to Json enum:

Json supports conversion from bool, i128, f64, String, &str, Vec<Json> and Vec<Property> types using the From trait.

let json: jsondata::Json = 10.into();
let json: jsondata::Json = true.into();
let json: jsondata::Json = "hello world".into();

On the other direction, Json enum can be converted to Rust native types using accessor methods,

is_null() to check whether Json is Null
boolean(), integer(), float(), string() methods return the underlying value as Option<T> where T is bool or i128 or f64 or String.
array(), return JSON array as Vec<Json>.
object(), return JSON object as Vec<Property>.

Some of the properties implemented for Json are:

Json implements total ordering.
Default value for Json is Null.
Json types are clone-able but do not implement Copy.
Json value can be serialized into JSON format using Display trait.

Panics

Json implements AsRef and AsMut traits for str, Vec<Json>, Vec<Property> types. This means, call to as_ref() and as_mut() shall panic when underlying Json variant do not match with expected type.

Variants

NullBool(bool)Integer(Integral)Float(Floating)String(String)Array(Vec<Json>)Object(Vec<Property>)

Methods

`impl Json`[src]

Implementation provides methods to construct and validate Json values.

`pub fn new<T>(value: T) -> Json where Self: From<T>,` [src]

Construct Json from bool, i128, f64, String, str, Vec.

Array can be composed as:

use jsondata::Json;

let mut js = Json::new::<Vec<Json>>(Vec::new());
js.append("", Json::new(10));
js.append("", Json::new("hello world".to_string()));

It is also possible to construct the vector of Json outside the append() method, and finally use Json::new() to construct the array.

Object can be composed as:

use jsondata::{Json, Property};

let mut js = Json::new::<Vec<Property>>(Vec::new());
js.set("/key1", Json::new(10));
js.set("/key2", Json::new(true));

It is also possible to construct the vector of properties outside the set() method, and finally use Json::new() to construct the object.

`pub fn validate(&mut self) -> Result<()>`[src]

Validate parts of JSON text that are not yet parsed. Typically, when used in database context, JSON documents are validated once but parsed multiple times.

`pub fn compute(&mut self) -> Result<()>`[src]

Compute parses unparsed text and convert them into numbers. When a JSON document is parsed once but operated on multiple times it is better to call compute for better performance.

use jsondata::Json;

let text = r#"[null,true,false,10,"true"]"#;
let mut json: Json = text.parse().unwrap();
json.compute();

// perform lookup and arithmetic operations on parsed document.

`impl Json`[src]

Implementation provides CRUD access into Json document using Json Pointer. For all methods,

Path must be valid JSON Pointer.
Path fragment must be valid key if parent container is an object.
Path fragment must be a number index if parent container is an array.

`pub fn get(&self, path: &str) -> Result<Json>`[src]

Get a json field, within the document, locatable by path.

`pub fn set(&mut self, path: &str, value: Json) -> Result<()>`[src]

Set a json field, within the document, locatable by path.

`pub fn delete(&mut self, path: &str) -> Result<()>`[src]

Delete a JSON field, within the document, locatable by path.

`pub fn append(&mut self, path: &str, value: Json) -> Result<()>`[src]

Append a string or array to a JSON field within the document that is either a string or array.

`pub fn range<R>(&self, range: R) -> Json where R: RangeBounds<isize>,` [src]

Range operation on Json array,

Range [start..end].
RangeFrom [start..].
RangeFull [..].
RangeInclusive [start..=end].
RangeTo [..end].
RangeToInclusive [..=end].

If range is called on non array Json, returns a Json Error.

`impl Json`[src]

Implementation clones underlying type for each Json variant. The return value is always an Option because JSON follows a schema-less data representation.