Grid: Factor out a ListGridBackend

The new backend encapsulates the implementation details of
using mutable lists for managing the grid's data.

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/extensions/grids/Grid.kt

@@ -23,7 +23,7 @@ abstract class Grid<T>(
     private val fallbackElement: T = nullElement,
 ) {
 
-    private val grid: MutableList<MutableList<T>> = MutableList(height) { MutableList(width) { nullElement } }
+    private val grid: GridBackend<T> = ListGridBackend(width, height, nullElement)
 
     /**
      * A function that maps each `Char` that may occur in the `input: List<String>` to a value of type [T].
@@ -41,9 +41,7 @@ abstract class Grid<T>(
         overrideElement: T = nullElement,
         overrides: List<Coordinates> = emptyList()
     ) : this(height, width, nullElement, overrideElement) {
-        overrides.forEach {
-            grid[it.y][it.x] = overrideElement
-        }
+        overrides.forEach { grid[it] = overrideElement }
     }
 
     /**
@@ -64,27 +62,22 @@ abstract class Grid<T>(
 
     protected fun initGrid(input: List<String>) = input.forEachIndexed { y, line ->
         line.forEachIndexed { x, char ->
-            grid[y][x] = char.toElementType()
+            grid[x, y] = char.toElementType()
         }
     }
 
     /**
      * @return The value at the specified cell.
      */
-    operator fun get(x: Int, y: Int): T {
-        return grid
-            .getOrNull(y)
-            ?.getOrNull(x)
-            ?: fallbackElement
-    }
+    operator fun get(x: Int, y: Int): T = grid.getOrNull(x, y) ?: fallbackElement
 
     operator fun set(x: Int, y: Int, value: T) {
-        grid[y][x] = value
+        grid[x, y] = value
     }
 
-    fun getAt(position: Coordinates) = get(position.x, position.y)
+    fun getAt(position: Coordinates) = grid.getOrNull(position) ?: fallbackElement
     fun setAt(position: Coordinates, element: T) {
-        this.set(position.x, position.y, element)
+        grid[position] = element
     }
 
     /**
@@ -93,37 +86,18 @@ abstract class Grid<T>(
      * in this Grid, and vice-versa.
      * Structural changes in the base Grid make the behavior of the view undefined.
      */
-    fun subGridAt(x: Int, y: Int, width: Int, height: Int = width): List<List<T>> {
-        return buildList {
-            for (r in y..<y + height) {
-                add(grid[r].subList(x, x + width))
-            }
-        }
-    }
+    fun subGridAt(x: Int, y: Int, width: Int, height: Int = width): List<List<T>> = grid.subGridAt(x, y, width, height)
 
-    fun <R> forEachIndex(action: (x: Int, y: Int) -> R): Sequence<R> = sequence {
-        for (y in grid.indices) {
-            for (x in grid[0].indices) {
-                yield(action(x, y))
-            }
-        }
-    }
+    fun <R> forEachIndex(action: (x: Int, y: Int) -> R): Sequence<R> = grid.mapToSequence(action)
 
-    fun <R> forEachElement(action: (x: Int, y: Int, element: T) -> R): Sequence<R> = sequence {
-        for (y in grid.indices) {
-            for (x in grid[0].indices) {
-                yield(action(x, y, get(x, y)))
-            }
-        }
+    fun <R> forEachElement(action: (x: Int, y: Int, element: T) -> R): Sequence<R> = grid.mapToSequence { x, y ->
+        action(x, y, get(x, y))
     }
 
-    fun <R> forEachCoordinates(action: (position: Coordinates, element: T) -> R): Sequence<R> = sequence {
-        for (y in grid.indices) {
-            for (x in grid[0].indices) {
-                yield(action(Coordinates(x, y), get(x, y)))
-            }
+    fun <R> forEachCoordinates(action: (position: Coordinates, element: T) -> R): Sequence<R> =
+        grid.mapToSequence { x, y ->
+            action(Coordinates(x, y), get(x, y))
         }
-    }
 
     /**
      * Returns the first element matching the given [value].

src/main/kotlin/de/ronny_h/aoc/extensions/grids/GridBackend.kt

@@ -0,0 +1,61 @@
+package de.ronny_h.aoc.extensions.grids
+
+interface GridBackend<T> {
+    operator fun get(x: Int, y: Int): T
+    operator fun get(at: Coordinates): T
+
+    operator fun set(x: Int, y: Int, value: T)
+    operator fun set(at: Coordinates, value: T)
+
+    /**
+     * @return an element at the given [x] and [y] coordinates or null if the index is out of bounds of this GridBackend.
+     */
+    fun getOrNull(x: Int, y: Int): T?
+    fun getOrNull(at: Coordinates): T?
+
+    /**
+     * @return a view of the portion of this Grid between the specified [x], [y] (inclusive) and [x] + [width], [y] + [height] (exclusive).
+     * The returned list of lists is backed by this Grid, so non-structural changes in the returned list are reflected
+     * in this Grid, and vice-versa.
+     * Structural changes in the base Grid make the behavior of the view undefined.
+     */
+    fun subGridAt(x: Int, y: Int, width: Int, height: Int = width): List<List<T>>
+
+    fun <R> mapToSequence(transform: (x: Int, y: Int) -> R): Sequence<R>
+}
+
+class ListGridBackend<T>(width: Int, height: Int, nullElement: T) : GridBackend<T> {
+    private val grid: MutableList<MutableList<T>> = MutableList(height) { MutableList(width) { nullElement } }
+
+    override fun get(x: Int, y: Int) = grid[y][x]
+    override fun get(at: Coordinates): T = grid[at.y][at.x]
+
+    override fun set(x: Int, y: Int, value: T) {
+        grid[y][x] = value
+    }
+
+    override fun set(at: Coordinates, value: T) {
+        grid[at.y][at.x] = value
+    }
+
+    override fun getOrNull(x: Int, y: Int): T? = grid
+        .getOrNull(y)
+        ?.getOrNull(x)
+
+    override fun getOrNull(at: Coordinates): T? = getOrNull(at.x, at.y)
+
+    override fun subGridAt(x: Int, y: Int, width: Int, height: Int): List<List<T>> = buildList {
+        for (row in y..<y + height) {
+            add(grid[row].subList(x, x + width))
+        }
+    }
+
+    override fun <R> mapToSequence(transform: (x: Int, y: Int) -> R): Sequence<R> = sequence {
+        for (y in grid.indices) {
+            for (x in grid[0].indices) {
+                yield(transform(x, y))
+            }
+        }
+    }
+
+}

src/test/kotlin/de/ronny_h/aoc/extensions/grids/ListGridBackendTest.kt

@@ -0,0 +1,75 @@
+package de.ronny_h.aoc.extensions.grids
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.data.forAll
+import io.kotest.data.row
+import io.kotest.matchers.shouldBe
+
+class ListGridBackendTest : StringSpec({
+
+    "get returns the existing element: the one that's set or the fallback element" {
+        val grid: GridBackend<Char> = ListGridBackend(2, 2, '#')
+        grid[0, 0] = '0'
+        grid[Coordinates(1, 1)] = '1'
+
+        forAll(
+            row(0, 0, '0'),
+            row(0, 1, '#'),
+            row(1, 0, '#'),
+            row(1, 1, '1'),
+        ) { x, y, expected ->
+            grid[x, y] shouldBe expected
+            grid[Coordinates(x, y)] shouldBe expected
+        }
+    }
+
+    "get for non existing element throws an Exception" {
+        val grid: GridBackend<Char> = ListGridBackend(2, 2, '#')
+
+        shouldThrow<IndexOutOfBoundsException> {
+            grid[3, 0]
+        }
+    }
+
+    "getOrNull returns null for non existing elements" {
+        val grid: GridBackend<Char> = ListGridBackend(2, 2, '#')
+        grid[0, 0] = '0'
+        grid[Coordinates(1, 1)] = '1'
+
+        forAll(
+            row(0, 0, '0'),
+            row(0, 1, '#'),
+            row(1, 0, '#'),
+            row(1, 1, '1'),
+            row(2, 0, null),
+            row(0, 2, null),
+        ) { x, y, expected ->
+            grid.getOrNull(x, y) shouldBe expected
+            grid.getOrNull(Coordinates(x, y)) shouldBe expected
+        }
+    }
+
+    "subGridAt returns a list of lists for the specified section" {
+        val grid: GridBackend<Char> = ListGridBackend(3, 3, '#')
+        grid[0, 0] = '0'
+        grid[Coordinates(1, 1)] = '1'
+        grid[Coordinates(2, 2)] = '2'
+
+        grid.subGridAt(1, 1, 2, 2) shouldBe listOf(
+            listOf('1', '#'),
+            listOf('#', '2'),
+        )
+    }
+
+    "mapToSequence transforms each grid coordinates row by row" {
+        val grid = ListGridBackend(2, 2, 0)
+        grid[1, 0] = 1
+        grid[0, 1] = 2
+        grid[1, 1] = 3
+
+        grid.mapToSequence { x, y ->
+            "${grid[x, y]}"
+        }.toList() shouldBe listOf("0", "1", "2", "3")
+    }
+})