Refactor Solver trait to streamline usage

src/solvers/trash_compactor.rs

@@ -1,51 +1,32 @@
 use crate::solvers::Solver;
 use grid::*;
-use std::fs::File;
-use std::io;
+use std::io::BufRead;
 
-pub struct TrashCompactor {
-    part1: u64,
-    part2: u64,
-}
+pub struct TrashCompactor {}
 
 impl Solver for TrashCompactor {
-    fn get_puzzle_index(&self) -> u8 {
-        6
-    }
-    fn get_puzzle_name(&self) -> &str {
-        "Trash Compactor"
-    }
-    fn get_input_filename(&self) -> &str {
-        "trash_compactor.txt"
-    }
-    fn get_part1(&self) -> u64 {
-        self.part1
-    }
-    fn get_part2(&self) -> u64 {
-        self.part2
-    }
-    fn process_data(&mut self, lines: io::Lines<io::BufReader<File>>) {
+    const PUZZLE_INDEX: u8 = 6;
+    const PUZZLE_NAME: &'static str = "Trash Compactor";
+    const INPUT_FILENAME: &'static str = "trash_compactor.txt";
+
+    fn process_data<R: BufRead>(&self, reader: R) -> (u64, u64) {
+        let mut part1 = 0;
         let mut grid = Grid::new(0, 0);
-        for line in lines.map_while(Result::ok) {
+        for line in reader.lines().map_while(Result::ok) {
             let v: Vec<&str> = line.split(' ').filter(|s| !s.is_empty()).collect();
             match v[0].parse::<u32>() {
                 Ok(_) => grid.push_row(v.iter().map(|n| n.parse::<u64>().unwrap()).collect()),
                 Err(_) => {
                     for (i, sign) in v.iter().enumerate() {
                         if *sign == "+" {
-                            self.part1 += grid.iter_col(i).sum::<u64>();
+                            part1 += grid.iter_col(i).sum::<u64>();
                         } else {
-                            self.part1 += grid.iter_col(i).product::<u64>();
+                            part1 += grid.iter_col(i).product::<u64>();
                         }
                     }
                 }
             }
         }
-    }
-}
-
-impl TrashCompactor {
-    pub fn new() -> TrashCompactor {
-        TrashCompactor { part1: 0, part2: 0 }
+        (part1, 0)
     }
 }