fix Len, Keys, and GetALL method to get checkExpired option

arc.go

@@ -313,45 +313,49 @@ func (c *ARC) remove(key interface{}) bool {
  return false
 }
 
-func (c *ARC) keys() []interface{} {
+// GetALL returns all key-value pairs in the cache.
+func (c *ARC) GetALL(checkExpired bool) map[interface{}]interface{} {
  c.mu.RLock()
  defer c.mu.RUnlock()
- keys := make([]interface{}, len(c.items))
- var i = 0
- for k := range c.items {
- keys[i] = k
- i++
+ items := make(map[interface{}]interface{}, len(c.items))
+ now := time.Now()
+ for k, item := range c.items {
+ if checkExpired && c.has(k, &now) {
+ items[k] = item.value
+ }
  }
- return keys
+ return items
 }
 
 // Keys returns a slice of the keys in the cache.
-func (c *ARC) Keys() []interface{} {
- keys := []interface{}{}
- for _, k := range c.keys() {
- _, err := c.GetIFPresent(k)
- if err == nil {
+func (c *ARC) Keys(checkExpired bool) []interface{} {
+ c.mu.RLock()
+ defer c.mu.RUnlock()
+ keys := make([]interface{}, 0, len(c.items))
+ now := time.Now()
+ for k := range c.items {
+ if checkExpired && c.has(k, &now) {
  keys = append(keys, k)
  }
  }
  return keys
 }
 
-// GetALL returns all key-value pairs in the cache.
-func (c *ARC) GetALL() map[interface{}]interface{} {
- m := make(map[interface{}]interface{})
- for _, k := range c.keys() {
- v, err := c.GetIFPresent(k)
- if err == nil {
- m[k] = v
+// Len returns the number of items in the cache.
+func (c *ARC) Len(checkExpired bool) int {
+ c.mu.RLock()
+ defer c.mu.RUnlock()
+ if !checkExpired {
+ return len(c.items)
+ }
+ var length int
+ now := time.Now()
+ for k := range c.items {
+ if c.has(k, &now) {
+ length++
  }
  }
- return m
-}
-
-// Len returns the number of items in the cache.
-func (c *ARC) Len() int {
- return len(c.GetALL())
+ return length
 }
 
 // Purge is used to completely clear the cache

arc_test.go

@@ -24,14 +24,14 @@ func TestARCLength(t *testing.T) {
  gc.Get("test1")
  gc.Get("test2")
  gc.Get("test3")
- length := gc.Len()
+ length := gc.Len(true)
  expectedLength := 2
  if length != expectedLength {
  t.Errorf("Expected length is %v, not %v", expectedLength, length)
  }
  time.Sleep(time.Millisecond)
  gc.Get("test4")
- length = gc.Len()
+ length = gc.Len(true)
  expectedLength = 1
  if length != expectedLength {
  t.Errorf("Expected length is %v, not %v", expectedLength, length)

cache.go

@@ -21,13 +21,13 @@ type Cache interface {
  SetWithExpire(interface{}, interface{}, time.Duration) error
  Get(interface{}) (interface{}, error)
  GetIFPresent(interface{}) (interface{}, error)
- GetALL() map[interface{}]interface{}
- Has(interface{}) bool
+ GetALL(bool) map[interface{}]interface{}
  get(interface{}, bool) (interface{}, error)
  Remove(interface{}) bool
  Purge()
- Keys() []interface{}
- Len() int
+ Keys(bool) []interface{}
+ Len(bool) int
+ Has(interface{}) bool
 
  statsAccessor
 }

helpers_test.go

@@ -72,7 +72,7 @@ func testGetALL(t *testing.T, evT string) {
  for i := 0; i < size; i++ {
  cache.Set(i, i*i)
  }
- m := cache.GetALL()
+ m := cache.GetALL(true)
  for i := 0; i < size; i++ {
  v, ok := m[i]
  if !ok {
@@ -87,7 +87,7 @@ func testGetALL(t *testing.T, evT string) {
  time.Sleep(time.Millisecond)
 
  cache.Set(size, size*size)
- m = cache.GetALL()
+ m = cache.GetALL(true)
  if len(m) != 1 {
  t.Errorf("%v != %v", len(m), 1)
  }

lfu.go

@@ -266,33 +266,49 @@ func (c *LFUCache) keys() []interface{} {
  return keys
 }
 
-// Keys returns a slice of the keys in the cache.
-func (c *LFUCache) Keys() []interface{} {
- keys := []interface{}{}
- for _, k := range c.keys() {
- _, err := c.GetIFPresent(k)
- if err == nil {
- keys = append(keys, k)
+// GetALL returns all key-value pairs in the cache.
+func (c *LFUCache) GetALL(checkExpired bool) map[interface{}]interface{} {
+ c.mu.RLock()
+ defer c.mu.RUnlock()
+ items := make(map[interface{}]interface{}, len(c.items))
+ now := time.Now()
+ for k, item := range c.items {
+ if checkExpired && c.has(k, &now) {
+ items[k] = item.value
  }
  }
- return keys
+ return items
 }
 
-// GetALL returns all key-value pairs in the cache.
-func (c *LFUCache) GetALL() map[interface{}]interface{} {
- m := make(map[interface{}]interface{})
- for _, k := range c.keys() {
- v, err := c.GetIFPresent(k)
- if err == nil {
- m[k] = v
+// Keys returns a slice of the keys in the cache.
+func (c *LFUCache) Keys(checkExpired bool) []interface{} {
+ c.mu.RLock()
+ defer c.mu.RUnlock()
+ keys := make([]interface{}, 0, len(c.items))
+ now := time.Now()
+ for k := range c.items {
+ if checkExpired && c.has(k, &now) {
+ keys = append(keys, k)
  }
  }
- return m
+ return keys
 }
 
 // Len returns the number of items in the cache.
-func (c *LFUCache) Len() int {
- return len(c.GetALL())
+func (c *LFUCache) Len(checkExpired bool) int {
+ c.mu.RLock()
+ defer c.mu.RUnlock()
+ if !checkExpired {
+ return len(c.items)
+ }
+ var length int
+ now := time.Now()
+ for k := range c.items {
+ if c.has(k, &now) {
+ length++
+ }
+ }
+ return length
 }
 
 // Completely clear the cache

lfu_test.go

@@ -27,9 +27,9 @@ func TestLFULength(t *testing.T) {
  gc := buildTestLoadingCache(t, TYPE_LFU, 1000, loader)
  gc.Get("test1")
  gc.Get("test2")
- length := gc.Len()
+ length := gc.Len(true)
  expectedLength := 2
- if gc.Len() != expectedLength {
+ if length != expectedLength {
  t.Errorf("Expected length is %v, not %v", length, expectedLength)
  }
 }

lru.go

@@ -236,33 +236,49 @@ func (c *LRUCache) keys() []interface{} {
  return keys
 }
 
-// Keys returns a slice of the keys in the cache.
-func (c *LRUCache) Keys() []interface{} {
- keys := []interface{}{}
- for _, k := range c.keys() {
- _, err := c.GetIFPresent(k)
- if err == nil {
- keys = append(keys, k)
+// GetALL returns all key-value pairs in the cache.
+func (c *LRUCache) GetALL(checkExpired bool) map[interface{}]interface{} {
+ c.mu.RLock()
+ defer c.mu.RUnlock()
+ items := make(map[interface{}]interface{}, len(c.items))
+ now := time.Now()
+ for k, item := range c.items {
+ if checkExpired && c.has(k, &now) {
+ items[k] = item.Value.(*lruItem).value
  }
  }
- return keys
+ return items
 }
 
-// GetALL returns all key-value pairs in the cache.
-func (c *LRUCache) GetALL() map[interface{}]interface{} {
- m := make(map[interface{}]interface{})
- for _, k := range c.keys() {
- v, err := c.GetIFPresent(k)
- if err == nil {
- m[k] = v
+// Keys returns a slice of the keys in the cache.
+func (c *LRUCache) Keys(checkExpired bool) []interface{} {
+ c.mu.RLock()
+ defer c.mu.RUnlock()
+ keys := make([]interface{}, 0, len(c.items))
+ now := time.Now()
+ for k := range c.items {
+ if checkExpired && c.has(k, &now) {
+ keys = append(keys, k)
  }
  }
- return m
+ return keys
 }
 
 // Len returns the number of items in the cache.
-func (c *LRUCache) Len() int {
- return len(c.GetALL())
+func (c *LRUCache) Len(checkExpired bool) int {
+ c.mu.RLock()
+ defer c.mu.RUnlock()
+ if !checkExpired {
+ return len(c.items)
+ }
+ var length int
+ now := time.Now()
+ for k := range c.items {
+ if c.has(k, &now) {
+ length++
+ }
+ }
+ return length
 }
 
 // Completely clear the cache

lru_test.go

@@ -23,7 +23,7 @@ func TestLRULength(t *testing.T) {
  gc := buildTestLoadingCache(t, TYPE_LRU, 1000, loader)
  gc.Get("test1")
  gc.Get("test2")
- length := gc.Len()
+ length := gc.Len(true)
  expectedLength := 2
  if length != expectedLength {
  t.Errorf("Expected length is %v, not %v", length, expectedLength)

simple.go

@@ -227,33 +227,49 @@ func (c *SimpleCache) keys() []interface{} {
  return keys
 }
 
-// Keys returns a slice of the keys in the cache.
-func (c *SimpleCache) Keys() []interface{} {
- keys := []interface{}{}
- for _, k := range c.keys() {
- _, err := c.GetIFPresent(k)
- if err == nil {
- keys = append(keys, k)
+// GetALL returns all key-value pairs in the cache.
+func (c *SimpleCache) GetALL(checkExpired bool) map[interface{}]interface{} {
+ c.mu.RLock()
+ defer c.mu.RUnlock()
+ items := make(map[interface{}]interface{})
+ now := time.Now()
+ for k, item := range c.items {
+ if checkExpired && c.has(k, &now) {
+ items[k] = item.value
  }
  }
- return keys
+ return items
 }
 
-// GetALL returns all key-value pairs in the cache.
-func (c *SimpleCache) GetALL() map[interface{}]interface{} {
- m := make(map[interface{}]interface{})
- for _, k := range c.keys() {
- v, err := c.GetIFPresent(k)
- if err == nil {
- m[k] = v
+// Keys returns a slice of the keys in the cache.
+func (c *SimpleCache) Keys(checkExpired bool) []interface{} {
+ c.mu.RLock()
+ defer c.mu.RUnlock()
+ keys := make([]interface{}, 0, len(c.items))
+ now := time.Now()
+ for k := range c.items {
+ if checkExpired && c.has(k, &now) {
+ keys = append(keys, k)
  }
  }
- return m
+ return keys
 }
 
 // Len returns the number of items in the cache.
-func (c *SimpleCache) Len() int {
- return len(c.GetALL())
+func (c *SimpleCache) Len(checkExpired bool) int {
+ c.mu.RLock()
+ defer c.mu.RUnlock()
+ if !checkExpired {
+ return len(c.items)
+ }
+ var length int
+ now := time.Now()
+ for k := range c.items {
+ if c.has(k, &now) {
+ length++
+ }
+ }
+ return length
 }
 
 // Completely clear the cache

simple_test.go

@@ -23,7 +23,7 @@ func TestSimpleLength(t *testing.T) {
  gc := buildTestLoadingCache(t, TYPE_SIMPLE, 1000, loader)
  gc.Get("test1")
  gc.Get("test2")
- length := gc.Len()
+ length := gc.Len(true)
  expectedLength := 2
  if length != expectedLength {
  t.Errorf("Expected length is %v, not %v", length, expectedLength)
@@ -49,7 +49,7 @@ func TestSimpleUnboundedNoEviction(t *testing.T) {
  gcu := buildTestLoadingCache(t, TYPE_SIMPLE, 0, loader)
 
  for i := 0; i < numbers; i++ {
- current_size := gcu.Len()
+ current_size := gcu.Len(true)
  if current_size != size_tracker {
  t.Errorf("Excepted cache size is %v not %v", current_size, size_tracker)
  }