Enum JsonValue 

pub enum JsonValue<'a> {
    Raw(&'a [u8]),
    String(&'a str),
    Number(&'a [u8]),
    Bool(bool),
    Null,
    Array(LazyArray<'a>),
    Object(LazyObject<'a>),
}

Zero-copy JSON value representation

Variants

Raw(&'a [u8])

Raw bytes slice (not parsed yet)

String(&'a str)

Parsed string (zero-copy)

Number(&'a [u8])

Number stored as bytes for lazy parsing

Bool(bool)

Boolean value

Null

Null value

Array(LazyArray<'a>)

Array with lazy evaluation

Object(LazyObject<'a>)

Object with lazy evaluation

Implementations

impl<'a> JsonValue<'a>

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

Get value as string if it’s a string type

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

Get value as f64 if it’s a number

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

Get value as i64 if it’s an integer number

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

Get value as bool if it’s a boolean

pub fn is_null(&self) -> bool

Check if value is null

pub fn as_array(&self) -> Option<&LazyArray<'a>>

Get value as array

pub fn as_object(&self) -> Option<&LazyObject<'a>>

Get value as object

pub fn parse_raw(&mut self) -> Result<()>

Force parse raw bytes into the appropriate structured variant.

Classifies the underlying bytes by their first non-whitespace character and replaces JsonValue::Raw with the matching typed variant (Null, Bool, Number, String, Array, or Object). Variants other than Raw are left unchanged.

Numbers, strings, arrays, and objects keep zero-copy semantics by borrowing from the original byte slice. Strings containing escape sequences cannot be represented in JsonValue::String<&str> without allocation and are rejected.

Errors

Returns Error::InvalidJson when the bytes are empty, contain an unterminated string, contain an escaped string (zero-copy not possible), or do not begin with a recognised JSON token. Returns Error::Utf8 when string contents are not valid UTF-8.

Examples

use pjson_rs::parser::JsonValue;

let mut v = JsonValue::Raw(b"42");
v.parse_raw().unwrap();
assert_eq!(v.as_i64(), Some(42));

let mut v = JsonValue::Raw(b"\"hello\"");
v.parse_raw().unwrap();
assert_eq!(v.as_str(), Some("hello"));

Trait Implementations

impl<'a> Clone for JsonValue<'a>

fn clone(&self) -> JsonValue<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for JsonValue<'a>

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

Formats the value using the given formatter.