add cache with replace

Author: markus621

cache/cache_simple.go

@@ -0,0 +1,82 @@
+package cache
+
+import (
+	"sync"
+)
+
+type (
+	cacheReplace[K comparable, V any] struct {
+		list map[K]V
+		mux  sync.RWMutex
+	}
+)
+
+func NewWithReplace[K comparable, V any]() TCacheReplace[K, V] {
+	return &cacheReplace[K, V]{
+		list: make(map[K]V, 1000),
+	}
+}
+
+func (v *cacheReplace[K, V]) Has(key K) bool {
+	v.mux.RLock()
+	defer v.mux.RUnlock()
+
+	_, ok := v.list[key]
+
+	return ok
+}
+
+func (v *cacheReplace[K, V]) Get(key K) (V, bool) {
+	v.mux.RLock()
+	defer v.mux.RUnlock()
+
+	item, ok := v.list[key]
+	if !ok {
+		var zeroValue V
+		return zeroValue, false
+	}
+
+	return item, true
+}
+
+func (v *cacheReplace[K, V]) Set(key K, value V) {
+	v.mux.Lock()
+	defer v.mux.Unlock()
+
+	v.list[key] = value
+}
+
+func (v *cacheReplace[K, V]) Replace(data map[K]V) {
+	v.mux.Lock()
+	defer v.mux.Unlock()
+
+	v.list = data
+}
+
+func (v *cacheReplace[K, V]) Del(key K) {
+	v.mux.Lock()
+	defer v.mux.Unlock()
+
+	delete(v.list, key)
+}
+
+func (v *cacheReplace[K, V]) Keys() []K {
+	v.mux.RLock()
+	defer v.mux.RUnlock()
+
+	result := make([]K, 0, len(v.list))
+	for k := range v.list {
+		result = append(result, k)
+	}
+
+	return result
+}
+
+func (v *cacheReplace[K, V]) Flush() {
+	v.mux.Lock()
+	defer v.mux.Unlock()
+
+	for k := range v.list {
+		delete(v.list, k)
+	}
+}

cache/cache_time.go

@@ -9,28 +9,28 @@ import (
 )
 
 type (
-	withTTL[K comparable, T interface{}] struct {
+	cacheWithTTL[K comparable, V any] struct {
 		ttl  time.Duration
-		list map[K]*ttlItem[T]
+		list map[K]*itemCacheTTL[V]
 		mux  sync.RWMutex
 	}
 
-	ttlItem[T interface{}] struct {
-		link T
+	itemCacheTTL[V interface{}] struct {
+		link V
 		ts   int64
 	}
 )
 
-func NewWithTTL[K comparable, T interface{}](ctx context.Context, ttl time.Duration) TCache[K, T] {
-	cache := &withTTL[K, T]{
+func NewWithTTL[K comparable, V any](ctx context.Context, ttl time.Duration) TCacheTTL[K, V] {
+	cache := &cacheWithTTL[K, V]{
 		ttl:  ttl,
-		list: make(map[K]*ttlItem[T], 1000),
+		list: make(map[K]*itemCacheTTL[V], 1000),
 	}
 	go cache.cleaner(ctx)
 	return cache
 }
 
-func (v *withTTL[K, T]) cleaner(ctx context.Context) {
+func (v *cacheWithTTL[K, V]) cleaner(ctx context.Context) {
 	routine.Interval(ctx, v.ttl, func(ctx context.Context) {
 		curr := time.Now().Unix()
 
@@ -42,7 +42,7 @@ func (v *withTTL[K, T]) cleaner(ctx context.Context) {
 	})
 }
 
-func (v *withTTL[K, T]) Has(key K) bool {
+func (v *cacheWithTTL[K, V]) Has(key K) bool {
 	v.mux.RLock()
 	defer v.mux.RUnlock()
 
@@ -51,47 +51,47 @@ func (v *withTTL[K, T]) Has(key K) bool {
 	return ok
 }
 
-func (v *withTTL[K, T]) Get(key K) (T, bool) {
+func (v *cacheWithTTL[K, V]) Get(key K) (V, bool) {
 	v.mux.RLock()
 	defer v.mux.RUnlock()
 
 	item, ok := v.list[key]
 	if !ok {
-		var zeroValue T
+		var zeroValue V
 		return zeroValue, false
 	}
 
 	return item.link, true
 }
 
-func (v *withTTL[K, T]) Set(key K, value T) {
+func (v *cacheWithTTL[K, V]) Set(key K, value V) {
 	v.mux.Lock()
 	defer v.mux.Unlock()
 
-	v.list[key] = &ttlItem[T]{
+	v.list[key] = &itemCacheTTL[V]{
 		link: value,
 		ts:   time.Now().Add(v.ttl).Unix(),
 	}
 }
 
-func (v *withTTL[K, T]) SetWithTTL(key K, value T, ttl time.Time) {
+func (v *cacheWithTTL[K, V]) SetWithTTL(key K, value V, ttl time.Time) {
 	v.mux.Lock()
 	defer v.mux.Unlock()
 
-	v.list[key] = &ttlItem[T]{
+	v.list[key] = &itemCacheTTL[V]{
 		link: value,
 		ts:   ttl.Unix(),
 	}
 }
 
-func (v *withTTL[K, T]) Del(key K) {
+func (v *cacheWithTTL[K, V]) Del(key K) {
 	v.mux.Lock()
 	defer v.mux.Unlock()
 
 	delete(v.list, key)
 }
 
-func (v *withTTL[K, T]) Keys() []K {
+func (v *cacheWithTTL[K, V]) Keys() []K {
 	v.mux.RLock()
 	defer v.mux.RUnlock()
 
@@ -103,7 +103,7 @@ func (v *withTTL[K, T]) Keys() []K {
 	return result
 }
 
-func (v *withTTL[K, T]) Flush() {
+func (v *cacheWithTTL[K, V]) Flush() {
 	v.mux.Lock()
 	defer v.mux.Unlock()
 

cache/common.go

@@ -2,12 +2,21 @@ package cache
 
 import "time"
 
-type TCache[K comparable, T interface{}] interface {
+type TCache[K comparable, V interface{}] interface {
 	Has(key K) bool
-	Get(key K) (T, bool)
-	Set(key K, value T)
-	SetWithTTL(key K, value T, ttl time.Time)
+	Get(key K) (V, bool)
+	Set(key K, value V)
 	Del(key K)
 	Keys() []K
 	Flush()
 }
+
+type TCacheTTL[K comparable, V interface{}] interface {
+	TCache[K, V]
+	SetWithTTL(key K, value V, ttl time.Time)
+}
+
+type TCacheReplace[K comparable, V interface{}] interface {
+	TCache[K, V]
+	Replace(data map[K]V)
+}