Merge branch 'master' into generic

Author: karlseguin

cache.go

@@ -115,6 +115,13 @@ func (c *Cache[T]) Get(key string) *Item[T] {
 	return item
 }
 
+// Same as Get but does not promote the value. This essentially circumvents the
+// "least recently used" aspect of this cache. To some degree, it's akin to a
+// "peak"
+func (c *Cache[T]) GetWithoutPromote(key string) *Item[T] {
+	return c.bucket(key).get(key)
+}
+
 // Used when the cache was created with the Track() configuration option.
 // Avoid otherwise
 func (c *Cache[T]) TrackingGet(key string) TrackedItem[T] {

cache_test.go

@@ -138,6 +138,20 @@ func Test_CachePromotedItemsDontGetPruned(t *testing.T) {
 	assert.Equal(t, cache.Get("11").Value(), 11)
 }
 
+func Test_GetWithoutPromoteDoesNotPromote(t *testing.T) {
+	cache := New(Configure[int]().ItemsToPrune(10).GetsPerPromote(1))
+	for i := 0; i < 500; i++ {
+		cache.Set(strconv.Itoa(i), i, time.Minute)
+	}
+	cache.SyncUpdates()
+	cache.GetWithoutPromote("9")
+	cache.SyncUpdates()
+	cache.GC()
+	assert.Equal(t, cache.Get("9"), nil)
+	assert.Equal(t, cache.Get("10").Value(), 10)
+	assert.Equal(t, cache.Get("11").Value(), 11)
+}
+
 func Test_CacheTrackerDoesNotCleanupHeldInstance(t *testing.T) {
 	cache := New(Configure[int]().ItemsToPrune(11).Track())
 	item0 := cache.TrackingSet("0", 0, time.Minute)

layeredcache.go

@@ -75,6 +75,13 @@ func (c *LayeredCache[T]) Get(primary, secondary string) *Item[T] {
 	return item
 }
 
+// Same as Get but does not promote the value. This essentially circumvents the
+// "least recently used" aspect of this cache. To some degree, it's akin to a
+// "peak"
+func (c *LayeredCache[T]) GetWithoutPromote(primary, secondary string) *Item[T] {
+	return c.bucket(primary).get(primary, secondary)
+}
+
 func (c *LayeredCache[T]) ForEachFunc(primary string, matches func(key string, item *Item[T]) bool) {
 	c.bucket(primary).forEachFunc(primary, matches)
 }
@@ -345,6 +352,9 @@ func (c *LayeredCache[T]) gc() int {
 			c.bucket(item.group).delete(item.group, item.key)
 			c.size -= item.size
 			c.list.Remove(node)
+			if c.onDelete != nil {
+				c.onDelete(item)
+			}
 			item.promotions = -2
 			dropped += 1
 		}

layeredcache_test.go

@@ -188,6 +188,20 @@ func Test_LayeredCache_PromotedItemsDontGetPruned(t *testing.T) {
 	assert.Equal(t, cache.Get("11", "a").Value(), 11)
 }
 
+func Test_LayeredCache_GetWithoutPromoteDoesNotPromote(t *testing.T) {
+	cache := Layered(Configure[int]().ItemsToPrune(10).GetsPerPromote(1))
+	for i := 0; i < 500; i++ {
+		cache.Set(strconv.Itoa(i), "a", i, time.Minute)
+	}
+	cache.SyncUpdates()
+	cache.GetWithoutPromote("9", "a")
+	cache.SyncUpdates()
+	cache.GC()
+	assert.Equal(t, cache.Get("9", "a"), nil)
+	assert.Equal(t, cache.Get("10", "a").Value(), 10)
+	assert.Equal(t, cache.Get("11", "a").Value(), 11)
+}
+
 func Test_LayeredCache_TrackerDoesNotCleanupHeldInstance(t *testing.T) {
 	cache := Layered(Configure[int]().ItemsToPrune(10).Track())
 	item0 := cache.TrackingSet("0", "a", 0, time.Minute)
@@ -207,13 +221,21 @@ func Test_LayeredCache_TrackerDoesNotCleanupHeldInstance(t *testing.T) {
 }
 
 func Test_LayeredCache_RemovesOldestItemWhenFull(t *testing.T) {
-	cache := Layered(Configure[int]().MaxSize(5).ItemsToPrune(1))
+	onDeleteFnCalled := false
+	onDeleteFn := func(item *Item[int]) {
+		if item.key == "a" {
+			onDeleteFnCalled = true
+		}
+	}
+	cache := Layered(Configure[int]().MaxSize(5).ItemsToPrune(1).OnDelete(onDeleteFn))
+
 	cache.Set("xx", "a", 23, time.Minute)
 	for i := 0; i < 7; i++ {
 		cache.Set(strconv.Itoa(i), "a", i, time.Minute)
 	}
 	cache.Set("xx", "b", 9001, time.Minute)
 	cache.SyncUpdates()
+
 	assert.Equal(t, cache.Get("xx", "a"), nil)
 	assert.Equal(t, cache.Get("0", "a"), nil)
 	assert.Equal(t, cache.Get("1", "a"), nil)
@@ -222,6 +244,7 @@ func Test_LayeredCache_RemovesOldestItemWhenFull(t *testing.T) {
 	assert.Equal(t, cache.Get("xx", "b").Value(), 9001)
 	assert.Equal(t, cache.GetDropped(), 4)
 	assert.Equal(t, cache.GetDropped(), 0)
+	assert.Equal(t, onDeleteFnCalled, true)
 }
 
 func Test_LayeredCache_ResizeOnTheFly(t *testing.T) {

readme.md

@@ -1,4 +1,9 @@
 # CCache
+
+Generic version is on the way:
+https://github.com/karlseguin/ccache/tree/generic
+
+
 CCache is an LRU Cache, written in Go, focused on supporting high concurrency.
 
 Lock contention on the list is reduced by:
@@ -64,6 +69,9 @@ The returned `*Item` exposes a number of methods:
 
 By returning expired items, CCache lets you decide if you want to serve stale content or not. For example, you might decide to serve up slightly stale content (< 30 seconds old) while re-fetching newer data in the background. You might also decide to serve up infinitely stale content if you're unable to get new data from your source.
 
+### GetWithoutPromote
+Same as `Get` but does not "promote" the value, which is to say it circumvents the "lru" aspect of this cache. Should only be used in limited cases, such as peaking at the value.
+
 ### Set
 `Set` expects the key, value and ttl: