Struct bam::bgzip::write::Writer

pub struct Writer<W: Write> { /* fields omitted */ }

Writes bgzip file.

You can create a writer using from_path or using WriterBuilder. Additional threads are used to compress blocks, while the main thread reads the writes to a file/stream. If additional_threads is 0, the main thread will compress blocks itself.

It is highly not recommended to continue writing after an error, as in that case the writer may miss some blocks.

Implementations

impl Writer<File>

pub fn build() -> WriterBuilder

Creates a Writer Builder.

pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self>

Opens a writer from a file with default parameters (see Writer Builder).

impl<W: Write> Writer<W>

pub fn pause(&mut self)

Pauses multi-thread writer this and does nothing for single-thread writer.

Practically, this function increases sleeping time for compressing threads, so the threads are still active, but wake up rarely.

impl<W: Write> Writer<W>

pub fn end_context(&mut self)

Ends current context: marks this point as more preferable when splitting bgzip blocks.

pub fn flush_contents(&mut self) -> Result<()>

Saves current contents (if non-empty) into a block and adds to the compression queue.

pub fn write_block(&mut self, block: Block) -> (Block, Result<()>)

Adds a block to the compression queue and returns an empty block and a result of compression/writing.

If you use write as well as write_block, call flush_contents before using write_block.

pub fn write_empty(&mut self) -> Result<()>

Saves current contents into a block, and adds an empty block to the queue.

pub fn finish(&mut self) -> Result<()>

Finishes writing (writes an empty block and flushes contents).

pub fn take_stream(self) -> W

Finishes writing, consumes the writer and returns inner stream.

Trait Implementations

impl<W: Write> Drop for Writer<W>

fn drop(&mut self)

Executes the destructor for this type.

impl<W: Write> Write for Writer<W>

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

Saves current buffer to a block and writes all blocks in a queue.

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

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

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

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

fn is_write_vectored(&self) -> bool

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

Determines if this Writer has an efficient write_vectored implementation.

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

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

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

Attempts to write multiple buffers 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” adapter for this instance of Write.