cache

Dec 11, 2017

Changes in this version

type Upstream

+ func ProxyFunc(u UpstreamFunc, c Interface) Upstream

Oct 24, 2017

Changes in this version

type Cache

+ func (c *Cache) Cap() int

Aug 23, 2017

Changes in this version

type EvictionPolicy

+ const PolicyTTL

+ type TTL struct

+ func NewTTL(size int) *TTL

+ func (c *TTL) Evict(keys ...interface{}) int

+ func (c *TTL) Get(k interface{}) (v interface{}, exp *time.Time, err error)

+ func (c *TTL) Metrics() Metrics

+ func (c *TTL) Set(x, y interface{}, exp *time.Time) (err error)

+ func (c *TTL) Trim(now time.Time) []interface{}

Aug 23, 2017

Changes in this version

+ var ErrExpired = errors.New("Key expired.")

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

+ var ErrMaxSize = errors.New("Cache full.")

Jun 18, 2017

Changes in this version

+ type EvictionPolicy int

+ const PolicyFIFO

+ const PolicyLFU

+ const PolicyLRU

+ const PolicyNone

type FIFO

+ func (c *FIFO) Get(k interface{}) (v interface{}, exp *time.Time, err error)

type Interface

+ func NewCache(size int, policy EvictionPolicy) Interface

+ Metrics func() Metrics

Jun 17, 2017

Changes in this version

+ const DefaultLFUQueueSize

+ const DefaultLRUQueueSize

+ var ExpiredError = errors.New("Key expired.")

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

+ var MaxSizeError = errors.New("Cache full.")

+ func Exp(ttl time.Duration) *time.Time

+ func Never() *time.Time

type Cache

+ func New(size int) *Cache

+ func (c *Cache) Evict(keys ...interface{}) (size int)

+ func (c *Cache) Metrics() *Metrics

+ func (c *Cache) Set(k, v interface{}, exp *time.Time) error

+ func (c *Cache) Size() int

+ func (c *Cache) Trim(now time.Time) []interface{}

+ type FIFO struct

+ func NewFIFO(size int) *FIFO

+ func (c *FIFO) Evict(keys ...interface{}) int

+ func (c *FIFO) Metrics() *Metrics

+ func (c *FIFO) Set(k, v interface{}, exp *time.Time) (err error)

+ func (c *FIFO) Trim(now time.Time) []interface{}

+ type Interface interface

+ Evict func(keys ...interface{}) (size int)

+ Set func(key, value interface{}, exp *time.Time) error

+ type LFU struct

+ func NewLFU(size int) *LFU

+ func (c *LFU) Evict(keys ...interface{}) int

+ func (c *LFU) Flush()

+ func (c *LFU) Get(x interface{}) (y interface{}, exp *time.Time, err error)

+ func (c *LFU) Metrics() *Metrics

+ func (c *LFU) Set(x, y interface{}, exp *time.Time) (err error)

+ func (c *LFU) Trim(now time.Time) []interface{}

+ type LRU struct

+ func NewLRU(size int) *LRU

+ func (c *LRU) Evict(keys ...interface{}) int

+ func (c *LRU) Flush()

+ func (c *LRU) Get(x interface{}) (y interface{}, exp *time.Time, err error)

+ func (c *LRU) Metrics() *Metrics

+ func (c *LRU) Set(x, y interface{}, exp *time.Time) (err error)

+ func (c *LRU) Trim(now time.Time) []interface{}

+ type Metrics struct

+ Evict int64

+ Expired int64

+ Hit int64

+ Items int64

+ Miss int64

type Upstream

+ func Proxy(u Upstream, c Interface) Upstream

+ Get func(x interface{}) (y interface{}, exp *time.Time, err error)

type UpstreamFunc

+ func (f UpstreamFunc) Get(x interface{}) (y interface{}, exp *time.Time, err error)

Apr 19, 2017

Changes in this version

+ const DefaultExpireInterval

+ const DefaultMaxItems

+ var NoUpstreamError = errors.New("No Upstream assigned to cache")

+ type BlockUpstream struct

+ func (b *BlockUpstream) Fetch(x interface{}) (interface{}, error)

+ type Cache struct

+ MaxAge time.Duration

+ MaxItems int

+ Namespace string

+ Upstream Upstream

+ func (c *Cache) Fetch(x interface{}) (interface{}, error)

+ func (c *Cache) Get(x interface{}) (interface{}, bool, error)

+ func (c *Cache) Run(ctx context.Context) error

+ func (c *Cache) Stats() (uint64, uint64, uint64, uint64)

+ type Node struct

+ Data interface{}

+ Element *list.Element

+ Exp time.Time

+ Key interface{}

+ Requests int64

+ type StaticUpstream map[interface{}]interface

+ func (u StaticUpstream) Fetch(x interface{}) (interface{}, error)

+ type Upstream interface

+ Fetch func(interface{}) (interface{}, error)

+ func Blocking(up Upstream) Upstream

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

+ func (f UpstreamFunc) Fetch(x interface{}) (interface{}, error)