73 lines
1.9 KiB
Go
73 lines
1.9 KiB
Go
//go:build migrated_fynedo
|
|
|
|
package async
|
|
|
|
// Map is a generic wrapper around [sync.Map].
|
|
type Map[K any, V any] struct {
|
|
// Use "comparable" as type constraint and map[K]V as the inner type
|
|
// once Go 1.20 is our minimum version so interfaces can be used as keys.
|
|
m map[any]V
|
|
}
|
|
|
|
// Delete deletes the value for a key.
|
|
func (m *Map[K, V]) Delete(key K) {
|
|
delete(m.m, key)
|
|
}
|
|
|
|
// Len returns the length of the map. It is O(n) over the number of items.
|
|
func (m *Map[K, V]) Len() (count int) {
|
|
return len(m.m)
|
|
}
|
|
|
|
// Load returns the value stored in the map for a key, or nil if no value is present.
|
|
// The ok result indicates whether value was found in the map.
|
|
func (m *Map[K, V]) Load(key K) (value V, ok bool) {
|
|
val, ok := m.m[key]
|
|
return val, ok
|
|
}
|
|
|
|
// LoadAndDelete deletes the value for a key, returning the previous value if any.
|
|
// The loaded result reports whether the key was present.
|
|
func (m *Map[K, V]) LoadAndDelete(key K) (value V, loaded bool) {
|
|
val, ok := m.m[key]
|
|
delete(m.m, key)
|
|
return val, ok
|
|
}
|
|
|
|
// LoadOrStore returns the existing value for the key if present.
|
|
// Otherwise, it stores and returns the given value.
|
|
// The loaded result is true if the value was loaded, false if stored.
|
|
func (m *Map[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {
|
|
if m.m == nil {
|
|
m.m = make(map[any]V)
|
|
}
|
|
|
|
if val, ok := m.m[key]; ok {
|
|
return val, true
|
|
}
|
|
m.m[key] = value
|
|
return value, false
|
|
}
|
|
|
|
// Range calls f sequentially for each key and value present in the map. If f returns false, range stops the iteration.
|
|
func (m *Map[K, V]) Range(f func(key K, value V) bool) {
|
|
for k, v := range m.m {
|
|
if !f(k.(K), v) {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// Store sets the value for a key.
|
|
func (m *Map[K, V]) Store(key K, value V) {
|
|
if m.m == nil {
|
|
m.m = make(map[any]V)
|
|
}
|
|
m.m[key] = value
|
|
}
|
|
|
|
// Clear removes all entries from the map.
|
|
func (m *Map[K, V]) Clear() {
|
|
m.m = make(map[any]V) // Use range-and-delete loop once Go 1.20 is the minimum version.
|
|
}
|