Struct Writer 

pub struct Writer<'a, W> { /* private fields */ }

The Writer is the primary interface for writing values to an avro datafile or a byte container (say a Vec<u8>). It takes a reference to the schema for validating the values being written and an output stream W which can be any type implementing the Write trait.

Implementations

impl<'a, W: Write> Writer<'a, W>

pub fn new(schema: &'a Schema, out_stream: W) -> Result<Self, AvrowErr>

Creates a new avro Writer instance taking a reference to a Schema and a type implementing Write.

pub fn with_codec( schema: &'a Schema, out_stream: W, codec: Codec, ) -> Result<Self, AvrowErr>

Same as the new method, but additionally takes a Codec as parameter. Codecs can be used to compress the encoded data being written in an avro datafile. Supported codecs as per spec are:

• null (default): No compression is applied.
• snappy (--features snappy)
• deflate (--features deflate)
• zstd compression (--feature zstd)
• bzip compression (--feature bzip)
• xz compression (--features xz)

pub fn write<T: Into<Value>>(&mut self, value: T) -> Result<(), AvrowErr>

Appends a value to the buffer. Before a value gets written, it gets validated with the schema referenced by this writer.

Note:

writes are buffered internally as per the flush interval (for performance) and the underlying buffer may not reflect values immediately. Call flush to explicitly write all buffered data. Alternatively calling into_inner on the writer guarantees that flush will happen and will hand over the underlying buffer with all data written.

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

Appends a native Rust value to the buffer. The value must implement Serde’s Serialize trait.

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

Sync/flush any buffered data to the underlying buffer.

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

Consumes self and yields the inner Write instance. Additionally calls flush if no flush has happened before this call.