zippopotamus 0.1.2

Lazy implementation of zip
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98


use bitvec::prelude::*;
use crate::{huffman::*, lz77::{lz77_decode, lz77_encode}};
use std::{cell::LazyCell, collections::HashMap, path::PathBuf};
use std::fs;
///Use std::fmt::Error for error type because it's
///a convenient unit struct
use std::fmt::Error;
//use bincode::*;
use serde::{Serialize, Deserialize};

///Custom file format used for testing before implementing the PKware spec
#[derive(Serialize, Deserialize)]
struct Zpp {
    filename: String,
    huff_table: HashMap<u8, (u16, u8)>,
    encoded: Vec<u8>,
    binary_len: usize,
}

///Compresses a file into "filename.zpp" and returns the compression ratio if successful
pub fn compress_file(source: &PathBuf) -> Result<f32, Error> {

    let oldfilename = source.file_name().unwrap().to_str().ok_or(Error)?.to_string();

    let mut newpathbuf = source.clone();
    newpathbuf.set_extension("zpp");

    let mut zpp = Zpp {
        filename: oldfilename,
        huff_table: HashMap::new(),
        encoded: Vec::new(),
        binary_len: 0,
    };

    let bytes = fs::read(source).map_err(|_| Error)?;
    //let lz77_encoded = bytes;
    let lz77_encoded = lz77_encode(&bytes[..]);

    let mut huff_coder = HuffmanTree::from_bytes(&lz77_encoded);

    let code_dict = huff_coder.gen_dict();
    let (encoded, len) = huff_encode(&lz77_encoded[..], &code_dict)?;
    // let encoded = lz77_encoded;

    zpp.huff_table = code_dict;
    zpp.encoded = encoded;
    zpp.binary_len = len;

    let serialized = bincode::serialize(&zpp).map_err(|_| Error)?;
    let compression_ratio = bytes.len() as f32 / (serialized.len() as f32);

    fs::write(newpathbuf, serialized).map_err(|_| Error)?;

    Ok(compression_ratio)
}

pub fn decompress_file(source: &PathBuf) -> Result<(), Error> {
    //if source.extension().unwrap().to_str() != Some("zpp") { return Err(Error); }

    let serialized = fs::read(source).map_err(|_| Error)?;
    let zpp: Zpp = bincode::deserialize(&serialized[..]).map_err(|_| Error)?;

    let lz77_encoded = huff_decode(&zpp.encoded, &zpp.huff_table, zpp.binary_len).map_err(|_| Error)?;
    let decoded = lz77_decode(&lz77_encoded)?;

    fs::write(zpp.filename, decoded).map_err(|_| Error)?;

    Ok(())
}


/*
Fuck I forgot what I wrote this shit for

use std::io::{Read, Write};

pub fn get_meta<R: Read>(reader: R) -> Meta {
    Meta {}
}

pub fn deflate<R: Read, W: Write>(reader: R, writer: W) ->
    Result<u64, DeflateError> {


}

pub enum DeflateError {
    Io(std::io::Error),
    //InvalidData(&str),
}


struct Meta {

}
//pub fn parse_meta() ->
*/