cbytecache

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

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

type Clock interface {
	// Start the clock.
	Start()
	// Stop the clock.
	Stop()
	// Active checks if close is started.
	Active() bool
	// Now returns current time considering jumps.
	Now() time.Time
	// Jump performs time travel to delta (maybe negative). Now and scheduled jobs considers jumps.
	Jump(delta time.Duration)
	// Schedule registers fn to call at every d.
	Schedule(d time.Duration, fn func())
}

type Config struct {
	// Capacity represents maximum cache payload size (it doesn't consider index size).
	Capacity MemorySize
	// ArenaCapacity determines fixed memory arena size.
	// If this param omit defaultArenaCapacity (16KB) will use instead.
	ArenaCapacity MemorySize

	// Hasher calculates uint64 hash of entries keys.
	// Mandatory param.
	Hasher hash.Hasher
	// Buckets represents buckets (data shards) count. Must be power of two.
	// Mandatory param.
	Buckets uint
	// ExpireInterval represents entry lifetime period.
	// After this period entry may be evicted in any time. Reading of entry after that period will fail as expired.
	// Mandatory param.
	ExpireInterval time.Duration

	// EvictInterval represents period between eviction operations.
	// If this param omit ExpireInterval will use instead.
	EvictInterval time.Duration
	// EvictWorkers limits workers count for evict operation.
	// If this param omit defaultEvictWorkers (16) will use instead.
	EvictWorkers uint

	// VacuumInterval represents period between vacuum operations.
	VacuumInterval time.Duration
	// VacuumWorkers limits workers count for vacuum operation.
	// If this param omit defaultVacuumWorkers (16) will use instead.
	VacuumWorkers uint
	// VacuumRatio represents how many of memory available to release must be released. Available range is [0:1.0].
	// There are three predefined ratios:
	// * VacuumRatioWeak - release 25% of memory available to release
	// * VacuumRatioModerate - release 50%
	// * VacuumRatioAggressive - release 75%
	// Lower value will trigger reallocation rarely. Higher value will keep the lowest cache size, but causes often
	// reallocations.
	// If this param omit VacuumRatioModerate (50%) will use instead.
	VacuumRatio float64

	// ResetWorkers limits workers count for reset operation.
	// If this param omit defaultResetWorkers (16) will use instead.
	ResetWorkers uint
	// ReleaseWorkers limits workers count for release operation.
	// If this param omit defaultReleaseWorkers (16) will use instead.
	ReleaseWorkers uint

	// CollisionCheck enables collision checks.
	CollisionCheck bool

	// Clock implementation.
	// If this param omit nativeClock{} will use instead.
	Clock Clock

	// ExpireListener triggers on every expired item.
	ExpireListener Listener

	// DumpWriter represents writer for dumps.
	DumpWriter DumpWriter
	// DumpInterval indicates how often need dump cache data.
	DumpInterval time.Duration
	// DumpWriteWorkers limits workers count that sends entries to DumpWriter.
	// If this param omit defaultDumpWriteWorkers (16) will use instead.
	DumpWriteWorkers uint

	// DumpReader represents dump loader that fills cache with dumped data.
	DumpReader DumpReader
	// DumpReadBuffer represents how many items from dump may be processed at once.
	DumpReadBuffer uint
	// DumpReadWorkers limits workers count that processes entries comes from DumpReader.
	// If this param omit defaultDumpReadWorkers (16) will use instead.
	DumpReadWorkers uint
	// Load dump data asynchronously.
	DumpReadAsync bool

	// Metrics writer handler.
	MetricsWriter MetricsWriter
	// Logger is a logging interface to display verbose messages.
	Logger Logger
}

type DummyMetrics struct{}

type DumpReader interface {
	// Read reads entry from underlying data stream.
	// It returns entry and any error encountered.
	Read() (Entry, error)
}

type DumpWriter interface {
	// Write writes entry data to the underlying data stream.
	// It returns the number of bytes written from entry and any error encountered.
	Write(entry Entry) (int, error)
	// Flush indicates to writer that all cache data was dumped.
	Flush() error
}

type Enqueuer interface {
	Enqueue(any) error
}

type Entry struct {
	Key    string
	Body   []byte
	Expire uint32
}

type Listener interface {
	Listen(entry Entry) error
}

type Logger interface {
	Printf(format string, v ...any)
	Print(v ...any)
	Println(v ...any)
}

type MarshallerTo interface {
	Size() int
	MarshalTo([]byte) (int, error)
}

type MemorySize uint64

type MetricsWriter interface {
	// Alloc registers how many arenas allocates and increase cache size (total and free).
	Alloc(bucket string, size uint32)
	// Fill registers how many arenas fills and calculate cache size (inc fill and dec free).
	Fill(bucket string, size uint32)
	// Reset registers how many arenas resets and calculate cache size (inc free and dec used).
	Reset(bucket string, size uint32)
	// Release registers how many arenas releases and calculate cache size (dec total and free).
	Release(bucket string, size uint32)
	// Set registers how many entries writes to cache.
	Set(bucket string, dur time.Duration)
	// Hit registers how many entries reads from cache.
	Hit(bucket string, dur time.Duration)
	// Del registers how many entries deletes from cache.
	Del(bucket string)
	// Evict registers how many entries evicts from cache.
	// Param alive indicates is entry deleted or not.
	Evict(bucket string, alive bool)
	// Miss registers how many reads failed due to not found error.
	Miss(bucket string)
	// Expire registers how many entries in cache marks as expired.
	Expire(bucket string)
	// Corrupt registers how many entries reads failed due to corruption error.
	Corrupt(bucket string)
	// Collision registers how many keys collisions triggers due to hasher.
	Collision(bucket string)
	// NoSpace registers how many writes failed due to no space error.
	NoSpace(bucket string)
	// Dump registers how many entries dumped.
	Dump(bucket string)
	// Load registers how many entries loaded from dump.
	Load(bucket string)
}

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

type Unmarshaller interface {
	Unmarshal([]byte) error
}