Enum `FlushDecompress`

#[non_exhaustive]
pub enum FlushDecompress

Values which indicate the form of flushing to be used when decompressing 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.

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.

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 FlushDecompress`

fn clone(&self) -> FlushDecompress

`impl Copy for FlushDecompress`

`impl Debug for FlushDecompress`

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

`impl Eq for FlushDecompress`

`impl PartialEq for FlushDecompress`

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

`impl StructuralPartialEq for FlushDecompress`

Auto Trait Implementations

`impl Freeze for FlushDecompress`

`impl RefUnwindSafe for FlushDecompress`

`impl Send for FlushDecompress`

`impl Sync for FlushDecompress`

`impl Unpin for FlushDecompress`

`impl UnsafeUnpin for FlushDecompress`

`impl UnwindSafe for FlushDecompress`

Blanket Implementations

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

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for FlushDecompress where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for FlushDecompress where T: ?Sized,`

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

`impl<T> CloneToUninit for FlushDecompress where T: Clone,`

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

`impl<T> From<T> for FlushDecompress`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for FlushDecompress where T: Clone,`

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

`impl<T, U> Into<U> for FlushDecompress 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 FlushDecompress where U: Into<T>,`

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

`impl<T, U> TryInto<U> for FlushDecompress where U: TryFrom<T>,`

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