LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Basit Ali
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

README.md

@@ -1,50 +0,0 @@
-# go-cache
-
-Simple thread safe key/value cache for Go.
-
-## Usage
-
-You can initialize the cache using:
-
-```go
-    cache = gocache.NewCache()
-```
-
-And perform the operations using:
-
-```go
-   // GET a value using key, which returns (value, error)
-   cache.Get(key)
-   
-   // SET a value using key
-   cache.Set(key, value)
-   
-   // REMOVE a key/value pair using key
-   cache.Remove(key)
-   
-   // And FLUSH, which removes all items from the cache
-   cache.Flush()
-```
-
-## Cache Expiration
-
-You can also add an **expiration** to the cache, expired cache will be auto deleted by the `sweeper`.
-
-To initialize a cache using `sweeper` we can use:
-
-```go
-    cache := NewCacheWithSweeper(10 * time.Minute, 10 * time.Minute, decisionFunc, onEviction)
-```
-
-Here, first two parameters are `interval` and `expireAfter`, sweeper will run in the background after specified `interval` to check for expired cache to delete.
-
-The `decisionFunc` and `onEviction` are **optional** functions with the following signature:
-```go
-    decisionFunc func(v interface{}) bool
-    
-    onEviction func(k string, v interface{})
-```
-
-We can use `decisionFunc` as a callback, it will be called by the cache before deleting a key/value, it takes in the value to delete and returns `true` to delete and `false` for not deleting a key/value pair even after expired.
-
-The `onEviction` is a callback which will be called every time a cache is deleted with its key/value as parameters.

cache.go

@@ -4,5 +4,4 @@ type Cache interface {
 	Get(key string) (interface{}, error)
 	Set(key string, data interface{}) error
 	Remove(key string) error
-	Flush()
 }

delete_expired.go

@@ -1,21 +0,0 @@
-package gocache
-
-import "time"
-
-func (cache *myCache) deleteExpired() {
-	cache.mutex.Lock()
-	defer cache.mutex.Unlock()
-
-	now := time.Now().UnixNano()
-	for k, v := range cache.items {
-		if cache.decisionFunc != nil && !cache.decisionFunc(v.data) {
-			continue
-		}
-		if v.expiration > 0 && now > v.expiration {
-			if cache.onEviction != nil {
-				cache.onEviction(k, v.data)
-			}
-			delete(cache.items, k)
-		}
-	}
-}

errors.go

@@ -3,5 +3,5 @@ package gocache
 import "errors"
 
 var (
-	ErrKeyNotFound = errors.New("key not found")
+	ErrKeyNotFound = errors.New("Key not found")
 )

flush.go

@@ -1,8 +0,0 @@
-package gocache
-
-func (cache *myCache) Flush() {
-	cache.mutex.Lock()
-	defer cache.mutex.Unlock()
-
-	cache.items = make(map[string]*value)
-}

get.go

@@ -9,5 +9,5 @@ func (cache *myCache) Get(key string) (interface{}, error) {
 		return nil, ErrKeyNotFound
 	}
 
-	return item.data, nil
+	return item, nil
 }

my_cache.go

@@ -2,15 +2,11 @@ package gocache
 
 import (
 	"sync"
-	"time"
 )
 
 type myCache struct {
 	mutex sync.Mutex
 	items map[string]*value
-	expireAfter  int64
-	decisionFunc func(v interface{}) bool
-	onEviction   func(k string, v interface{})
 }
 
 func NewCache() Cache {
@@ -18,21 +14,3 @@ func NewCache() Cache {
 		items: make(map[string]*value),
 	}
 }
-
-func NewCacheWithSweeper(interval, expireAfter time.Duration,
-	decisionFunc func(v interface{}) bool, onEviction func(k string, v interface{})) Cache {
-	c := &myCache{
-		items:        make(map[string]*value),
-		expireAfter:  expireAfter.Nanoseconds(),
-		decisionFunc: decisionFunc,
-		onEviction:   onEviction,
-	}
-
-	if interval > 0 && expireAfter > 0 {
-		s := newSweeper(c, interval)
-		// runtime.SetFinalizer(c, s.stopSweeper)
-		go s.run(c)
-	}
-
-	return c
-}

set.go

@@ -1,12 +1,10 @@
 package gocache
 
-import "time"
-
 func (cache *myCache) Set(key string, data interface{}) error {
 	cache.mutex.Lock()
 	defer cache.mutex.Unlock()
 
-	value := newValue(key, data, time.Now().UnixNano()+cache.expireAfter)
+	value := newValue(key, data)
 	cache.items[key] = value
 
 	return nil

sweeper.go

@@ -1,32 +0,0 @@
-package gocache
-
-import "time"
-
-type sweeper struct {
-	Interval time.Duration
-	stop     chan bool
-}
-
-func (s *sweeper) run(c *myCache) {
-	ticker := time.NewTicker(s.Interval)
-	for {
-		select {
-		case <-ticker.C:
-			c.deleteExpired()
-		case <-s.stop:
-			ticker.Stop()
-			return
-		}
-	}
-}
-
-func newSweeper(c *myCache, i time.Duration) *sweeper {
-	return &sweeper{
-		Interval: i,
-		stop:     make(chan bool),
-	}
-}
-
-func (s *sweeper) stopSweeper() {
-	s.stop <- true
-}

value.go

@@ -3,13 +3,11 @@ package gocache
 type value struct {
 	key  string
 	data interface{}
-	expiration int64
 }
 
-func newValue(key string, data interface{}, expiration int64) *value {
+func newValue(key string, data interface{}) *value {
 	return &value{
 		key:  key,
 		data: data,
-		expiration: expiration,
 	}
 }