Struct Number 

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

A JSON number.

Implementations

impl<'json, 'p> Number<'json, 'p>

pub fn get(&mut self) -> Result<ParsedNumber<'_>, ParseNumberError>

Try to parse the number.

Errors

If parsing fails, this will return a ParseNumberError.

Examples found in repository

examples/format.rs (line 36)

    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)
            }
        }
    }

examples/debug.rs (line 24)

fn main() {
    let json = r#"{
        "one": 1,
        "array": [true, false, null],
        "object": {"pi": 3.14, "exp": 1e5, "ignore": "this"}
    }"#;

    let mut document = Document::new(json);

    // root
    let mut root = document
        .next()
        .expect("failed to parse document")
        .and_then(Any::object)
        .expect("failed to get an object from the document");

    // "one"
    let element = root.next().expect("failed to parse object");
    let Some((key, Any::Number(mut one))) = element else {
        panic!("failed to get a number from the object");
    };
    let one = one.get().expect("failed to parse number");

    assert_eq!(key, "one");
    assert_eq!(one.as_u8(), Some(1));

    // "array"
    let element = root.next().expect("failed to parse object");
    let Some((key, Any::Array(mut array))) = element else {
        panic!("failed to get an array from the object");
    };

    assert_eq!(key, "array");

    // "array" -> 0
    let mut r#true = array
        .next()
        .expect("failed to parse array")
        .and_then(Any::literal)
        .expect("failed to get a true value from the array");

    // debug print the true literal
    println!("{true:#?}");

    let r#true = r#true.get().expect("failed to parse a true value");
    assert_eq!(r#true, true);

    // skip the rest of "array"
    array.finish().expect("failed to parse array");

    // skip the rest of root
    root.finish().expect("failed to parse object");

    // finish document
    document.finish().expect("failed to parse document");
}

examples/no_std.rs (line 26)

fn main() {
    let json = r#"{
        "one": 1,
        "array": [true, false, null],
        "object": {"pi": 3.14, "exp": 1e5, "ignore": "this"}
    }"#;

    let mut document = Document::new(json);

    // root
    let mut root = document
        .next()
        .expect("failed to parse document")
        .and_then(Any::object)
        .expect("failed to get an object from the document");

    // "one"
    let element = root.next().expect("failed to parse object");
    let Some((key, Any::Number(mut one))) = element else {
        panic!("failed to get a number from the object");
    };
    let one = one.get().expect("failed to parse number");

    assert_eq!(key, "one");
    assert_eq!(one.as_u8(), Some(1));

    // "array"
    let element = root.next().expect("failed to parse object");
    let Some((key, Any::Array(mut array))) = element else {
        panic!("failed to get an array from the object");
    };

    assert_eq!(key, "array");

    // "array" -> 0
    let r#true = array
        .next()
        .expect("failed to parse array")
        .and_then(Any::literal)
        .expect("failed to get a true value from the array")
        .get()
        .expect("failed to parse a true value");

    assert_eq!(r#true, true);

    // "array" -> 1
    let r#false = array
        .next()
        .expect("failed to parse array")
        .and_then(Any::literal)
        .expect("failed to get a false value from the array")
        .get()
        .expect("failed to parse a false value");

    assert_eq!(r#false, false);

    // "array" -> 2
    let null = array
        .next()
        .expect("failed to parse array")
        .and_then(Any::literal)
        .expect("failed to get a null value from the array")
        .get()
        .expect("failed to parse a null value");

    assert_eq!(null, None);

    // finish "array"
    let array_element = array.next().expect("failed to parse array");
    assert!(array_element.is_none());

    // "object"
    let element = root.next().expect("failed to parse object");
    let Some((key, Any::Object(mut object))) = element else {
        panic!("failed to get an object from the object");
    };

    assert_eq!(key, "object");

    // "object" -> "pi"
    let object_element = object.next().expect("failed to parse inner object");
    let Some((key, Any::Number(mut pi))) = object_element else {
        panic!("failed to get a number from the inner object");
    };
    let pi = pi.get().expect("failed to parse a number");

    assert_eq!(key, "pi");
    assert_eq!(pi, 3.14);

    // "object" -> "exp"
    let object_element = object.next().expect("failed to parse inner object");
    let Some((key, Any::Number(mut exp))) = object_element else {
        panic!("failed to get a number from the inner object");
    };
    let exp = exp.get().expect("failed to parse a number");

    assert_eq!(key, "exp");
    assert_eq!(exp.as_f32(), 1e5);

    // skip the rest of "object"
    object.finish().expect("failed to parse inner object");

    // finish root
    root.finish().expect("failed to parse object");

    // finish document
    document.finish().expect("failed to parse document");
}

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

Finish parsing the number 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 ParseNumberError.

Trait Implementations

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

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

Formats the value using the given formatter.