Add initial implementation of Huffman coding

Author: WanzenBug

.gitignore

@@ -0,0 +1,4 @@
+target
+.idea/
+*.iml
+Cargo.lock

Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "huffman"
+version = "0.1.0"
+authors = ["WanzenBug <[email protected]>"]
+
+[lib]
+name = "huffman"
+path = "src/lib.rs"
+
+[[bin]]
+name = "encode"
+path = "src/bin/encode.rs"
+
+[[bin]]
+name = "decode"
+path = "src/bin/decode.rs"
+
+[dependencies]
+bitstream-rs = "0.1.2"
+bit-vec = "0.4.3"
+clap = "2.20.0"

src/bin/decode.rs

@@ -0,0 +1,45 @@
+extern crate huffman;
+extern crate clap;
+
+mod util;
+
+use std::fs::File;
+use std::io::{copy, BufReader, BufWriter, Write};
+use huffman::{HuffmanReader};
+use clap::{App, Arg};
+
+fn main() {
+    let matches = App::new("Huffman decoder")
+        .version("0.1")
+        .author("Moritz Wanzenböck <[email protected]>")
+        .about("Decompress files using pure Huffman coding")
+        .arg(Arg::with_name("INPUT")
+            .required(true)
+            .help("Sets the input file to use")
+            .index(1))
+        .arg(Arg::with_name("OUTPUT")
+            .required(true)
+            .help("Sets the output file to use")
+            .index(2))
+        .arg(Arg::with_name("verbose")
+            .short("v")
+            .help("Sets verbose output"))
+        .get_matches();
+
+    let infile = matches.value_of("INPUT").and_then(|file| File::open(file).ok()).expect("Input: No such file");
+    let outfile = matches.value_of("OUTPUT").and_then(|file| File::create(file).ok()).expect("Output: Could not create file");
+    let mut read = util::StatsReader::new(BufReader::new(infile));
+    let mut write = util::StatsWriter::new(BufWriter::new(outfile));
+    {
+        let mut reader = HuffmanReader::new(&mut read).expect("Could not read huffman table");
+        copy(&mut reader, &mut write).expect("Something went wrong while encoding");
+    }
+    if matches.is_present("verbose") {
+        write.flush().expect("Flush failed");
+        let written = write.get_stats().processed;
+        let read = read.get_stats().processed;
+
+        println!("Read:    {} bytes", read);
+        println!("Written: {} bytes", written);
+    }
+}

src/bin/encode.rs

@@ -0,0 +1,49 @@
+extern crate huffman;
+extern crate clap;
+
+mod util;
+
+use std::fs::File;
+use std::io::{copy, BufReader, BufWriter, Write, Read, Cursor};
+use huffman::{HuffmanWriter, HuffmanTree};
+use clap::{App, Arg};
+
+fn main() {
+    let matches = App::new("Huffman encoder")
+        .version("0.1")
+        .author("Moritz Wanzenböck <[email protected]>")
+        .about("Compresses files using pure Huffman coding")
+        .arg(Arg::with_name("INPUT")
+            .required(true)
+            .help("Sets the input file to use")
+            .index(1))
+        .arg(Arg::with_name("OUTPUT")
+            .required(true)
+            .help("Sets the output file to use")
+            .index(2))
+        .arg(Arg::with_name("verbose")
+            .short("v")
+            .help("Sets verbose output"))
+        .get_matches();
+
+    let infile = matches.value_of("INPUT").and_then(|file| File::open(file).ok()).expect("Input: No such file");
+    let outfile = matches.value_of("OUTPUT").and_then(|file| File::create(file).ok()).expect("Output: Could not create file");
+    let mut read = util::StatsReader::new(BufReader::new(infile));
+    let mut write = util::StatsWriter::new(BufWriter::new(outfile));
+    {
+        let mut vec = Vec::new();
+        read.read_to_end(&mut vec).expect("Error reading input");
+        let tree = HuffmanTree::new(&vec[..]);
+        let mut encoder = HuffmanWriter::new(&mut write, &tree).expect("Could not write huffman table");
+        let mut read_vec = Cursor::new(vec);
+        copy(&mut read_vec, &mut encoder).expect("Something went wrong while decoding");
+    }
+    if matches.is_present("verbose") {
+        write.flush().expect("Flush failed");
+        let written = write.get_stats().processed;
+        let read = read.get_stats().processed;
+
+        println!("Read:    {} bytes", read);
+        println!("Written: {} bytes", written);
+    }
+}

src/bin/util.rs

@@ -0,0 +1,65 @@
+use std::io::{Read, Write, Result};
+
+pub struct StatsReader<R> where R: Read {
+    inner: R,
+    read_bytes: usize,
+}
+
+pub struct StatsWriter<W> where W: Write {
+    inner: W,
+    written_bytes: usize,
+}
+
+pub struct Stats {
+    pub processed: usize,
+}
+
+impl<R> StatsReader<R> where R: Read {
+    pub fn new(reader: R) -> Self {
+        StatsReader {
+            inner: reader,
+            read_bytes: 0
+        }
+    }
+
+    pub fn get_stats(&self) -> Stats {
+        Stats {
+            processed: self.read_bytes
+        }
+    }
+}
+
+impl<W> StatsWriter<W> where W: Write {
+    pub fn new(writer: W) -> Self {
+        StatsWriter {
+            inner: writer,
+            written_bytes: 0,
+        }
+    }
+
+    pub fn get_stats(&self) -> Stats {
+        Stats {
+            processed: self.written_bytes,
+        }
+    }
+}
+
+impl<R> Read for StatsReader<R> where R: Read {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+        let n = self.inner.read(buf)?;
+        self.read_bytes += n;
+        Ok(n)
+    }
+}
+
+impl<W> Write for StatsWriter<W> where W: Write {
+    fn write(&mut self, buf: &[u8]) -> Result<usize> {
+        let n = self.inner.write(buf)?;
+        self.written_bytes += n;
+        Ok(n)
+    }
+
+    fn flush(&mut self) -> Result<()> {
+        self.inner.flush()
+    }
+}