From 0b95ae8b2f14e8567c3db40f6cec7029607c57e4 Mon Sep 17 00:00:00 2001
From: qydysky <qydysky@foxmail.com>
Date: Sun, 20 Apr 2025 15:07:11 +0800
Subject: [PATCH] 1 (#46)

---
 sync/MapG.go | 113 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 113 insertions(+)
 create mode 100644 sync/MapG.go

diff --git a/sync/MapG.go b/sync/MapG.go
new file mode 100644
index 0000000..2e12c08
--- /dev/null
+++ b/sync/MapG.go
@@ -0,0 +1,113 @@
+package part
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+var (
+	_ = MapFunc[any, any](&MapG[any, any]{})
+)
+
+type MapG[T, E any] struct {
+	size atomic.Int64
+	m    sync.Map
+}
+
+func (t *MapG[T, E]) Store(k T, v E) {
+	if _, loaded := t.m.Swap(k, v); !loaded {
+		t.size.Add(1)
+	}
+}
+
+func (t *MapG[T, E]) CompareAndSwap(key T, old E, new E) (swapped bool) {
+	return t.m.CompareAndSwap(key, old, new)
+}
+
+func (t *MapG[T, E]) CompareAndDelete(key T, old E) (deleted bool) {
+	deleted = t.m.CompareAndDelete(key, old)
+	if deleted {
+		t.size.Add(-1)
+	}
+	return
+}
+
+func (t *MapG[T, E]) LoadAndDelete(key T) (value E, loaded bool) {
+	v, l := t.m.LoadAndDelete(key)
+	loaded = l
+	value = v.(E)
+	if l {
+		t.size.Add(-1)
+	}
+	return
+}
+
+func (t *MapG[T, E]) Swap(key T, value E) (previous E, loaded bool) {
+	v, l := t.m.Swap(key, value)
+	loaded = l
+	previous = v.(E)
+	return
+}
+
+func (t *MapG[T, E]) LoadOrStore(key T, value E) (actual E, loaded bool) {
+	v, l := t.m.LoadOrStore(key, value)
+	loaded = l
+	actual = v.(E)
+	if !loaded {
+		t.size.Add(1)
+	}
+	return
+}
+
+func (t *MapG[T, E]) Load(k T) (E, bool) {
+	v, ok := t.m.Load(k)
+	if ok {
+		return v.(E), true
+	}
+	return *new(E), false
+}
+
+func (t *MapG[T, E]) Range(f func(key T, value E) bool) {
+	t.m.Range(func(key, value any) bool {
+		return f(key.(T), value.(E))
+	})
+}
+
+func (t *MapG[T, E]) Delete(k T) {
+	if _, ok := t.m.LoadAndDelete(k); ok {
+		t.size.Add(-1)
+	}
+}
+
+func (t *MapG[T, E]) Clear() {
+	t.ClearAll()
+}
+
+func (t *MapG[T, E]) ClearAll() {
+	t.m.Range(func(key, _ any) bool {
+		t.m.Delete(key)
+		return true
+	})
+	t.size.Store(0)
+}
+
+func (t *MapG[T, E]) Len() int {
+	return int(t.size.Load())
+}
+
+func (t *MapG[T, E]) Copy() (m MapG[T, E]) {
+	t.Range(func(k T, v E) bool {
+		m.Store(k, v)
+		return true
+	})
+	return
+}
+
+func (t *MapG[T, E]) CopyP() (m *MapG[T, E]) {
+	m = &MapG[T, E]{}
+	t.Range(func(k T, v E) bool {
+		m.Store(k, v)
+		return true
+	})
+	return
+}
-- 
2.39.2