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,

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_objects(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.