Very wrong but it's a start; storing the huffman tree.

src/hufftree/canonical.rs

@@ -97,7 +97,6 @@ impl CanonicalHufftree {
 
         // So that popping bits removes them from the "start" of the text.
         let mut text: BitVec = text.iter().rev().collect();
-        println!("Reversed encoded text: {:?}", text);
         let mut buffer = BitVec::new();
 
         while text.len() > 0 {
@@ -117,9 +116,13 @@ impl CanonicalHufftree {
             Ok(decoded_text)
         }
     }
+
+    pub fn get_character_codes(&self) -> BiMap<char, BitVec> {
+        self.characters_and_codes.clone()
+    }
 }
 
-fn convert_no_to_bit_vec(mut numb: u32) -> BitVec {
+pub fn convert_no_to_bit_vec(mut numb: u32) -> BitVec {
     let mut output_vec = BitVec::new();
     while numb > 0 {
         if numb % 2 == 0 {
@@ -203,7 +206,6 @@ mod canonical_tests {
 
         let input_text = String::from("aaabacacaaaabbbbbbbccccccccccccaacc");
         let encoded_text = canonical.encode_text(&input_text);
-        println!("Encoded text:{:?}", encoded_text);
 
         let decoded_text = canonical.decode_text(encoded_text).unwrap();
 

src/hufftree/mod.rs

@@ -1,2 +1,2 @@
 pub mod canonical;
-mod base;
+pub mod base;

src/storage.rs

@@ -0,0 +1,54 @@
+use crate::hufftree::canonical::convert_no_to_bit_vec;
+use crate::hufftree::canonical::CanonicalHufftree;
+use bit_vec::BitVec;
+use std::io::Read;
+use std::io::Write;
+
+pub fn store_tree<F: Write>(tree: CanonicalHufftree, writer: &mut F) -> Result<(), String> {
+    let mut buff = BitVec::new();
+    let mut character_buff: [u8; 4] = [0; 4];
+
+    for (character, code) in tree.get_character_codes() {
+        let code_length: u32 = code.len().try_into().unwrap();
+        let mut code_length_vec = convert_no_to_bit_vec(code_length);
+        buff.append(&mut code_length_vec);
+        buff.append(&mut BitVec::from_elem(8, false));
+        character.encode_utf8(&mut character_buff);
+        buff.append(&mut BitVec::from_bytes(&character_buff));
+
+        character_buff.fill(0);
+    }
+
+    let buff = buff.to_bytes();
+    let buff_len: u32 = buff.len().try_into().unwrap();
+
+    writer.write_all(&buff_len.to_be_bytes()).unwrap();
+    writer.write_all(&buff).unwrap();
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod test {
+    use std::collections::HashMap;
+    use crate::hufftree::base::Hufftree;
+
+    use super::*;
+
+    #[test]
+    fn stores_length_and_rest() {
+        let mut chars_and_freq: HashMap<char, i32> = HashMap::new();
+        chars_and_freq.insert('a', 25);
+        chars_and_freq.insert('b', 14);
+        chars_and_freq.insert('c', 5);
+
+        let huff = Hufftree::new(chars_and_freq);
+        let canonical = CanonicalHufftree::from_tree(huff);
+
+        let mut virtual_buffer = Vec::new();
+        store_tree(canonical, &mut virtual_buffer).unwrap();
+
+        println!("Buffer:{:?}", virtual_buffer);
+
+    }
+}