Add arraymap data structure

Author: unitoftime

ds/arraymap.go

@@ -0,0 +1,80 @@
+package ds
+
+import (
+	"iter"
+
+	"golang.org/x/exp/constraints"
+)
+
+// Acts like a map, but backed by an integer indexed slice instead of a map
+// This is mostly for use cases where you have a small list of increasing numbers that you want to store in an array, but you dont want to worry about ensuring the bounds are always correct
+// Note: If you put a huge key in here, the slice will allocate a ton of space.
+type ArrayMap[K constraints.Integer, V any] struct {
+	// TODO: set slice should just be a bitmask
+	set []bool // Tracks whether or not the data at a location is set or empty
+	slice []V // Tracks the data
+}
+
+func NewArrayMap[K constraints.Integer, V any]() ArrayMap[K, V] {
+	return ArrayMap[K, V]{
+		set: make([]bool, 0),
+		slice: make([]V, 0),
+	}
+}
+
+func(m *ArrayMap[K, V]) grow(idx K) {
+	requiredLength := idx + 1
+	growAmount := requiredLength - K(len(m.set))
+	if growAmount <= 0 {
+		return // No need to grow if the sliceIdx is already in bounds
+	}
+
+	m.set = append(m.set, make([]bool, growAmount)...)
+	m.slice = append(m.slice, make([]V, growAmount)...)
+}
+
+func(m *ArrayMap[K, V]) Put(idx K, val V) {
+	if idx < 0 {
+		return
+	}
+
+	m.grow(idx) // Ensure index is within bounds
+
+	m.set[idx] = true
+	m.slice[idx] = val
+}
+
+func(m *ArrayMap[K, V]) Get(idx K) (V, bool) {
+	if idx < 0 || idx >= K(len(m.set)) {
+		var v V
+		return v, false
+	}
+
+	return m.slice[idx], m.set[idx]
+}
+
+// Delete a specific index
+func(m *ArrayMap[K, V]) Delete(idx K) {
+	m.set[idx] = false
+}
+
+// Clear the entire slice
+func(m *ArrayMap[K, V]) Clear() {
+	m.slice = m.slice[:0]
+}
+
+// Iterate through the entire slice
+func(m *ArrayMap[K, V]) All() iter.Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		for i, v := range m.slice {
+			// Ensure that the map key is set
+			if !m.set[i] {
+				continue
+			}
+
+			if !yield(K(i), v) {
+				break
+			}
+		}
+	}
+}

ds/arraymap_test.go

@@ -0,0 +1,72 @@
+package ds
+
+import "testing"
+
+func TestArrayMap(t *testing.T) {
+	m := NewArrayMap[int, string]()
+
+	// Add and check 100
+	m.Put(100, "100")
+	v, ok := m.Get(100)
+	check(t, ok)
+	compare(t, v, "100")
+
+
+	// Doesn't have 50
+	v, ok = m.Get(50)
+	check(t, !ok)
+	compare(t, v, "")
+
+
+	// Add and check 50 (inside current bounds)
+	m.Put(50, "50")
+	v, ok = m.Get(50)
+	check(t, ok)
+	compare(t, v, "50")
+
+	// Doesn't have 150
+	v, ok = m.Get(150)
+	check(t, !ok)
+	compare(t, v, "")
+
+
+	// Add and check 150 (outside current bounds)
+	m.Put(150, "150")
+	v, ok = m.Get(150)
+	check(t, ok)
+	compare(t, v, "150")
+
+	// Iterate and check all expectations
+	expectedInts := []int{
+		50, 100, 150,
+	}
+	expectedStrings := []string{
+		"50", "100", "150",
+	}
+
+	i := 0
+	for k, v := range m.All() {
+		compare(t, k, expectedInts[i])
+		compare(t, v, expectedStrings[i])
+		i++
+	}
+
+	// Deleting 20 changes nothing
+	m.Delete(20)
+	i = 0
+	for k, v := range m.All() {
+		compare(t, k, expectedInts[i])
+		compare(t, v, expectedStrings[i])
+		i++
+	}
+
+	// Deleting the first makes us skip it in the expected list
+	m.Delete(50)
+	i = 1
+	for k, v := range m.All() {
+		compare(t, k, expectedInts[i])
+		compare(t, v, expectedStrings[i])
+		i++
+	}
+
+}

ds/slicemap.go

@@ -251,6 +251,13 @@ func (r Rect) BottomHalf() Rect {
 	return r.CutBottom(0.5 * r.H())
 }
 
+// Returns a centered square with height and width set by amount
+func (r Rect) SliceSquare(amount float64) Rect {
+	r = r.SliceHorizontal(amount)
+	r = r.SliceVertical(amount)
+	return r
+}
+
 // Returns a centered horizontal sliver with height set by amount
 func (r Rect) SliceHorizontal(amount float64) Rect {
 	r.CutTop((r.H() - amount) / 2)