Merge pull request #3 from Code-Hex/add/lru

Add lru cache

Author: Code-Hex

README.md

@@ -6,6 +6,8 @@ go-generics-cache is an in-memory key:value store/cache that is suitable for app
 
 - implemented with [Go Generics](https://go.dev/blog/generics-proposal)
 - a thread-safe `map[string]interface{}` with expiration times
+- LRU cache
+  - See [examples](https://github.com/Code-Hex/go-generics-cache/blob/main/lru/example_test.go)
 
 ## Requirements
 

lru/example_test.go

@@ -0,0 +1,38 @@
+package lru_test
+
+import (
+	"fmt"
+
+	"github.com/Code-Hex/go-generics-cache/lru"
+)
+
+func ExampleLRUCache() {
+	c := lru.New[string, int]()
+	c.Set("a", 1)
+	c.Set("b", 2)
+	av, aok := c.Get("a")
+	bv, bok := c.Get("b")
+	cv, cok := c.Get("c")
+	fmt.Println(av, aok)
+	fmt.Println(bv, bok)
+	fmt.Println(cv, cok)
+	// Output:
+	// 1 true
+	// 2 true
+	// 0 false
+}
+
+func ExampleCacheKeys() {
+	c := lru.New[string, int]()
+	c.Set("a", 1)
+	c.Set("b", 2)
+	c.Set("c", 3)
+	keys := c.Keys()
+	for _, key := range keys {
+		fmt.Println(key)
+	}
+	// Output:
+	// a
+	// b
+	// c
+}

lru/lru.go

@@ -0,0 +1,114 @@
+package lru
+
+import (
+	"container/list"
+	"sync"
+)
+
+// Cache is a thread safe LRU cache
+type Cache[K comparable, V any] struct {
+	cap   int
+	list  *list.List
+	items map[K]*list.Element
+	mu    sync.RWMutex
+}
+
+type item[K comparable, V any] struct {
+	Key   K
+	Value V
+}
+
+// New creates a new LRU cache whose capacity is the default size (128).
+func New[K comparable, V any]() *Cache[K, V] {
+	return NewCap[K, V](128)
+}
+
+// NewCap creates a new LRU cache whose capacity is the specified size.
+func NewCap[K comparable, V any](cap int) *Cache[K, V] {
+	return &Cache[K, V]{
+		cap:   cap,
+		list:  list.New(),
+		items: make(map[K]*list.Element),
+	}
+}
+
+// Get looks up a key's value from the cache.
+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
+	}
+	return
+}
+
+// Set sets a value to the cache with key. replacing any existing value.
+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)
+		e.Value.(*item[K, V]).Value = val
+		return
+	}
+
+	e := c.list.PushFront(&item[K, V]{
+		Key:   key,
+		Value: val,
+	})
+	c.items[key] = e
+
+	if c.list.Len() > c.cap {
+		c.deleteOldest()
+	}
+}
+
+// Keys returns the keys of the cache. the order is from oldest to newest.
+func (c *Cache[K, V]) Keys() []K {
+	c.mu.RLock()
+	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)
+	}
+	return keys
+}
+
+// Len returns the number of items in the cache.
+func (c *Cache[K, V]) Len() int {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return c.list.Len()
+}
+
+// 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()
+	if e, ok := c.items[key]; ok {
+		c.delete(e)
+	}
+}
+
+// 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.items[key]
+	return ok
+}
+
+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.(*item[K, V])
+	delete(c.items, item.Key)
+}

lru/lru_test.go

@@ -0,0 +1,82 @@
+package lru_test
+
+import (
+	"testing"
+
+	"github.com/Code-Hex/go-generics-cache/lru"
+)
+
+func TestSet(t *testing.T) {
+	// set capacity is 1
+	cache := lru.NewCap[string, int](1)
+	cache.Set("foo", 1)
+	if got := cache.Len(); got != 1 {
+		t.Fatalf("invalid length: %d", got)
+	}
+	if got, ok := cache.Get("foo"); got != 1 || !ok {
+		t.Fatalf("invalid value got %d, cachehit %v", got, ok)
+	}
+
+	// if over the cap
+	cache.Set("bar", 2)
+	if got := cache.Len(); got != 1 {
+		t.Fatalf("invalid length: %d", got)
+	}
+	bar, ok := cache.Get("bar")
+	if bar != 2 || !ok {
+		t.Fatalf("invalid value bar %d, cachehit %v", bar, ok)
+	}
+
+	// checks deleted oldest
+	if _, ok := cache.Get("foo"); ok {
+		t.Fatalf("invalid delete oldest value foo %v", ok)
+	}
+
+	// valid: if over the cap but same key
+	cache.Set("bar", 100)
+	if got := cache.Len(); got != 1 {
+		t.Fatalf("invalid length: %d", got)
+	}
+	bar, ok = cache.Get("bar")
+	if bar != 100 || !ok {
+		t.Fatalf("invalid replacing value bar %d, cachehit %v", bar, ok)
+	}
+}
+
+func TestContains(t *testing.T) {
+	cache := lru.New[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)
+		}
+	}
+}
+
+func TestDelete(t *testing.T) {
+	cache := lru.NewCap[string, int](1)
+	cache.Set("foo", 1)
+	if got := cache.Len(); got != 1 {
+		t.Fatalf("invalid length: %d", got)
+	}
+
+	cache.Delete("foo2")
+	if got := cache.Len(); got != 1 {
+		t.Fatalf("invalid length after deleted does not exist key: %d", got)
+	}
+
+	cache.Delete("foo")
+	if got := cache.Len(); got != 0 {
+		t.Fatalf("invalid length after deleted: %d", got)
+	}
+	if _, ok := cache.Get("foo"); ok {
+		t.Fatalf("invalid get after deleted %v", ok)
+	}
+
+}