Struct DeserializerConfig

Source

pub struct DeserializerConfig { /* private fields */ }

Expand description

Configures how JSON is deserialized.

The configuration is independent of the input so it can be created once (even as a constant) and used for many inputs. The methods from_str and from_slice work like the functions of the same name. To create a Deserializer with the configuration use Deserializer::from_str_with_config or Deserializer::from_slice_with_config.

use deser_json::DeserializerConfig;

const CONFIG: DeserializerConfig =
    DeserializerConfig::new().exact_numbers(false);
let value: Vec<f64> = CONFIG.from_str("[0.10, 1e5]").unwrap();
assert_eq!(value, [0.1, 1e5]);

Implementations§

Source §

impl DeserializerConfig

Source

pub const fn new() -> DeserializerConfig

Creates the default configuration.

Source

pub const fn bytes(self, format: BytesFormat) -> DeserializerConfig

Sets how strings are decoded into bytes.

JSON has no bytes, types that expect bytes (like Vec<u8>) accept strings and sequences of integers instead. By default strings are decoded as base64, both with the standard and the URL-safe alphabet and with or without padding. This changes how strings are decoded, for BytesFormat::SEQ they are still decoded as base64.

let value: Vec<u8> =
    deser_json::from_str(r#""Af8=""#).unwrap();
assert_eq!(value, [1, 255]);
let value: Vec<u8> =
    deser_json::from_str(r#""Af8""#).unwrap();
assert_eq!(value, [1, 255]);
let value: Vec<u8> =
    deser_json::from_str("[1, 255]").unwrap();
assert_eq!(value, [1, 255]);

Strings in other encodings than base64 need this, for instance hex (BytesFormat::encoded::<deser_encoding::Hex>() with deser-encoding).

The format is placed into the state (see bytes). Values that use an adapter for bytes are not affected.

Source

pub const fn trailing(self, trailing: Trailing) -> DeserializerConfig

Controls what may follow a value.

By default (Trailing::Strict) only whitespace may follow the value. Trailing::Newline reads JSON Lines and Trailing::Stop stops after the value without looking at what follows:

use deser_json::{DeserializerConfig, Trailing};

assert!(
    deser_json::from_str::<Vec<u32>>("[1] trash")
        .is_err()
);
const STOP: DeserializerConfig =
    DeserializerConfig::new().trailing(Trailing::Stop);
assert_eq!(STOP.from_str::<Vec<u32>>("[1] trash").unwrap(), [1]);

With Trailing::Newline a Deserializer reads the lines one by one. Errors only discard their line:

use deser_json::{
    Deserializer, DeserializerConfig, Trailing,
};

const LINES: DeserializerConfig =
    DeserializerConfig::new().trailing(Trailing::Newline);
let mut de =
    Deserializer::from_str_with_config("1\n\nnope\n3\n", &LINES);
let mut values = Vec::new();
while !de.is_end() {
    match de.deserialize::<u32>() {
        Ok(value) => values.push(value),
        Err(err) => assert_eq!(err.line(), Some(3)),
    }
}
assert_eq!(values, [1, 3]);

Source

pub const fn track_locations(self, yes: bool) -> DeserializerConfig

Enables or disables location tracking.

The byte range of every event is always published into the state (see State::input_range). When enabled additionally the input is set as source (see Source) which allows resolving the ranges into lines and columns, for instance with the Spanned type of deser-location. This copies the input.

Source

pub const fn exact_numbers(self, yes: bool) -> DeserializerConfig

Enables or disables exact numbers.

When enabled (which is the default) floats which lose precision as f64 and integers that do not fit into 128 bits are emitted as Number extension values. These carry the text of the number together with its value as f64, which is what types that do not know about exact numbers receive. Types like Decimal (and the types of rust_decimal or bigdecimal) use the text to deserialize the number exactly:

use deser::ext::Decimal;

let value: Decimal =
    deser_json::from_str("0.10000000000000000001")
        .unwrap();
assert_eq!(value.as_str(), "0.10000000000000000001");
let value: f64 =
    deser_json::from_str("0.10000000000000000001")
        .unwrap();
assert_eq!(value, 0.1);

Floats whose text is the shortest representation of their value (as formatted by Debug, for instance 0.5 or 3.14) are emitted as plain floats as the text can be recovered from the value. This keeps the common case fast. When disabled, all floats are emitted as plain floats.

Source