From 716dd31f7cf52d9772fd4ed687f9cdc921443a35 Mon Sep 17 00:00:00 2001
From: Luke Shumaker <lukeshu@lukeshu.com>
Date: Thu, 26 Jan 2023 12:23:15 -0700
Subject: Set up as a separate repo

---
 lib/containers/syncmap.go   | 53 -----------------------------------
 lib/containers/syncpool.go  | 33 ----------------------
 lib/containers/syncvalue.go | 67 ---------------------------------------------
 3 files changed, 153 deletions(-)
 delete mode 100644 lib/containers/syncmap.go
 delete mode 100644 lib/containers/syncpool.go
 delete mode 100644 lib/containers/syncvalue.go

(limited to 'lib')

diff --git a/lib/containers/syncmap.go b/lib/containers/syncmap.go
deleted file mode 100644
index 74da4b3..0000000
--- a/lib/containers/syncmap.go
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (C) 2022-2023  Luke Shumaker <lukeshu@lukeshu.com>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package containers
-
-import (
-	"sync"
-)
-
-type SyncMap[K comparable, V any] struct {
-	inner sync.Map
-}
-
-func (m *SyncMap[K, V]) Delete(key K) {
-	m.inner.Delete(key)
-}
-
-func (m *SyncMap[K, V]) Load(key K) (value V, ok bool) {
-	_value, ok := m.inner.Load(key)
-	if ok {
-		//nolint:forcetypeassert // Typed wrapper around untyped lib.
-		value = _value.(V)
-	}
-	return value, ok
-}
-
-func (m *SyncMap[K, V]) LoadAndDelete(key K) (value V, loaded bool) {
-	_value, ok := m.inner.LoadAndDelete(key)
-	if ok {
-		//nolint:forcetypeassert // Typed wrapper around untyped lib.
-		value = _value.(V)
-	}
-	return value, ok
-}
-
-func (m *SyncMap[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {
-	_actual, loaded := m.inner.LoadOrStore(key, value)
-	//nolint:forcetypeassert // Typed wrapper around untyped lib.
-	actual = _actual.(V)
-	return actual, loaded
-}
-
-func (m *SyncMap[K, V]) Range(f func(key K, value V) bool) {
-	m.inner.Range(func(key, value any) bool {
-		//nolint:forcetypeassert // Typed wrapper around untyped lib.
-		return f(key.(K), value.(V))
-	})
-}
-
-func (m *SyncMap[K, V]) Store(key K, value V) {
-	m.inner.Store(key, value)
-}
diff --git a/lib/containers/syncpool.go b/lib/containers/syncpool.go
deleted file mode 100644
index cb5398d..0000000
--- a/lib/containers/syncpool.go
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (C) 2022-2023  Luke Shumaker <lukeshu@lukeshu.com>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package containers
-
-import (
-	"sync"
-)
-
-type SyncPool[T any] struct {
-	New func() T
-
-	inner sync.Pool
-}
-
-func (p *SyncPool[T]) Get() (val T, ok bool) {
-	_val := p.inner.Get()
-	switch {
-	case _val != nil:
-		//nolint:forcetypeassert // Typed wrapper around untyped lib.
-		return _val.(T), true
-	case p.New != nil:
-		return p.New(), true
-	default:
-		var zero T
-		return zero, false
-	}
-}
-
-func (p *SyncPool[T]) Put(val T) {
-	p.inner.Put(val)
-}
diff --git a/lib/containers/syncvalue.go b/lib/containers/syncvalue.go
deleted file mode 100644
index 160db3c..0000000
--- a/lib/containers/syncvalue.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright (C) 2022-2023  Luke Shumaker <lukeshu@lukeshu.com>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package containers
-
-import (
-	"sync"
-)
-
-// SyncValue is a typed equivalent of sync/atomic.Value.
-//
-// It is not actually a wrapper around sync/atomic.Value for
-// allocation-performance reasons.
-type SyncValue[T comparable] struct {
-	mu  sync.Mutex
-	ok  bool
-	val T
-}
-
-// This uses a dumb mutex-based solution because
-//
-//  1. Performance is good enough, because in the fast-path mutexes
-//     use the same compare-and-swap as sync/atomic.Value; and because
-//     all of these methods are short we're unlikely to hit the
-//     mutex's slow path.
-//
-//  2. We could use sync/atomic.Pointer[T], which by itself would have
-//     the same performance characteristics as sync/atomic.Value but
-//     without the benefit of runtime_procPin()/runtime_procUnpin().
-//     We want to avoid that because it means we're doing an
-//     allocation for every store/swap; avoiding that is our whole
-//     reason for not just wraping sync/atomic.Value.  So then we'd
-//     want to use a SyncPool to reuse allocations; but (1) that adds
-//     more sync-overhead, and (2) it also gets trickier because we'd
-//     have to be careful about not adding a pointer back to the pool
-//     when load has grabbed the pointer but not yet dereferenced it.
-
-func (v *SyncValue[T]) Load() (val T, ok bool) {
-	v.mu.Lock()
-	defer v.mu.Unlock()
-	return v.val, v.ok
-}
-
-func (v *SyncValue[T]) Store(val T) {
-	v.mu.Lock()
-	defer v.mu.Unlock()
-	v.val, v.ok = val, true
-}
-
-func (v *SyncValue[T]) Swap(newV T) (oldV T, oldOK bool) {
-	v.mu.Lock()
-	defer v.mu.Unlock()
-	oldV, oldOK = v.val, v.ok
-	v.val, v.ok = newV, true
-	return
-}
-
-func (v *SyncValue[T]) CompareAndSwap(oldV, newV T) (swapped bool) {
-	v.mu.Lock()
-	defer v.mu.Unlock()
-	if !v.ok || v.val != oldV {
-		return false
-	}
-	v.val = newV
-	return true
-}
-- 
cgit v1.2.3-2-g168b