Struct compression::prelude::LzssEncoder

pub struct LzssEncoder<F> where
    F: Fn(LzssCode, LzssCode) -> Ordering + Copy,  { /* fields omitted */ }

Examples

use compression::prelude::*;
use std::cmp::Ordering;

fn main() {
    pub fn comparison(lhs: LzssCode, rhs: LzssCode) -> Ordering {
        match (lhs, rhs) {
            (
                LzssCode::Reference {
                    len: llen,
                    pos: lpos,
                },
                LzssCode::Reference {
                    len: rlen,
                    pos: rpos,
                },
            ) => ((llen << 3) + rpos).cmp(&((rlen << 3) + lpos)).reverse(),
            (LzssCode::Symbol(_), LzssCode::Symbol(_)) => Ordering::Equal,
            (_, LzssCode::Symbol(_)) => Ordering::Greater,
            (LzssCode::Symbol(_), _) => Ordering::Less,
        }
    }
    let compressed = b"aabbaabbaabbaabb\n"
        .into_iter()
        .cloned()
        .encode(&mut LzssEncoder::new(comparison, 0x1_0000, 256, 3, 3), Action::Finish)
        .collect::<Result<Vec<_>, _>>()
        .unwrap();

    let decompressed = compressed
        .iter()
        .cloned()
        .decode(&mut LzssDecoder::new(0x1_0000))
        .collect::<Result<Vec<_>, _>>()
        .unwrap();
}

Methods

impl<F> LzssEncoder<F> where
    F: Fn(LzssCode, LzssCode) -> Ordering + Copy, 

pub fn new(
    comp: F,
    size_of_window: usize,
    max_match: usize,
    min_match: usize,
    lazy_level: usize
) -> Self

pub fn with_dict(
    comp: F,
    size_of_window: usize,
    max_match: usize,
    min_match: usize,
    lazy_level: usize,
    dict: &[u8]
) -> Self

Trait Implementations

impl<F> Encoder for LzssEncoder<F> where
    F: Fn(LzssCode, LzssCode) -> Ordering + Copy, 

type Error = CompressionError

type In = u8

type Out = LzssCode

fn next<I: Iterator<Item = u8>>(
    &mut self,
    iter: &mut I,
    action: Action
) -> Option<Result<LzssCode, CompressionError>>

impl<F: Debug> Debug for LzssEncoder<F> where
    F: Fn(LzssCode, LzssCode) -> Ordering + Copy, 

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

Formats the value using the given formatter.