Obeyed the omniscient Clippy

src/hufftree/base.rs

@@ -69,14 +69,14 @@ impl Hufftree {
     }
 }
 
-pub fn get_char_frequencies(text: &String) -> HashMap<char, i32> {
+pub fn get_char_frequencies(text: &str) -> HashMap<char, i32> {
     let mut map = HashMap::new();
 
     for character in text.chars() {
-        if map.contains_key(&character) {
-            map.entry(character).and_modify(|e| *e += 1);
+        if let std::collections::hash_map::Entry::Vacant(e) = map.entry(character) {
+            e.insert(1);
         } else {
-            map.insert(character, 1);
+            map.entry(character).and_modify(|e| *e += 1);
         }
     }
 

src/hufftree/canonical.rs

@@ -31,7 +31,7 @@ impl PartialOrd for CharTempCode {
 
 impl PartialEq for CharTempCode {
     fn eq(&self, other: &Self) -> bool {
-        return self.code_length == other.code_length;
+        self.code_length == other.code_length
     }
 }
 
@@ -62,12 +62,10 @@ impl CanonicalHufftree {
         let mut first = true;
         let mut prev_length = 0;
         let mut working_code: u32 = 0b0;
-        while character_and_codes.len() > 0 {
-            let temp_char = character_and_codes.pop().unwrap();
-
+        while let Some(temp_char) = character_and_codes.pop() {
             // This will results in the vector being ordered with the most frequent
             // character first, ordered by code length.
-            storage_char_codes.push((temp_char.character.clone(), temp_char.code_length as u32));
+            storage_char_codes.push((temp_char.character, temp_char.code_length as u32));
 
             let mut code = BitVec::new();
             code.grow(temp_char.code_length, false);
@@ -82,15 +80,11 @@ impl CanonicalHufftree {
 
             if temp_char.code_length > prev_length {
                 working_code += 1;
-                working_code = working_code << (temp_char.code_length - prev_length);
-
+                working_code <<= temp_char.code_length - prev_length;
 
                 let code = convert_no_to_bit_vec_known_length(working_code, &mut code);
                 output_characters_and_codes
-                    .insert_no_overwrite(
-                        temp_char.character,
-                        code
-                    )
+                    .insert_no_overwrite(temp_char.character, code)
                     .expect("There was already a character with that code.");
 
                 assert!(output_characters_and_codes.contains_left(&temp_char.character));
@@ -104,10 +98,7 @@ impl CanonicalHufftree {
                 let code = convert_no_to_bit_vec_known_length(working_code, &mut code);
 
                 output_characters_and_codes
-                    .insert_no_overwrite(
-                        temp_char.character,
-                        code
-                    )
+                    .insert_no_overwrite(temp_char.character, code)
                     .expect("There was already a character with that code.");
             }
 
@@ -131,8 +122,7 @@ impl CanonicalHufftree {
         let mut first = true;
         let mut prev_length = 0;
         let mut working_code: u32 = 0b0;
-        while temp_storage.len() > 0 {
-            let (temp_char, code_length) = temp_storage.pop().unwrap();
+        while let Some((temp_char, code_length)) = temp_storage.pop() {
             // This will result in the vector being ordered with the most frequent
             // character first, ordered by code length.
             //
@@ -149,13 +139,11 @@ impl CanonicalHufftree {
 
             if code_length > prev_length {
                 working_code += 1;
-                working_code = working_code << (code_length - prev_length);
+                working_code <<= code_length - prev_length;
 
                 let code = convert_no_to_bit_vec_known_length(working_code, &mut code);
-                bi.insert_no_overwrite(
-                    temp_char,
-                     code,
-                ).expect("There was already a character with that code.");
+                bi.insert_no_overwrite(temp_char, code)
+                    .expect("There was already a character with that code.");
             } else {
                 assert_eq!(
                     code_length, prev_length,
@@ -163,10 +151,8 @@ impl CanonicalHufftree {
                 );
                 working_code += 1;
                 let code = convert_no_to_bit_vec_known_length(working_code, &mut code);
-                bi.insert_no_overwrite(
-                    temp_char,
-                     code,
-                ).expect("There was already a character with that code.");
+                bi.insert_no_overwrite(temp_char, code)
+                    .expect("There was already a character with that code.");
             }
 
             prev_length = code_length;
@@ -180,7 +166,7 @@ impl CanonicalHufftree {
     }
 
     // TODO: Optimise this (the vector copying is probably extremely inefficient)
-    pub fn encode_text(&self, text: &String) -> BitVec {
+    pub fn encode_text(&self, text: &str) -> BitVec {
         let mut converted_text = BitVec::new();
 
         for character in text.chars() {
@@ -199,7 +185,7 @@ impl CanonicalHufftree {
         let mut text: BitVec = text.iter().rev().collect();
         let mut buffer = BitVec::new();
 
-        while text.len() > 0 {
+        while !text.is_empty() {
             buffer.push(text.pop().unwrap());
             match self.characters_and_codes.get_by_right(&buffer) {
                 Some(character) => {
@@ -234,22 +220,22 @@ pub fn convert_no_to_bit_vec(mut numb: u32) -> BitVec {
         } else {
             output_vec.push(true);
         }
-        numb = numb / 2;
+        numb /=  2;
     }
     let output_vec = output_vec.iter().rev().collect();
     output_vec
 }
 
-pub fn convert_no_to_bit_vec_known_length(mut numb: u32, bits: &mut BitVec) -> BitVec  {
+pub fn convert_no_to_bit_vec_known_length(mut numb: u32, bits: &mut BitVec) -> BitVec {
     let mut counter = 0;
     while numb > 0 {
         if numb % 2 == 0 {
-            bits.set(counter ,false);
+            bits.set(counter, false);
         } else {
             bits.set(counter, true);
         }
 
-        numb = numb / 2;
+        numb /=  2;
         counter += 1;
     }
 

src/node.rs

@@ -10,13 +10,19 @@ pub struct Node {
 
 impl Ord for Node {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        return self.frequency.cmp(&other.frequency)
+        self.frequency.cmp(&other.frequency)
     }
 }
 
 impl PartialOrd for Node {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        return Some(self.frequency.cmp(&other.frequency))
+        Some(self.frequency.cmp(&other.frequency))
+    }
+}
+
+impl Default for Node {
+    fn default() -> Self {
+        Self::new()
     }
 }
 

src/storage.rs

@@ -19,7 +19,7 @@ use std::io::Write;
 pub fn store_tree_and_text<F: Write>(
     tree: CanonicalHufftree,
     writer: &mut F,
-    text: &String,
+    text: &str,
 ) -> Result<(), String> {
     let mut buff = BitVec::new();
     let mut character_buff: [u8; 4] = [0; 4];
@@ -40,7 +40,7 @@ pub fn store_tree_and_text<F: Write>(
     buff.append(&mut BitVec::from_elem(32, true));
     bit_length += 32;
 
-    let encoded_text = tree.encode_text(&text);
+    let encoded_text = tree.encode_text(text);
 
     let text_bits: u32 = encoded_text.len().try_into().unwrap();
 
@@ -91,7 +91,7 @@ pub fn read_tree_and_text<F: Read>(reader: &mut F) -> String {
         length_of_file_in_bits -= 64;
 
         // For small encodings
-        if length_of_file_in_bits < 64 || length_of_file_in_bits == 64 {
+        if length_of_file_in_bits <= 64 {
             break;
         }
         reader
@@ -104,7 +104,7 @@ pub fn read_tree_and_text<F: Read>(reader: &mut F) -> String {
 
     // println!("Length of file remaining: {}", length_of_file_in_bits);
 
-    if length_of_file_in_bits < 32 || length_of_file_in_bits == 32 {
+    if length_of_file_in_bits <= 32 {
         let mut rest_of_binary = Vec::new();
         reader
             .read_to_end(&mut rest_of_binary)
@@ -144,7 +144,7 @@ fn four_b_to_u32(b: &[u8; 4]) -> u32 {
         result += bt32;
 
         if i != 3 {
-            result = result << 8;
+            result <<= 8;
         }
     }
 
@@ -234,7 +234,6 @@ mod test {
         let mut virtual_buffer = Vec::new();
         store_tree_and_text(canonical, &mut virtual_buffer, &input_text).unwrap();
 
-
         let decoded_text = read_tree_and_text(&mut &virtual_buffer[0..virtual_buffer.len()]);
 
         assert_eq!(decoded_text, input_text);