Struct Serializer 

pub struct Serializer { /* private fields */ }

Serializes values into JSON.

Every call to serialize writes a value. What follows the values depends on SerializerConfig::trailing: by default only a single value can be written, with Trailing::Newline every value is followed by a line break (JSON Lines).

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(&"x").unwrap();
assert_eq!(serializer.finish(), "[1,2]\n\"x\"\n");

The serializer is also the stream serializer of JSON (see StreamSerializer): the output can be taken while values are written, and large values can be written in parts. To write to a Write use SerializerConfig::writer:

use deser_json::SerializerConfig;

let mut writer = SerializerConfig::new().writer(Vec::new());
writer.set_buffer_limit(4);
writer.write(&vec!["a", "b", "c"]).unwrap();
assert_eq!(writer.into_inner(), br#"["a","b","c"]"#);

Implementations

impl Serializer

pub fn new() -> Serializer

Creates a serializer.

pub fn with_config(config: &SerializerConfig) -> Serializer

Creates a serializer with the given configuration.

pub fn with_written(config: &SerializerConfig, written: usize) -> Serializer

Creates a serializer for a stream that continues after the given number of values.

This is useful to append to a stream that was written before (see SerializerConfig::trailing for what separates the values).

pub fn config(&self) -> &SerializerConfig

Returns the configuration.

pub fn written(&self) -> usize

Returns the number of values that were written.

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

Serializes a value.

If the value fails to serialize, nothing is written.

pub fn serialize_with<F>( &mut self, value: &dyn Serialize, setup: F, ) -> Result<(), Error>

where F: FnOnce(&mut SerializeDriver<'_>),

Serializes a value with a configured driver.

The callback is invoked with the driver before the value is serialized, for instance to add Layers.

pub fn as_str(&self) -> &str

Returns the output written so far (that was not cleared).

pub fn finish(self) -> String

Returns the output.

Trait Implementations

impl Clone for Serializer

fn clone(&self) -> Serializer

Clones the serializer.

The clone of a serializer that writes a value in parts cannot write more values (see StreamSerializer::in_progress).

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

Performs copy-assignment from source.

impl Debug for Serializer

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

Formats the value using the given formatter.

impl Default for Serializer

fn default() -> Serializer

Returns the “default value” for a type.

impl Serializer for Serializer

fn drive(&mut self, driver: &mut SerializeDriver<'_>) -> Result<(), Error>

Receives the events of a value from the driver and writes them into the output.

fn serialize(&mut self, value: &dyn Serialize) -> Result<(), Error>

Serializes a value.

fn serialize_with<F>( &mut self, value: &dyn Serialize, setup: F, ) -> Result<(), Error>

where F: FnOnce(&mut SerializeDriver<'_>), Self: Sized,

Serializes a value with a configured driver.

impl StreamSerializer for Serializer

fn output(&self) -> &[u8]

Returns the bytes serialized so far which were not cleared yet.

fn clear_output(&mut self)

Discards the bytes returned by output, for instance because they were written.

fn supports_partial(&self) -> bool

Returns true if the serializer implements drive_partial.

fn drive_partial( &mut self, driver: &mut SerializeDriver<'_>, limit: usize, ) -> Result<Written, Error>

Serializes a value, or a part of it, and appends its bytes to the output.

fn in_progress(&self) -> bool

Returns true if a value is partially serialized.