Rename Grid "default_copy" to "same_size_with" and allow any copy value

Author: maneatingape

src/util/grid.rs

@@ -17,13 +17,13 @@
 //! ```
 //!
 //! 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
+//! ASCII characters, a common occurence in Advent of Code inputs. The [`same_size_with`] 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
+//! [`same_size_with`]: Grid::same_size_with
 use crate::util::point::*;
 use std::ops::{Index, IndexMut};
 
@@ -35,6 +35,7 @@ pub struct Grid<T> {
 }
 
 impl Grid<u8> {
+    #[inline]
     pub fn parse(input: &str) -> Self {
         let raw: Vec<_> = input.lines().map(str::as_bytes).collect();
         let width = raw[0].len() as i32;
@@ -46,6 +47,7 @@ impl Grid<u8> {
 }
 
 impl<T: Copy + PartialEq> Grid<T> {
+    #[inline]
     pub fn find(&self, needle: T) -> Option<Point> {
         let to_point = |index| {
             let x = (index as i32) % self.width;
@@ -63,11 +65,12 @@ impl<T: Copy> Grid<T> {
 }
 
 impl<T> Grid<T> {
-    pub fn default_copy<U: Default + Copy>(&self) -> Grid<U> {
+    #[inline]
+    pub fn same_size_with<U: Copy>(&self, value: U) -> Grid<U> {
         Grid {
             width: self.width,
             height: self.height,
-            bytes: vec![U::default(); (self.width * self.height) as usize],
+            bytes: vec![value; (self.width * self.height) as usize],
         }
     }
 

src/year2018/day13.rs

@@ -86,7 +86,7 @@ pub fn parse(input: &str) -> Input {
 
 pub fn part1(input: &Input) -> String {
     let mut carts = input.carts.clone();
-    let mut occupied = input.grid.default_copy();
+    let mut occupied = input.grid.same_size_with(false);
 
     loop {
         // Turn order is important.
@@ -109,7 +109,7 @@ pub fn part1(input: &Input) -> String {
 
 pub fn part2(input: &Input) -> String {
     let mut carts = input.carts.clone();
-    let mut occupied = input.grid.default_copy();
+    let mut occupied = input.grid.same_size_with(false);
 
     while carts.len() > 1 {
         // Turn order is important.

src/year2022/day12.rs

@@ -46,7 +46,7 @@ pub fn part2(input: &Input) -> u32 {
 fn bfs(input: &Input, end: u8) -> u32 {
     let (grid, start) = input;
     let mut todo = VecDeque::from([(*start, 0)]);
-    let mut visited = grid.default_copy::<bool>();
+    let mut visited = grid.same_size_with(false);
 
     while let Some((point, cost)) = todo.pop_front() {
         if grid[point] == end {

src/year2023/day03.rs

@@ -14,7 +14,7 @@ pub fn parse(input: &str) -> Input {
     // In order to tell if we've already seen a number before, store its index at the location
     // of every digit, using zero to indicate no value. For example:
     // `467..114..` => `1110022200`
-    let mut seen: Grid<usize> = grid.default_copy();
+    let mut seen: Grid<usize> = grid.same_size_with(0);
     // Stores each unique part number. The first value is a dummy placeholder.
     let mut parts = vec![0];
     let mut number = 0;

src/year2023/day14.rs

@@ -100,10 +100,10 @@ pub fn parse(input: &str) -> Input {
     }
 
     let mut rounded = Vec::new();
-    let mut north = grid.default_copy();
-    let mut west = grid.default_copy();
-    let mut south = grid.default_copy();
-    let mut east = grid.default_copy();
+    let mut north = grid.same_size_with(0);
+    let mut west = grid.same_size_with(0);
+    let mut south = grid.same_size_with(0);
+    let mut east = grid.same_size_with(0);
     let mut roll_north = Vec::new();
     let mut roll_west = Vec::new();
     let mut roll_south = Vec::new();

src/year2023/day16.rs

@@ -44,10 +44,10 @@ struct Shared<'a> {
 pub fn parse(input: &str) -> Input {
     let grid = Grid::parse(input);
 
-    let mut up: Grid<i32> = grid.default_copy();
-    let mut down: Grid<i32> = grid.default_copy();
-    let mut left: Grid<i32> = grid.default_copy();
-    let mut right: Grid<i32> = grid.default_copy();
+    let mut up: Grid<i32> = grid.same_size_with(0);
+    let mut down: Grid<i32> = grid.same_size_with(0);
+    let mut left: Grid<i32> = grid.same_size_with(0);
+    let mut right: Grid<i32> = grid.same_size_with(0);
 
     for x in 0..grid.width {
         let mut last = -1;
@@ -151,8 +151,8 @@ fn count(input: &Input, start: Pair) -> usize {
     let Input { grid, up, down, left, right } = input;
 
     let mut todo = VecDeque::with_capacity(1_000);
-    let mut seen: Grid<u8> = grid.default_copy();
-    let mut energized: Grid<bool> = grid.default_copy();
+    let mut seen: Grid<u8> = grid.same_size_with(0);
+    let mut energized: Grid<bool> = grid.same_size_with(false);
 
     todo.push_back(start);
 

src/year2024/day06.rs

@@ -161,10 +161,10 @@ struct Shortcut {
 
 impl Shortcut {
     fn from(grid: &Grid<u8>) -> Self {
-        let mut up = copy(grid);
-        let mut down = copy(grid);
-        let mut left = copy(grid);
-        let mut right = copy(grid);
+        let mut up = grid.same_size_with(ORIGIN);
+        let mut down = grid.same_size_with(ORIGIN);
+        let mut left = grid.same_size_with(ORIGIN);
+        let mut right = grid.same_size_with(ORIGIN);
 
         for x in 0..grid.width {
             let mut last = Point::new(x, -1);
@@ -217,11 +217,3 @@ impl Shortcut {
         Shortcut { up, down, left, right }
     }
 }
-
-fn copy(grid: &Grid<u8>) -> Grid<Point> {
-    Grid {
-        width: grid.width,
-        height: grid.height,
-        bytes: vec![ORIGIN; (grid.width * grid.height) as usize],
-    }
-}