Struct LazyValue

pub struct LazyValue<'a> { /* private fields */ }

LazyValue wrappers a unparsed raw JSON text. It is borrowed from the origin JSON text.

LazyValue can be get, get_unchecked or deserialize from a JSON text.

Examples

use sonic_rs::{get, JsonValueTrait, LazyValue, Value};

// get a lazyvalue from a json, the "a"'s value will not be parsed
let input = r#"{
 "a": "hello world",
 "b": true,
 "c": [0, 1, 2],
 "d": {
    "sonic": "rs"
  }
}"#;
let lv_a: LazyValue = get(input, &["a"]).unwrap();
let lv_c: LazyValue = get(input, &["c"]).unwrap();

// use as_raw_xx to get the unparsed JSON text
assert_eq!(lv_a.as_raw_str(), "\"hello world\"");
assert_eq!(lv_c.as_raw_str(), "[0, 1, 2]");

// use as_xx to get the parsed value
assert_eq!(lv_a.as_str().unwrap(), "hello world");
assert_eq!(lv_c.as_str(), None);
assert!(lv_c.is_array());

Serde Examples

LazyValue<'a> can only be deserialized with borrowed. If need to be owned, use OwnedLazyValue.

use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, Serialize, PartialEq)]
struct TestLazyValue<'a> {
    #[serde(borrow)]
    borrowed_lv: LazyValue<'a>,
}

let input = r#"{ "borrowed_lv": "hello"}"#;

let data: TestLazyValue = sonic_rs::from_str(input).unwrap();
assert_eq!(data.borrowed_lv.as_raw_str(), "\"hello\"");

Convert to serde_json::Value

LazyValue<'a> can convert into serde_json::Value from bytes slice.

 use sonic_rs::{pointer, JsonValueTrait};

 let json: &str = r#"{
     "bool": true,
     "int": -1,
     "uint": 0,
     "float": 1.1,
     "string": "hello",
     "string_escape": "\"hello\"",
     "array": [1,2,3],
     "object": {"a":"aaa"},
     "strempty": "",
     "objempty": {},
     "arrempty": []
 }"#;
 let lazy_value = sonic_rs::get(json, pointer![].iter()).unwrap();

 for (key, expect_value) in [
     ("bool", serde_json::json!(true)),
     ("int", serde_json::json!(-1)),
     ("uint", serde_json::json!(0)),
     ("float", serde_json::json!(1.1)),
     ("string", serde_json::json!("hello")),
     ("string_escape", serde_json::json!("\"hello\"")),
     ("array", serde_json::json!([1, 2, 3])),
     ("object", serde_json::json!({"a":"aaa"})),
     ("strempty", serde_json::json!("")),
     ("objempty", serde_json::json!({})),
     ("arrempty", serde_json::json!([])),
 ] {
     let value = lazy_value.get(key);

     let trans_value =
         serde_json::from_slice::<serde_json::Value>(value.unwrap().as_raw_str().as_bytes())
             .unwrap();
     assert_eq!(trans_value, expect_value);
     println!("checked {key} with {trans_value:?}");
 }

Implementations

impl<'a> LazyValue<'a>

pub fn as_raw_str(&self) -> &str

Export the raw JSON text as str.

Examples

use sonic_rs::{get, LazyValue};

let lv: LazyValue = sonic_rs::get(r#"{"a": "hello world"}"#, &["a"]).unwrap();
assert_eq!(lv.as_raw_str(), "\"hello world\"");

pub fn as_raw_cow(&self) -> Cow<'a, str>

Export the raw JSON text as Cow<'de, str>. The lifetime 'de is the origin JSON.

Examples

use sonic_rs::{get, LazyValue};

let lv: LazyValue = sonic_rs::get(r#"{"a": "hello world"}"#, &["a"]).unwrap();
assert_eq!(lv.as_raw_cow(), "\"hello world\"");

pub fn as_raw_faststr(&self) -> FastStr

Export the raw json text as faststr.

Note

If the input json is not bytes or faststr, there will be a string copy.

Examples

use faststr::FastStr;
use sonic_rs::LazyValue;

let lv: LazyValue = sonic_rs::get(r#"{"a": "hello world"}"#, &["a"]).unwrap();
// will copy the raw_str into a new faststr
assert_eq!(lv.as_raw_faststr(), "\"hello world\"");

let fs = FastStr::new(r#"{"a": "hello world"}"#);
let lv: LazyValue = sonic_rs::get(&fs, &["a"]).unwrap();
assert_eq!(lv.as_raw_faststr(), "\"hello world\""); // zero-copy

Trait Implementations

impl<'a> Clone for LazyValue<'a>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for LazyValue<'a>

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

Formats the value using the given formatter.

impl Default for LazyValue<'_>

fn default() -> Self

Returns the “default value” for a type.

impl<'de: 'a, 'a> Deserialize<'de> for LazyValue<'a>

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> Display for LazyValue<'a>

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

Formats the value using the given formatter.

impl<'de> From<LazyValue<'de>> for OwnedLazyValue

fn from(lv: LazyValue<'de>) -> Self

Converts to this type from the input type.

impl<'a> Hash for LazyValue<'a>

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<'a> JsonValueTrait for LazyValue<'a>

type ValueType<'v> = LazyValue<'v> where Self: 'v

fn as_bool(&self) -> Option<bool>

Returns the bool if self is a boolean.

fn as_number(&self) -> Option<Number>

Returns the Number if self is a Number.

fn as_raw_number(&self) -> Option<RawNumber>

Returns the RawNumber without precision loss if self is a Number.

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

Returns the str if self is a string.

fn get_type(&self) -> JsonType

Gets the type of the value. Returns JsonType::Null as default if self is Option::None or Result::Err(_).

fn get<I: Index>(&self, index: I) -> Option<LazyValue<'_>>

Index into a JSON array or map. A string-like 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.

fn pointer<P: IntoIterator>(&self, path: P) -> Option<LazyValue<'_>>

where P::Item: Index,

Looks up a value by a path.

fn is_boolean(&self) -> bool

Returns true if the value is a bool.

fn is_true(&self) -> bool

Returns true if the value is true.

fn is_false(&self) -> bool

Returns true if the value is false.

fn is_null(&self) -> bool

Returns true if the self value is null.

fn is_number(&self) -> bool

Returns true if the value is a number.

fn is_str(&self) -> bool

Returns true if the value is a string.

fn is_array(&self) -> bool

Returns true if the value is an array.

fn is_object(&self) -> bool

Returns true if the value is an object.

fn is_f64(&self) -> bool

Returns true if the value is a number and it is an f64. It will returns false if the value is a u64 or i64.

fn is_i64(&self) -> bool

Returns true if the value is a integer number and it between i64::MIN and i64::MAX

fn is_u64(&self) -> bool

Returns true if the value is a integer number and it between 0 and i64::MAX

fn as_i64(&self) -> Option<i64>

If self meets is_i64, represent it as i64 if possible. Returns None otherwise.

fn as_u64(&self) -> Option<u64>

If self meets is_i64, represent it as u64 if possible. Returns None otherwise.

fn as_f64(&self) -> Option<f64>

If self is a number, represent it as f64 if possible. Returns None otherwise. The integer number will be converted to f64.

impl<'a> Ord for LazyValue<'a>

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.

impl PartialEq for LazyValue<'_>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for LazyValue<'_>

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<'a> Serialize for LazyValue<'a>

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'de> TryFrom<LazyValue<'de>> for Value

Try parse a LazyValue into a Value. LazyValue is always a valid JSON, at least it is followed the JSON syntax.

However, in some cases, the parse will failed and return errors, such as the float number in JSON is inifity.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: LazyValue<'de>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> Eq for LazyValue<'a>