Struct JsonNumber 

pub struct JsonNumber { /* private fields */ }

A JSON number that preserves its exact, validated source representation.

Parsing never silently rounds or truncates: the original token is kept verbatim and conversions to i64/u64/f64 are explicit and fallible. Equality is structural over the representation — 1.0, 1, and 1e0 are distinct JsonNumbers. Compare numerically by converting first.

Implementations

impl JsonNumber

pub fn new(input: &str) -> Result<Self, JsonNumberError>

Creates a number from a string, validating it against the strict JSON number grammar (no leading +, no leading zeros, no NaN/Infinity).

pub fn as_str(&self) -> &str

Returns the exact source representation.

pub fn is_integer(&self) -> bool

Returns true if the representation has no fraction or exponent.

pub fn to_i64(&self) -> Result<i64, JsonNumberError>

Converts to i64, or fails if the value is not an integer or is out of range.

pub fn to_u64(&self) -> Result<u64, JsonNumberError>

Converts to u64, or fails if the value is not a non-negative integer or is out of range.

Examples found in repository

examples/basic.rs (line 24)

fn main() {
    // Treat this as untrusted input: parse under a conservative limit profile.
    let input = r#"{ "service": "api", "port": 8080, "tags": ["a", "b"], "enabled": true }"#;
    let limits = JsonLimits::conservative();

    let value = match parse_with_limits(input.as_bytes(), limits) {
        Ok(value) => value,
        Err(err) => {
            eprintln!("rejected: {err}");
            return;
        }
    };

    if let JsonValue::Object(object) = &value {
        if let Some(port) = object.get("port").and_then(JsonValue::as_number) {
            println!("port = {}", port.to_u64().unwrap());
        }
        if let Some(tags) = object.get("tags").and_then(JsonValue::as_array) {
            println!("tags = {}", tags.len());
        }
    }

    // Deterministic, member-order-preserving serialization.
    println!("compact = {}", to_compact_string(&value));

    // Strict by default: these are all rejected.
    for bad in [r#"{"a":1,"a":2}"#, "{ /* c */ }", "[1,]", "NaN"] {
        match parse_with_limits(bad.as_bytes(), limits) {
            Ok(_) => println!("accepted (unexpected): {bad}"),
            Err(err) => println!("rejected {bad:?}: {}", err.kind_str()),
        }
    }
}

pub fn to_f64(&self) -> Result<f64, JsonNumberError>

Converts to f64. Fails only if the magnitude overflows f64 to infinity; ordinary rounding of the decimal value is not an error.

pub fn try_from_f64(value: f64) -> Result<Self, JsonNumberError>

Builds a number from an f64. Fails if the value is NaN or infinite.

Trait Implementations

impl Clone for JsonNumber

fn clone(&self) -> JsonNumber

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for JsonNumber

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

Formats the value using the given formatter.

impl Eq for JsonNumber

impl Hash for JsonNumber

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 PartialEq for JsonNumber

fn eq(&self, other: &JsonNumber) -> 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 StructuralPartialEq for JsonNumber