Struct ThreadObjectWriter

pub struct ThreadObjectWriter<'scope, T>
where
    T: Send + Sync + 'static,
{
    sender: Sender<T>,
    handle: WorkHandle<'scope>,
    meter: ProgressBar,
}

Write objects in a background thread.

Fields

sender: Sender<T>

handle: WorkHandle<'scope>

meter: ProgressBar

Implementations

impl<'scope, T> ThreadObjectWriter<'scope, T>

where T: Send + Sync + 'scope,

pub fn wrap<W>( writer: W, ) -> ThreadObjectWriterBuilder<W, impl Send + FnOnce() -> Result<W>>

where W: ObjectWriter<T> + Send + Sync + 'scope,

pub fn bg_open<W, F>(thunk: F) -> ThreadObjectWriterBuilder<W, F>

where W: ObjectWriter<T> + 'scope, F: Send + FnOnce() -> Result<W>,

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

pub fn satellite<'a>(&'a self) -> ThreadWriterSatellite<'a, 'scope, T>

where 'scope: 'a,

Create a satellite writer that writes to the same backend as this writer.

Satellites can be used to enable multiple data-generating threads to write to the same thread writer, turning it into a multi-producer, single-consumer writing pipeline. Satellite writers should be finished, and closing them does not finish the original thread writer (it still needs to have ObjectWriter::finish called, typically after all satellites are done, but it calling ObjectWriter::finish while satellites are still active will wait until the satellites have finished and closed their connections to the consumer thread).

Satellites hold a reference to the original thread writer, to discourage keeping them alive after the thread writer has been finished. They work best with std::thread::scope:

let writer = ThreadWriter::new(writer);
scope(|s| {
    for i in 0..NTHREADS {
        let out = writer.satellite();
        s.spawn(move || {
            // process and write to out
            out.finish().expect("closing writer failed");
        })
    }
})

Trait Implementations

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

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

Write one object.

fn finish(self) -> Result<usize>

Finish and close the target.

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.