[−][src]Struct csv_async::AsyncWriterBuilder
Builds a CSV writer with various configuration knobs.
This builder can be used to tweak the field delimiter, record terminator
and more. Once a CSV AsyncWriter
is built, its configuration cannot be
changed.
Implementations
impl AsyncWriterBuilder
[src]
pub fn create_writer<W: AsyncWrite + Unpin>(&self, wtr: W) -> AsyncWriter<W>
[src]
Build a CSV writer from this configuration that writes data to wtr
.
Note that the CSV writer is buffered automatically, so you should not
wrap wtr
in a buffered writer like.
Example
use std::error::Error; use csv_async::AsyncWriterBuilder; async fn example() -> Result<(), Box<dyn Error>> { let mut wtr = AsyncWriterBuilder::new().create_writer(vec![]); wtr.write_record(&["a", "b", "c"]).await?; wtr.write_record(&["x", "y", "z"]).await?; let data = String::from_utf8(wtr.into_inner().await?)?; assert_eq!(data, "a,b,c\nx,y,z\n"); Ok(()) }
pub fn from_writer<W: AsyncWrite + Unpin>(&self, wtr: W) -> AsyncWriter<W>
[src]
Please use AsyncWriterBuilder::create_writer function instead
Build a CSV writer from this configuration that writes data to wtr
.
impl AsyncWriterBuilder
[src]
pub fn create_serializer<W: AsyncWrite + Unpin>(
&self,
wtr: W
) -> AsyncSerializer<W>
[src]
&self,
wtr: W
) -> AsyncSerializer<W>
Build a CSV serde
serializer from this configuration that writes data to ser
.
Note that the CSV serializer is buffered automatically, so you should not
wrap ser
in a buffered writer.
Example
use std::error::Error; use csv_async::AsyncWriterBuilder; use serde::Serialize; #[derive(Serialize)] struct Row<'a> { name: &'a str, x: u64, y: u64, } async fn example() -> Result<(), Box<dyn Error>> { let mut ser = AsyncWriterBuilder::new().has_headers(false).create_serializer(vec![]); ser.serialize(Row {name: "p1", x: 1, y: 2}).await?; ser.serialize(Row {name: "p2", x: 3, y: 4}).await?; let data = String::from_utf8(ser.into_inner().await?)?; assert_eq!(data, "p1,1,2\np2,3,4\n"); Ok(()) }
impl AsyncWriterBuilder
[src]
pub fn new() -> AsyncWriterBuilder
[src]
Create a new builder for configuring CSV writing.
To convert a builder into a writer, call one of the methods starting
with from_
.
Example
use std::error::Error; use csv_async::AsyncWriterBuilder; async fn example() -> Result<(), Box<dyn Error>> { let mut wtr = AsyncWriterBuilder::new().from_writer(vec![]); wtr.write_record(&["a", "b", "c"]).await?; wtr.write_record(&["x", "y", "z"]).await?; let data = String::from_utf8(wtr.into_inner().await?)?; assert_eq!(data, "a,b,c\nx,y,z\n"); Ok(()) }
pub fn get_core_builder_ref(&self) -> &CoreWriterBuilder
[src]
This getter is no longer needed and will be removed
Returns csv_core Builder reference.
pub fn delimiter(&mut self, delimiter: u8) -> &mut AsyncWriterBuilder
[src]
The field delimiter to use when writing CSV.
The default is b','
.
Example
use std::error::Error; use csv_async::AsyncWriterBuilder; async fn example() -> Result<(), Box<dyn Error>> { let mut wtr = AsyncWriterBuilder::new() .delimiter(b';') .from_writer(vec![]); wtr.write_record(&["a", "b", "c"]).await?; wtr.write_record(&["x", "y", "z"]).await?; let data = String::from_utf8(wtr.into_inner().await?)?; assert_eq!(data, "a;b;c\nx;y;z\n"); Ok(()) }
pub fn has_headers(&mut self, yes: bool) -> &mut AsyncWriterBuilder
[src]
Whether to write a header row before writing any other row.
When this is enabled and the serialize
method is used to write data
with something that contains field names (i.e., a struct), then a
header row is written containing the field names before any other row
is written.
This option has no effect when using other methods to write rows. That
is, if you don't use serialize
, then you must write your header row
explicitly if you want a header row.
This is enabled by default.
pub fn does_have_headers(&self) -> bool
[src]
This getter is no longer needed and will be removed
Returns information if writer should write header line.
pub fn is_flexible(&self) -> bool
[src]
This getter is no longer needed and will be removed
Returns information if writer is flexible (can write different number of columns in different rows).
pub fn flexible(&mut self, yes: bool) -> &mut AsyncWriterBuilder
[src]
Whether the number of fields in records is allowed to change or not.
When disabled (which is the default), writing CSV data will return an error if a record is written with a number of fields different from the number of fields written in a previous record.
When enabled, this error checking is turned off.
Example: writing flexible records
use std::error::Error; use csv_async::AsyncWriterBuilder; async fn example() -> Result<(), Box<dyn Error>> { let mut wtr = AsyncWriterBuilder::new() .flexible(true) .from_writer(vec![]); wtr.write_record(&["a", "b"]).await?; wtr.write_record(&["x", "y", "z"]).await?; let data = String::from_utf8(wtr.into_inner().await?)?; assert_eq!(data, "a,b\nx,y,z\n"); Ok(()) }
Example: error when flexible
is disabled
use std::error::Error; use csv_async::AsyncWriterBuilder; async fn example() -> Result<(), Box<dyn Error>> { let mut wtr = AsyncWriterBuilder::new() .flexible(false) .from_writer(vec![]); wtr.write_record(&["a", "b"]).await?; let err = wtr.write_record(&["x", "y", "z"]).await.unwrap_err(); match *err.kind() { csv_async::ErrorKind::UnequalLengths { expected_len, len, .. } => { assert_eq!(expected_len, 2); assert_eq!(len, 3); } ref wrong => { panic!("expected UnequalLengths but got {:?}", wrong); } } Ok(()) }
pub fn terminator(&mut self, term: Terminator) -> &mut AsyncWriterBuilder
[src]
The record terminator to use when writing CSV.
A record terminator can be any single byte. The default is \n
.
Note that RFC 4180 specifies that record terminators should be \r\n
.
To use \r\n
, use the special Terminator::CRLF
value.
Example: CRLF
This shows how to use RFC 4180 compliant record terminators.
use std::error::Error; use csv_async::{Terminator, AsyncWriterBuilder}; async fn example() -> Result<(), Box<dyn Error>> { let mut wtr = AsyncWriterBuilder::new() .terminator(Terminator::CRLF) .from_writer(vec![]); wtr.write_record(&["a", "b", "c"]).await?; wtr.write_record(&["x", "y", "z"]).await?; let data = String::from_utf8(wtr.into_inner().await?)?; assert_eq!(data, "a,b,c\r\nx,y,z\r\n"); Ok(()) }
pub fn quote_style(&mut self, style: QuoteStyle) -> &mut AsyncWriterBuilder
[src]
The quoting style to use when writing CSV.
By default, this is set to QuoteStyle::Necessary
, which will only
use quotes when they are necessary to preserve the integrity of data.
Note that unless the quote style is set to Never
, an empty field is
quoted if it is the only field in a record.
Example: non-numeric quoting
This shows how to quote non-numeric fields only.
use std::error::Error; use csv_async::{QuoteStyle, AsyncWriterBuilder}; async fn example() -> Result<(), Box<dyn Error>> { let mut wtr = AsyncWriterBuilder::new() .quote_style(QuoteStyle::NonNumeric) .from_writer(vec![]); wtr.write_record(&["a", "5", "c"]).await?; wtr.write_record(&["3.14", "y", "z"]).await?; let data = String::from_utf8(wtr.into_inner().await?)?; assert_eq!(data, "\"a\",5,\"c\"\n3.14,\"y\",\"z\"\n"); Ok(()) }
Example: never quote
This shows how the CSV writer can be made to never write quotes, even if it sacrifices the integrity of the data.
use std::error::Error; use csv_async::{QuoteStyle, AsyncWriterBuilder}; async fn example() -> Result<(), Box<dyn Error>> { let mut wtr = AsyncWriterBuilder::new() .quote_style(QuoteStyle::Never) .from_writer(vec![]); wtr.write_record(&["a", "foo\nbar", "c"]).await?; wtr.write_record(&["g\"h\"i", "y", "z"]).await?; let data = String::from_utf8(wtr.into_inner().await?)?; assert_eq!(data, "a,foo\nbar,c\ng\"h\"i,y,z\n"); Ok(()) }
pub fn quote(&mut self, quote: u8) -> &mut AsyncWriterBuilder
[src]
The quote character to use when writing CSV.
The default is b'"'
.
Example
use std::error::Error; use csv_async::AsyncWriterBuilder; async fn example() -> Result<(), Box<dyn Error>> { let mut wtr = AsyncWriterBuilder::new() .quote(b'\'') .from_writer(vec![]); wtr.write_record(&["a", "foo\nbar", "c"]).await?; wtr.write_record(&["g'h'i", "y\"y\"y", "z"]).await?; let data = String::from_utf8(wtr.into_inner().await?)?; assert_eq!(data, "a,'foo\nbar',c\n'g''h''i',y\"y\"y,z\n"); Ok(()) }
pub fn double_quote(&mut self, yes: bool) -> &mut AsyncWriterBuilder
[src]
Enable double quote escapes.
This is enabled by default, but it may be disabled. When disabled, quotes in field data are escaped instead of doubled.
Example
use std::error::Error; use csv_async::AsyncWriterBuilder; async fn example() -> Result<(), Box<dyn Error>> { let mut wtr = AsyncWriterBuilder::new() .double_quote(false) .from_writer(vec![]); wtr.write_record(&["a", "foo\"bar", "c"]).await?; wtr.write_record(&["x", "y", "z"]).await?; let data = String::from_utf8(wtr.into_inner().await?)?; assert_eq!(data, "a,\"foo\\\"bar\",c\nx,y,z\n"); Ok(()) }
pub fn escape(&mut self, escape: u8) -> &mut AsyncWriterBuilder
[src]
The escape character to use when writing CSV.
In some variants of CSV, quotes are escaped using a special escape
character like \
(instead of escaping quotes by doubling them).
By default, writing these idiosyncratic escapes is disabled, and is
only used when double_quote
is disabled.
Example
use std::error::Error; use csv_async::AsyncWriterBuilder; async fn example() -> Result<(), Box<dyn Error>> { let mut wtr = AsyncWriterBuilder::new() .double_quote(false) .escape(b'$') .from_writer(vec![]); wtr.write_record(&["a", "foo\"bar", "c"]).await?; wtr.write_record(&["x", "y", "z"]).await?; let data = String::from_utf8(wtr.into_inner().await?)?; assert_eq!(data, "a,\"foo$\"bar\",c\nx,y,z\n"); Ok(()) }
pub fn get_buffer_capacity(&self) -> usize
[src]
This getter is no longer needed and will be removed
Returns buffer capacity.
pub fn buffer_capacity(&mut self, capacity: usize) -> &mut AsyncWriterBuilder
[src]
Set the capacity (in bytes) of the internal buffer used in the CSV writer. This defaults to a reasonable setting.
Trait Implementations
impl Debug for AsyncWriterBuilder
[src]
impl Default for AsyncWriterBuilder
[src]
pub fn default() -> AsyncWriterBuilder
[src]
Auto Trait Implementations
impl RefUnwindSafe for AsyncWriterBuilder
impl Send for AsyncWriterBuilder
impl Sync for AsyncWriterBuilder
impl Unpin for AsyncWriterBuilder
impl UnwindSafe for AsyncWriterBuilder
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,