[LIB] Cleanup temp lib structs

Author: connorslade

Cargo.lock

@@ -6,3 +6,4 @@ edition = "2021"
 [dependencies]
 common = { path = "../common" }
 hashbrown = "0.13.1"
+nd_vec = "0.4.0"

aoc_2021/Cargo.toml

@@ -1,18 +1,9 @@
 use hashbrown::HashSet;
 
 use common::{Answer, Solution};
+use nd_vec::vector;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-struct Point {
-    x: usize,
-    y: usize,
-}
-
-impl Point {
-    fn new(x: usize, y: usize) -> Self {
-        Self { x, y }
-    }
-}
+type Point = nd_vec::Vec2<usize>;
 
 pub struct Day13;
 
@@ -69,23 +60,23 @@ impl Paper {
 
         match ins.direction {
             Direction::Horizontal => {
-                for i in self.data.clone().iter().filter(|x| x.x > ins.position) {
+                for i in self.data.clone().iter().filter(|x| x.x() > ins.position) {
                     self.data.remove(i);
-                    self.data.insert(Point::new(ins.position * 2 - i.x, i.y));
+                    self.data.insert(vector!(ins.position * 2 - i.x(), i.y()));
                 }
             }
             Direction::Vertical => {
-                for i in self.data.clone().iter().filter(|x| x.y > ins.position) {
+                for i in self.data.clone().iter().filter(|x| x.y() > ins.position) {
                     self.data.remove(i);
-                    self.data.insert(Point::new(i.x, ins.position * 2 - i.y));
+                    self.data.insert(vector!(i.x(), ins.position * 2 - i.y()));
                 }
             }
         }
     }
 
     fn bounds(&self) -> (usize, usize) {
-        let x = self.data.iter().map(|x| x.x).max().unwrap();
-        let y = self.data.iter().map(|x| x.y).max().unwrap();
+        let x = self.data.iter().map(|x| x.x()).max().unwrap();
+        let y = self.data.iter().map(|x| x.y()).max().unwrap();
         (x, y)
     }
 
@@ -95,7 +86,7 @@ impl Paper {
 
         for y in 0..=my {
             for x in 0..=mx {
-                let point = Point::new(x, y);
+                let point = vector!(x, y);
                 if self.data.contains(&point) {
                     out.push('#');
                 } else {
@@ -113,7 +104,7 @@ fn parse_point(raw: &str) -> Point {
     let parts = raw.split_once(',').unwrap();
     let x = parts.0.parse().unwrap();
     let y = parts.1.parse().unwrap();
-    Point::new(x, y)
+    vector!(x, y)
 }
 
 fn parse_fold(raw: &str) -> Fold {

aoc_2021/src/day_13.rs

@@ -4,6 +4,7 @@ use nd_vec::vector;
 type Point = nd_vec::Vec2<usize>;
 
 const NEW_POINT: Point = vector!(500, 0);
+
 pub struct Day14;
 
 impl Solution for Day14 {
@@ -47,7 +48,7 @@ impl Solution for Day14 {
 
 #[derive(Debug)]
 struct World {
-    data: Matrix<Element>,
+    data: Vec<Vec<Element>>,
     working: Point,
 
     x_adjust: usize,
@@ -63,12 +64,6 @@ enum Element {
     Air,
 }
 
-#[derive(Debug, Default, Clone, PartialEq, Eq)]
-pub struct Matrix<T> {
-    data: Vec<T>,
-    width: usize,
-}
-
 #[derive(Debug)]
 struct Line(Point, Point);
 
@@ -89,11 +84,12 @@ impl World {
         }
 
         let x_adjust = min_x - max_y;
-        let mut out = Matrix::new_filled(max_x - min_x + max_x + 1, max_y + 3, Element::Air);
+        let mut out = vec![vec![Element::Air; max_x - min_x + max_x + 1]; max_y + 3];
+
         lines
             .iter()
             .flat_map(|x| x.points())
-            .for_each(|x| out.set(x.x() - x_adjust, x.y(), Element::Wall));
+            .for_each(|x| out[x.y()][x.x() - x_adjust] = Element::Wall);
 
         Self {
             data: out,
@@ -125,48 +121,18 @@ impl World {
 
     fn count_sand(&self) -> usize {
         self.data
-            .raw()
             .iter()
+            .flat_map(|x| x.iter())
             .filter(|x| **x == Element::Sand)
             .count()
     }
 
     fn get(&self, x: usize, y: usize) -> &Element {
-        self.data.get(x - self.x_adjust, y)
+        &self.data[y][x - self.x_adjust]
     }
 
     fn get_mut(&mut self, x: usize, y: usize) -> &mut Element {
-        self.data.get_mut(x - self.x_adjust, y)
-    }
-}
-
-impl<T> Matrix<T> {
-    fn new_filled(width: usize, height: usize, val: T) -> Self
-    where
-        T: Clone,
-    {
-        Self {
-            data: vec![val; width * height],
-            width,
-        }
-    }
-
-    fn raw(&self) -> &Vec<T> {
-        &self.data
-    }
-
-    fn set(&mut self, x: usize, y: usize, data: T) {
-        self.data[y * self.width + x] = data;
-    }
-
-    fn get(&self, x: usize, y: usize) -> &T {
-        debug_assert!(x < self.width, "x out of bounds");
-        &self.data[y * self.width + x]
-    }
-
-    fn get_mut(&mut self, x: usize, y: usize) -> &mut T {
-        debug_assert!(x < self.width, "x out of bounds");
-        &mut self.data[y * self.width + x]
+        &mut self.data[y][x - self.x_adjust]
     }
 }