provider

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

type Entry interface {
	// Key represents the key.
	Key() string
	// Value represents the value.
	Value() []byte
	// CreateTime represents the time when the entry is created.
	CreateTime() time.Time
}

type InMemoryCacheConfig struct {
	// MaxSize is the overall maximum number of bytes the cache can hold.
	MaxSize uint64 `yaml:"max_size"`
	// MaxItemSize is the maximum size of a single item.
	MaxItemSize uint64 `yaml:"max_item_size"`
	// DefaultTTL is the defautl ttl of a single item.
	DefaultTTL string `yaml:"default_ttl"`
	// TTLEviction specifies if evction of items by TTL is enabled.
	// Set to true if`DefaultTTL` is -1.
	TTLEviction bool
}

type Iterator interface {
	// HasNext return true if there is more items to be returned.
	HasNext() bool
	// Next return the next item.
	Next() Entry
	// Close closes the iterator
	// and releases any allocated resources.
	Close()
}

type Options struct {
	// TTL controls the time-to-live for a given cache entry.
	// Cache entries that are older than the TTL will not be returned.
	TTL time.Duration

	// InitialCapacity controls the initial capacity of the cache.
	InitialCapacity int
}

type Provider interface {
	// Get retrieves an element based on a key, returning nil if the element
	// does not exist.
	Get(ctx context.Context, key string) []byte

	// Set adds an element to the cache.
	Set(key string, value []byte, ttl time.Duration)

	// Delete deletes an element in the cache.
	Delete(ctx context.Context, key string) bool

	// Keys returns a slice of cache keys.
	Keys(ctx context.Context, prefix string) []string

	// Purge purges all keys matching the specified pattern from the cache.
	Purge(ctx context.Context, pattern string) error

	// Flush deletes all elements from the cache.
	Flush(ctx context.Context) error

	// Size returns the number of entries currently stored in the Cache.
	Size() int
}

type ProviderBackendConfig struct {
	Backend    string              `yaml:"backend"`
	Layered    bool                `yaml:"layered"`
	LayeredTTL string              `yaml:"layered_ttl"`
	InMemory   InMemoryCacheConfig `yaml:"inmemory"`
	Redis      RedisClientConfig   `yaml:"redis"`
}

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

type RedisClientConfig struct {
	// Endpoint holds the endpoint addresses of the Redis server.
	// Either a single address or a list of host:port addresses
	// of cluster/sentinel nodes.
	Endpoint string `yaml:"endpoint"`

	// Username to authenticate the current connection with one of the connections
	// defined in the ACL list when connecting to a Redis 6.0 instance, or greater,
	// that is using the Redis ACL system.
	Username string `yaml:"username"`

	// Optional password. Must match the password specified in the
	// requirepass server configuration option (if connecting to a Redis 5.0 instance, or lower),
	// or the User Password when connecting to a Redis 6.0 instance, or greater,
	// that is using the Redis ACL system.
	Password string `yaml:"password"`

	// DB Database to be selected after connecting to the server.
	DB int `yaml:"db"`

	// MaxItemSize specifies the maximum size of an item stored in Redis.
	// Items bigger than MaxItemSize are skipped. If set to 0, no maximum size is enforced.
	MaxItemSize int `yaml:"max_item_size"`

	// MaxQueueBufferSize is the maximum number of enqueued job operations allowed.
	MaxQueueBufferSize int `yaml:"max_queue_buffer_size"`

	// MaxQueueConcurrency is the maximum number of concurrent async job operations.
	MaxQueueConcurrency int `yaml:"max_queue_concurrency"`
}

type RemoteCacheClient interface {
	// Fetch fetches a key from the remote cache.
	// Returns nil if an error occurs.
	Fetch(ctx context.Context, keys string) []byte

	// Store stores a key and value into the the remote cache.
	// Returns an error in case the operation fails.
	Store(key string, value []byte, ttl time.Duration) error

	// StoreAsync asynchronously stores a key and value into the the remote cache.
	StoreAsync(key string, value []byte, ttl time.Duration) error

	// Delete deletes a key from the remote cache.
	Delete(ctx context.Context, key string) error

	// Keys returns a slice of cache keys.
	Keys(ctx context.Context, prefix string) []string

	// Purge purges all keys matching the spedified pattern from the remote cache.
	Purge(ctx context.Context, pattern string) error

	// Flush deletes all keys from the remote cache.
	Flush(ctx context.Context) error

	// Stop closes the client connection.
	Stop()
}

type SimpleOptions struct {
	// InitialCapacity controls the initial capacity of the cache.
	InitialCapacity int
}