98 lines
1.9 KiB
Go
98 lines
1.9 KiB
Go
package result
|
|
|
|
import (
|
|
"seanime/internal/util"
|
|
)
|
|
|
|
type Map[K interface{}, V any] struct {
|
|
store util.RWMutexMap
|
|
}
|
|
|
|
type mapItem[K interface{}, V any] struct {
|
|
value V
|
|
}
|
|
|
|
func NewResultMap[K interface{}, V any]() *Map[K, V] {
|
|
return &Map[K, V]{}
|
|
}
|
|
|
|
func (c *Map[K, V]) Set(key K, value V) {
|
|
c.store.Store(key, &mapItem[K, V]{value})
|
|
}
|
|
|
|
func (c *Map[K, V]) Get(key K) (V, bool) {
|
|
item, ok := c.store.Load(key)
|
|
if !ok {
|
|
return (&mapItem[K, V]{}).value, false
|
|
}
|
|
ci := item.(*mapItem[K, V])
|
|
return ci.value, true
|
|
}
|
|
|
|
func (c *Map[K, V]) Has(key K) bool {
|
|
_, ok := c.store.Load(key)
|
|
return ok
|
|
}
|
|
|
|
func (c *Map[K, V]) GetOrSet(key K, createFunc func() (V, error)) (V, error) {
|
|
value, ok := c.Get(key)
|
|
if ok {
|
|
return value, nil
|
|
}
|
|
|
|
newValue, err := createFunc()
|
|
if err != nil {
|
|
return newValue, err
|
|
}
|
|
c.Set(key, newValue)
|
|
return newValue, nil
|
|
}
|
|
|
|
func (c *Map[K, V]) Delete(key K) {
|
|
c.store.Delete(key)
|
|
}
|
|
|
|
func (c *Map[K, V]) Clear() {
|
|
c.store.Range(func(key interface{}, value interface{}) bool {
|
|
c.store.Delete(key)
|
|
return true
|
|
})
|
|
}
|
|
|
|
// ClearN clears the map and returns the number of items cleared
|
|
func (c *Map[K, V]) ClearN() int {
|
|
count := 0
|
|
c.store.Range(func(key interface{}, value interface{}) bool {
|
|
c.store.Delete(key)
|
|
count++
|
|
return true
|
|
})
|
|
return count
|
|
}
|
|
|
|
func (c *Map[K, V]) Range(callback func(key K, value V) bool) {
|
|
c.store.Range(func(key, value interface{}) bool {
|
|
ci := value.(*mapItem[K, V])
|
|
return callback(key.(K), ci.value)
|
|
})
|
|
}
|
|
|
|
func (c *Map[K, V]) Values() []V {
|
|
values := make([]V, 0)
|
|
c.store.Range(func(key, value interface{}) bool {
|
|
item := value.(*mapItem[K, V]) // Correct type assertion
|
|
values = append(values, item.value)
|
|
return true
|
|
})
|
|
return values
|
|
}
|
|
|
|
func (c *Map[K, V]) Keys() []K {
|
|
keys := make([]K, 0)
|
|
c.store.Range(func(key, value interface{}) bool {
|
|
keys = append(keys, key.(K))
|
|
return true
|
|
})
|
|
return keys
|
|
}
|