Added Increment/Decrement

cache.go

@@ -1,14 +1,16 @@
 package cache
 
 import (
+	"fmt"
+	"reflect"
 	"runtime"
 	"sync"
 	"time"
 )
 
-// Cache is an in-memory cache similar to memcached that is suitable for applications
+// Cache is an in-memory key:value store cache similar to memcached that is suitable for
-// running on a single machine. Any object can be stored, for a given duration or forever,
+// applications running on a single machine. Any object can be stored, for a given duration
-// and the cache can be used safely by multiple goroutines.
+// or forever, and the cache can be used safely by multiple goroutines.
 //
 // Installation:
 //     goinstall github.com/pmylund/go-cache
@@ -33,8 +35,8 @@ import (
 //
 //     // Since Go is statically typed, and cache values can be anything, type assertion
 //     // is needed when values are being passed to functions that don't take arbitrary types,
-//     // (i.e. interface{}). The simplest way to do this for values which will only be passed
+//     // (i.e. interface{}). The simplest way to do this for values which will only be used
-//     // once is:
+//     // once--e.g. for passing to another function--is:
 //     foo, found := c.Get("foo")
 //     if found {
 //             MyFunction(foo.(string))
@@ -51,6 +53,7 @@ import (
 //     if x, found := c.Get("foo"); found {
 //             foo = x.(string)
 //     }
+//     ...
 //     // foo can then be passed around freely as a string
 //
 //     // Want performance? Store pointers!
@@ -107,7 +110,7 @@ type janitor struct {
 
 // Adds an item to the cache. If the duration is 0, the cache's default expiration time
 // is used. If it is -1, the item never expires.
-func (c *cache) Set(key string, x interface{}, d time.Duration) {
+func (c *cache) Set(k string, x interface{}, d time.Duration) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
@@ -122,7 +125,7 @@ func (c *cache) Set(key string, x interface{}, d time.Duration) {
 		t := time.Now().Add(d)
 		e = &t
 	}
-	c.Items[key] = &Item{
+	c.Items[k] = &Item{
 		Object: x,
 		Expires: expires,
 		Expiration: e,
@@ -130,27 +133,91 @@ func (c *cache) Set(key string, x interface{}, d time.Duration) {
 }
 
 // Gets an item from the cache.
-func (c *cache) Get(key string) (interface{}, bool) {
+func (c *cache) Get(k string) (interface{}, bool) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
-	item, found := c.Items[key]
+	item, found := c.Items[k]
 	if !found {
 		return nil, false
 	}
 	if item.Expired() {
-		delete(c.Items, key)
+		delete(c.Items, k)
 		return nil, false
 	}
 	return item.Object, true
 }
 
-// Deletes an item from the cache. Does nothing if the item does not exist in the cache.
+// Increment an item of type int, int8, int16, int32, int64, uintptr, uint, uint8,
-func (c *cache) Delete(key string) {
+// uint32, uint64, float32 or float64 by n. Returns an error if the item's value is
+// not an integer, if it was not found, or if it is not possible to increment it by
+// n.
+func (c *cache) IncrementFloat(k string, n float64) error {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
-	delete(c.Items, key)
+	v, found := c.Items[k]
+	if !found {
+		return fmt.Errorf("V not found")
+	}
+
+	t := reflect.TypeOf(v.Object)
+	switch t.Kind() {
+	default:
+		return fmt.Errorf("The value of %s is not an integer", k)
+	case reflect.Uint:
+		v.Object = v.Object.(uint) + uint(n)
+	case reflect.Uintptr:
+		v.Object = v.Object.(uintptr) + uintptr(n)
+	case reflect.Uint8:
+		v.Object = v.Object.(uint8) + uint8(n)
+	case reflect.Uint16:
+		v.Object = v.Object.(uint16) + uint16(n)
+	case reflect.Uint32:
+		v.Object = v.Object.(uint32) + uint32(n)
+	case reflect.Uint64:
+		v.Object = v.Object.(uint64) + uint64(n)
+	case reflect.Int:
+		v.Object = v.Object.(int) + int(n)
+	case reflect.Int8:
+		v.Object = v.Object.(int8) + int8(n)
+	case reflect.Int16:
+		v.Object = v.Object.(int16) + int16(n)
+	case reflect.Int32:
+		v.Object = v.Object.(int32) + int32(n)
+	case reflect.Int64:
+		v.Object = v.Object.(int64) + int64(n)
+	case reflect.Float32:
+		v.Object = v.Object.(float32) + float32(n)
+	case reflect.Float64:
+		v.Object = v.Object.(float64) + n
+	}
+	return nil
+}
+
+// Increment an item of type int, int8, int16, int32, int64, uintptr, uint, uint8,
+// uint32, or uint64, float32 or float64 by n. Returns an error if the item's value
+// is not an integer, if it was not found, or if it is not possible to increment it
+// by n.
+func (c *cache) Increment(k string, n int64) error {
+	return c.IncrementFloat(k, float64(n))
+}
+
+// Decrement an item of type int, int8, int16, int32, int64, uintptr, uint, uint8,
+// uint32, or uint64, float32 or float64 by n. Returns an error if the item's value
+// is not an integer, if it was not found, or if it is not possible to decrement it
+// by n.
+func (c *cache) Decrement(k string, n int64) error {
+	return c.Increment(k, n*-1)
+}
+
+
+// Deletes an item from the cache. Does nothing if the item does not exist in the cache.
+func (c *cache) Delete(k string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	delete(c.Items, k)
 }
 
 // Deletes all expired items from the cache.
@@ -163,7 +230,6 @@ func (c *cache) DeleteExpired() {
 			delete(c.Items, k)
 		}
 	}
-
 }
 
 // Deletes all items in the cache

cache_test.go

@@ -119,3 +119,233 @@ func TestStorePointerToStruct(t *testing.T) {
 		t.Fatal("TestStruct.Num is not 2")
 	}
 }
+
+func TestIncrementUint(t *testing.T) {
+	tc := New(0, 0)
+	tc.Set("tuint", uint(1), 0)
+	err := tc.Increment("tuint", 2)
+	if err != nil {
+		t.Error("Error incrementing:", err)
+	}
+
+	x, found := tc.Get("tuint")
+	if !found {
+		t.Error("tuint was not found")
+	}
+	if x.(uint) != 3 {
+		t.Error("tuint is not 3:", x)
+	}
+}
+
+func TestIncrementUintptr(t *testing.T) {
+	tc := New(0, 0)
+	tc.Set("tuintptr", uintptr(1), 0)
+	err := tc.Increment("tuintptr", 2)
+	if err != nil {
+		t.Error("Error incrementing:", err)
+	}
+
+	x, found := tc.Get("tuintptr")
+	if !found {
+		t.Error("tuintptr was not found")
+	}
+	if x.(uintptr) != 3 {
+		t.Error("tuintptr is not 3:", x)
+	}
+}
+
+func TestIncrementUint8(t *testing.T) {
+	tc := New(0, 0)
+	tc.Set("tuint8", uint8(1), 0)
+	err := tc.Increment("tuint8", 2)
+	if err != nil {
+		t.Error("Error incrementing:", err)
+	}
+
+	x, found := tc.Get("tuint8")
+	if !found {
+		t.Error("tuint8 was not found")
+	}
+	if x.(uint8) != 3 {
+		t.Error("tuint8 is not 3:", x)
+	}
+}
+
+func TestIncrementUint16(t *testing.T) {
+	tc := New(0, 0)
+	tc.Set("tuint16", uint16(1), 0)
+	err := tc.Increment("tuint16", 2)
+	if err != nil {
+		t.Error("Error incrementing:", err)
+	}
+
+	x, found := tc.Get("tuint16")
+	if !found {
+		t.Error("tuint16 was not found")
+	}
+	if x.(uint16) != 3 {
+		t.Error("tuint16 is not 3:", x)
+	}
+}
+
+func TestIncrementUint32(t *testing.T) {
+	tc := New(0, 0)
+	tc.Set("tuint32", uint32(1), 0)
+	err := tc.Increment("tuint32", 2)
+	if err != nil {
+		t.Error("Error incrementing:", err)
+	}
+
+	x, found := tc.Get("tuint32")
+	if !found {
+		t.Error("tuint32 was not found")
+	}
+	if x.(uint32) != 3 {
+		t.Error("tuint32 is not 3:", x)
+	}
+}
+
+func TestIncrementUint64(t *testing.T) {
+	tc := New(0, 0)
+	tc.Set("tuint64", uint64(1), 0)
+	err := tc.Increment("tuint64", 2)
+	if err != nil {
+		t.Error("Error incrementing:", err)
+	}
+
+	x, found := tc.Get("tuint64")
+	if !found {
+		t.Error("tuint64 was not found")
+	}
+	if x.(uint64) != 3 {
+		t.Error("tuint64 is not 3:", x)
+	}
+}
+
+func TestIncrementInt(t *testing.T) {
+	tc := New(0, 0)
+	tc.Set("tint", 1, 0)
+	err := tc.Increment("tint", 2)
+	if err != nil {
+		t.Error("Error incrementing:", err)
+	}
+	x, found := tc.Get("tint")
+	if !found {
+		t.Error("tint was not found")
+	}
+	if x.(int) != 3 {
+		t.Error("tint is not 3:", x)
+	}
+}
+
+func TestIncrementInt8(t *testing.T) {
+	tc := New(0, 0)
+	tc.Set("tint8", int8(1), 0)
+	err := tc.Increment("tint8", 2)
+	if err != nil {
+		t.Error("Error incrementing:", err)
+	}
+	x, found := tc.Get("tint8")
+	if !found {
+		t.Error("tint8 was not found")
+	}
+	if x.(int8) != 3 {
+		t.Error("tint8 is not 3:", x)
+	}
+}
+
+func TestIncrementInt16(t *testing.T) {
+	tc := New(0, 0)
+	tc.Set("tint16", int16(1), 0)
+	err := tc.Increment("tint16", 2)
+	if err != nil {
+		t.Error("Error incrementing:", err)
+	}
+	x, found := tc.Get("tint16")
+	if !found {
+		t.Error("tint16 was not found")
+	}
+	if x.(int16) != 3 {
+		t.Error("tint16 is not 3:", x)
+	}
+}
+
+func TestIncrementInt32(t *testing.T) {
+	tc := New(0, 0)
+	tc.Set("tint32", int32(1), 0)
+	err := tc.Increment("tint32", 2)
+	if err != nil {
+		t.Error("Error incrementing:", err)
+	}
+	x, found := tc.Get("tint32")
+	if !found {
+		t.Error("tint32 was not found")
+	}
+	if x.(int32) != 3 {
+		t.Error("tint32 is not 3:", x)
+	}
+}
+
+func TestIncrementInt64(t *testing.T) {
+	tc := New(0, 0)
+	tc.Set("tint64", int64(1), 0)
+	err := tc.Increment("tint64", 2)
+	if err != nil {
+		t.Error("Error incrementing:", err)
+	}
+	x, found := tc.Get("tint64")
+	if !found {
+		t.Error("tint64 was not found")
+	}
+	if x.(int64) != 3 {
+		t.Error("tint64 is not 3:", x)
+	}
+}
+
+func TestIncrementFloat32(t *testing.T) {
+	tc := New(0, 0)
+	tc.Set("float32", float32(1.5), 0)
+	err := tc.Increment("float32", 2)
+	if err != nil {
+		t.Error("Error incrementing:", err)
+	}
+	x, found := tc.Get("float32")
+	if !found {
+		t.Error("float32 was not found")
+	}
+	if x.(float32) != 3.5 {
+		t.Error("float32 is not 3.5:", x)
+	}
+}
+
+func TestIncrementFloat64(t *testing.T) {
+	tc := New(0, 0)
+	tc.Set("float64", float64(1.5), 0)
+	err := tc.Increment("float64", 2)
+	if err != nil {
+		t.Error("Error incrementing:", err)
+	}
+	x, found := tc.Get("float64")
+	if !found {
+		t.Error("float64 was not found")
+	}
+	if x.(float64) != 3.5 {
+		t.Error("float64 is not 3.5:", x)
+	}
+}
+
+func TestDecrementInt64(t *testing.T) {
+	tc := New(0, 0)
+	tc.Set("int64", int64(5), 0)
+	err := tc.Decrement("int64", 2)
+	if err != nil {
+		t.Error("Error incrementing:", err)
+	}
+	x, found := tc.Get("int64")
+	if !found {
+		t.Error("int64 was not found")
+	}
+	if x.(int64) != 3 {
+		t.Error("int64 is not 3:", x)
+	}
+}