Struct compression::prelude::LzssDecoder

pub struct LzssDecoder { /* 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 LzssDecoder

pub fn new(size_of_window: usize) -> Self

pub fn with_dict(size_of_window: usize, dict: &[u8]) -> Self

Trait Implementations

impl Decoder for LzssDecoder

type Input = LzssCode

type Error = CompressionError

type Output = u8

fn next<I: Iterator<Item = Self::Input>>(
    &mut self,
    s: &mut I
) -> Option<Result<Self::Output, Self::Error>>

impl Debug for LzssDecoder

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

Formats the value using the given formatter.