sm/cache
1
0
Fork 0
Code

Added Increment/Decrement

Browse Source
This commit is contained in:
Patrick Mylund Nielsen 2012-01-02 13:52:43 +01:00
parent 848f8b6c3a
commit 2a304e4c5c
2 changed files with 310 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
cache.go
View File

@ -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
}
// Deletes an item from the cache. Does nothing if the item does not exist in the cache.
func (c *cache) Delete(key string) {
// 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()
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

230
cache_test.go
View File

@ -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)
}
}