ttlcache

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

type Clock interface {
	// Start the clock.
	Start()
	// Stop the clock.
	Stop()
	// Active checks if clock 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[T any] struct {
	Size          uint64
	Buckets       uint
	Hasher        Hasher
	TTLInterval   time.Duration
	EvictInterval time.Duration
	EvictWorkers  uint

	DumpWriter       DumpWriter
	DumpEncoder      Encoder[T]
	DumpInterval     time.Duration
	DumpWriteWorkers uint

	DumpReader      DumpReader
	DumpDecoder     Decoder[T]
	DumpReadBuffer  uint
	DumpReadWorkers uint
	DumpReadAsync   bool

	MetricsWriter MetricsWriter
	Clock         Clock
	Logger        Logger
}

type Decoder[T any] interface {
	Decode(*T, []byte) error
}

type DummyMetrics struct{}

type DumpReader interface {
	Read() (Entry, error)
}

type DumpWriter interface {
	Write(entry Entry) (int, error)
	Flush() error
}

type Encoder[T any] interface {
	Encode([]byte, T) ([]byte, int, error)
}

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

type Hasher interface {
	Sum64(string) uint64
}

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

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

type MetricsWriter interface {
	Set(bucket string, dur time.Duration)
	Hit(bucket string, dur time.Duration)
	Del(bucket string)
	Miss(bucket string)
	Expire(bucket string)
	Overflow(bucket string)
	Evict(bucket string)
	Dump(bucket string)
	Load(bucket string)
}

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

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