Merge pull request #10 from Code-Hex/refactor/cache

Author: Code-Hex

README.md

@@ -43,20 +43,21 @@ import (
 	"time"
 
 	cache "github.com/Code-Hex/go-generics-cache"
-	"github.com/Code-Hex/go-generics-cache/simple"
 )
 
 func main() {
-	// Create a simple cache. key as string, value as int.
-	simpleCache := simple.NewCache[string, int]()
+	// use simple cache algorithm without options.
+	c := cache.New[string, int]()
+	c.Set("a", 1)
+	gota, aok := c.Get("a")
+	gotb, bok := c.Get("b")
+	fmt.Println(gota, aok) // 1 true
+	fmt.Println(gotb, bok) // 0 false
 
 	// Create a cache for Number constraint. key as string, value as int.
-	nc := cache.NewNumber[string, int](simpleCache)
+	nc := cache.NewNumber[string, int]()
 	nc.Set("age", 26, cache.WithExpiration(time.Hour))
 
-	// This will be compile error, because string is not satisfied cache.Number constraint.
-	// nc := cache.NewNumber[string, string](simpleCache)
-
 	incremented := nc.Increment("age", 1)
 	fmt.Println(incremented) // 27
 

cache.go

@@ -3,45 +3,35 @@ package cache
 import (
 	"sync"
 	"time"
+
+	"github.com/Code-Hex/go-generics-cache/lfu"
+	"github.com/Code-Hex/go-generics-cache/lru"
+	"github.com/Code-Hex/go-generics-cache/simple"
 )
 
-// Cache is a common-cache interface.
-type Cache[K comparable, V any] interface {
+// Interface is a common-cache interface.
+type Interface[K comparable, V any] interface {
 	Get(key K) (value V, ok bool)
-	Set(key K, val V, opts ...ItemOption)
+	Set(key K, val V)
 	Keys() []K
 	Delete(key K)
-	Contains(key K) bool
 }
 
+var (
+	_ Interface[any, any] = (*simple.Cache[any, any])(nil)
+	_ Interface[any, any] = (*lru.Cache[any, any])(nil)
+	_ Interface[any, any] = (*lfu.Cache[any, any])(nil)
+)
+
 // Item is an item
 type Item[K comparable, V any] struct {
-	Key            K
-	Value          V
-	ReferenceCount int
-	Expiration     time.Duration
-	CreatedAt      time.Time
-	ReferencedAt   time.Time
-}
-
-// Referenced increments a reference counter and updates `ReferencedAt`
-// to current time.
-func (i *Item[K, V]) Referenced() {
-	i.ReferenceCount++
-	i.ReferencedAt = nowFunc()
+	Key        K
+	Value      V
+	Expiration time.Duration
 }
 
 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)
 
@@ -50,42 +40,155 @@ type itemOptions struct {
 }
 
 // WithExpiration is an option to set expiration time for any items.
+// If the expiration is zero or negative value, it treats as w/o expiration.
 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] {
+// 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)
 	}
-	now := nowFunc()
 	return &Item[K, V]{
-		Key:            key,
-		Value:          val,
-		ReferenceCount: 1,
-		Expiration:     o.expiration,
-		CreatedAt:      now,
-		ReferencedAt:   now,
+		Key:        key,
+		Value:      val,
+		Expiration: o.expiration,
+	}
+}
+
+// Cache is a cache.
+type Cache[K comparable, V any] struct {
+	cache       Interface[K, *Item[K, V]]
+	expirations map[K]chan struct{}
+	// mu is used to do lock in some method process.
+	mu sync.RWMutex
+}
+
+// Option is an option for cache.
+type Option[K comparable, V any] func(*options[K, V])
+
+type options[K comparable, V any] struct {
+	cache Interface[K, *Item[K, V]]
+}
+
+func newOptions[K comparable, V any]() *options[K, V] {
+	return &options[K, V]{
+		cache: simple.NewCache[K, *Item[K, V]](),
+	}
+}
+
+// AsLRU is an option to make a new Cache as LRU algorithm.
+func AsLRU[K comparable, V any](opts ...lru.Option) Option[K, V] {
+	return func(o *options[K, V]) {
+		o.cache = lru.NewCache[K, *Item[K, V]](opts...)
+	}
+}
+
+// AsLFU is an option to make a new Cache as LFU algorithm.
+func AsLFU[K comparable, V any](opts ...lfu.Option) Option[K, V] {
+	return func(o *options[K, V]) {
+		o.cache = lfu.NewCache[K, *Item[K, V]](opts...)
+	}
+}
+
+// New creates a new Cache.
+func New[K comparable, V any](opts ...Option[K, V]) *Cache[K, V] {
+	o := newOptions[K, V]()
+	for _, optFunc := range opts {
+		optFunc(o)
+	}
+	return &Cache[K, V]{
+		cache:       o.cache,
+		expirations: make(map[K]chan struct{}, 0),
+	}
+}
+
+// Get looks up a key's value from the cache.
+func (c *Cache[K, V]) Get(key K) (value V, ok bool) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	item, ok := c.cache.Get(key)
+	if !ok {
+		return
+	}
+	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, opts ...ItemOption) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	item := newItem(key, val, opts...)
+	if item.Expiration <= 0 {
+		c.cache.Set(key, item)
+		return
+	}
+
+	if _, ok := c.cache.Get(key); ok {
+		c.doneWatchExpiration(key)
 	}
+
+	c.cache.Set(key, item)
+	c.installExpirationWatcher(item.Key, item.Expiration)
+}
+
+func (c *Cache[K, V]) installExpirationWatcher(key K, exp time.Duration) {
+	done := make(chan struct{})
+	c.expirations[key] = done
+	go func() {
+		select {
+		case <-time.After(exp):
+			c.Delete(key)
+		case <-done:
+		}
+	}()
+}
+
+func (c *Cache[K, V]) doneWatchExpiration(key K) {
+	if ch, ok := c.expirations[key]; ok {
+		close(ch)
+	}
+}
+
+// Keys returns the keys of the cache. the order is relied on algorithms.
+func (c *Cache[K, V]) Keys() []K {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return c.cache.Keys()
+}
+
+// Delete deletes the item with provided key from the cache.
+func (c *Cache[K, V]) Delete(key K) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.cache.Delete(key)
+}
+
+// Contains reports whether key is within cache.
+func (c *Cache[K, V]) Contains(key K) bool {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	_, ok := c.cache.Get(key)
+	return ok
 }
 
 // NumberCache is a in-memory cache which is able to store only Number constraint.
 type NumberCache[K comparable, V Number] struct {
-	Cache[K, V]
+	*Cache[K, V]
 	// nmu is used to do lock in Increment/Decrement process.
-	// Note that this must be here as a separate mutex because mu in Cache struct is Locked in GetItem,
+	// Note that this must be here as a separate mutex because mu in Cache struct is Locked in Get,
 	// and if we call mu.Lock in Increment/Decrement, it will cause deadlock.
 	nmu sync.Mutex
 }
 
 // NewNumber creates a new cache for Number constraint.
-func NewNumber[K comparable, V Number](baseCache Cache[K, V]) *NumberCache[K, V] {
+func NewNumber[K comparable, V Number](opts ...Option[K, V]) *NumberCache[K, V] {
 	return &NumberCache[K, V]{
-		Cache: baseCache,
+		Cache: New(opts...),
 	}
 }
 

cache_test.go

@@ -3,14 +3,12 @@ package cache_test
 import (
 	"sync"
 	"testing"
-	"time"
 
 	cache "github.com/Code-Hex/go-generics-cache"
-	"github.com/Code-Hex/go-generics-cache/simple"
 )
 
 func TestMultiThreadIncr(t *testing.T) {
-	nc := cache.NewNumber[string, int](simple.NewCache[string, int]())
+	nc := cache.NewNumber[string, int]()
 	nc.Set("counter", 0)
 
 	var wg sync.WaitGroup
@@ -31,7 +29,7 @@ func TestMultiThreadIncr(t *testing.T) {
 }
 
 func TestMultiThreadDecr(t *testing.T) {
-	nc := cache.NewNumber[string, int](simple.NewCache[string, int]())
+	nc := cache.NewNumber[string, int]()
 	nc.Set("counter", 100)
 
 	var wg sync.WaitGroup
@@ -50,82 +48,3 @@ 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)
-			}
-		})
-	}
-}
-
-func TestReferenced(t *testing.T) {
-	tm := time.Now()
-	reset := cache.SetNowFunc(tm)
-
-	item := cache.NewItem("hello", "world")
-	if item.ReferenceCount != 1 {
-		t.Errorf("want ref count is 1 but got %d", item.ReferenceCount)
-	}
-	if !item.ReferencedAt.Equal(tm) {
-		t.Errorf("unexpected referenced_at got %v", item.ReferencedAt)
-	}
-
-	reset()
-	// update referenced_at
-	wantReferencedAt := tm.Add(time.Hour)
-	reset = cache.SetNowFunc(wantReferencedAt)
-	defer reset()
-
-	item.Referenced()
-
-	if item.ReferenceCount != 2 {
-		t.Errorf("want ref count is 2 but got %d", item.ReferenceCount)
-	}
-	if !item.ReferencedAt.Equal(wantReferencedAt) {
-		t.Errorf("unexpected referenced_at got %v", item.ReferencedAt)
-	}
-}