Struct AsyncZstdWriter 

pub struct AsyncZstdWriter<'dict, W> { /* private fields */ }

A writer that writes a compressed zstd stream to the underlying writer. Works as either a tokio or futures writer if their respective features are enabled.

The underlying writer W should implement the following traits:

• tokio
  • tokio::io::AsyncWrite (required for tokio::io::AsyncWrite impl)
• futures
  • futures::AsyncWrite (required for futures::AsyncWrite impl)

For sync I/O support, see crate::ZstdWriter.

Construction

Create a builder using AsyncZstdWriter::builder. See ZstdWriterBuilder for builder options. Call ZstdWriterBuilder::build to build the AsyncZstdWriter instance.

// Tokio example
let mut writer = zstd_framed::AsyncZstdWriter::builder(compressed_file)
    .with_compression_level(3) // Set custom compression level
    .with_seek_table(1024 * 1024) // Write zstd seekable format table
    .build()?;

// ...

writer.shutdown().await?; // Shut down the writer

// futures example
let mut writer = zstd_framed::AsyncZstdWriter::builder(compressed_file)
    .with_compression_level(3) // Set custom compression level
    .with_seek_table(1024 * 1024) // Write zstd seekable format table
    .build()?;

// ...

writer.close().await?; // Close the writer

Writing multiple frames

To allow for efficient seeking (e.g. when using ZstdReaderBuilder::with_seek_table), you can write multiple zstd frames to the underlying writer. If the .with_seek_table() option is given during construction, multiple frames will be created automatically to fit within the given max_frame_size.

Alternatively, you can use AsyncZstdWriter::finish_frame() to explicitly split the underlying stream into multiple frames. .finish_frame() can be used even when not using the .with_seek_table() option (but note the seek table will only be written when using .with_seek_table()).

Clean shutdown

To ensure the writer shuts down cleanly (including flushing any in-memory buffers and writing the seek table if enabled with .with_seek_table()), make sure to call the Tokio .shutdown() method or the or futures .close() method!

Implementations

impl<W> AsyncZstdWriter<'_, W>

pub fn builder(writer: W) -> ZstdWriterBuilder<W>

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

Trait Implementations

impl<W> AsyncWrite for AsyncZstdWriter<'_, W>

where W: AsyncWrite + Unpin,

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, data: &[u8], ) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempts to flush the object, ensuring that any buffered data reach their destination.

fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

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

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

impl<W> AsyncWrite for AsyncZstdWriter<'_, W>

where W: AsyncWrite + Unpin,

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, data: &[u8], ) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempt to flush the object, ensuring that any buffered data reach their destination.

fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempt to close the object.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Attempt to write bytes from bufs into the object using vectored IO operations.

impl<'__pin, 'dict, W> Unpin for AsyncZstdWriter<'dict, W>

where PinnedFieldsOf<__Origin<'__pin, 'dict, W>>: Unpin,