Implement a MapGridBackend

= a grid backend based on a mutable map

Author: rhaendel

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

@@ -1,5 +1,8 @@
 package de.ronny_h.aoc.extensions.grids
 
+import kotlin.math.max
+import kotlin.math.min
+
 interface GridBackend<T> {
     operator fun get(x: Int, y: Int): T
     operator fun get(at: Coordinates): T
@@ -57,5 +60,55 @@ class ListGridBackend<T>(width: Int, height: Int, nullElement: T) : GridBackend<
             }
         }
     }
+}
+
+class MapGridBackend<T>(defaultValue: T) : GridBackend<T> {
+    private var minX = Int.MAX_VALUE
+    private var maxX = Int.MIN_VALUE
+    private var minY = Int.MAX_VALUE
+    private var maxY = Int.MIN_VALUE
+
+    private val grid = mutableMapOf<Coordinates, T>().withDefault { defaultValue }
+
+    override fun get(x: Int, y: Int): T = get(Coordinates(x, y))
+
+    override fun get(at: Coordinates): T {
+        if (at.x !in minX..maxX || at.y !in minY..maxY) {
+            throw IndexOutOfBoundsException("Coordinates $at are not inside the bound of this Grid (min and max coordinates for which values were set)")
+        }
+        return grid.getValue(at)
+    }
+
+    override fun set(x: Int, y: Int, value: T) = set(Coordinates(x, y), value)
+
+    override fun set(at: Coordinates, value: T) {
+        minX = min(minX, at.x)
+        minY = min(minY, at.y)
+        maxX = max(maxX, at.x)
+        maxY = max(maxY, at.y)
+        grid[at] = value
+    }
+
+    override fun getOrNull(x: Int, y: Int): T? = grid[Coordinates(x, y)]
+
+    override fun getOrNull(at: Coordinates): T? = grid[at]
+
+    override fun subGridAt(x: Int, y: Int, width: Int, height: Int): List<List<T>> = buildList {
+        for (row in y..<y + height) {
+            add(buildList {
+                for (col in x..<x + width) {
+                    add(grid.getValue(Coordinates(col, row)))
+                }
+            }
+            )
+        }
+    }
 
+    override fun <R> mapToSequence(transform: (x: Int, y: Int) -> R): Sequence<R> = sequence {
+        for (row in minY..maxY) {
+            for (col in minX..maxX) {
+                yield(transform(col, row))
+            }
+        }
+    }
 }

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

@@ -0,0 +1,77 @@
+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 MapGridBackendTest : StringSpec({
+
+    "get returns the existing element: the one that's set or the fallback element" {
+        val grid: GridBackend<Char> = MapGridBackend('#')
+        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 an element out of the bound of the elements set throws an Exception" {
+        val grid: GridBackend<Char> = MapGridBackend('#')
+        grid[0, 0] = '0'
+        grid[Coordinates(1, 1)] = '1'
+
+        shouldThrow<IndexOutOfBoundsException> {
+            grid[3, 0]
+        }
+    }
+
+    "getOrNull returns null for non existing elements" {
+        val grid: GridBackend<Char> = MapGridBackend('#')
+        grid[0, 0] = '0'
+        grid[Coordinates(1, 1)] = '1'
+
+        forAll(
+            row(0, 0, '0'),
+            row(0, 1, null),
+            row(1, 0, null),
+            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> = MapGridBackend('#')
+        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 = MapGridBackend(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")
+    }
+})