Struct CompressionOptions

pub struct CompressionOptions {
    pub max_hash_checks: u16,
    pub lazy_if_less_than: u16,
    pub matching_type: MatchingType,
    pub special: SpecialOptions,
}

A struct describing the options for a compressor or compression function.

These values are not stable and still subject to change!

Fields

max_hash_checks: u16

The maximum number of checks to make in the hash table for matches.

Higher numbers mean slower, but better compression. Very high (say >1024) values will impact compression speed a lot. The maximum match length is 2^15, so values higher than this won’t make any difference, and will be truncated to 2^15 by the compression function/writer.

Default value: 128

lazy_if_less_than: u16

Only lazy match if we have a length less than this value.

Higher values degrade compression slightly, but improve compression speed.

• 0: Never lazy match. (Same effect as setting MatchingType to greedy, but may be slower).
• 1...257: Only check for a better match if the first match was shorter than this value.
• 258: Always lazy match.

As the maximum length of a match is 258, values higher than this will have no further effect.

• Default value: 32

matching_type: MatchingType

Whether to use lazy or greedy matching.

Lazy matching will provide better compression, at the expense of compression speed.

As a special case, if max_hash_checks is set to 0, and matching_type is set to lazy, compression using only run-length encoding (i.e maximum match distance of 1) is performed. (This may be changed in the future but is defined like this at the moment to avoid API breakage.

See MatchingType

• Default value: MatchingType::Lazy

special: SpecialOptions

Force fixed/stored blocks (Not implemented yet).

• Default value: SpecialOptions::Normal

Implementations

impl CompressionOptions

pub const fn high() -> CompressionOptions

Returns compression settings roughly corresponding to the HIGH(9) setting in miniz.

pub const fn fast() -> CompressionOptions

Returns a fast set of compression settings

Ideally this should roughly correspond to the FAST(1) setting in miniz. However, that setting makes miniz use a somewhat different algorithm, so currently hte fast level in this library is slower and better compressing than the corresponding level in miniz.

pub const fn huffman_only() -> CompressionOptions

Returns a set of compression settings that makes the compressor only compress using Huffman coding. (Ignoring any length/distance matching)

This will normally have the worst compression ratio (besides only using uncompressed data), but may be the fastest method in some cases.

pub const fn rle() -> CompressionOptions

Returns a set of compression settings that makes the compressor compress only using run-length encoding (i.e only looking for matches one byte back).

This is very fast, but tends to compress worse than looking for more matches using hash chains that the slower settings do. Works best on data that has runs of equivalent bytes, like binary or simple images, less good for text.

Trait Implementations

impl Clone for CompressionOptions

fn clone(&self) -> CompressionOptions

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CompressionOptions

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

Formats the value using the given formatter.

impl Default for CompressionOptions

fn default() -> CompressionOptions

Returns the options describing the default compression level.

impl From<Compression> for CompressionOptions

fn from(compression: Compression) -> CompressionOptions

Converts to this type from the input type.

impl Hash for CompressionOptions

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CompressionOptions

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for CompressionOptions

impl Eq for CompressionOptions

impl StructuralPartialEq for CompressionOptions