replaced my Array2D with maneatingape (similar logic, easier migration later)

Author: majcn

src/maneatingape/grid.rs

@@ -0,0 +1,92 @@
+// source: https://github.com/maneatingape/advent-of-code-rust/blob/72c8feb22030d55d7a08f16c119425b2ba759470/src/util/hash.rs
+
+//! Fast 2 dimensional Grid backed by a single `vec`. This module is designed to work with [`Point`].
+//!
+//! The traits [`Index`] and [`IndexMut`] are implemented for [`Point`] to allow usage like:
+//!
+//! ```
+//!   # use aoc::util::grid::Grid;
+//!   # use aoc::util::point::Point;
+//!
+//!   let mut grid = Grid::parse("1");
+//!   let point = Point::new(0, 0);
+//!
+//!   let foo = grid[point];
+//!   assert_eq!(foo, b'1');
+//!
+//!   grid[point] = foo + 1;
+//!   assert_eq!(grid[point], b'2');
+//! ```
+//!
+//! A convenience [`parse`] method creates a `Grid` directly from a 2 dimenionsal set of
+//! ASCII characters, a common occurence in Advent of Code inputs. The [`default_copy`] function
+//! creates a grid of the same size, that can be used for in BFS algorithms for tracking visited
+//! location or for tracking cost in Djikstra.
+//!
+//! [`Point`]: crate::util::point
+//! [`parse`]: Grid::parse
+//! [`default_copy`]: Grid::default_copy
+use crate::maneatingape::point::*;
+use std::ops::{Index, IndexMut};
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct Grid<T> {
+    pub width: i32,
+    pub height: i32,
+    pub bytes: Vec<T>,
+}
+
+impl Grid<u8> {
+    pub fn parse(input: &str) -> Self {
+        let raw: Vec<_> = input.lines().map(str::as_bytes).collect();
+        let width = raw[0].len() as i32;
+        let height = raw.len() as i32;
+        let mut bytes = Vec::with_capacity((width * height) as usize);
+        raw.iter().for_each(|slice| bytes.extend_from_slice(slice));
+        Grid {
+            width,
+            height,
+            bytes,
+        }
+    }
+}
+
+impl<T: Copy + PartialEq> Grid<T> {
+    pub fn default_copy<U: Default + Copy>(&self) -> Grid<U> {
+        Grid {
+            width: self.width,
+            height: self.height,
+            bytes: vec![U::default(); (self.width * self.height) as usize],
+        }
+    }
+
+    pub fn find(&self, needle: T) -> Option<Point> {
+        let to_point = |index| {
+            let x = (index as i32) % self.width;
+            let y = (index as i32) / self.width;
+            Point::new(x, y)
+        };
+        self.bytes.iter().position(|&h| h == needle).map(to_point)
+    }
+
+    #[inline]
+    pub fn contains(&self, point: Point) -> bool {
+        point.x >= 0 && point.x < self.width && point.y >= 0 && point.y < self.height
+    }
+}
+
+impl<T> Index<Point> for Grid<T> {
+    type Output = T;
+
+    #[inline]
+    fn index(&self, point: Point) -> &Self::Output {
+        &self.bytes[(self.width * point.y + point.x) as usize]
+    }
+}
+
+impl<T> IndexMut<Point> for Grid<T> {
+    #[inline]
+    fn index_mut(&mut self, point: Point) -> &mut Self::Output {
+        &mut self.bytes[(self.width * point.y + point.x) as usize]
+    }
+}

src/maneatingape/iter.rs

@@ -117,4 +117,4 @@ impl<I: Iterator> Iterator for Chunk<I, 8> {
         let h = self.iter.next()?;
         Some([a, b, c, d, e, f, g, h])
     }
-}
+}

src/maneatingape/mod.rs

@@ -1,3 +1,4 @@
+pub mod grid;
 pub mod hash;
 pub mod heap;
 pub mod integer;

src/util/grid.rs

@@ -1,3 +1 @@
 pub mod bignumbers;
-pub mod grid;
-pub mod list;