redis

type JsonSerializer struct {
}

type LRunnable[T any] func() (T, error)

type RCache[T any] struct {
	ValueSerializer Serializer // serializer / deserializer
	// contains filtered or unexported fields
}

type RCacheConfig struct {
	//expire time for each entry
	Exp time.Duration

	// Disable use of distributed lock to synchronize access to the key in the cache.
	//
	// Most of the operations are atomic except Get(...) with supplier callback.
	// If your are loading the cache manually using Put(...), then you probably don't need synchronization at all.
	NoSync bool
}

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

type RLockConfig struct {
	// Backoff duration.
	//
	// This is not an exact configuration. Linear back off strategy is used with a window size of 5ms, which means RLock will attempt to acquire the lock every 5ms.
	//
	// The number of times we may attempt to acquire the lock is called steps, which is by default 200 (that's 1s = 200 * 5ms).
	// When BackoffDuration is provided, this duration is divided by 5ms to convert to steps and then used by RLock.
	BackoffDuration time.Duration
}

type RedisConnParam struct {
	Address  string
	Port     string
	Username string
	Password string
	Db       int
}

type Runnable func() error

type Serializer interface {
	Serialize(t any) (string, error)
	Deserialize(ptr any, v string) error
}