cache

Documentation

Index

• type Cache
• type ChanOnlyOne
  • func NewChanOnlyOne() *ChanOnlyOne
  • func (c *ChanOnlyOne) Compute(k interface{}, fn func() (interface{}, error)) (interface{}, error)
• type GetSetCache
  • func NewCache(size int, expiry time.Duration, jitterFn JitterFn) *GetSetCache
  • func (c *GetSetCache) GetOrSet(k interface{}, setFn SetFn) (v interface{}, err error)
• type JitterFn
  • func NewJitterFn(jitter time.Duration) JitterFn
• type OnlyOne
• type SetFn

Types

type Cache

type Cache interface {
	GetOrSet(k interface{}, setFn SetFn) (v interface{}, err error)
}

var NoCache Cache = &noCache{}

type ChanOnlyOne

type ChanOnlyOne struct {
	// contains filtered or unexported fields
}

func NewChanOnlyOne

func NewChanOnlyOne() *ChanOnlyOne

func (*ChanOnlyOne) Compute

func (c *ChanOnlyOne) Compute(k interface{}, fn func() (interface{}, error)) (interface{}, error)

type GetSetCache

type GetSetCache struct {
	// contains filtered or unexported fields
}

func NewCache

func NewCache(size int, expiry time.Duration, jitterFn JitterFn) *GetSetCache

func (*GetSetCache) GetOrSet

func (c *GetSetCache) GetOrSet(k interface{}, setFn SetFn) (v interface{}, err error)

type JitterFn

type JitterFn func() time.Duration

func NewJitterFn

func NewJitterFn(jitter time.Duration) JitterFn

type OnlyOne

type OnlyOne interface {
	// Compute returns the value of calling fn(), but only calls fn once concurrently for
	// each k.
	Compute(k interface{}, fn func() (interface{}, error)) (interface{}, error)
}

OnlyOne ensures only one concurrent evaluation of a keyed expression.

type SetFn

type SetFn func() (v interface{}, err error)