Struct RawJsonMember

Source

pub struct RawJsonMember<'text, 'raw, 'a> { /* private fields */ }

Expand description

Represents a member access result for a JSON object.

This struct is returned by RawJsonValue::to_member() and allows you to handle both present and missing object members. It wraps an optional value that is Some if the member exists and None if it doesn’t.

§Examples

let json = RawJson::parse(r#"{"name": "Alice", "age": 30}"#)?;
let obj = json.value();

// Access an existing member
let name_member = obj.to_member("name")?;
let name: String = name_member.required()?.try_into()?;
assert_eq!(name, "Alice");

// Access a missing member
let city_member = obj.to_member("city")?;
let city: Option<String> = city_member.try_into()?;
assert_eq!(city, None);

Implementations§

Source §

impl<'text, 'raw, 'a> RawJsonMember<'text, 'raw, 'a>

Source

pub fn required(self) -> Result<RawJsonValue<'text, 'raw>, JsonParseError>

Returns the member value if it exists, or an error if it’s missing.

This method is useful when you need to ensure that a required member is present in the JSON object.

§Examples

let json = RawJson::parse(r#"{"name": "Alice"}"#)?;
let obj = json.value();

// Required member exists
let name = obj.to_member("name")?.required()?;
assert_eq!(name.to_unquoted_string_str()?, "Alice");

// Required member missing - returns error
let age_result = obj.to_member("age")?.required();
assert!(age_result.is_err());

Source

pub fn get(self) -> Option<RawJsonValue<'text, 'raw>>

Returns the inner raw JSON value as an Option.

This method provides direct access to the underlying Option<RawJsonValue>, allowing you to handle the presence or absence of the member yourself.

§Examples

let json = RawJson::parse(r#"{"name": "Alice", "age": 30}"#)?;
let obj = json.value();

// Existing member
let name_member = obj.to_member("name")?;
if let Some(name_value) = name_member.get() {
    assert_eq!(name_value.to_unquoted_string_str()?, "Alice");
}

// Missing member
let city_member = obj.to_member("city")?;
assert!(city_member.get().is_none());

// Using with pattern matching
match obj.to_member("age")?.get() {
    Some(age_value) => {
        let age: i32 = age_value.as_integer_str()?.parse()
            .map_err(|e| age_value.invalid(e))?;
        assert_eq!(age, 30);
    }
    None => println!("Age not provided"),
}

Source

pub fn map<F, T>(self, f: F) -> Result<Option<T>, JsonParseError>
where F: FnOnce(RawJsonValue<'text, 'raw>) -> Result<T, JsonParseError>,

Applies a transformation function to the member value if it exists.

This method is similar to Option::map, but designed for transformations that can fail with a JsonParseError. If the member exists, the function is applied to its value. If the member doesn’t exist, Ok(None) is returned.

§Examples

let json = RawJson::parse(r#"{"name": "Alice", "age": "30"}"#)?;
let obj = json.value();

// Transform existing member
let age_member = obj.to_member("age")?;
let age: Option<i32> = age_member.map(|v| {
    v.to_unquoted_string_str()?.parse().map_err(|e| v.invalid(e))
})?;
assert_eq!(age, Some(30));

// Transform missing member
let city_member = obj.to_member("city")?;
let city: Option<String> = city_member.map(|v| v.try_into())?;
assert_eq!(city, None);

This is particularly useful when you need to perform parsing or validation on optional members without having to handle the Option separately:

let json = RawJson::parse(r#"{"score": "95.5"}"#)?;
let obj = json.value();

// Parse optional numeric string
let score: Option<f64> = obj.to_member("score")?.map(|v| {
    v.to_unquoted_string_str()?.parse().map_err(|e| v.invalid(e))
})?;
assert_eq!(score, Some(95.5));