144 lines
2.8 KiB
Go
144 lines
2.8 KiB
Go
package lock
|
|
|
|
import (
|
|
"sync"
|
|
)
|
|
|
|
type Dict[K comparable, V any] struct {
|
|
dict map[K]V
|
|
lock sync.RWMutex
|
|
}
|
|
|
|
func NewDict[K comparable, V any]() *Dict[K, V] {
|
|
return &Dict[K, V]{
|
|
dict: make(map[K]V),
|
|
}
|
|
}
|
|
|
|
// Count get dict key count
|
|
func (d *Dict[K, V]) Count() int {
|
|
d.lock.RLock()
|
|
defer d.lock.RUnlock()
|
|
return len(d.dict)
|
|
}
|
|
|
|
// Keys get dict keys
|
|
func (d *Dict[K, V]) Keys() []K {
|
|
d.lock.RLock()
|
|
defer d.lock.RUnlock()
|
|
keys := make([]K, 0, len(d.dict))
|
|
for k := range d.dict {
|
|
keys = append(keys, k)
|
|
}
|
|
return keys
|
|
}
|
|
|
|
// Set set k v to dict, overwrite old value if exists
|
|
func (d *Dict[K, V]) Set(key K, value V) {
|
|
d.lock.Lock()
|
|
defer d.lock.Unlock()
|
|
d.dict[key] = value
|
|
}
|
|
|
|
// Has if exists, return true
|
|
func (d *Dict[K, V]) Has(key K) bool {
|
|
d.lock.RLock()
|
|
defer d.lock.RUnlock()
|
|
_, exists := d.dict[key]
|
|
return exists
|
|
}
|
|
|
|
// Get if exists, return value and true
|
|
func (d *Dict[K, V]) Get(key K) (V, bool) {
|
|
d.lock.RLock()
|
|
defer d.lock.RUnlock()
|
|
value, exists := d.dict[key]
|
|
return value, exists
|
|
}
|
|
|
|
// Del if exists and del success, return true
|
|
func (d *Dict[K, V]) Del(key K) bool {
|
|
d.lock.Lock()
|
|
defer d.lock.Unlock()
|
|
_, exists := d.dict[key]
|
|
delete(d.dict, key)
|
|
return exists
|
|
}
|
|
|
|
// Remove if exists and remove success, return old value and true
|
|
func (d *Dict[K, V]) Remove(key K) (V, bool) {
|
|
d.lock.Lock()
|
|
defer d.lock.Unlock()
|
|
value, exists := d.dict[key]
|
|
delete(d.dict, key)
|
|
return value, exists
|
|
}
|
|
|
|
// SetIfNotExists if not exists and set success, return true
|
|
func (d *Dict[K, V]) SetIfNotExists(key K, value V) bool {
|
|
d.lock.Lock()
|
|
defer d.lock.Unlock()
|
|
_, exists := d.dict[key]
|
|
if !exists {
|
|
d.dict[key] = value
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// GetOrSetIfNotExists if key exists return old:true, or, set new value, and return new:false
|
|
func (d *Dict[K, V]) GetOrSetIfNotExists(key K, new V) (V, bool) {
|
|
d.lock.Lock()
|
|
defer d.lock.Unlock()
|
|
old, exists := d.dict[key]
|
|
if !exists {
|
|
d.dict[key] = new
|
|
return new, false
|
|
}
|
|
return old, true
|
|
}
|
|
|
|
// Travel travels all dict keys and values
|
|
func (d *Dict[K, V]) Travel(travel func(key K, value V) bool) {
|
|
d.lock.RLock()
|
|
defer d.lock.RUnlock()
|
|
for key, value := range d.dict {
|
|
cont := travel(key, value)
|
|
if !cont {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Clear dict directly
|
|
func (d *Dict[K, V]) Clear() {
|
|
d.lock.Lock()
|
|
defer d.lock.Unlock()
|
|
d.dict = map[K]V{}
|
|
}
|
|
|
|
// Update replace dict directly
|
|
func (d *Dict[K, V]) Update(dict map[K]V) {
|
|
d.lock.Lock()
|
|
defer d.lock.Unlock()
|
|
d.dict = dict
|
|
}
|
|
|
|
// Replace replace dict directly and return old dict
|
|
func (d *Dict[K, V]) Replace(dict map[K]V) map[K]V {
|
|
d.lock.Lock()
|
|
defer d.lock.Unlock()
|
|
old := d.dict
|
|
d.dict = dict
|
|
return old
|
|
}
|
|
|
|
// Append dict directly
|
|
func (d *Dict[K, V]) Append(dict map[K]V) {
|
|
d.lock.Lock()
|
|
defer d.lock.Unlock()
|
|
for k, v := range dict {
|
|
d.dict[k] = v
|
|
}
|
|
}
|