cache

type Cache ¶

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

type CacheWithDisposal ¶ added in v0.21.3

type CacheWithDisposal interface {
	Name() string
	GetOrSet(k interface{}, setFn SetFn) (v interface{}, disposer Derefer, err error)
}

CacheWithDisposal is a cache that calls a disposal callback when an entry has been evicted and is no longer in use. Because of the structure of Go, it uses release callbacks and is not a Cache.

type ChanOnlyOne ¶ added in v0.21.2

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

func NewChanOnlyOne() *ChanOnlyOne

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

type Derefer ¶ added in v0.21.3

type Derefer func() error

Derefer is the type of a function that returns an object to the cache, possibly causing its eviction.

type GetSetCache ¶

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

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

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

type JitterFn ¶

type JitterFn func() time.Duration

func NewJitterFn(jitter time.Duration) JitterFn

type OnlyOne ¶ added in v0.21.2

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 ParamsWithDisposal ¶ added in v0.21.3

type ParamsWithDisposal struct {
	Name   string
	Logger logging.Logger
	Size   int
	Shards int
	// OnDispose disposes of an entry.  It is called when the last reference to an entry
	// is released.  If it fails not much can be done.
	OnDispose func(value interface{}) error
}

type SetFn ¶

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

type SingleThreadedCacheWithDisposal ¶ added in v0.21.3

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

SingleThreadedCacheWithDisposal is a CacheWithDisposal that uses a single critical section to prevent concurrent access to the cache and to reference counts on values.

func NewSingleThreadedCacheWithDisposal(p ParamsWithDisposal) *SingleThreadedCacheWithDisposal

func (c *SingleThreadedCacheWithDisposal) GetOrSet(k interface{}, setFn SetFn) (interface{}, Derefer, error)

func (c *SingleThreadedCacheWithDisposal) Name() string