fixed cache item behavior

Author: Code-Hex

cache.go

@@ -2,12 +2,60 @@ package cache
 
 import (
 	"sync"
+	"time"
 )
 
 // Cache is a common-cache interface.
 type Cache[K comparable, V any] interface {
 	Get(key K) (value V, ok bool)
-	Set(key K, val V)
+	Set(key K, val V, opts ...ItemOption)
+}
+
+// Item is an item
+type Item[K comparable, V any] struct {
+	Key        K
+	Value      V
+	Expiration time.Duration
+	CreatedAt  time.Time
+}
+
+var nowFunc = time.Now
+
+// HasExpired returns true if the item has expired.
+// If the item's expiration is zero value, returns false.
+func (i Item[K, T]) HasExpired() bool {
+	if i.Expiration <= 0 {
+		return false
+	}
+	return i.CreatedAt.Add(i.Expiration).Before(nowFunc())
+}
+
+// ItemOption is an option for cache item.
+type ItemOption func(*itemOptions)
+
+type itemOptions struct {
+	expiration time.Duration // default none
+}
+
+// WithExpiration is an option to set expiration time for any items.
+func WithExpiration(exp time.Duration) ItemOption {
+	return func(o *itemOptions) {
+		o.expiration = exp
+	}
+}
+
+// NewItem creates a new item with specified any options.
+func NewItem[K comparable, V any](key K, val V, opts ...ItemOption) *Item[K, V] {
+	o := new(itemOptions)
+	for _, optFunc := range opts {
+		optFunc(o)
+	}
+	return &Item[K, V]{
+		Key:        key,
+		Value:      val,
+		Expiration: o.expiration,
+		CreatedAt:  nowFunc(),
+	}
 }
 
 // NumberCache is a in-memory cache which is able to store only Number constraint.

cache_test.go

@@ -3,6 +3,7 @@ package cache_test
 import (
 	"sync"
 	"testing"
+	"time"
 
 	cache "github.com/Code-Hex/go-generics-cache"
 	"github.com/Code-Hex/go-generics-cache/simple"
@@ -49,3 +50,54 @@ func TestMultiThreadDecr(t *testing.T) {
 		t.Errorf("want %v but got %v", 0, counter)
 	}
 }
+
+func TestHasExpired(t *testing.T) {
+	cases := []struct {
+		name      string
+		exp       time.Duration
+		createdAt time.Time
+		current   time.Time
+		want      bool
+	}{
+		// expiration == createdAt + exp
+		{
+			name: "item expiration is zero",
+			want: false,
+		},
+		{
+			name:      "item expiration > current time",
+			exp:       time.Hour * 24,
+			createdAt: time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+			current:   time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+			want:      false,
+		},
+		{
+			name:      "item expiration < current time",
+			exp:       time.Hour * 24,
+			createdAt: time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+			current:   time.Date(2009, time.November, 12, 23, 0, 0, 0, time.UTC),
+			want:      true,
+		},
+		{
+			name:      "item expiration == current time",
+			exp:       time.Second,
+			createdAt: time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+			current:   time.Date(2009, time.November, 10, 23, 0, 1, 0, time.UTC),
+			want:      false,
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			reset := cache.SetNowFunc(tc.current)
+			defer reset()
+
+			it := &cache.Item[int, int]{
+				Expiration: tc.exp,
+				CreatedAt:  tc.createdAt,
+			}
+			if got := it.HasExpired(); tc.want != got {
+				t.Fatalf("want %v, but got %v", tc.want, got)
+			}
+		})
+	}
+}

export_test.go

@@ -0,0 +1,11 @@
+package cache
+
+import "time"
+
+func SetNowFunc(tm time.Time) (reset func()) {
+	backup := nowFunc
+	nowFunc = func() time.Time { return tm }
+	return func() {
+		nowFunc = backup
+	}
+}

lru/lru.go

@@ -17,11 +17,6 @@ type Cache[K comparable, V any] struct {
 
 var _ cache.Cache[interface{}, any] = (*Cache[interface{}, any])(nil)
 
-type item[K comparable, V any] struct {
-	Key   K
-	Value V
-}
-
 // NewCache creates a new LRU cache whose capacity is the default size (128).
 func NewCache[K comparable, V any]() *Cache[K, V] {
 	return NewCacheWithCap[K, V](128)
@@ -40,30 +35,33 @@ func NewCacheWithCap[K comparable, V any](cap int) *Cache[K, V] {
 func (c *Cache[K, V]) Get(key K) (zero V, _ bool) {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
-	if e, ok := c.items[key]; ok {
-		// updates cache order
-		c.list.MoveToFront(e)
-		return e.Value.(*item[K, V]).Value, true
+	e, ok := c.items[key]
+	if !ok {
+		return
+	}
+	item := e.Value.(*cache.Item[K, V])
+	if item.HasExpired() {
+		return
 	}
-	return
+	// updates cache order
+	c.list.MoveToFront(e)
+	return item.Value, true
 }
 
 // Set sets a value to the cache with key. replacing any existing value.
-func (c *Cache[K, V]) Set(key K, val V) {
+func (c *Cache[K, V]) Set(key K, val V, opts ...cache.ItemOption) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
 	if e, ok := c.items[key]; ok {
 		// updates cache order
 		c.list.MoveToFront(e)
-		e.Value.(*item[K, V]).Value = val
+		e.Value.(*cache.Item[K, V]).Value = val
 		return
 	}
 
-	e := c.list.PushFront(&item[K, V]{
-		Key:   key,
-		Value: val,
-	})
+	item := cache.NewItem(key, val, opts...)
+	e := c.list.PushFront(item)
 	c.items[key] = e
 
 	if c.list.Len() > c.cap {
@@ -77,7 +75,7 @@ func (c *Cache[K, V]) Keys() []K {
 	defer c.mu.RUnlock()
 	keys := make([]K, 0, len(c.items))
 	for ent := c.list.Back(); ent != nil; ent = ent.Prev() {
-		keys = append(keys, ent.Value.(*item[K, V]).Key)
+		keys = append(keys, ent.Value.(*cache.Item[K, V]).Key)
 	}
 	return keys
 }
@@ -113,6 +111,6 @@ func (c *Cache[K, V]) deleteOldest() {
 
 func (c *Cache[K, V]) delete(e *list.Element) {
 	c.list.Remove(e)
-	item := e.Value.(*item[K, V])
+	item := e.Value.(*cache.Item[K, V])
 	delete(c.items, item.Key)
 }

simple/example_test.go

@@ -5,12 +5,13 @@ import (
 	"sort"
 	"time"
 
+	cache "github.com/Code-Hex/go-generics-cache"
 	"github.com/Code-Hex/go-generics-cache/simple"
 )
 
 func ExampleCache() {
-	c := simple.NewCache[string, int](simple.WithExpiration(time.Hour))
-	c.Set("a", 1)
+	c := simple.NewCache[string, int]()
+	c.Set("a", 1, cache.WithExpiration(time.Hour))
 	c.Set("b", 2)
 	av, aok := c.Get("a")
 	bv, bok := c.Get("b")

simple/simple.go

@@ -1,119 +1,48 @@
 package simple
 
 import (
-	"errors"
-	"fmt"
 	"sync"
-	"time"
 
 	cache "github.com/Code-Hex/go-generics-cache"
 )
 
-var (
-	// ErrNotFound is an error which indicate an item is not found.
-	ErrNotFound = errors.New("not found item")
-
-	// ErrExpired is an error which indicate an item is expired.
-	ErrExpired = errors.New("expired item")
-)
-
-// Item is an item
-type Item[T any] struct {
-	Value      T
-	Expiration time.Duration
-	CreatedAt  time.Time
-}
-
-var nowFunc = time.Now
-
-// HasExpired returns true if the item has expired.
-// If the item's expiration is zero value, returns false.
-func (i Item[T]) HasExpired() bool {
-	if i.Expiration <= 0 {
-		return false
-	}
-	return i.CreatedAt.Add(i.Expiration).Before(nowFunc())
-}
-
 // Cache is a simple cache has no clear priority for evict cache.
 type Cache[K comparable, V any] struct {
-	items   map[K]*Item[V]
-	options *options
-	mu      sync.RWMutex
+	items map[K]*cache.Item[K, V]
+	mu    sync.RWMutex
 }
 
 var _ cache.Cache[interface{}, any] = (*Cache[interface{}, any])(nil)
 
 // NewCache creates a new cache.
-func NewCache[K comparable, V any](opts ...Option) *Cache[K, V] {
-	o := new(options)
-	for _, optFunc := range opts {
-		optFunc(o)
-	}
+func NewCache[K comparable, V any]() *Cache[K, V] {
 	return &Cache[K, V]{
-		items:   make(map[K]*Item[V]),
-		options: o,
-	}
-}
-
-// Option is an option for cache.
-type Option func(o *options)
-
-type options struct {
-	expiration time.Duration // default none
-}
-
-// WithExpiration is an option to set expiration time for any items.
-func WithExpiration(exp time.Duration) Option {
-	return func(o *options) {
-		o.expiration = exp
+		items: make(map[K]*cache.Item[K, V]),
 	}
 }
 
 // Set sets any item to the cache. replacing any existing item.
 // The default item never expires.
-func (c *Cache[K, V]) Set(k K, v V) {
-	item := &Item[V]{
-		Value:      v,
-		Expiration: c.options.expiration,
-		CreatedAt:  nowFunc(),
-	}
-	c.SetItem(k, item)
-}
-
-// SetItem sets any item to the cache. replacing any existing item.
-// The default item never expires.
-func (c *Cache[K, V]) SetItem(k K, v *Item[V]) {
+func (c *Cache[K, V]) Set(k K, v V, opts ...cache.ItemOption) {
 	c.mu.Lock()
-	c.items[k] = v
+	c.items[k] = cache.NewItem(k, v, opts...)
 	c.mu.Unlock()
 }
 
 // Get gets an item from the cache.
 // Returns the item or zero value, and a bool indicating whether the key was found.
 func (c *Cache[K, V]) Get(k K) (val V, ok bool) {
-	item, err := c.GetItem(k)
-	if err != nil {
-		return
-	}
-	return item.Value, true
-}
-
-// GetItem gets an item from the cache.
-// Returns an error if the item was not found or expired. If there is no error, the
-// incremented value is returned.
-func (c *Cache[K, V]) GetItem(k K) (val *Item[V], _ error) {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 
 	got, found := c.items[k]
 	if !found {
-		return nil, fmt.Errorf("key[%v]: %w", k, ErrNotFound)
+		return
 	}
 	if got.HasExpired() {
-		return nil, fmt.Errorf("key[%v]: %w", k, ErrExpired)
+		return
 	}
-	return got, nil
+	return got.Value, true
 }
 
 // Keys returns cache keys. the order is random.