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. pretty writes every entry on a line of its own:

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

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

const PRETTY: SerializerConfig =
    SerializerConfig::new().pretty(Indent::Spaces(2));
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 trailing(self, trailing: Trailing) -> SerializerConfig

Sets what follows the values of a stream.

This is the counterpart of DeserializerConfig::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_json::{Serializer, SerializerConfig, Trailing};

const LINES: SerializerConfig =
    SerializerConfig::new().trailing(Trailing::Newline);
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 indent(self, indent: Indent) -> SerializerConfig

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 compact. To indent with spaces after separators use pretty.

use deser_json::{Indent, SerializerConfig};

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

Source

pub const fn compact(self, yes: bool) -> SerializerConfig

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_json::SerializerConfig;

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

Source

pub const fn inline(self, policy: InlinePolicy) -> SerializerConfig

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

use deser::Serialize;
use deser_json::{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::new()
    .pretty(Indent::Spaces(2))
    .inline(InlinePolicy::LeafIfFits(80));
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 pretty(self, indent: Indent) -> SerializerConfig

Enables or disables pretty printing.

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

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

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

Source

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

Sets how bytes are represented.

JSON has no bytes, by default they are written as base64 strings (BytesFormat::BASE64). Values can request a different format (see bytes) which takes precedence. Map keys cannot be sequences, bytes in keys are always strings.

use deser::adapters::Base64UrlNoPad;
use deser::BytesFormat;
use deser_json::SerializerConfig;

assert_eq!(deser_json::to_string(&b"\xfb\xff").unwrap(), r#""+/8=""#);
const URL_SAFE: SerializerConfig = SerializerConfig::new()
    .bytes(BytesFormat::encoded::<Base64UrlNoPad>());
assert_eq!(URL_SAFE.to_string(&b"\xfb\xff").unwrap(), r#""-_8""#);
const SEQ: SerializerConfig =
    SerializerConfig::new().bytes(BytesFormat::SEQ);
assert_eq!(SEQ.to_string(&b"\xfb\xff").unwrap(), "[251,255]");

More encodings (such as hex) are provided by deser-encoding. Bytes in other formats than base64 (or sequences) need to be deserialized with the same format (see DeserializerConfig::bytes).

Source

pub fn to_string(&self, value: &dyn Serialize) -> Result<String, Error>

Serializes the given value.

Source

pub fn to_string_with<F>( &self, value: &dyn Serialize, 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_json::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 trailing. The output of large values is written in parts while they are serialized.

use deser_json::{SerializerConfig, Trailing};

const LINES: SerializerConfig =
    SerializerConfig::new().trailing(Trailing::Newline);
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