removed expiration code from some algorithm pkgs

Author: Code-Hex

lfu/lfu.go

@@ -15,7 +15,7 @@ type Cache[K comparable, V any] struct {
 	mu    sync.RWMutex
 }
 
-var _ cache.Cache[interface{}, any] = (*Cache[interface{}, any])(nil)
+var _ cache.Interface[interface{}, any] = (*Cache[interface{}, any])(nil)
 
 // NewCache creates a new LFU cache whose capacity is the default size (128).
 func NewCache[K comparable, V any]() *Cache[K, V] {
@@ -40,16 +40,13 @@ func (c *Cache[K, V]) Get(key K) (zero V, _ bool) {
 	if !ok {
 		return
 	}
-	if e.item.HasExpired() {
-		return
-	}
-	e.item.Referenced()
+	e.referenced()
 	heap.Fix(c.queue, e.index)
-	return e.item.Value, true
+	return e.val, 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 ...cache.ItemOption) {
+func (c *Cache[K, V]) Set(key K, val V) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
@@ -60,10 +57,10 @@ func (c *Cache[K, V]) Set(key K, val V, opts ...cache.ItemOption) {
 
 	if len(c.items) == c.cap {
 		evictedEntry := heap.Pop(c.queue).(*entry[K, V])
-		delete(c.items, evictedEntry.item.Key)
+		delete(c.items, evictedEntry.key)
 	}
 
-	e := newEntry(key, val, opts...)
+	e := newEntry(key, val)
 	heap.Push(c.queue, e)
 	c.items[key] = e
 }
@@ -74,7 +71,7 @@ func (c *Cache[K, V]) Keys() []K {
 	defer c.mu.RUnlock()
 	keys := make([]K, 0, len(c.items))
 	for _, entry := range *c.queue {
-		keys = append(keys, entry.item.Key)
+		keys = append(keys, entry.key)
 	}
 	return keys
 }
@@ -89,17 +86,6 @@ func (c *Cache[K, V]) Delete(key K) {
 	}
 }
 
-// Contains reports whether key is within cache.
-func (c *Cache[K, V]) Contains(key K) bool {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-	e, ok := c.items[key]
-	if !ok {
-		return false
-	}
-	return !e.item.HasExpired()
-}
-
 // Len returns the number of items in the cache.
 func (c *Cache[K, V]) Len() int {
 	c.mu.RLock()

lfu/lfu_internal_test.go

@@ -1,69 +1 @@
 package lfu
-
-import (
-	"testing"
-	"time"
-
-	cache "github.com/Code-Hex/go-generics-cache"
-)
-
-func TestContains(t *testing.T) {
-	t.Run("without expiration", func(t *testing.T) {
-		cache := NewCache[string, int]()
-		cache.Set("foo", 1)
-		cache.Set("bar", 2)
-		cache.Set("baz", 3)
-		for _, key := range []string{
-			"foo",
-			"bar",
-			"baz",
-		} {
-			if !cache.Contains(key) {
-				t.Errorf("not found: %s", key)
-			}
-		}
-		if cache.Contains("not found") {
-			t.Errorf("found")
-		}
-	})
-
-	t.Run("with expiration", func(t *testing.T) {
-		c := NewCache[string, int]()
-		key := "foo"
-		exp := time.Hour
-		c.Set(key, 1, cache.WithExpiration(exp))
-		// modify directly
-		e, ok := c.items[key]
-		if !ok {
-			t.Fatal("unexpected not found key")
-		}
-		item := e.item
-		item.CreatedAt = time.Now().Add(-2 * exp)
-
-		if c.Contains(key) {
-			t.Errorf("found")
-		}
-	})
-}
-
-func TestGet(t *testing.T) {
-	c := NewCache[string, int]()
-	key := "foo"
-	exp := time.Hour
-	c.Set(key, 1, cache.WithExpiration(exp))
-	_, ok := c.Get(key)
-	if !ok {
-		t.Fatal("unexpected not found")
-	}
-	// modify directly
-	e, ok := c.items[key]
-	if !ok {
-		t.Fatal("unexpected not found key")
-	}
-	item := e.item
-	item.CreatedAt = time.Now().Add(-2 * exp)
-	_, ok2 := c.Get(key)
-	if ok2 {
-		t.Fatal("unexpected found (expired)")
-	}
-}

lfu/priority_queue_test.go

@@ -27,10 +27,10 @@ func TestPriorityQueue(t *testing.T) {
 		if entry.index != idx {
 			t.Errorf("want index %d, but got %d", entry.index, idx)
 		}
-		if entry.item.ReferenceCount != 1 {
+		if entry.referenceCount != 1 {
 			t.Errorf("want count 1")
 		}
-		if got := entry.item.Value; nums[idx] != got {
+		if got := entry.val; nums[idx] != got {
 			t.Errorf("want value %d but got %d", nums[idx], got)
 		}
 	}
@@ -53,8 +53,8 @@ func TestPriorityQueue(t *testing.T) {
 	if got.index != -1 {
 		t.Errorf("want index -1, but got %d", got.index)
 	}
-	if wantValue != got.item.Value {
-		t.Errorf("want the lowest priority value is %d, but got %d", wantValue, got.item.Value)
+	if wantValue != got.val {
+		t.Errorf("want the lowest priority value is %d, but got %d", wantValue, got.val)
 	}
 	if want, got := len(nums)-1, queue.Len(); want != got {
 		t.Errorf("want %d, but got %d", want, got)
@@ -66,8 +66,8 @@ func TestPriorityQueue(t *testing.T) {
 	if got.index != -1 {
 		t.Errorf("want index -1, but got %d", got.index)
 	}
-	if wantValue2 != got2.item.Value {
-		t.Errorf("want the lowest priority value is %d, but got %d", wantValue2, got2.item.Value)
+	if wantValue2 != got2.val {
+		t.Errorf("want the lowest priority value is %d, but got %d", wantValue2, got2.val)
 	}
 	if want, got := len(nums)-2, queue.Len(); want != got {
 		t.Errorf("want %d, but got %d", want, got)

lfu/priotiry_queue.go

@@ -2,22 +2,34 @@ package lfu
 
 import (
 	"container/heap"
+	"time"
 
 	cache "github.com/Code-Hex/go-generics-cache"
 )
 
 type entry[K comparable, V any] struct {
-	index int
-	item  *cache.Item[K, V]
+	index          int
+	key            K
+	val            V
+	referenceCount int
+	referencedAt   time.Time
 }
 
 func newEntry[K comparable, V any](key K, val V, opts ...cache.ItemOption) *entry[K, V] {
 	return &entry[K, V]{
-		index: 0,
-		item:  cache.NewItem(key, val, opts...),
+		index:          0,
+		key:            key,
+		val:            val,
+		referenceCount: 1,
+		referencedAt:   time.Now(),
 	}
 }
 
+func (e *entry[K, V]) referenced() {
+	e.referenceCount++
+	e.referencedAt = time.Now()
+}
+
 type priorityQueue[K comparable, V any] []*entry[K, V]
 
 func newPriorityQueue[K comparable, V any](cap int) *priorityQueue[K, V] {
@@ -31,10 +43,10 @@ var _ heap.Interface = (*priorityQueue[interface{}, interface{}])(nil)
 func (l priorityQueue[K, V]) Len() int { return len(l) }
 
 func (l priorityQueue[K, V]) Less(i, j int) bool {
-	if l[i].item.ReferenceCount == l[j].item.ReferenceCount {
-		return l[i].item.ReferencedAt.Before(l[j].item.ReferencedAt)
+	if l[i].referenceCount == l[j].referenceCount {
+		return l[i].referencedAt.Before(l[j].referencedAt)
 	}
-	return l[i].item.ReferenceCount < l[j].item.ReferenceCount
+	return l[i].referenceCount < l[j].referenceCount
 }
 
 func (l priorityQueue[K, V]) Swap(i, j int) {
@@ -60,7 +72,7 @@ func (l *priorityQueue[K, V]) Pop() interface{} {
 }
 
 func (pq *priorityQueue[K, V]) update(e *entry[K, V], val V) {
-	e.item.Value = val
-	e.item.Referenced()
+	e.val = val
+	e.referenced()
 	heap.Fix(pq, e.index)
 }

lru/lru.go

@@ -15,7 +15,12 @@ type Cache[K comparable, V any] struct {
 	mu    sync.RWMutex
 }
 
-var _ cache.Cache[interface{}, any] = (*Cache[interface{}, any])(nil)
+type entry[K comparable, V any] struct {
+	key K
+	val V
+}
+
+var _ cache.Interface[interface{}, any] = (*Cache[interface{}, any])(nil)
 
 // NewCache creates a new LRU cache whose capacity is the default size (128).
 func NewCache[K comparable, V any]() *Cache[K, V] {
@@ -39,32 +44,29 @@ func (c *Cache[K, V]) Get(key K) (zero V, _ bool) {
 	if !ok {
 		return
 	}
-	item := e.Value.(*cache.Item[K, V])
-	if item.HasExpired() {
-		return
-	}
-	item.Referenced()
 	// updates cache order
 	c.list.MoveToFront(e)
-	return item.Value, true
+	return e.Value.(*entry[K, V]).val, 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 ...cache.ItemOption) {
+func (c *Cache[K, V]) Set(key K, val V) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
 	if e, ok := c.items[key]; ok {
 		// updates cache order
 		c.list.MoveToFront(e)
-		item := e.Value.(*cache.Item[K, V])
-		item.Value = val
-		item.Referenced()
+		entry := e.Value.(*entry[K, V])
+		entry.val = val
 		return
 	}
 
-	item := cache.NewItem(key, val, opts...)
-	e := c.list.PushFront(item)
+	newEntry := &entry[K, V]{
+		key: key,
+		val: val,
+	}
+	e := c.list.PushFront(newEntry)
 	c.items[key] = e
 
 	if c.list.Len() > c.cap {
@@ -78,8 +80,8 @@ 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() {
-		item := ent.Value.(*cache.Item[K, V])
-		keys = append(keys, item.Key)
+		entry := ent.Value.(*entry[K, V])
+		keys = append(keys, entry.key)
 	}
 	return keys
 }
@@ -100,25 +102,13 @@ func (c *Cache[K, V]) Delete(key K) {
 	}
 }
 
-// Contains reports whether key is within cache.
-func (c *Cache[K, V]) Contains(key K) bool {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-	e, ok := c.items[key]
-	if !ok {
-		return false
-	}
-	item := e.Value.(*cache.Item[K, V])
-	return !item.HasExpired()
-}
-
 func (c *Cache[K, V]) deleteOldest() {
 	e := c.list.Back()
 	c.delete(e)
 }
 
 func (c *Cache[K, V]) delete(e *list.Element) {
 	c.list.Remove(e)
-	item := e.Value.(*cache.Item[K, V])
-	delete(c.items, item.Key)
+	entry := e.Value.(*entry[K, V])
+	delete(c.items, entry.key)
 }