The highest tagged major version is
README
¶
go-cache
A TTL cache designed to be used as a base for your own customizations, or used straight out of the box
Documentation
¶
Index ¶
- type Cache
- type Hook
- type LookupCache
- type LookupCfg
- type LookupMap
- type TTLCache
- func (c *TTLCache) Clear()
- func (c *TTLCache) ClearUnsafe()
- func (c *TTLCache) Get(key string) (interface{}, bool)
- func (c *TTLCache) GetUnsafe(key string) (interface{}, bool)
- func (c *TTLCache) Has(key string) bool
- func (c *TTLCache) HasUnsafe(key string) bool
- func (c *TTLCache) Init()
- func (c *TTLCache) Invalidate(key string) bool
- func (c *TTLCache) InvalidateUnsafe(key string) bool
- func (c *TTLCache) Lock()
- func (c *TTLCache) Put(key string, value interface{}) bool
- func (c *TTLCache) PutUnsafe(key string, value interface{}) bool
- func (c *TTLCache) Set(key string, value interface{})
- func (c *TTLCache) SetEvictionCallback(hook Hook)
- func (c *TTLCache) SetInvalidateCallback(hook Hook)
- func (c *TTLCache) SetTTL(ttl time.Duration, update bool)
- func (c *TTLCache) SetUnsafe(key string, value interface{})
- func (c *TTLCache) Size() int
- func (c *TTLCache) SizeUnsafe() int
- func (c *TTLCache) Start(freq time.Duration) bool
- func (c *TTLCache) Stop() bool
- func (c *TTLCache) Unlock()
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Cache ¶
type Cache interface {
// Start will start the cache background eviction routine with given sweep frequency.
// If already running or a freq <= 0 provided, this is a no-op. This will block until
// the eviction routine has started
Start(freq time.Duration) bool
// Stop will stop cache background eviction routine. If not running this is a no-op. This
// will block until the eviction routine has stopped
Stop() bool
// SetEvictionCallback sets the eviction callback to the provided hook
SetEvictionCallback(hook Hook)
// SetInvalidateCallback sets the invalidate callback to the provided hook
SetInvalidateCallback(hook Hook)
// SetTTL sets the cache item TTL. Update can be specified to force updates of existing items in
// the cache, this will simply add the change in TTL to their current expiry time
SetTTL(ttl time.Duration, update bool)
// Get fetches the value with key from the cache, extending its TTL
Get(key string) (interface{}, bool)
// Put attempts to place the value at key in the cache, doing nothing if
// a value with this key already exists. Returned bool is success state
Put(key string, value interface{}) bool
// Set places the value at key in the cache. This will overwrite any
// existing value, and call the update callback so. Existing values
// will have their TTL extended upon update
Set(key string, value interface{})
// Has checks the cache for a value with key, this will not update TTL
Has(key string) bool
// Invalidate deletes a value from the cache, calling the invalidate callback
Invalidate(key string) bool
// Clear empties the cache, calling the invalidate callback
Clear()
// Size returns the current size of the cache
Size() int
}
Cache represents a TTL cache with customizable callbacks, it exists here to abstract away the "unsafe" methods in the case that you do not want your own implementation atop TTLCache{}.
type Hook ¶
type Hook func(key string, value interface{})
Hook defines a function hook that can be supplied as a callback.
type LookupCache ¶
type LookupCache interface {
Cache
// GetBy fetches a cached value by supplied lookup identifier and key
GetBy(lookup string, key string) (interface{}, bool)
// HasBy checks if a value is cached under supplied lookup identifier and key
HasBy(lookup string, key string) bool
// InvalidateBy invalidates a value by supplied lookup identifier and key
InvalidateBy(lookup string, key string) bool
}
LookupCache is a cache built on-top of TTLCache, providing multi-key lookups for items in the cache by means of additional lookup maps. These maps simply store additional keys => original key, with hook-ins to automatically call user supplied functions on adding an item, or on updating/deleting an item to keep the LookupMap up-to-date.
func NewLookup ¶
func NewLookup(cfg LookupCfg) LookupCache
NewLookup returns a new initialized LookupCache.
type LookupCfg ¶
type LookupCfg struct {
// RegisterLookups is called on init to register lookups
// within LookupCache's internal LookupMap
RegisterLookups func(*LookupMap)
// AddLookups is called on each addition to the cache, to
// set any required additional key lookups for supplied item
AddLookups func(*LookupMap, interface{})
// DeleteLookups is called on each eviction/invalidation of
// an item in the cache, to remove any unused key lookups
DeleteLookups func(*LookupMap, interface{})
}
LookupCfg is the LookupCache configuration.
type LookupMap ¶
type LookupMap struct {
// contains filtered or unexported fields
}
LookupMap is a structure that provides lookups for keys to primary keys under supplied lookup identifiers. This is essentially a wrapper around map[string](map[string]string).
func (*LookupMap) RegisterLookup ¶
RegisterLookup registers a lookup identifier in the LookupMap, note this can only be doing during the cfg.RegisterLookups() hook.
type TTLCache ¶
type TTLCache struct {
// contains filtered or unexported fields
}
TTLCache is the underlying Cache implementation, providing both the base Cache interface and access to "unsafe" methods so that you may build your customized caches ontop of this structure.
func (*TTLCache) ClearUnsafe ¶
func (c *TTLCache) ClearUnsafe()
ClearUnsafe is mutex-unprotected logic for Cache.Clean().
func (*TTLCache) Init ¶
func (c *TTLCache) Init()
Init performs Cache initialization, this MUST be called.
func (*TTLCache) Invalidate ¶
func (*TTLCache) InvalidateUnsafe ¶
InvalidateUnsafe is mutex-unprotected logic for Cache.Invalidate().
func (*TTLCache) SetEvictionCallback ¶
func (*TTLCache) SetInvalidateCallback ¶
func (*TTLCache) SetUnsafe ¶
SetUnsafe is the mutex-unprotected logic for Cache.Set(), it calls externally-set functions.
func (*TTLCache) SizeUnsafe ¶
SizeUnsafe is mutex unprotected logic for Cache.Size().
Source Files