Struct String

pub struct String<'json, 'p> { /* private fields */ }

A JSON string.

Implementations

impl<'json, 'p> String<'json, 'p>

pub fn get(&mut self) -> Result<ParsedString<'json>, ParseStringError>

Try to parse the string. Note that escape sequences will not be evaluated!

Errors

If parsing the string fails, this will return a ParseStringError.

Examples found in repository

examples/format.rs (line 30)

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &mut *self.0.borrow_mut() {
            Any::String(string) => {
                let parsed = string.get().expect("failed to parse string");
                let raw = parsed.unescaped();
                write!(f, "{raw:?}")
            }

            Any::Number(number) => {
                let parsed = number.get().expect("failed to parse number");
                <number::ParsedNumber as fmt::Display>::fmt(&parsed, f)
            }

            Any::Object(object) => {
                let mut map = f.debug_map();

                while let Some((key, value)) = object.next().expect("failed to parse an object") {
                    let raw_key = key.unescaped();
                    map.entry(&raw_key, &Format(RefCell::new(value)));
                }

                map.finish()
            }

            Any::Array(array) => {
                let mut list = f.debug_list();

                while let Some(value) = array.next().expect("failed to parse an array") {
                    list.entry(&Format(RefCell::new(value)));
                }

                list.finish()
            }

            Any::Literal(literal) => {
                let parsed = literal.get().expect("failed to parse literal");
                <literal::ParsedLiteral as fmt::Display>::fmt(&parsed, f)
            }
        }
    }

pub fn finish(&mut self) -> Result<(), ParseStringError>

Finish parsing the string so that the parent can continue.

If Self::get has been called, this is not needed.

Errors

If parsing fails in this string, the error is returned as a ParseStringError.

Trait Implementations

impl<'json, 'p> Debug for String<'json, 'p>

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

Formats the value using the given formatter.