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

---
 value.go | 67 ----------------------------------------------------------------
 1 file changed, 67 deletions(-)
 delete mode 100644 value.go

(limited to 'value.go')

diff --git a/value.go b/value.go
deleted file mode 100644
index 99c8876..0000000
--- a/value.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 typedsync
-
-import (
-	"sync"
-)
-
-// Value is a typed equivalent of sync/atomic.Value.
-//
-// It is not actually a wrapper around sync/atomic.Value for
-// allocation-performance reasons.
-type Value[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 Pool 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 *Value[T]) Load() (val T, ok bool) {
-	v.mu.Lock()
-	defer v.mu.Unlock()
-	return v.val, v.ok
-}
-
-func (v *Value[T]) Store(val T) {
-	v.mu.Lock()
-	defer v.mu.Unlock()
-	v.val, v.ok = val, true
-}
-
-func (v *Value[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 *Value[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