cache

package module

Go to main page

Versions in this module

v1

v1.4.1

Oct 10, 2026

v1.4.0

Oct 10, 2026

Changes in this version

type AsyncCache

+ func (c *AsyncCache[T]) Read(ctx context.Context) (T, error)

+ func (c *AsyncCache[T]) SetReadPolicy(policy ReadPolicy[T])

+ func (c *AsyncCache[T]) SetValueCondition(cond func(s Snapshot[T]) bool)

type Option

+ func WithReadPolicy[T any](policy ReadPolicy[T]) Option

+ func WithValueCondition[T any](cond func(s Snapshot[T]) bool) Option

+ type ReadPolicy func(s Snapshot[T]) bool

type Stats

+ PassThroughs uint64

v1.3.0

Oct 10, 2026

Changes in this version

+ const DefaultInterval

+ var ErrClosed = errors.New("cache: async cache closed")

+ type AsyncCache struct

+ func NewAsyncCache[T any](loader Loader[T], opts ...Option) *AsyncCache[T]

+ func NewAsync[T any](interval time.Duration, loader Loader[T], opts ...Option) *AsyncCache[T]

+ func (c *AsyncCache[T]) Close() error

+ func (c *AsyncCache[T]) CloseWithContext(ctx context.Context) error

+ func (c *AsyncCache[T]) Closed() bool

+ func (c *AsyncCache[T]) Done() <-chan struct{}

+ func (c *AsyncCache[T]) ForceUpdate()

+ func (c *AsyncCache[T]) Get() T

+ func (c *AsyncCache[T]) GetSync(f func(current T))

+ func (c *AsyncCache[T]) GetWithOK() (T, bool)

+ func (c *AsyncCache[T]) HasValue() bool

+ func (c *AsyncCache[T]) Interval() time.Duration

+ func (c *AsyncCache[T]) Jitter() float64

+ func (c *AsyncCache[T]) Next(ctx context.Context) (Snapshot[T], error)

+ func (c *AsyncCache[T]) Params() any

+ func (c *AsyncCache[T]) Refresh(ctx context.Context) (Snapshot[T], error)

+ func (c *AsyncCache[T]) SetCondition(cond Condition)

+ func (c *AsyncCache[T]) SetError(handler func(ctx *Context[T]))

+ func (c *AsyncCache[T]) SetErrorHandler(handler ErrorHandler[T])

+ func (c *AsyncCache[T]) SetInterval(interval time.Duration)

+ func (c *AsyncCache[T]) SetParams(params any)

+ func (c *AsyncCache[T]) Snapshot() Snapshot[T]

+ func (c *AsyncCache[T]) Stats() Stats

+ func (c *AsyncCache[T]) Timeout() time.Duration

+ func (c *AsyncCache[T]) Trigger() bool

+ func (c *AsyncCache[T]) ValueOr(def T) T

+ func (c *AsyncCache[T]) View(f func(s Snapshot[T]))

+ func (c *AsyncCache[T]) WaitFirst(ctx context.Context) error

+ func (c *AsyncCache[T]) WaitFirstUpdate(waitTime time.Duration) error

+ func (c *AsyncCache[T]) WaitValue(ctx context.Context) (T, error)

+ type AsyncCacheContext = Context[T]

+ type CacheLRU struct

+ func NewCacheLRUWithTTL[K comparable, V any](capacity int, ttl time.Duration) *CacheLRU[K, V]

+ func NewCacheLRU[K comparable, V any](capacity int) *CacheLRU[K, V]

+ func NewShardedCacheLRU[K comparable, V any](capacity int, ttl time.Duration, shards int) *CacheLRU[K, V]

+ func (l *CacheLRU[K, V]) All() iter.Seq2[K, V]

+ func (l *CacheLRU[K, V]) Capacity() int

+ func (l *CacheLRU[K, V]) Cleanup() int

+ func (l *CacheLRU[K, V]) Clear()

+ func (l *CacheLRU[K, V]) DefaultTTL() time.Duration

+ func (l *CacheLRU[K, V]) Get(key K) (V, bool)

+ func (l *CacheLRU[K, V]) GetOrLoad(ctx context.Context, key K, loader func(ctx context.Context) (V, error)) (V, error)

+ func (l *CacheLRU[K, V]) GetOrLoadWithTTL(ctx context.Context, key K, ttl time.Duration, ...) (V, error)

+ func (l *CacheLRU[K, V]) Keys() []K

+ func (l *CacheLRU[K, V]) Len() int

+ func (l *CacheLRU[K, V]) Peek(key K) (V, bool)

+ func (l *CacheLRU[K, V]) Range(f func(key K, value V) bool)

+ func (l *CacheLRU[K, V]) Remove(key K) (V, bool)

+ func (l *CacheLRU[K, V]) ResetStats()

+ func (l *CacheLRU[K, V]) Set(key K, value V)

+ func (l *CacheLRU[K, V]) SetIfAbsent(key K, value V) bool

+ func (l *CacheLRU[K, V]) SetWithTTL(key K, value V, ttl time.Duration)

+ func (l *CacheLRU[K, V]) Shards() int

+ func (l *CacheLRU[K, V]) Size() int

+ func (l *CacheLRU[K, V]) Stats() LRUStats

+ func (l *CacheLRU[K, V]) Values() []V

+ type Condition func(info RefreshInfo) bool

+ type Context struct

+ func (c *Context[T]) Ctx() context.Context

+ func (c *Context[T]) Current() T

+ func (c *Context[T]) Deadline() (time.Time, bool)

+ func (c *Context[T]) Done() <-chan struct{}

+ func (c *Context[T]) Error() error

+ func (c *Context[T]) GetCurrent() T

+ func (c *Context[T]) HasCurrent() bool

+ func (c *Context[T]) Params() any

+ func (c *Context[T]) Snapshot() Snapshot[T]

+ type ErrorHandler func(ctx *Context[T], err error)

+ type LRUStats struct

+ Capacity int

+ Evictions uint64

+ Expirations uint64

+ Hits uint64

+ Len int

+ LoadErrors uint64

+ Loads uint64

+ Misses uint64

+ Shards int

+ type Loader func(ctx *Context[T]) (T, error)

+ type Option func(*Options)

+ func WithAutoStop() Option

+ func WithCondition(cond Condition) Option

+ func WithInterval(d time.Duration) Option

+ func WithJitter(ratio float64) Option

+ func WithLazyStart() Option

+ func WithOnError(f func(err error)) Option

+ func WithParams(params any) Option

+ func WithTimeout(d time.Duration) Option

+ type Options struct

+ AutoStop bool

+ Condition Condition

+ Interval time.Duration

+ Jitter float64

+ Lazy bool

+ OnError func(err error)

+ Params any

+ Timeout time.Duration

+ type RefreshInfo struct

+ ConsecutiveFailures uint64

+ Err error

+ Interval time.Duration

+ Loaded bool

+ Now time.Time

+ Params any

+ RefreshedAt time.Time

+ UpdatedAt time.Time

+ Version uint64

+ type Snapshot struct

+ Err error

+ Loaded bool

+ RefreshedAt time.Time

+ UpdatedAt time.Time

+ Value T

+ Version uint64

+ func (s Snapshot[T]) Age(now time.Time) time.Duration

+ func (s Snapshot[T]) OK() bool

+ func (s Snapshot[T]) Stale() bool

+ type Stats struct

+ Closed bool

+ ConditionErrors uint64

+ ConsecutiveFailures uint64

+ Failures uint64

+ LastAttempt time.Time

+ LastError error

+ LastSuccess time.Time

+ Refreshes uint64

+ Skipped uint64

+ Version uint64

v1.2.0

Dec 16, 2021

Changes in this version

type Cache

+ ForceUpdate func()

type CacheBlock

+ func (cache *CacheBlock) ForceUpdate()

type CacheInterval

+ func (cache *CacheInterval) ForceUpdate()

v1.1.2

Oct 26, 2021

v1.1.1

Oct 21, 2021

v1.1.0

Jun 2, 2021

Changes in this version

type Cache

+ func NewBlockCache(interval time.Duration, u UpdateMehtod) Cache

+ type CacheBlock struct

+ func (cache *CacheBlock) Destroy()

+ func (cache *CacheBlock) GetUpdate() time.Time

+ func (cache *CacheBlock) SetOnUpdateError(errFunc func(err interface{}))

+ func (cache *CacheBlock) SetShare(share interface{})

+ func (cache *CacheBlock) Value() interface{}

+ type CacheInterval struct

+ func (cache *CacheInterval) Destroy()

+ func (cache *CacheInterval) GetUpdate() time.Time

+ func (cache *CacheInterval) SetOnUpdateError(errFunc func(err interface{}))

+ func (cache *CacheInterval) SetShare(share interface{})

+ func (cache *CacheInterval) Value() interface{}

v1.0.2

Jun 2, 2021

Changes in this version

type Cache

+ func (cache *Cache) GetUpdate() time.Time

v1.0.1

Jun 1, 2021

v1.0.0

Jun 1, 2021

Changes in this version

type Cache

+ LastUpdate time.Time

+ func NewWithBlock(interval time.Duration, u UpdateMehtod) *Cache

+ func NewWithEvery(u UpdateMehtod) *Cache

+ func (cache *Cache) Destroy()

+ func (cache *Cache) SetOnUpdateError(errFunc func(err interface{}))

+ func (cache *Cache) SetShare(share interface{})

v0

v0.3.2

May 8, 2021

v0.3.1

May 8, 2021

v0.3.0

Feb 26, 2021

v0.2.0

Feb 26, 2021

v0.1.0

Feb 4, 2021

Changes in this version

+ type Cache struct

+ func New(u UpdateMehtod) *Cache

+ func (cache *Cache) SetBlock(is bool)

+ func (cache *Cache) SetOnError(errFunc func(err interface{}))

+ func (cache *Cache) SetUpdateCond(method func() bool)

+ func (cache *Cache) SetUpdateInterval(interval time.Duration)

+ func (cache *Cache) SetUpdateMethod(method UpdateMehtod)

+ func (cache *Cache) Update()

+ func (cache *Cache) Value() interface{}

+ type UpdateMehtod func() interface

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