Added Increment/Decrement
This commit is contained in:
Patrick Mylund Nielsen
parent
848f8b6c3a
commit
2a304e4c5c
94
cache.go
94
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
|
||||
}
|
||||
|
||||
// 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
230
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)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue