Struct Writer 

pub struct Writer<W: Write> { /* private fields */ }

Writes CSV data to a std::io::Write sink.

The writer handles auto-quoting of fields that contain the delimiter, newlines, or double-quotes. It also validates that all rows have the same number of fields (unless flexible mode is enabled).

Internal buffering is used to avoid many small writes to the underlying writer. Callers should not wrap the writer in a BufWriter.

Example

let mut w = Writer::new(Vec::new());
w.write_row(["name", "age", "city"]).unwrap();
w.write_row(["Alice", "30", "New York, NY"]).unwrap();
let result = String::from_utf8(w.into_inner().unwrap()).unwrap();
assert_eq!(result, "name,age,city\r\nAlice,30,\"New York, NY\"\r\n");

Implementations

impl<W: Write> Writer<W>

pub fn new(writer: W) -> Self

Create a new writer wrapping the given output sink.

pub fn delimiter(&mut self, byte: u8) -> &mut Self

Set the field delimiter byte (default is ,).

pub fn flexible(&mut self, yes: bool) -> &mut Self

Enable flexible mode, which skips the field count consistency check.

pub fn write_row<I, T>(&mut self, row: I) -> Result<(), WriteError>

where I: IntoIterator<Item = T>, T: AsRef<[u8]>,

Write a single row. Each element in the iterator is written as a CSV field. Fields are auto-quoted if they contain the delimiter, a newline (\n or \r), or a double-quote (").

Whitespace trimming is never performed. The empty byte slice &[] produces an empty field.

Errors

Returns WriteError::InconsistentFieldCount if the number of fields differs from previous rows (unless flexible mode is enabled). Returns WriteError::Io if the underlying writer fails.

pub fn flush(&mut self) -> Result<(), WriteError>

Flush the internal buffer to the underlying writer.

pub fn into_inner(self) -> Result<W, WriteError>

Unwrap the writer, flushing any remaining data and returning the underlying writer.

Trait Implementations

impl<W: Write> Drop for Writer<W>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.