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_jsonc::DeserializerConfig;

const CONFIG: DeserializerConfig =
    DeserializerConfig::builder().exact_numbers(false).build();
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 builder() -> DeserializerConfigBuilder

Returns a builder for the configuration (see DeserializerConfigBuilder).

Source

pub const fn into_builder(self) -> DeserializerConfigBuilder

Returns a builder that starts with this configuration.

Source

pub fn set_context(&mut self, context: Context)

Sets the context the values are deserialized in.

The values of the context are the defaults of the extension values of the state (see Context), for instance the variants of open enums. The deserializers and readers created with the configuration use this context. A context set on the driver takes precedence.

use deser::Context;
use deser::de::DuplicateKeys;
use deser_jsonc::DeserializerConfig;
use std::collections::BTreeMap;

let config = DeserializerConfig::builder()
    .context(Context::with(DuplicateKeys::Last))
    .build();
let value: BTreeMap<String, u32> =
    config.from_str(r#"{"a": 1, "a": 2}"#).unwrap();
assert_eq!(value["a"], 2);

Source

pub fn context(&self) -> &Context

Returns the context the values are deserialized in.

Source

pub const fn set_trailing(&mut self, trailing: Trailing)

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_jsonc::{DeserializerConfig, Trailing};

assert!(
    deser_jsonc::from_str::<Vec<u32>>("[1] trash")
        .is_err()
);
const STOP: DeserializerConfig =
    DeserializerConfig::builder().trailing(Trailing::Stop).build();
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_jsonc::{
    Deserializer, DeserializerConfig, Trailing,
};

const LINES: DeserializerConfig =
    DeserializerConfig::builder().trailing(Trailing::Newline).build();
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 set_exact_numbers(&mut self, yes: bool)

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_jsonc::from_str("0.10000000000000000001")
        .unwrap();
assert_eq!(value.as_str(), "0.10000000000000000001");
let value: f64 =
    deser_jsonc::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