Merge pull request #4 from Code-Hex/add/simple

Add simple

Author: Code-Hex

README.md

@@ -4,8 +4,10 @@
 
 go-generics-cache is an in-memory key:value store/cache that is suitable for applications running on a single machine. This in-memory cache uses [Go Generics](https://go.dev/blog/generics-proposal) which will be introduced in 1.18.
 
+- a thread-safe
 - implemented with [Go Generics](https://go.dev/blog/generics-proposal)
-- a thread-safe `map[string]interface{}` with expiration times
+- Simple `map[string]interface{}` with expiration times
+  - See [examples](https://github.com/Code-Hex/go-generics-cache/blob/main/simple/example_test.go)
 - LRU cache
   - See [examples](https://github.com/Code-Hex/go-generics-cache/blob/main/lru/example_test.go)
 
@@ -30,8 +32,6 @@ go version devel go1.18-c2397905e0 Sat Nov 13 03:33:55 2021 +0000 darwin/arm64
 
 See also [examples](https://github.com/Code-Hex/go-generics-cache/blob/main/example_test.go)
 
-playground: https://gotipplay.golang.org/p/FXRk6ngYV-s
-
 ```go
 package main
 
@@ -40,44 +40,24 @@ import (
 	"time"
 
 	cache "github.com/Code-Hex/go-generics-cache"
+	"github.com/Code-Hex/go-generics-cache/simple"
 )
 
 func main() {
-	// Create a cache. key as string, value as int.
-	c1 := cache.New[string, int]()
-
-	// Sets the value of int. you can set with expiration option.
-	c1.Set("foo", 1, cache.WithExpiration(time.Hour))
-
-	// the value never expires.
-	c1.Set("bar", 2)
-
-	foo, ok := c1.Get("foo")
-	if ok {
-		fmt.Println(foo) // 1
-	}
-
-	fmt.Println(c1.Keys()) // outputs "foo" "bar" may random
-
-	// Create a cache. key as int, value as string.
-	c2 := cache.New[int, string]()
-	c2.Set(1, "baz")
-	baz, ok := c2.Get(1)
-	if ok {
-		fmt.Println(baz) // "baz"
-	}
+	// Create a simple cache. key as string, value as int.
+	simpleCache := simple.New[string, int](simple.WithExpiration(time.Hour))
 
-	// Create a cache for Number constraint.. key as string, value as int.
-	nc := cache.NewNumber[string, int]()
+	// Create a cache for Number constraint. key as string, value as int.
+	nc := cache.NewNumber[string, int](simpleCache)
 	nc.Set("age", 26)
 
 	// This will be compile error, because string is not satisfied cache.Number constraint.
-	// nc := cache.NewNumber[string, string]()
+	// nc := cache.NewNumber[string, string](simpleCache)
 
-	incremented, _ := nc.Increment("age", 1)
+	incremented := nc.Increment("age", 1)
 	fmt.Println(incremented) // 27
 
-	decremented, _ := nc.Decrement("age", 1)
+	decremented := nc.Decrement("age", 1)
 	fmt.Println(decremented) // 26
 }
 ```

cache.go

@@ -1,173 +1,50 @@
 package cache
 
 import (
-	"errors"
-	"fmt"
 	"sync"
-	"time"
 )
 
-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 base struct for creating in-memory cache.
-type Cache[K comparable, V any] struct {
-	items map[K]Item[V]
-	mu    sync.RWMutex
-}
-
-// New creates a new cache.
-func New[K comparable, V any]() *Cache[K, V] {
-	return &Cache[K, V]{
-		items: make(map[K]Item[V]),
-	}
-}
-
-// ItemOption is an option for cache item.
-type ItemOption 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) ItemOption {
-	return func(o *options) {
-		o.expiration = exp
-	}
-}
-
-// 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, opts ...ItemOption) {
-	o := new(options)
-	for _, optFunc := range opts {
-		optFunc(o)
-	}
-	item := Item[V]{
-		Value:      v,
-		Expiration: o.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]) {
-	c.mu.Lock()
-	c.items[k] = v
-	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 val, fmt.Errorf("key[%v]: %w", k, ErrNotFound)
-	}
-	if got.HasExpired() {
-		return val, fmt.Errorf("key[%v]: %w", k, ErrExpired)
-	}
-	return got, nil
-}
-
-// Keys returns cache keys. the order is random.
-func (c *Cache[K, _]) Keys() []K {
-	ret := make([]K, 0, len(c.items))
-	for key := range c.items {
-		ret = append(ret, key)
-	}
-	return ret
+// 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)
 }
 
 // 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,
 	// 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]() *NumberCache[K, V] {
+func NewNumber[K comparable, V Number](baseCache Cache[K, V]) *NumberCache[K, V] {
 	return &NumberCache[K, V]{
-		Cache: New[K, V](),
+		Cache: baseCache,
 	}
 }
 
 // Increment an item of type Number constraint by n.
-// Returns an error if the item was not found or expired. If there is no error, the
-// incremented value is returned.
-func (nc *NumberCache[K, V]) Increment(k K, n V) (val V, err error) {
+// Returns the incremented value.
+func (nc *NumberCache[K, V]) Increment(key K, n V) V {
 	// In order to avoid lost update, we must lock whole Increment/Decrement process.
 	nc.nmu.Lock()
 	defer nc.nmu.Unlock()
-	got, err := nc.Cache.GetItem(k)
-	if err != nil {
-		return val, err
-	}
-
-	nv := got.Value + n
-	got.Value = nv
-	nc.Cache.SetItem(k, got)
-
-	return nv, nil
+	got, _ := nc.Cache.Get(key)
+	nv := got + n
+	nc.Cache.Set(key, nv)
+	return nv
 }
 
 // Decrement an item of type Number constraint by n.
-// Returns an error if the item was not found or expired. If there is no error, the
-// decremented value is returned.
-func (nc *NumberCache[K, V]) Decrement(k K, n V) (val V, err error) {
+// Returns the decremented value.
+func (nc *NumberCache[K, V]) Decrement(key K, n V) V {
 	nc.nmu.Lock()
 	defer nc.nmu.Unlock()
-	got, err := nc.Cache.GetItem(k)
-	if err != nil {
-		return val, err
-	}
-
-	nv := got.Value - n
-	got.Value = nv
-	nc.Cache.SetItem(k, got)
-
-	return nv, nil
+	got, _ := nc.Cache.Get(key)
+	nv := got - n
+	nc.Cache.Set(key, nv)
+	return nv
 }

cache_test.go

@@ -1,102 +1,23 @@
-package cache
+package cache_test
 
 import (
-	"errors"
 	"sync"
 	"testing"
-	"time"
-)
-
-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) {
-			backup := nowFunc
-			nowFunc = func() time.Time { return tc.current }
-			defer func() { nowFunc = backup }()
-
-			it := Item[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 TestGetItemExpired(t *testing.T) {
-	c := New[struct{}, int]()
-	c.SetItem(struct{}{}, Item[int]{
-		Value:      1,
-		Expiration: time.Hour * 24,
-		CreatedAt:  time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
-	})
 
-	backup := nowFunc
-	nowFunc = func() time.Time {
-		return time.Date(2009, time.November, 12, 23, 0, 0, 0, time.UTC)
-	}
-	defer func() { nowFunc = backup }()
-
-	v, err := c.GetItem(struct{}{})
-	if !errors.Is(err, ErrExpired) {
-		t.Errorf("want error %v but got %v", ErrExpired, err)
-	}
-	zeroValItem := Item[int]{}
-	if zeroValItem != v {
-		t.Errorf("want %v but got %v", zeroValItem, v)
-	}
-
-}
+	cache "github.com/Code-Hex/go-generics-cache"
+	"github.com/Code-Hex/go-generics-cache/simple"
+)
 
 func TestMultiThreadIncr(t *testing.T) {
-	nc := NewNumber[string, int]()
+	nc := cache.NewNumber[string, int](simple.New[string, int]())
 	nc.Set("counter", 0)
 
 	var wg sync.WaitGroup
 
 	for i := 0; i < 100; i++ {
 		wg.Add(1)
 		go func() {
-			_, err := nc.Increment("counter", 1)
-			if err != nil {
-				t.Logf("err: %v", err)
-			}
+			_ = nc.Increment("counter", 1)
 			wg.Done()
 		}()
 	}
@@ -109,18 +30,15 @@ func TestMultiThreadIncr(t *testing.T) {
 }
 
 func TestMultiThreadDecr(t *testing.T) {
-	nc := NewNumber[string, int]()
+	nc := cache.NewNumber[string, int](simple.New[string, int]())
 	nc.Set("counter", 100)
 
 	var wg sync.WaitGroup
 
 	for i := 0; i < 100; i++ {
 		wg.Add(1)
 		go func() {
-			_, err := nc.Decrement("counter", 1)
-			if err != nil {
-				t.Logf("err: %v", err)
-			}
+			_ = nc.Decrement("counter", 1)
 			wg.Done()
 		}()
 	}