type Cache struct {
// contains filtered or unexported fields
}
Cache is a 'cache map'.
func NewCache(cacher Cacher) *Cache
NewCache creates a new 'cache map'. The cacher is optional and may be nil.
func (r *Cache) Capacity() int
Capacity returns cache capacity.
func (r *Cache) Close() error
Close closes the 'cache map' and forcefully releases all 'cache node'.
func (r *Cache) CloseWeak() error
CloseWeak closes the 'cache map' and evict all 'cache node' from cacher, but unlike Close it doesn't forcefully releases 'cache node'.
func (r *Cache) Delete(ns, key uint64, onDel func()) bool
Delete removes and ban 'cache node' with the given namespace and key. A banned 'cache node' will never inserted into the 'cache tree'. Ban only attributed to the particular 'cache node', so when a 'cache node' is recreated it will not be banned.
If onDel is not nil, then it will be executed if such 'cache node' doesn't exist or once the 'cache node' is released.
Delete return true is such 'cache node' exist.
func (r *Cache) Evict(ns, key uint64) bool
Evict evicts 'cache node' with the given namespace and key. This will simply call Cacher.Evict.
Evict return true is such 'cache node' exist.
func (r *Cache) EvictAll()
EvictAll evicts all 'cache node'. This will simply call Cacher.EvictAll.
func (r *Cache) EvictNS(ns uint64)
EvictNS evicts 'cache node' with the given namespace. This will simply call Cacher.EvictNS.
func (r *Cache) Get(ns, key uint64, setFunc func() (size int, value Value)) *Handle
Get gets 'cache node' with the given namespace and key. If cache node is not found and setFunc is not nil, Get will atomically creates the 'cache node' by calling setFunc. Otherwise Get will returns nil.
The returned 'cache handle' should be released after use by calling Release method.
func (r *Cache) Nodes() int
Nodes returns number of 'cache node' in the map.
func (r *Cache) SetCapacity(capacity int)
SetCapacity sets cache capacity.
func (r *Cache) Size() int
Size returns sums of 'cache node' size in the map.
type Cacher interface {
// Capacity returns cache capacity.
Capacity() int
// SetCapacity sets cache capacity.
SetCapacity(capacity int)
// Promote promotes the 'cache node'.
Promote(n *Node)
// Ban evicts the 'cache node' and prevent subsequent 'promote'.
Ban(n *Node)
// Evict evicts the 'cache node'.
Evict(n *Node)
// EvictNS evicts 'cache node' with the given namespace.
EvictNS(ns uint64)
// EvictAll evicts all 'cache node'.
EvictAll()
// Close closes the 'cache tree'
Close() error
}
Cacher provides interface to implements a caching functionality. An implementation must be safe for concurrent use.
func NewLRU(capacity int) Cacher
NewLRU create a new LRU-cache.
type Handle struct {
// contains filtered or unexported fields
}
Handle is a 'cache handle' of a 'cache node'.
func (h *Handle) Release()
Release releases this 'cache handle'. It is safe to call release multiple times.
func (h *Handle) Value() Value
Value returns the value of the 'cache node'.
type NamespaceGetter struct {
Cache *Cache
NS uint64
}
NamespaceGetter provides convenient wrapper for namespace.
func (g *NamespaceGetter) Get(key uint64, setFunc func() (size int, value Value)) *Handle
Get simply calls Cache.Get() method.
type Node struct {
CacheData unsafe.Pointer
// contains filtered or unexported fields
}
Node is a 'cache node'.
func (n *Node) GetHandle() *Handle
GetHandle returns an handle for this 'cache node'.
func (n *Node) Key() uint64
Key returns this 'cache node' key.
func (n *Node) NS() uint64
NS returns this 'cache node' namespace.
func (n *Node) Ref() int32
Ref returns this 'cache node' ref counter.
func (n *Node) Size() int
Size returns this 'cache node' size.
func (n *Node) Value() Value
Value returns this 'cache node' value.
type Value interface{}
Value is a 'cacheable object'. It may implements util.Releaser, if so the the Release method will be called once object is released.