File size: 2,713 Bytes
ee8f748 | 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 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 | package csync
import (
"encoding/json"
"iter"
"maps"
"sync"
)
// Map is a concurrent map implementation that provides thread-safe access.
type Map[K comparable, V any] struct {
inner map[K]V
mu sync.RWMutex
}
// NewMap creates a new thread-safe map with the specified key and value types.
func NewMap[K comparable, V any]() *Map[K, V] {
return &Map[K, V]{
inner: make(map[K]V),
}
}
// NewMapFrom creates a new thread-safe map from an existing map.
func NewMapFrom[K comparable, V any](m map[K]V) *Map[K, V] {
return &Map[K, V]{
inner: m,
}
}
// Set sets the value for the specified key in the map.
func (m *Map[K, V]) Set(key K, value V) {
m.mu.Lock()
defer m.mu.Unlock()
m.inner[key] = value
}
// Del deletes the specified key from the map.
func (m *Map[K, V]) Del(key K) {
m.mu.Lock()
defer m.mu.Unlock()
delete(m.inner, key)
}
// Get gets the value for the specified key from the map.
func (m *Map[K, V]) Get(key K) (V, bool) {
m.mu.RLock()
defer m.mu.RUnlock()
v, ok := m.inner[key]
return v, ok
}
// Len returns the number of items in the map.
func (m *Map[K, V]) Len() int {
m.mu.RLock()
defer m.mu.RUnlock()
return len(m.inner)
}
// GetOrSet gets and returns the key if it exists, otherwise, it executes the
// given function, set its return value for the given key, and returns it.
func (m *Map[K, V]) GetOrSet(key K, fn func() V) V {
got, ok := m.Get(key)
if ok {
return got
}
value := fn()
m.Set(key, value)
return value
}
// Take gets an item and then deletes it.
func (m *Map[K, V]) Take(key K) (V, bool) {
m.mu.Lock()
defer m.mu.Unlock()
v, ok := m.inner[key]
delete(m.inner, key)
return v, ok
}
// Seq2 returns an iter.Seq2 that yields key-value pairs from the map.
func (m *Map[K, V]) Seq2() iter.Seq2[K, V] {
dst := make(map[K]V)
m.mu.RLock()
maps.Copy(dst, m.inner)
m.mu.RUnlock()
return func(yield func(K, V) bool) {
for k, v := range dst {
if !yield(k, v) {
return
}
}
}
}
// Seq returns an iter.Seq that yields values from the map.
func (m *Map[K, V]) Seq() iter.Seq[V] {
return func(yield func(V) bool) {
for _, v := range m.Seq2() {
if !yield(v) {
return
}
}
}
}
var (
_ json.Unmarshaler = &Map[string, any]{}
_ json.Marshaler = &Map[string, any]{}
)
func (Map[K, V]) JSONSchemaAlias() any { //nolint
m := map[K]V{}
return m
}
// UnmarshalJSON implements json.Unmarshaler.
func (m *Map[K, V]) UnmarshalJSON(data []byte) error {
m.mu.Lock()
defer m.mu.Unlock()
m.inner = make(map[K]V)
return json.Unmarshal(data, &m.inner)
}
// MarshalJSON implements json.Marshaler.
func (m *Map[K, V]) MarshalJSON() ([]byte, error) {
m.mu.RLock()
defer m.mu.RUnlock()
return json.Marshal(m.inner)
}
|