Struct StreamWriter 

pub struct StreamWriter<'a, F: Write + Seek> { /* private fields */ }

Allows writing data to a stream.

This object does not implement Seek and there is no variant of this object that allows seeking or writing to arbitrary offsets. Stream data must be written sequentially.

After a StreamWriter is closed (dropped), it is not possible to create a new StreamWriter for the same stream.

Write calls are never split across chunks

The Write implementation of this type makes a guarantee: For a given call to StreamWriter::write, if the current stream is using chunked compression, then the data will be written to a single compressed chunk. This is an implementation guarantee; it is not required by the MSFZ specification.

This allows readers to rely on complete records being stored within a single chunk. For example, when copying the TPI, an encoder could issue a sequence of write() calls whose boundaries align with the boundaries of the records within the TPI. This would allow the reader to read records directly from the chunk decompressed buffer, without needing to allocate a separate buffer or copy the records. (We do not currently implement that behavior; this is describing a hypothetical.)

Implementations

impl<'a, F: Write + Seek> StreamWriter<'a, F>

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

Ends the current chunk, if any.

This function is a performance hint for compression. It is not necessary to call this function.

pub fn bytes_available_in_chunk_buffer(&self) -> usize

The number of bytes that can be written to the current chunk buffer, without exceeding the configured maximum.

pub fn set_compression_enabled(&mut self, value: bool)

Specifies whether to use chunked compression or not. The default value for this setting is true (chunked compression is enabled).

This does not have any immediate effect. It controls the behavior of the write() implementation for this stream.

If this is called with false, then write() calls that follow this will cause stream data to be written to disk without compression.

pub fn set_alignment(&mut self, value: Pow2)

Specifies the on-disk alignment requirement for the start of the stream data.

This only applies to uncompressed streams. Compressed stream data is always stored within compressed chunks, so the alignment is meaningless.

Trait Implementations

impl<'a, F: Write + Seek> Write for StreamWriter<'a, F>

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

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

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

Writes 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, args: Arguments<'_>) -> Result<(), Error>

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

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

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.