Struct Serializer 

pub struct Serializer { /* private fields */ }

Serializes records into delimited text.

Every value is a record, the names of the columns are written before the first one.

use deser_csv::Serializer;

#[derive(deser::Serialize)]
struct Row {
    name: &'static str,
    age: u32,
}

let mut serializer = Serializer::new();
serializer.serialize(&Row { name: "jane", age: 42 }).unwrap();
serializer.serialize(&Row { name: "john", age: 23 }).unwrap();
assert_eq!(serializer.finish(), "name,age\njane,42\njohn,23\n");

The serializer is also the stream serializer of delimited text (see StreamSerializer): the output can be taken while records are written. To write to a Write use SerializerConfig::writer. A serializer created with document writes the records of sequences instead, like SerializerConfig::to_string.

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_headers<I, S>(config: SerializerConfig, names: I) -> Serializer

where I: IntoIterator<Item = S>, S: Into<String>,

Creates a serializer for a stream that continues with the given names of the columns.

The names are not written, for instance because the records are appended to an existing file.

use std::collections::BTreeMap;
use deser_csv::{Serializer, SerializerConfig};

let mut serializer =
    Serializer::with_headers(SerializerConfig::new(), ["b", "a"]);
serializer.serialize(&BTreeMap::from([("a", 1), ("b", 2)])).unwrap();
assert_eq!(serializer.finish(), "2,1\n");

pub fn document(config: SerializerConfig) -> Serializer

Creates a serializer whose values are sequences of records.

Every value is written like with SerializerConfig::to_string: the elements of the sequence are the records. The records are written while they are serialized, so large documents can be written in parts (see StreamSerializer::drive_partial).

use deser_csv::{Serializer, SerializerConfig};

let mut serializer = Serializer::document(SerializerConfig::new());
serializer.serialize(&vec![(1, "a"), (2, "b")]).unwrap();
assert_eq!(serializer.finish(), "1,a\n2,b\n");

pub fn config(&self) -> &SerializerConfig

Returns the configuration.

pub fn headers(&self) -> Option<&[String]>

Returns the names of the columns.

This is None until the first record was written (unless the names were given, see with_headers).

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

Serializes a record (or the records of a sequence, see document).

If the record fails to serialize, nothing is written.

pub fn serialize_with<F, T: Serialize + ?Sized>( &mut self, value: &T, setup: F, ) -> Result<(), Error>

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

Serializes a record 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) -> Self

Returns a duplicate of the value.

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<T>(&mut self, value: &T) -> Result<(), Error>

where T: Serialize + ?Sized, Self: Sized,

Serializes a value.

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

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

Serializes a value with a configured driver.

fn serialize_ref(&mut self, value: SerializeRef<'_>) -> Result<(), Error>

Serializes the value of a reference.

impl StreamSerializer for Serializer

fn supports_partial(&self) -> bool

Documents are written in parts (between records).

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 drive_partial( &mut self, driver: &mut SerializeDriver<'_>, limit: usize, ) -> Result<bool, 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.