Enum `CompressionLevel`

enum CompressionLevel

How much processing the compressor should do to compress the data. NoCompression and Bestspeed have special meanings, the other levels determine the number of checks for matches in the hash chains and whether to use lazy or greedy parsing.

Variants

NoCompression: Don't do any compression, only output uncompressed blocks.
BestSpeed: Fast compression. Uses a special compression routine that is optimized for speed.
BestCompression: Slow/high compression. Do a lot of checks to try to find good matches.
UberCompression: Even more checks, can be very slow.
DefaultLevel: Default compromise between speed and compression.
DefaultCompression: Use the default compression level.

Implementations

`impl Clone for CompressionLevel`

fn clone(self: &Self) -> CompressionLevel

`impl Copy for CompressionLevel`

`impl Debug for CompressionLevel`

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

`impl Eq for CompressionLevel`

`impl Freeze for CompressionLevel`

`impl Hash for CompressionLevel`

fn hash<__H: $crate::hash::Hasher>(self: &Self, state: &mut __H)

`impl PartialEq for CompressionLevel`

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

`impl RefUnwindSafe for CompressionLevel`

`impl Send for CompressionLevel`

`impl StructuralPartialEq for CompressionLevel`

`impl Sync for CompressionLevel`

`impl Unpin for CompressionLevel`

`impl UnsafeUnpin for CompressionLevel`

`impl UnwindSafe for CompressionLevel`

`impl<T> Any for CompressionLevel`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for CompressionLevel`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for CompressionLevel`

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

`impl<T> CloneToUninit for CompressionLevel`

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

`impl<T> From for CompressionLevel`

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

`impl<T> ToOwned for CompressionLevel`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for CompressionLevel`

fn into(self: 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 for CompressionLevel`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for CompressionLevel`

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