Struct SerializerConfig

Source

pub struct SerializerConfig { /* private fields */ }

Expand description

Configures how values are serialized to JSON.

By default the output is as short as possible: no line breaks and no spaces. set_pretty writes every entry on a line of its own:

use std::collections::BTreeMap;
use deser_json5::{Indent, SerializerConfig};

let value = BTreeMap::from([("name", vec!["a", "b"])]);
assert_eq!(
    deser_json5::to_string(&value).unwrap(),
    r#"{"name":["a","b"]}"#
);

const PRETTY: SerializerConfig =
    SerializerConfig::builder().pretty(Indent::Spaces(2)).build();
assert_eq!(
    PRETTY.to_string(&value).unwrap(),
    "{\n  \"name\": [\n    \"a\",\n    \"b\"\n  ]\n}"
);

In indented output maps and sequences with the Layout::Compact hint (see hints) are written on a single line. The output never ends with a line break.

to_string works like the to_string function.

Implementations§

Source §

impl SerializerConfig

Source

pub const fn new() -> SerializerConfig

Creates the default configuration.

Source

pub const fn builder() -> SerializerConfigBuilder

Returns a builder for the configuration (see SerializerConfigBuilder).

Source

pub const fn into_builder(self) -> SerializerConfigBuilder

Returns a builder that starts with this configuration.

Source

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

Sets the context the values are serialized in.

The values of the context are the defaults of the extension values of the state (see Context), for instance the BytesFormat. The serializers and writers created with the configuration use this context. A context set on the driver takes precedence.

Source

pub fn context(&self) -> &Context

Returns the context the values are serialized in.

Source

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

Sets what follows the values of a stream.

This is the counterpart of DeserializerConfig::set_trailing for writing more than one value (with a Serializer or a stream writer), it does not affect to_string:

Trailing::Strict: the stream holds a single value, writing a second one fails. This is the default.
Trailing::Newline: every value is followed by a line break (JSON Lines). The values must not be indented.
Trailing::Stop: values are separated by line breaks.

use deser_json5::{Serializer, SerializerConfig, Trailing};

const LINES: SerializerConfig =
    SerializerConfig::builder().trailing(Trailing::Newline).build();
let mut serializer = Serializer::with_config(LINES);
serializer.serialize(&vec![1, 2]).unwrap();
serializer.serialize(&vec![3]).unwrap();
assert_eq!(serializer.finish(), "[1,2]\n[3]\n");

Source

pub const fn set_indent(&mut self, indent: Indent)

Sets how the output is indented.

By default (Indent::None) the value is written on a single line. Otherwise every entry of a map or sequence is written on a line of its own, indented by its depth. Empty maps and sequences are always written as {} and []. This does not change the spaces after separators, see set_compact. To indent with spaces after separators use set_pretty.

use deser_json5::{Indent, SerializerConfig};

const TAB: SerializerConfig = SerializerConfig::builder().indent(Indent::Tab).build();
assert_eq!(TAB.to_string(&vec![1, 2]).unwrap(), "[\n\t1,\n\t2\n]");

Source

pub const fn set_compact(&mut self, yes: bool)

Controls the spaces after separators.

When enabled (which is the default) there are no spaces after : and ,. When disabled a space follows every : and every , that is not followed by a line break:

use std::collections::BTreeMap;
use deser_json5::SerializerConfig;

let value = BTreeMap::from([("a", vec![1, 2])]);
const SPACED: SerializerConfig = SerializerConfig::builder().compact(false).build();
assert_eq!(SPACED.to_string(&value).unwrap(), r#"{"a": [1, 2]}"#);

Source

pub const fn set_inline(&mut self, policy: InlinePolicy)

Sets when maps and sequences are written on a single line in indented output.

use deser::Serialize;
use deser_json5::{Indent, InlinePolicy, SerializerConfig};

#[derive(Serialize)]
struct Shape {
    name: &'static str,
    points: Vec<Vec<i32>>,
}

let shape = Shape {
    name: "line",
    points: vec![vec![0, 0], vec![3, 4]],
};
const CONFIG: SerializerConfig = SerializerConfig::builder()
    .pretty(Indent::Spaces(2))
    .inline(InlinePolicy::LeafIfFits(80)).build();
assert_eq!(CONFIG.to_string(&shape).unwrap(), r#"{
  "name": "line",
  "points": [
    [0, 0],
    [3, 4]
  ]
}"#);

This has no effect without indentation.

Source

pub const fn set_pretty(&mut self, indent: Indent)

Enables or disables pretty printing.

This sets the indentation and writes spaces after separators (see set_compact) unless the indentation is Indent::None, in which case the output is compact again.

use std::collections::BTreeMap;
use deser_json5::{Indent, SerializerConfig};

let value = BTreeMap::from([("a", 1)]);
const PRETTY: SerializerConfig =
    SerializerConfig::builder().pretty(Indent::Spaces(4)).build();
assert_eq!(PRETTY.to_string(&value).unwrap(), "{\n    \"a\": 1\n}");
const NOT_PRETTY: SerializerConfig = PRETTY.into_builder().pretty(Indent::None).build();
assert_eq!(NOT_PRETTY.to_string(&value).unwrap(), r#"{"a":1}"#);

Source

pub const fn set_non_finite_floats(&mut self, yes: bool)

Writes NaN and infinite floats as NaN, Infinity and -Infinity.

JSON cannot represent these values, by default (false) they are written as null. JSON5 (and for instance the json module of Python) supports them with these literals, the output is then no longer JSON. The serialization functions of deser-json5 enable this.

use deser_json5::SerializerConfig;

let values = [f64::NAN, f64::INFINITY, f64::NEG_INFINITY];
assert_eq!(
    SerializerConfig::new().to_string(&values).unwrap(),
    "[null,null,null]"
);
const NON_FINITE: SerializerConfig =
    SerializerConfig::builder().non_finite_floats(true).build();
assert_eq!(
    NON_FINITE.to_string(&values).unwrap(),
    "[NaN,Infinity,-Infinity]"
);

Source

pub fn to_string<T: Serialize + ?Sized>( &self, value: &T, ) -> Result<String, Error>

Serializes the given value.

Source

pub fn to_string_with<F, T: Serialize + ?Sized>( &self, value: &T, setup: F, ) -> Result<String, Error>
where F: FnOnce(&mut SerializeDriver<'_>),

Serializes the given value with a configured driver.

The callback is invoked with the driver before the serialization starts, for instance to add Layers.

use deser::ser::{Layer, Next};
use deser::{Atom, Error, Event};
use deser_json5::SerializerConfig;

/// Writes all numbers as strings.
struct NumbersAsStrings;

impl Layer for NumbersAsStrings {
    fn event(
        &mut self,
        event: Event<'_>,
        next: &mut Next<'_>,
    ) -> Result<(), Error> {
        match event {
            Event::Atom(Atom::U64(value)) => {
                next.emit(value.to_string().into())
            }
            event => next.emit(event),
        }
    }
}

let json = SerializerConfig::new()
    .to_string_with(&vec![1u64, 2], |driver| {
        driver.push_layer(NumbersAsStrings)
    })
    .unwrap();
assert_eq!(json, r#"["1","2"]"#);

Source §

impl SerializerConfig

Source

pub fn writer<W: Write>(&self, writer: W) -> Writer<W, Serializer>

Creates a writer of a stream of values (see deser::io::Writer).

What follows the values depends on set_trailing. The output of large values is written in parts while they are serialized.

use deser_json5::{SerializerConfig, Trailing};

const LINES: SerializerConfig =
    SerializerConfig::builder().trailing(Trailing::Newline).build();
let mut writer = LINES.writer(Vec::new());
writer.write(&1).unwrap();
writer.write(&"x").unwrap();
assert_eq!(writer.into_inner(), b"1\n\"x\"\n");

Source