From 2d939c9c6e62395ed924fe7c5cd4c4b294e391a9 Mon Sep 17 00:00:00 2001
From: Luke Shumaker <lukeshu@lukeshu.com>
Date: Sun, 5 Feb 2023 12:06:30 -0700
Subject: Rename to git.lukeshu.com/go/containers, split in to 2 separate
 packages

---
 syncutil/cachemap.go  | 116 ++++++++++++++++++++++++++++++++++++++++++++++++++
 syncutil/map_go118.go |   9 ++++
 syncutil/map_go120.go |   9 ++++
 3 files changed, 134 insertions(+)
 create mode 100644 syncutil/cachemap.go
 create mode 100644 syncutil/map_go118.go
 create mode 100644 syncutil/map_go120.go

(limited to 'syncutil')

diff --git a/syncutil/cachemap.go b/syncutil/cachemap.go
new file mode 100644
index 0000000..8eab4bc
--- /dev/null
+++ b/syncutil/cachemap.go
@@ -0,0 +1,116 @@
+// Copyright (C) 2023  Luke Shumaker <lukeshu@lukeshu.com>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package syncutil
+
+import (
+	"sync"
+
+	"git.lukeshu.com/go/containers/typedsync"
+)
+
+type cacheVal[V any] struct {
+	wg sync.WaitGroup
+	v  V
+}
+
+// The techniques used by CacheMap are similar to the techniques used
+// by encoding/json's type cache.
+
+// A CacheMap is similar to a typedsync.Map, but also has a
+// .LoadOrCompute sibling to .LoadOrStore.  This is useful for caching
+// the results of computation where it is undesirable for concurrent
+// calls to duplicate work.
+//
+// Compared to a plain typedsync.Map, a CacheMap has both more space
+// overhead and more time overhead.
+type CacheMap[K mapkey, V any] struct {
+	inner typedsync.Map[K, *cacheVal[V]]
+	pool  typedsync.Pool[*cacheVal[V]]
+}
+
+func (m *CacheMap[K, V]) Delete(key K) {
+	m.inner.Delete(key)
+}
+
+// Load returns the value stored in the map for a key.  If the value
+// for that key is actively being computed by LoadOrCompute, this
+// blocks until the value has been computed.
+func (m *CacheMap[K, V]) Load(key K) (value V, ok bool) {
+	_value, ok := m.inner.Load(key)
+	if !ok {
+		var zero V
+		return zero, false
+	}
+	_value.wg.Wait()
+	return _value.v, true
+}
+
+// LoadAndDelete deletes the value for a key, returning the previous
+// value if any.  The loaded result reports whether the key was
+// present.  If the value for that key was actively being computed by
+// LoadOrCompute, this immediately removes the partial value from the
+// CacheMap, but does not return until the computation has finished.
+func (m *CacheMap[K, V]) LoadAndDelete(key K) (value V, loaded bool) {
+	_value, ok := m.inner.LoadAndDelete(key)
+	if !ok {
+		var zero V
+		return zero, false
+	}
+	_value.wg.Wait()
+	return _value.v, true
+}
+
+// LoadOrStore returns the existing value for the key if
+// present. Otherwise, it stores and returns the given value.  The
+// loaded result is true if the value was loaded, false if stored.  If
+// the value for that key is actively being computed by LoadOrCompute,
+// this blocks until the value has been computed.
+func (m *CacheMap[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {
+	_value, _ := m.pool.Get()
+	if _value == nil {
+		_value = new(cacheVal[V])
+	}
+	_value.v = value
+	_actual, loaded := m.inner.LoadOrStore(key, _value)
+	if loaded {
+		*_value = cacheVal[V]{}
+		m.pool.Put(_value)
+		_actual.wg.Wait()
+	}
+	return _actual.v, loaded
+}
+
+// LoadOrCompute returns the existing value for the key if present.
+// Otherwise, it computes and stores a value using the given function.
+// The loaded result is true if the value was loaded, false if
+// computed.  If a prior call to LoadOrCompute is still computing the
+// value for that key, a latter call blocks until the computation is
+// complete, and then returns the initial call's value.
+func (m *CacheMap[K, V]) LoadOrCompute(key K, fn func(K) V) (actual V, loaded bool) {
+	_value, _ := m.pool.Get()
+	if _value == nil {
+		_value = new(cacheVal[V])
+	}
+	_value.wg.Add(1)
+	_actual, loaded := m.inner.LoadOrStore(key, _value)
+	if loaded {
+		*_value = cacheVal[V]{}
+		m.pool.Put(_value)
+		_actual.wg.Wait()
+	} else {
+		_actual.v = fn(key)
+		_actual.wg.Done()
+	}
+	return _actual.v, loaded
+}
+
+func (m *CacheMap[K, V]) Store(key K, value V) {
+	_value, _ := m.pool.Get()
+	if _value == nil {
+		_value = new(cacheVal[V])
+	}
+	_value.v = value
+	m.inner.Store(key, _value)
+}
diff --git a/syncutil/map_go118.go b/syncutil/map_go118.go
new file mode 100644
index 0000000..2e71015
--- /dev/null
+++ b/syncutil/map_go118.go
@@ -0,0 +1,9 @@
+// Copyright (C) 2023  Luke Shumaker <lukeshu@lukeshu.com>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+//go:build !go1.20
+
+package syncutil
+
+type mapkey = any
diff --git a/syncutil/map_go120.go b/syncutil/map_go120.go
new file mode 100644
index 0000000..d6f62c1
--- /dev/null
+++ b/syncutil/map_go120.go
@@ -0,0 +1,9 @@
+// Copyright (C) 2023  Luke Shumaker <lukeshu@lukeshu.com>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+//go:build go1.20
+
+package syncutil
+
+type mapkey = comparable
-- 
cgit v1.2.3-54-g00ecf