cache

Documentation

Index

• Constants
• Variables
• func TestBasic(t *testing.T, cache Cacher[ids.ID, int64])
• func TestEviction(t *testing.T, cache Cacher[ids.ID, int64])
• func TestIntSizeFunc(int64) int
• type Cacher
  • func NewSizedLRU[K comparable, V any](maxSize int, size func(V) int) Cacher[K, V]
• type Deduplicator
• type Empty
  • func (*Empty[K, _]) Evict(K)
  • func (*Empty[_, _]) Flush()
  • func (*Empty[K, V]) Get(K) (V, bool)
  • func (*Empty[_, _]) PortionFilled() float64
  • func (*Empty[K, V]) Put(K, V)
• type Evictable
• type EvictableLRU
  • func (c *EvictableLRU[_, V]) Deduplicate(value V) V
  • func (c *EvictableLRU[_, _]) Flush()
• type LRU
  • func (c *LRU[K, _]) Evict(key K)
  • func (c *LRU[_, _]) Flush()
  • func (c *LRU[K, V]) Get(key K) (V, bool)
  • func (c *LRU[_, _]) PortionFilled() float64
  • func (c *LRU[K, V]) Put(key K, value V)

Constants

const TestIntSize = 8

Variables

var CacherTests = []struct {
	Size int
	Func func(t *testing.T, c Cacher[ids.ID, int64])
}{
	{Size: 1, Func: TestBasic},
	{Size: 2, Func: TestEviction},
}

CacherTests is a list of all Cacher tests

Functions

func TestBasic

func TestBasic(t *testing.T, cache Cacher[ids.ID, int64])

func TestEviction

func TestEviction(t *testing.T, cache Cacher[ids.ID, int64])

func TestIntSizeFunc

func TestIntSizeFunc(int64) int

Types

type Cacher

type Cacher[K comparable, V any] interface {
	// Put inserts an element into the cache. If space is required, elements will
	// be evicted.
	Put(key K, value V)

	// Get returns the entry in the cache with the key specified, if no value
	// exists, false is returned.
	Get(key K) (V, bool)

	// Evict removes the specified entry from the cache
	Evict(key K)

	// Flush removes all entries from the cache
	Flush()

	// Returns fraction of cache currently filled (0 --> 1)
	PortionFilled() float64
}

Cacher acts as a best effort key value store.

func NewSizedLRU

func NewSizedLRU[K comparable, V any](maxSize int, size func(V) int) Cacher[K, V]

type Deduplicator

type Deduplicator[K comparable, V Evictable[K]] interface {
	// Deduplicate returns either the provided value, or a previously provided
	// value with the same ID that hasn't yet been evicted
	Deduplicate(V) V

	// Flush removes all entries from the cache
	Flush()
}

Deduplicator acts as a best effort deduplication service

type Empty

type Empty[K any, V any] struct{}

func (*Empty[K, _]) Evict

func (*Empty[K, _]) Evict(K)

func (*Empty[_, _]) Flush

func (*Empty[_, _]) Flush()

func (*Empty[K, V]) Get

func (*Empty[K, V]) Get(K) (V, bool)

func (*Empty[_, _]) PortionFilled

func (*Empty[_, _]) PortionFilled() float64

func (*Empty[K, V]) Put

func (*Empty[K, V]) Put(K, V)

type Evictable

type Evictable[K comparable] interface {
	Key() K
	Evict()
}

Evictable allows the object to be notified when it is evicted

type EvictableLRU

type EvictableLRU[K comparable, _ Evictable[K]] struct {
	Size int
	// contains filtered or unexported fields
}

EvictableLRU is an LRU cache that notifies the objects when they are evicted.

func (*EvictableLRU[_, V]) Deduplicate

func (c *EvictableLRU[_, V]) Deduplicate(value V) V

func (*EvictableLRU[_, _]) Flush

func (c *EvictableLRU[_, _]) Flush()

type LRU

type LRU[K comparable, V any] struct {

	// If set to < 0, will be set internally to 1.
	Size int
	// contains filtered or unexported fields
}

LRU is a key value store with bounded size. If the size is attempted to be exceeded, then an element is removed from the cache before the insertion is done, based on evicting the least recently used value.

func (*LRU[K, _]) Evict

func (c *LRU[K, _]) Evict(key K)

func (*LRU[_, _]) Flush

func (c *LRU[_, _]) Flush()

func (*LRU[K, V]) Get

func (c *LRU[K, V]) Get(key K) (V, bool)

func (*LRU[_, _]) PortionFilled

func (c *LRU[_, _]) PortionFilled() float64

func (*LRU[K, V]) Put

func (c *LRU[K, V]) Put(key K, value V)