Struct librapidarchive::concurrentbuf::ConcurrentWriteBuffer

pub struct ConcurrentWriteBuffer<T: Write + Send, P: Send + Clone> { /* fields omitted */ }

Write buffer that does all of it's buffered I/O concurrently.

By doing buffered I/O on a separate thread and storing the results in memory things like copy operations can be dramatically accelerated.

Record-oriented media considerations

This facility attempts to preserve the sizes of requests where possible. This is for the sake of record-oriented media, such as magnetic tape or UDP packets, where data is stored in records or packets whose sizes are determined by the size of the write request.

Specifically, 'ConcurrentWriteBuffer' does not merge write requests into a single, larger buffer. The inner writer will be presented with the original data buffer, and it will only be separated into smaller buffers if the inner writer only accepts the buffer partially. If you need such a facility for merging writes into larger buffers, consider using BufWriter or BlockingWriter depending on your needs. Such writers may be used in concert with this one.

Methods

impl<T, P> ConcurrentWriteBuffer<T, P> where
    T: 'static + Write + Send + RecoverableWrite<P>,
    P: 'static + Send + Clone + PartialEq, 

Important traits for ConcurrentWriteBuffer<T, P>

impl<T, P> Write for ConcurrentWriteBuffer<T, P> where
    T: 'static + Write + Send + RecoverableWrite<P>,
    P: 'static + Send + Clone + PartialEq, 

pub fn new(inner: T, limit: u64) -> ConcurrentWriteBuffer<T, P>

Trait Implementations

impl<T, P> ArchivalSink<P> for ConcurrentWriteBuffer<T, P> where
    T: 'static + Write + Send + RecoverableWrite<P>,
    P: 'static + Send + Clone + PartialEq, 

fn downcast_seek(&mut self) -> Option<&mut dyn Seek>

fn downcast_tapedevice(&mut self) -> Option<&mut dyn TapeDevice>

impl<T, P> RecoverableWrite<P> for ConcurrentWriteBuffer<T, P> where
    T: 'static + Write + Send + RecoverableWrite<P>,
    P: 'static + Send + Clone + PartialEq, 

fn begin_data_zone(&mut self, ident: P)

Mark the start of a new data zone.

fn resume_data_zone(&mut self, ident: P, committed: u64)

Mark the start of a data zone being recovered.

fn end_data_zone(&mut self)

End the current data zone.

fn uncommitted_writes(&self) -> Vec<DataZone<P>>

Inspect all data currently buffered within the current writer which has not yet been committed to a device.

impl<T, P> Drop for ConcurrentWriteBuffer<T, P> where
    T: Write + Send,
    P: Send + Clone, 

fn drop(&mut self)

Executes the destructor for this type.

impl<T, P> Write for ConcurrentWriteBuffer<T, P> where
    T: 'static + Write + Send + RecoverableWrite<P>,
    P: 'static + Send + Clone + PartialEq, 

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoVec]) -> Result<usize, Error>

🔬 This is a nightly-only experimental API. (iovec)

Like write, except that it writes from a slice of buffers.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.