utils

type CustomMutex interface {
	Lock(ctx context.Context) error
	Unlock()
	TryLock(ctx context.Context) bool
	TryUnlock() bool
}

type DeepCopier[T any] interface {
	Copy() *T
}

type LimitedSafeMap[K comparable, T any] interface {
	SafeMap[K, T]

	Sorted() []T
}

type LimitedSafeMapOrderBy[T any] func(a, b T) bool

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

type RWLocker interface {
	sync.Locker
	RLock()
	RUnlock()
}

type SafeMap[K comparable, T any] interface {
	Get(key K) (T, bool)
	Delete(key K) bool
	Has(key K) bool
	Set(key K, value T)
	Size() int

	Find(fn SafeMapLambda[T]) (T, bool)
	Search(fn SafeMapLambda[T]) (values []T)
	Each(fn SafeMapLambda[T])
}

type SafeMapEmbedded[K comparable, T any] interface {
	Get(key K) T
	Delete(key K) (ok bool)
	Each(fn SafeMapLambda[T])
	Size() int
}

type SafeMapGenerator[T any] func() T

type SafeMapLambda[T any] func(obj T) bool

type SafeSlice[T any] interface {
	json.Marshaler
	json.Unmarshaler

	Read() []T
	Remove(i int)
	Size() int
	Get(i int) T
	Set(i int, v T)
	Add(T)
	Index(fn SafeSliceIndex[T]) int
	Lock() (unlock SafeSliceUnlock)
	Replace([]T)
}

type SafeSliceIndex[T any] func(v T) bool

type SafeSliceUnlock func()

type SimpleMap[K comparable, T any] interface {
	Set(key K, value T)
	Delete(key K) (ok bool)
	Get(key K) (value T, ok bool)
	Size() int
	Each(fn func(key K, value T))
}