Trait ObjectWriter

pub trait ObjectWriter<T>: Sized {
    // Required methods
    fn write_object(&mut self, object: T) -> Result<()>;
    fn finish(self) -> Result<usize>;

    // Provided methods
    fn write_all_objects<I>(&mut self, objects: I) -> Result<usize>
       where I: Iterator<Item = T> { ... }
    fn write_and_finish<I>(self, objects: I) -> Result<usize>
       where I: Iterator<Item = T> { ... }
    fn with_transform<F, T2>(self, transform: F) -> MapWriter<F, T2, T, Self>
       where F: Fn(T2) -> Result<T> { ... }
}

Trait for writing objects to some kind of sink.

Required Methods

fn write_object(&mut self, object: T) -> Result<()>

Write one object.

fn finish(self) -> Result<usize>

Finish and close the target.

Provided Methods

fn write_all_objects<I>(&mut self, objects: I) -> Result<usize>

where I: Iterator<Item = T>,

Write an iterator full of objects.

fn write_and_finish<I>(self, objects: I) -> Result<usize>

where I: Iterator<Item = T>,

Write an iterator of objects and finish the writer.

fn with_transform<F, T2>(self, transform: F) -> MapWriter<F, T2, T, Self>

where F: Fn(T2) -> Result<T>,

Wrap this object writer in a transformed writer.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<T, W> ObjectWriter<T> for &mut W

where W: ObjectWriter<T>,

References can be used as object writers; however, ObjectWriter::finish must be called on the owned writer, not a reference. Closing the reference is a no-op.

fn write_object(&mut self, object: T) -> Result<()>

fn finish(self) -> Result<usize>

impl<T: Serialize, W: Write> ObjectWriter<T> for Writer<W>

fn write_object(&mut self, object: T) -> Result<()>

fn finish(self) -> Result<usize>

impl<W> ObjectWriter<RecordBatch> for ArrowWriter<W>

where W: Write + Send,

fn write_object(&mut self, batch: RecordBatch) -> Result<()>

fn finish(self) -> Result<usize>

impl<W> ObjectWriter<Chunk<Box<dyn Array>>> for FileWriter<W>

where W: Write,

Implementation of object writer for Polars Arrow writers

fn write_object( &mut self, chunk: PChunk<Box<dyn PArray + 'static>>, ) -> Result<()>

fn finish(self) -> Result<usize>

impl<W> ObjectWriter<DataFrame> for BatchedWriter<W>

where W: Write,

Implementation of object writer for Polars Parquet batched writer

fn write_object(&mut self, df: DataFrame) -> Result<()>

fn finish(self) -> Result<usize>

impl<W, R> ObjectWriter<Vec<R>> for SerializedFileWriter<W>

where W: Write + Send, for<'a> &'a [R]: RecordWriter<R>,

fn write_object(&mut self, object: Vec<R>) -> Result<()>

fn finish(self) -> Result<usize>

Implementors

impl ObjectWriter<RawAuthor> for AuthorWriter

impl ObjectWriter<RawBook> for BookWriter

impl ObjectWriter<RawBookGenre> for BookGenreWriter

impl ObjectWriter<RawInteraction> for IntWriter

impl ObjectWriter<RawReview> for ReviewWriter

impl ObjectWriter<RawWork> for WorkWriter

impl ObjectWriter<MARCRecord> for BookOutput

impl ObjectWriter<MARCRecord> for FieldOutput

impl ObjectWriter<Row<OLAuthorSource>> for AuthorProcessor

impl ObjectWriter<Row<OLEditionRecord>> for EditionProcessor

impl ObjectWriter<Row<OLWorkRecord>> for WorkProcessor

impl<'a, 'scope, T> ObjectWriter<T> for ThreadWriterSatellite<'a, 'scope, T>

where T: Send + Sync + 'static, 'scope: 'a,

impl<'scope, T: Send + Sync + 'static> ObjectWriter<T> for ThreadObjectWriter<'scope, T>

impl<F, T1, T2, W> ObjectWriter<T1> for MapWriter<F, T1, T2, W>

where W: ObjectWriter<T2>, F: Fn(T1) -> Result<T2>,

impl<R> ObjectWriter<R> for TableWriter<R>

where R: Send + Sync + 'static, for<'a> &'a [R]: RecordWriter<R>,

impl<T, W> ObjectWriter<Vec<T>> for ChunkWriter<T, W>

where W: ObjectWriter<T>,

impl<T, W> ObjectWriter<T> for UnchunkWriter<T, W>

where W: ObjectWriter<Vec<T>>,

impl<W: ObjectWriter<RecordBatch>> ObjectWriter<Vec<FieldRecord>> for FilterOutput<W>