cache

package module

Go to main page

Versions in this module

v0

v0.3.0

Mar 22, 2021

Changes in this version

+ type Expirable struct

+ Expire time.Duration

+ Value interface{}

+ func NewDefault(value interface{}) Expirable

+ func NewExpirable(value interface{}, expire time.Duration) Expirable

v0.2.1

Mar 19, 2021

v0.2.0

Dec 19, 2020

Changes in this version

+ const TypeArc

+ const TypeLfu

+ const TypeLru

+ const TypeSimple

type ARC

+ func (st ARC) HitCount() uint64

+ func (st ARC) HitRate() float64

+ func (st ARC) IncrHitCount() uint64

+ func (st ARC) IncrMissCount() uint64

+ func (st ARC) LookupCount() uint64

+ func (st ARC) MissCount() uint64

+ type BaseCache struct

+ func (st BaseCache) HitCount() uint64

+ func (st BaseCache) HitRate() float64

+ func (st BaseCache) IncrHitCount() uint64

+ func (st BaseCache) IncrMissCount() uint64

+ func (st BaseCache) LookupCount() uint64

+ func (st BaseCache) MissCount() uint64

+ type Builder struct

+ func NewARC(size int) *Builder

+ func NewLFU(size int) *Builder

+ func NewLRU(size int) *Builder

+ func NewWithEvictType(size int, tp string) *Builder

+ func (b *Builder) ARC() *Builder

+ func (b *Builder) AddedFunc(addedFunc AddedFunc) *Builder

+ func (b *Builder) Build() Cache

+ func (b *Builder) Clock(clock Clock) *Builder

+ func (b *Builder) DeserializeFunc(deserializeFunc DeserializeFunc) *Builder

+ func (b *Builder) EvictType(tp string) *Builder

+ func (b *Builder) EvictedFunc(evictedFunc EvictedFunc) *Builder

+ func (b *Builder) Expiration(expiration time.Duration) *Builder

+ func (b *Builder) LFU() *Builder

+ func (b *Builder) LRU() *Builder

+ func (b *Builder) LoaderExpireFunc(loaderExpireFunc LoaderExpireFunc) *Builder

+ func (b *Builder) LoaderFunc(loaderFunc LoaderFunc) *Builder

+ func (b *Builder) PurgeVisitorFunc(purgeVisitorFunc PurgeVisitorFunc) *Builder

+ func (b *Builder) SerializeFunc(serializeFunc SerializeFunc) *Builder

+ func (b *Builder) Simple() *Builder

+ type ExpirableValue struct

+ Expire time.Duration

+ Value interface{}

+ func NewDefaultValue(value interface{}) ExpirableValue

+ func NewExpirableValue(value interface{}, expire time.Duration) ExpirableValue

type LFUCache

+ func (st LFUCache) HitCount() uint64

+ func (st LFUCache) HitRate() float64

+ func (st LFUCache) IncrHitCount() uint64

+ func (st LFUCache) IncrMissCount() uint64

+ func (st LFUCache) LookupCount() uint64

+ func (st LFUCache) MissCount() uint64

type LRUCache

+ func (st LRUCache) HitCount() uint64

+ func (st LRUCache) HitRate() float64

+ func (st LRUCache) IncrHitCount() uint64

+ func (st LRUCache) IncrMissCount() uint64

+ func (st LRUCache) LookupCount() uint64

+ func (st LRUCache) MissCount() uint64

type SimpleCache

+ func (st SimpleCache) HitCount() uint64

+ func (st SimpleCache) HitRate() float64

+ func (st SimpleCache) IncrHitCount() uint64

+ func (st SimpleCache) IncrMissCount() uint64

+ func (st SimpleCache) LookupCount() uint64

+ func (st SimpleCache) MissCount() uint64

v0.1.0

Oct 8, 2020

Changes in this version

+ const TYPE_ARC

+ const TYPE_LFU

+ const TYPE_LRU

+ const TYPE_SIMPLE

+ var KeyNotFoundError = errors.New("Key not found.")

+ var NoExpiration *time.Duration = nil

+ type ARC struct

+ func (c *ARC) Get(key interface{}) (interface{}, error)

+ func (c *ARC) GetAll(checkExpired bool) map[interface{}]interface{}

+ func (c *ARC) GetIfPresent(key interface{}) (interface{}, error)

+ func (c *ARC) GetOrLoad(key interface{}, loader LoaderExpireFunc) (interface{}, error)

+ func (c *ARC) Has(key interface{}) bool

+ func (c *ARC) Keys(checkExpired bool) []interface{}

+ func (c *ARC) Len(checkExpired bool) int

+ func (c *ARC) Purge()

+ func (c *ARC) Remove(key interface{}) bool

+ func (c *ARC) Set(key, value interface{}) error

+ func (c *ARC) SetWithExpire(key, value interface{}, expiration time.Duration) error

+ type AddedFunc func(interface{}, interface{})

+ type Cache interface

+ Get func(key interface{}) (interface{}, error)

+ GetAll func(checkExpired bool) map[interface{}]interface{}

+ GetIfPresent func(key interface{}) (interface{}, error)

+ GetOrLoad func(key interface{}, loader LoaderExpireFunc) (interface{}, error)

+ Has func(key interface{}) bool

+ Keys func(checkExpired bool) []interface{}

+ Len func(checkExpired bool) int

+ Purge func()

+ Remove func(key interface{}) bool

+ Set func(key, value interface{}) error

+ SetWithExpire func(key, value interface{}, expiration time.Duration) error

+ type CacheBuilder struct

+ func New(size int) *CacheBuilder

+ func (cb *CacheBuilder) ARC() *CacheBuilder

+ func (cb *CacheBuilder) AddedFunc(addedFunc AddedFunc) *CacheBuilder

+ func (cb *CacheBuilder) Build() Cache

+ func (cb *CacheBuilder) Clock(clock Clock) *CacheBuilder

+ func (cb *CacheBuilder) DeserializeFunc(deserializeFunc DeserializeFunc) *CacheBuilder

+ func (cb *CacheBuilder) EvictType(tp string) *CacheBuilder

+ func (cb *CacheBuilder) EvictedFunc(evictedFunc EvictedFunc) *CacheBuilder

+ func (cb *CacheBuilder) Expiration(expiration time.Duration) *CacheBuilder

+ func (cb *CacheBuilder) LFU() *CacheBuilder

+ func (cb *CacheBuilder) LRU() *CacheBuilder

+ func (cb *CacheBuilder) LoaderExpireFunc(loaderExpireFunc LoaderExpireFunc) *CacheBuilder

+ func (cb *CacheBuilder) LoaderFunc(loaderFunc LoaderFunc) *CacheBuilder

+ func (cb *CacheBuilder) PurgeVisitorFunc(purgeVisitorFunc PurgeVisitorFunc) *CacheBuilder

+ func (cb *CacheBuilder) SerializeFunc(serializeFunc SerializeFunc) *CacheBuilder

+ func (cb *CacheBuilder) Simple() *CacheBuilder

+ type Clock interface

+ Now func() time.Time

+ func NewRealClock() Clock

+ type DeserializeFunc func(interface{}, interface{}) (interface{}, error)

+ type EvictedFunc func(interface{}, interface{})

+ type FakeClock interface

+ Advance func(d time.Duration)

+ func NewFakeClock() FakeClock

+ type Group struct

+ func (g *Group) Do(key interface{}, fn func() (interface{}, error), isWait bool) (interface{}, bool, error)

+ type LFUCache struct

+ func (c *LFUCache) Get(key interface{}) (interface{}, error)

+ func (c *LFUCache) GetAll(checkExpired bool) map[interface{}]interface{}

+ func (c *LFUCache) GetIfPresent(key interface{}) (interface{}, error)

+ func (c *LFUCache) GetOrLoad(key interface{}, loader LoaderExpireFunc) (interface{}, error)

+ func (c *LFUCache) Has(key interface{}) bool

+ func (c *LFUCache) Keys(checkExpired bool) []interface{}

+ func (c *LFUCache) Len(checkExpired bool) int

+ func (c *LFUCache) Purge()

+ func (c *LFUCache) Remove(key interface{}) bool

+ func (c *LFUCache) Set(key, value interface{}) error

+ func (c *LFUCache) SetWithExpire(key, value interface{}, expiration time.Duration) error

+ type LRUCache struct

+ func (c *LRUCache) Get(key interface{}) (interface{}, error)

+ func (c *LRUCache) GetAll(checkExpired bool) map[interface{}]interface{}

+ func (c *LRUCache) GetIfPresent(key interface{}) (interface{}, error)

+ func (c *LRUCache) GetOrLoad(key interface{}, loader LoaderExpireFunc) (interface{}, error)

+ func (c *LRUCache) Has(key interface{}) bool

+ func (c *LRUCache) Keys(checkExpired bool) []interface{}

+ func (c *LRUCache) Len(checkExpired bool) int

+ func (c *LRUCache) Purge()

+ func (c *LRUCache) Remove(key interface{}) bool

+ func (c *LRUCache) Set(key, value interface{}) error

+ func (c *LRUCache) SetWithExpire(key, value interface{}, expiration time.Duration) error

+ type LoaderExpireFunc func(interface{}) (interface{}, *time.Duration, error)

+ type LoaderFunc func(interface{}) (interface{}, error)

+ type PurgeVisitorFunc func(interface{}, interface{})

+ type RealClock struct

+ func (rc RealClock) Now() time.Time

+ type SerializeFunc func(interface{}, interface{}) (interface{}, error)

+ type SimpleCache struct

+ func (c *SimpleCache) Get(key interface{}) (interface{}, error)

+ func (c *SimpleCache) GetAll(checkExpired bool) map[interface{}]interface{}

+ func (c *SimpleCache) GetIfPresent(key interface{}) (interface{}, error)

+ func (c *SimpleCache) GetOrLoad(key interface{}, loader LoaderExpireFunc) (interface{}, error)

+ func (c *SimpleCache) Has(key interface{}) bool

+ func (c *SimpleCache) Keys(checkExpired bool) []interface{}

+ func (c *SimpleCache) Len(checkExpired bool) int

+ func (c *SimpleCache) Purge()

+ func (c *SimpleCache) Remove(key interface{}) bool

+ func (c *SimpleCache) Set(key, value interface{}) error

+ func (c *SimpleCache) SetWithExpire(key, value interface{}, expiration time.Duration) error

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL