fifocache

Documentation

Index

• func ShardInt[T constraints.Integer](v T) uint8
• type Cache
  • func New[K comparable, V any](capacity fscache.CapacityFunc, keyShardFunc func(K) uint8, ...) *Cache[K, V]
  • func (c *Cache[K, V]) Delete(key K)
  • func (c *Cache[K, V]) Evict(done chan int64)
  • func (c *Cache[K, V]) Get(key K) (value V, ok bool)
  • func (c *Cache[K, V]) Set(key K, value V, size int64)
• type DataCache
  • func NewDataCache(capacity fscache.CapacityFunc, ...) *DataCache
  • func (d *DataCache) Available() int64
  • func (d *DataCache) Capacity() int64
  • func (d *DataCache) DeletePaths(ctx context.Context, paths []string)
  • func (d *DataCache) EnsureNBytes(n int)
  • func (d *DataCache) Evict(ch chan int64)
  • func (d *DataCache) Flush()
  • func (d *DataCache) Get(ctx context.Context, key query.CacheKey) (fscache.Data, bool)
  • func (d *DataCache) Set(ctx context.Context, key query.CacheKey, value fscache.Data) error
  • func (d *DataCache) Used() int64
• type Queue
  • func NewQueue[T any]() *Queue[T]

Functions

func ShardInt

func ShardInt[T constraints.Integer](v T) uint8

Types

type Cache

type Cache[K comparable, V any] struct {
	// contains filtered or unexported fields
}

Cache implements an in-memory cache with FIFO-based eviction it's mostly like the S3-fifo, only without the ghost queue part

func New

func New[K comparable, V any](
	capacity fscache.CapacityFunc,
	keyShardFunc func(K) uint8,
	postSet func(key K, value V),
	postGet func(key K, value V),
	postEvict func(key K, value V),
) *Cache[K, V]

func (*Cache[K, V]) Delete

func (c *Cache[K, V]) Delete(key K)

func (*Cache[K, V]) Evict

func (c *Cache[K, V]) Evict(done chan int64)

func (*Cache[K, V]) Get

func (c *Cache[K, V]) Get(key K) (value V, ok bool)

func (*Cache[K, V]) Set

func (c *Cache[K, V]) Set(key K, value V, size int64)

type DataCache

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

func NewDataCache

func NewDataCache(
	capacity fscache.CapacityFunc,
	postSet func(key fscache.CacheKey, value fscache.Data),
	postGet func(key fscache.CacheKey, value fscache.Data),
	postEvict func(key fscache.CacheKey, value fscache.Data),
) *DataCache

func (*DataCache) Available

func (d *DataCache) Available() int64

func (*DataCache) Capacity

func (d *DataCache) Capacity() int64

func (*DataCache) DeletePaths

func (d *DataCache) DeletePaths(ctx context.Context, paths []string)

func (*DataCache) EnsureNBytes

func (d *DataCache) EnsureNBytes(n int)

func (*DataCache) Evict

func (d *DataCache) Evict(ch chan int64)

func (*DataCache) Flush

func (d *DataCache) Flush()

func (*DataCache) Get

func (d *DataCache) Get(ctx context.Context, key query.CacheKey) (fscache.Data, bool)

func (*DataCache) Set

func (d *DataCache) Set(ctx context.Context, key query.CacheKey, value fscache.Data) error

func (*DataCache) Used

func (d *DataCache) Used() int64

type Queue

type Queue[T any] struct {
	// contains filtered or unexported fields
}

func NewQueue

func NewQueue[T any]() *Queue[T]