Enum `BlockType`

enum BlockType

The type of data blocks to generate for a DEFLATE stream.

Variants

Uncompressed

Non-compressed blocks (BTYPE=00).

The input data will be divided into chunks up to 64 KiB big and stored in the DEFLATE stream without compression. This is mainly useful for test and development purposes.

Fixed

Compressed blocks with fixed Huffman codes (BTYPE=01).

The input data will be compressed into DEFLATE blocks using a fixed Huffman tree defined in the DEFLATE specification. This provides fast but poor compression, as the Zopfli algorithm is not actually used.

Dynamic

Select the most space-efficient block types for the input data. This is the recommended type for the vast majority of Zopfli applications.

This mode lets the Zopfli algorithm choose the combination of block types that minimizes data size. The emitted block types may be Uncompressed or Fixed, in addition to compressed with dynamic Huffman codes (BTYPE=10).

Implementations

`impl Clone for BlockType`

fn clone(self: &Self) -> BlockType

`impl Copy for BlockType`

`impl Debug for BlockType`

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

`impl Default for BlockType`

fn default() -> BlockType

`impl Eq for BlockType`

`impl Freeze for BlockType`

`impl PartialEq for BlockType`

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

`impl RefUnwindSafe for BlockType`

`impl Send for BlockType`

`impl StructuralPartialEq for BlockType`

`impl Sync for BlockType`

`impl Unpin for BlockType`

`impl UnsafeUnpin for BlockType`

`impl UnwindSafe for BlockType`

`impl<T> Any for BlockType`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for BlockType`

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

`impl<T> BorrowMut for BlockType`

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

`impl<T> CloneToUninit for BlockType`

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

`impl<T> From for BlockType`

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

`impl<T> ToOwned for BlockType`

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

`impl<T, U> Into for BlockType`

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

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

`impl<T, U> TryInto for BlockType`

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