cache

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

type Config[K comparable, V any] struct {
	// MaxEntries caps the live entry count (LRU eviction above it). 0 = unbounded.
	MaxEntries int
	// DefaultTTL applies to Set entries (SetTTL overrides per-entry). 0 = no expiry.
	DefaultTTL time.Duration
	// Clock is the time source (injectable for tests). nil = clock.System.
	Clock clock.Clock
	// OnEvict, if non-nil, is called with the key+value of every entry removed by
	// capacity eviction or expiry (not by an explicit Delete/Set-overwrite).
	OnEvict func(key K, val V)
	// MaxWeight caps the summed weight of the live entries, evicting above it as
	// MaxEntries does; both apply when both are set. 0 = unbounded. An entry
	// heavier than MaxWeight alone is stored and evicts every other entry: the
	// primitive has no error to refuse it with.
	MaxWeight int64
	// WeightOf, if non-nil, weighs an entry when it is stored; a negative answer
	// counts as 0, and one above math.MaxInt32 as math.MaxInt32. nil = every
	// entry weighs 1, so MaxWeight is then a count.
	WeightOf func(key K, val V) int64
	// Policy chooses the victim when the cache is full. The zero value is
	// PolicyLRU.
	Policy Policy
}

type Policy uint8

type StatsValue struct {
	Hits      uint64
	Misses    uint64
	Evictions uint64
	// Weight is the summed weight of the live entries when the cache weighs
	// them — Config.MaxWeight or Config.WeightOf set — and 0 when it does not.
	Weight int64
	// Policy is the eviction policy that runs: Config.Policy, or PolicyLRU
	// for a value the cache does not know.
	Policy Policy
}

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