From 2a304e4c5c686cd2edec1021d0636e91ee23bffb Mon Sep 17 00:00:00 2001 From: Patrick Mylund Nielsen Date: Mon, 2 Jan 2012 13:52:43 +0100 Subject: [PATCH] Added Increment/Decrement --- cache.go | 92 +++++++++++++++++--- cache_test.go | 230 ++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 309 insertions(+), 13 deletions(-) diff --git a/cache.go b/cache.go index 3eeedce..df24930 100644 --- a/cache.go +++ b/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 -// running on a single machine. Any object can be stored, for a given duration or forever, -// and the cache can be used safely by multiple goroutines. +// Cache is an in-memory key:value store cache similar to memcached that is suitable for +// applications running on a single machine. Any object can be stored, for a given duration +// 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 -// // once is: +// // (i.e. interface{}). The simplest way to do this for values which will only be used +// // 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 } +// Increment an item of type int, int8, int16, int32, int64, uintptr, uint, uint8, +// 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() + + 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(key string) { +func (c *cache) Delete(k string) { c.mu.Lock() defer c.mu.Unlock() - delete(c.Items, key) + 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 diff --git a/cache_test.go b/cache_test.go index a750ac0..cb8f977 100644 --- a/cache_test.go +++ b/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) + } +}