mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-12-04 22:20:53 +01:00
455 lines
8.0 KiB
Go
455 lines
8.0 KiB
Go
package simple
|
|
|
|
import (
|
|
"sync"
|
|
|
|
"codeberg.org/gruf/go-maps"
|
|
)
|
|
|
|
// Entry represents an item in the cache.
|
|
type Entry struct {
|
|
Key any
|
|
Value any
|
|
}
|
|
|
|
// Cache is the underlying Cache implementation, providing both the base Cache interface and unsafe access to underlying map to allow flexibility in building your own.
|
|
type Cache[Key comparable, Value any] struct {
|
|
// Evict is the hook that is called when an item is evicted from the cache.
|
|
Evict func(Key, Value)
|
|
|
|
// Invalid is the hook that is called when an item's data in the cache is invalidated, includes Add/Set.
|
|
Invalid func(Key, Value)
|
|
|
|
// Cache is the underlying hashmap used for this cache.
|
|
Cache maps.LRUMap[Key, *Entry]
|
|
|
|
// Embedded mutex.
|
|
sync.Mutex
|
|
}
|
|
|
|
// New returns a new initialized Cache with given initial length, maximum capacity and item TTL.
|
|
func New[K comparable, V any](len, cap int) *Cache[K, V] {
|
|
c := new(Cache[K, V])
|
|
c.Init(len, cap)
|
|
return c
|
|
}
|
|
|
|
// Init will initialize this cache with given initial length, maximum capacity and item TTL.
|
|
func (c *Cache[K, V]) Init(len, cap int) {
|
|
c.SetEvictionCallback(nil)
|
|
c.SetInvalidateCallback(nil)
|
|
c.Cache.Init(len, cap)
|
|
}
|
|
|
|
// SetEvictionCallback: implements cache.Cache's SetEvictionCallback().
|
|
func (c *Cache[K, V]) SetEvictionCallback(hook func(K, V)) {
|
|
c.locked(func() { c.Evict = hook })
|
|
}
|
|
|
|
// SetInvalidateCallback: implements cache.Cache's SetInvalidateCallback().
|
|
func (c *Cache[K, V]) SetInvalidateCallback(hook func(K, V)) {
|
|
c.locked(func() { c.Invalid = hook })
|
|
}
|
|
|
|
// Get: implements cache.Cache's Get().
|
|
func (c *Cache[K, V]) Get(key K) (V, bool) {
|
|
var (
|
|
// did exist in cache?
|
|
ok bool
|
|
|
|
// cached value.
|
|
v V
|
|
)
|
|
|
|
c.locked(func() {
|
|
var item *Entry
|
|
|
|
// Check for item in cache
|
|
item, ok = c.Cache.Get(key)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
// Set item value.
|
|
v = item.Value.(V)
|
|
})
|
|
|
|
return v, ok
|
|
}
|
|
|
|
// Add: implements cache.Cache's Add().
|
|
func (c *Cache[K, V]) Add(key K, value V) bool {
|
|
var (
|
|
// did exist in cache?
|
|
ok bool
|
|
|
|
// was entry evicted?
|
|
ev bool
|
|
|
|
// evicted key values.
|
|
evcK K
|
|
evcV V
|
|
|
|
// hook func ptrs.
|
|
evict func(K, V)
|
|
)
|
|
|
|
c.locked(func() {
|
|
// Check if in cache.
|
|
ok = c.Cache.Has(key)
|
|
if ok {
|
|
return
|
|
}
|
|
|
|
// Alloc new entry.
|
|
new := GetEntry()
|
|
new.Key = key
|
|
new.Value = value
|
|
|
|
// Add new entry to cache and catched any evicted item.
|
|
c.Cache.SetWithHook(key, new, func(_ K, item *Entry) {
|
|
evcK = item.Key.(K)
|
|
evcV = item.Value.(V)
|
|
ev = true
|
|
PutEntry(item)
|
|
})
|
|
|
|
// Set hook func ptr.
|
|
evict = c.Evict
|
|
})
|
|
|
|
if ev && evict != nil {
|
|
// Pass to eviction hook.
|
|
evict(evcK, evcV)
|
|
}
|
|
|
|
return !ok
|
|
}
|
|
|
|
// Set: implements cache.Cache's Set().
|
|
func (c *Cache[K, V]) Set(key K, value V) {
|
|
var (
|
|
// did exist in cache?
|
|
ok bool
|
|
|
|
// was entry evicted?
|
|
ev bool
|
|
|
|
// old value.
|
|
oldV V
|
|
|
|
// evicted key values.
|
|
evcK K
|
|
evcV V
|
|
|
|
// hook func ptrs.
|
|
invalid func(K, V)
|
|
evict func(K, V)
|
|
)
|
|
|
|
c.locked(func() {
|
|
var item *Entry
|
|
|
|
// Check for item in cache
|
|
item, ok = c.Cache.Get(key)
|
|
|
|
if ok {
|
|
// Set old value.
|
|
oldV = item.Value.(V)
|
|
|
|
// Update the existing item.
|
|
item.Value = value
|
|
} else {
|
|
// Alloc new entry.
|
|
new := GetEntry()
|
|
new.Key = key
|
|
new.Value = value
|
|
|
|
// Add new entry to cache and catched any evicted item.
|
|
c.Cache.SetWithHook(key, new, func(_ K, item *Entry) {
|
|
evcK = item.Key.(K)
|
|
evcV = item.Value.(V)
|
|
ev = true
|
|
PutEntry(item)
|
|
})
|
|
}
|
|
|
|
// Set hook func ptrs.
|
|
invalid = c.Invalid
|
|
evict = c.Evict
|
|
})
|
|
|
|
if ok && invalid != nil {
|
|
// Pass to invalidate hook.
|
|
invalid(key, oldV)
|
|
}
|
|
|
|
if ev && evict != nil {
|
|
// Pass to eviction hook.
|
|
evict(evcK, evcV)
|
|
}
|
|
}
|
|
|
|
// CAS: implements cache.Cache's CAS().
|
|
func (c *Cache[K, V]) CAS(key K, old V, new V, cmp func(V, V) bool) bool {
|
|
var (
|
|
// did exist in cache?
|
|
ok bool
|
|
|
|
// swapped value.
|
|
oldV V
|
|
|
|
// hook func ptrs.
|
|
invalid func(K, V)
|
|
)
|
|
|
|
c.locked(func() {
|
|
var item *Entry
|
|
|
|
// Check for item in cache
|
|
item, ok = c.Cache.Get(key)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
// Set old value.
|
|
oldV = item.Value.(V)
|
|
|
|
// Perform the comparison
|
|
if !cmp(old, oldV) {
|
|
var zero V
|
|
oldV = zero
|
|
return
|
|
}
|
|
|
|
// Update value.
|
|
item.Value = new
|
|
|
|
// Set hook func ptr.
|
|
invalid = c.Invalid
|
|
})
|
|
|
|
if ok && invalid != nil {
|
|
// Pass to invalidate hook.
|
|
invalid(key, oldV)
|
|
}
|
|
|
|
return ok
|
|
}
|
|
|
|
// Swap: implements cache.Cache's Swap().
|
|
func (c *Cache[K, V]) Swap(key K, swp V) V {
|
|
var (
|
|
// did exist in cache?
|
|
ok bool
|
|
|
|
// swapped value.
|
|
oldV V
|
|
|
|
// hook func ptrs.
|
|
invalid func(K, V)
|
|
)
|
|
|
|
c.locked(func() {
|
|
var item *Entry
|
|
|
|
// Check for item in cache
|
|
item, ok = c.Cache.Get(key)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
// Set old value.
|
|
oldV = item.Value.(V)
|
|
|
|
// Update value.
|
|
item.Value = swp
|
|
|
|
// Set hook func ptr.
|
|
invalid = c.Invalid
|
|
})
|
|
|
|
if ok && invalid != nil {
|
|
// Pass to invalidate hook.
|
|
invalid(key, oldV)
|
|
}
|
|
|
|
return oldV
|
|
}
|
|
|
|
// Has: implements cache.Cache's Has().
|
|
func (c *Cache[K, V]) Has(key K) (ok bool) {
|
|
c.locked(func() {
|
|
ok = c.Cache.Has(key)
|
|
})
|
|
return
|
|
}
|
|
|
|
// Invalidate: implements cache.Cache's Invalidate().
|
|
func (c *Cache[K, V]) Invalidate(key K) (ok bool) {
|
|
var (
|
|
// old value.
|
|
oldV V
|
|
|
|
// hook func ptrs.
|
|
invalid func(K, V)
|
|
)
|
|
|
|
c.locked(func() {
|
|
var item *Entry
|
|
|
|
// Check for item in cache
|
|
item, ok = c.Cache.Get(key)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
// Set old value.
|
|
oldV = item.Value.(V)
|
|
|
|
// Remove from cache map
|
|
_ = c.Cache.Delete(key)
|
|
|
|
// Free entry
|
|
PutEntry(item)
|
|
|
|
// Set hook func ptrs.
|
|
invalid = c.Invalid
|
|
})
|
|
|
|
if ok && invalid != nil {
|
|
// Pass to invalidate hook.
|
|
invalid(key, oldV)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// InvalidateAll: implements cache.Cache's InvalidateAll().
|
|
func (c *Cache[K, V]) InvalidateAll(keys ...K) (ok bool) {
|
|
var (
|
|
// deleted items.
|
|
items []*Entry
|
|
|
|
// hook func ptrs.
|
|
invalid func(K, V)
|
|
)
|
|
|
|
// Allocate a slice for invalidated.
|
|
items = make([]*Entry, 0, len(keys))
|
|
|
|
c.locked(func() {
|
|
for x := range keys {
|
|
var item *Entry
|
|
|
|
// Check for item in cache
|
|
item, ok = c.Cache.Get(keys[x])
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
// Append this old value.
|
|
items = append(items, item)
|
|
|
|
// Remove from cache map
|
|
_ = c.Cache.Delete(keys[x])
|
|
}
|
|
|
|
// Set hook func ptrs.
|
|
invalid = c.Invalid
|
|
})
|
|
|
|
if invalid != nil {
|
|
for x := range items {
|
|
// Pass to invalidate hook.
|
|
k := items[x].Key.(K)
|
|
v := items[x].Value.(V)
|
|
invalid(k, v)
|
|
|
|
// Free this entry.
|
|
PutEntry(items[x])
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// Clear: implements cache.Cache's Clear().
|
|
func (c *Cache[K, V]) Clear() { c.Trim(100) }
|
|
|
|
// Trim will truncate the cache to ensure it stays within given percentage of total capacity.
|
|
func (c *Cache[K, V]) Trim(perc float64) {
|
|
var (
|
|
// deleted items
|
|
items []*Entry
|
|
|
|
// hook func ptrs.
|
|
invalid func(K, V)
|
|
)
|
|
|
|
c.locked(func() {
|
|
// Calculate number of cache items to truncate.
|
|
max := (perc / 100) * float64(c.Cache.Cap())
|
|
diff := c.Cache.Len() - int(max)
|
|
if diff <= 0 {
|
|
return
|
|
}
|
|
|
|
// Set hook func ptr.
|
|
invalid = c.Invalid
|
|
|
|
// Truncate by calculated length.
|
|
items = c.truncate(diff, invalid)
|
|
})
|
|
|
|
if invalid != nil {
|
|
for x := range items {
|
|
// Pass to invalidate hook.
|
|
k := items[x].Key.(K)
|
|
v := items[x].Value.(V)
|
|
invalid(k, v)
|
|
|
|
// Free this entry.
|
|
PutEntry(items[x])
|
|
}
|
|
}
|
|
}
|
|
|
|
// Len: implements cache.Cache's Len().
|
|
func (c *Cache[K, V]) Len() (l int) {
|
|
c.locked(func() { l = c.Cache.Len() })
|
|
return
|
|
}
|
|
|
|
// Cap: implements cache.Cache's Cap().
|
|
func (c *Cache[K, V]) Cap() (l int) {
|
|
c.locked(func() { l = c.Cache.Cap() })
|
|
return
|
|
}
|
|
|
|
// locked performs given function within mutex lock (NOTE: UNLOCK IS NOT DEFERRED).
|
|
func (c *Cache[K, V]) locked(fn func()) {
|
|
c.Lock()
|
|
fn()
|
|
c.Unlock()
|
|
}
|
|
|
|
// truncate will truncate the cache by given size, returning deleted items.
|
|
func (c *Cache[K, V]) truncate(sz int, hook func(K, V)) []*Entry {
|
|
if hook == nil {
|
|
// No hook to execute, simply release all truncated entries.
|
|
c.Cache.Truncate(sz, func(_ K, item *Entry) { PutEntry(item) })
|
|
return nil
|
|
}
|
|
|
|
// Allocate a slice for deleted.
|
|
deleted := make([]*Entry, 0, sz)
|
|
|
|
// Truncate and catch all deleted k-v pairs.
|
|
c.Cache.Truncate(sz, func(_ K, item *Entry) {
|
|
deleted = append(deleted, item)
|
|
})
|
|
|
|
return deleted
|
|
}
|