Struct OwnedLazyValue

pub struct OwnedLazyValue { /* private fields */ }

OwnedLazyValue wrappers a unparsed raw JSON text. It is owned.

It can be converted from LazyValue. It can be used for serde.

Default value is a raw JSON text null.

Examples

use sonic_rs::{get, JsonValueTrait, OwnedLazyValue};

// 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 own_a = OwnedLazyValue::from(get(input, &["a"]).unwrap());
let own_c = OwnedLazyValue::from(get(input, &["c"]).unwrap());

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

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

Serde Examples

use serde::{Deserialize, Serialize};

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

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

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

Implementations

impl OwnedLazyValue

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_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 Clone for OwnedLazyValue

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OwnedLazyValue

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

Formats the value using the given formatter.

impl Default for OwnedLazyValue

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for OwnedLazyValue

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for OwnedLazyValue

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 Hash for OwnedLazyValue

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 JsonValueTrait for OwnedLazyValue

type ValueType<'v> = OwnedLazyValue

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

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

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

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 OwnedLazyValue

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 OwnedLazyValue

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 OwnedLazyValue

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for OwnedLazyValue