Add tests, missing functions

Author: donomii

README.md

@@ -1,2 +1,95 @@
 # genericsyncmap
-A thread-safe, type-safe map for golang that uses generics and locks to provide safety
+
+A typed, thread-safe map implementation for Go, built on top of `sync.Map` using generics.
+
+`genericsyncmap` provides the concurrency benefits of `sync.Map` with the safety and convenience of Go generics. It implements the full feature set of `sync.Map` (as of Go 1.20+), and is as close to a drop-in replacement as possible.  You can remove the type casts from your code, and replace them with this.
+
+## Features
+
+- **Type Safety**: No more `interface{}` casting or assertions. Compile-time checks for key and value types.
+- **Thread Safety**: Fully safe for concurrent use by multiple goroutines without additional locking.
+- **Full Parity**: Implements all methods found in the standard library's `sync.Map`.
+- **Zero Dependencies**: Built strictly on the standard library.
+
+## Installation
+
+```bash
+go get github.com/donomii/genericsyncmap
+```
+
+## Use
+
+### Basic Operations
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/donomii/genericsyncmap"
+)
+
+func main() {
+	// Create a new map with string keys and int values
+	m := syncmap.NewSyncMap[string, int]()
+
+	// Store values
+	m.Store("apple", 10)
+	m.Store("banana", 20)
+
+	// Load values
+	if val, ok := m.Load("apple"); ok {
+		fmt.Printf("Apple count: %d\n", val)
+	}
+
+	// Delete
+	m.Delete("banana")
+}
+```
+
+### Atomic Operations
+
+One of the main advantages of `sync.Map` is the ability to perform atomic operations without external locks. `genericsyncmap` exposes all of these in a type-safe way:
+
+```go
+// LoadOrStore
+val, loaded := m.LoadOrStore("cherry", 5)
+
+// LoadAndDelete
+val, loaded = m.LoadAndDelete("apple")
+
+// Swap (Store and return previous)
+prev, loaded := m.Swap("grape", 30)
+
+// CompareAndSwap (Swap only if old value matches)
+swapped := m.CompareAndSwap("grape", 30, 35)
+
+// CompareAndDelete (Delete only if value matches)
+deleted := m.CompareAndDelete("grape", 35)
+```
+
+### Iteration
+
+Use the `Range` method to iterate over the map. Returning `false` from the callback stops iteration.
+
+```go
+m.Range(func(key string, value int) bool {
+    fmt.Printf("%s: %d\n", key, value)
+    return true // continue iteration
+})
+```
+
+Helper methods `Keys()`, `Values()`, and `Len()` are also provided, though be aware that `Len()` requires iterating the entire map (O(N)).
+
+## Performance
+
+Since this is a thin wrapper around `sync.Map`, performance characteristics are identical:
+- Optimized for cases where keys are stable (loaded/read often, updated rarely).
+- Excellent for cache implementations.
+
+
+Benchmarks included in the repository (`go test -bench .`).
+
+## License
+
+MIT

go.mod

@@ -1,3 +1,3 @@
-module github.com/donomii/clusterF/syncmap
+module github.com/donomii/genericsyncmap
 
 go 1.24.0

syncmap.go

@@ -33,11 +33,44 @@ func (sm *SyncMap[K, V]) LoadOrStore(key K, value V) (V, bool) {
 	return actual.(V), loaded
 }
 
+// LoadAndDelete gets existing value and deletes it, returns value and whether it was loaded (deleted)
+func (sm *SyncMap[K, V]) LoadAndDelete(key K) (V, bool) {
+	val, loaded := sm.m.LoadAndDelete(key)
+	if loaded {
+		return val.(V), true
+	}
+	var zero V
+	return zero, false
+}
+
 // Delete removes a key
 func (sm *SyncMap[K, V]) Delete(key K) {
 	sm.m.Delete(key)
 }
 
+// Swap swaps the value for a key and returns the previous value if any.
+// The loaded result reports whether the key was present.
+func (sm *SyncMap[K, V]) Swap(key K, value V) (previous V, loaded bool) {
+	prev, loaded := sm.m.Swap(key, value)
+	if loaded {
+		return prev.(V), true
+	}
+	var zero V
+	return zero, false
+}
+
+// CompareAndSwap swaps the old and new values for key if the value stored in the map is equal to old.
+// The old value must be of a comparable type.
+func (sm *SyncMap[K, V]) CompareAndSwap(key K, old V, new V) (swapped bool) {
+	return sm.m.CompareAndSwap(key, old, new)
+}
+
+// CompareAndDelete deletes the entry for key if its value is equal to old.
+// The old value must be of a comparable type.
+func (sm *SyncMap[K, V]) CompareAndDelete(key K, old V) (deleted bool) {
+	return sm.m.CompareAndDelete(key, old)
+}
+
 // Range calls fn for each key-value pair.  Returning false quits the iteration
 func (sm *SyncMap[K, V]) Range(fn func(key K, value V) bool) {
 	sm.m.Range(func(key, value any) bool {