1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
|
package safe
import (
"maps"
"sync"
)
// SyncMap is a thread-safe map
type SyncMap[K comparable, V any] struct {
sync.RWMutex
m map[K]V
}
// NewSyncMap creates a new thread-safe map
func NewSyncMap[K comparable, V any]() *SyncMap[K, V] {
return &SyncMap[K, V]{
m: make(map[K]V),
}
}
func (m *SyncMap[K, V]) Store(k K, v V) {
m.Lock()
defer m.Unlock()
m.m[k] = v
}
func (m *SyncMap[K, V]) Load(k K) (v V, ok bool) {
m.RLock()
defer m.RUnlock()
v, ok = m.m[k]
return
}
// LoadOrStore returns the existing value for the key if present. Otherwise, it stores and returns the given value.
func (m *SyncMap[K, V]) LoadOrStore(k K, v V) (actual V, loaded bool) {
m.Lock()
defer m.Unlock()
actual, loaded = m.m[k]
if loaded {
return
}
m.m[k] = v
return v, false
}
// LoadAndDelete deletes the value for a key, and returns the previous value if any.
func (m *SyncMap[K, V]) LoadAndDelete(k K) (v V, loaded bool) {
m.Lock()
defer m.Unlock()
v, loaded = m.m[k]
if loaded {
delete(m.m, k)
}
return
}
func (m *SyncMap[K, V]) Delete(k K) {
m.Lock()
defer m.Unlock()
delete(m.m, k)
}
func (m *SyncMap[K, V]) Clear() {
m.Lock()
defer m.Unlock()
clear(m.m)
}
func (m *SyncMap[K, V]) Len() int {
m.RLock()
defer m.RUnlock()
return len(m.m)
}
func (m *SyncMap[K, V]) Clone() map[K]V {
m.RLock()
defer m.RUnlock()
return maps.Clone(m.m)
}
func (m *SyncMap[K, V]) Range(f func(k K, v V) bool) {
m.RLock()
defer m.RUnlock()
for k, v := range m.m {
if !f(k, v) {
break
}
}
}
|
