Enum FlushCompress

#[non_exhaustive]
pub enum FlushCompress

Values which indicate the form of flushing to be used when compressing in-memory data.

Variants

None = { _ }

A typical parameter for passing to compression/decompression functions, this indicates that the underlying stream to decide how much data to accumulate before producing output in order to maximize compression.

Partial = { _ }

All pending output is flushed to the output buffer, but the output is not aligned to a byte boundary.

All input data so far will be available to the decompressor (as with Flush::Sync). This completes the current deflate block and follows it with an empty fixed codes block that is 10 bits long, and it assures that enough bytes are output in order for the decompressor to finish the block before the empty fixed code block.

Sync = { _ }

All pending output is flushed to the output buffer and the output is aligned on a byte boundary so that the decompressor can get all input data available so far.

Flushing may degrade compression for some compression algorithms and so it should only be used when necessary. This will complete the current deflate block and follow it with an empty stored block.

Full = { _ }

All output is flushed as with Flush::Sync and the compression state is reset so decompression can restart from this point if previous compressed data has been damaged or if random access is desired.

Using this option too often can seriously degrade compression.

Finish = { _ }

Pending input is processed and pending output is flushed.

The return value may indicate that the stream is not yet done and more data has yet to be processed.

Trait Implementations

impl Clone for FlushCompress

fn clone(&self) -> FlushCompress

impl Copy for FlushCompress

impl Debug for FlushCompress

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Eq for FlushCompress

impl PartialEq for FlushCompress

fn eq(&self, other: &FlushCompress) -> bool

impl StructuralPartialEq for FlushCompress

Auto Trait Implementations

impl Freeze for FlushCompress

impl RefUnwindSafe for FlushCompress

impl Send for FlushCompress

impl Sync for FlushCompress

impl Unpin for FlushCompress

impl UnsafeUnpin for FlushCompress

impl UnwindSafe for FlushCompress

Blanket Implementations

impl<T> Any for FlushCompress where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for FlushCompress where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for FlushCompress where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for FlushCompress where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for FlushCompress

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for FlushCompress where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for FlushCompress where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for FlushCompress where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for FlushCompress where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>