inline suspend fun <K, V> KeyValueRepo<K, V>.actualizeAll(locker: SmartRWLocker? = null, clearMode: ActualizeAllClearMode = ActualizeAllClearMode.BeforeSet, getAll: () -> Map<K, V>)

inline suspend fun <K, V> KeyValueRepo<K, V>.actualizeAll(parentRepo: ReadCRUDRepo<V, K>, locker: SmartRWLocker? = null, clearMode: ActualizeAllClearMode = ActualizeAllClearMode.BeforeSet)

inline suspend fun <K, V> KeyValueRepo<K, V>.actualizeAll(parentRepo: ReadKeyValueRepo<K, V>, locker: SmartRWLocker? = null, clearMode: ActualizeAllClearMode = ActualizeAllClearMode.BeforeSet)

inline suspend fun <K, V> KeyValueRepo<K, List<V>>.actualizeAll(parentRepo: ReadKeyValuesRepo<K, V>, locker: SmartRWLocker? = null, clearMode: ActualizeAllClearMode = ActualizeAllClearMode.BeforeSet)

actualizeAllWithClearBeforeLoad

inline suspend fun <K, V> KeyValueRepo<K, V>.actualizeAllWithClearBeforeLoad(getAll: () -> Map<K, V>)

@JvmName(name = "actualizeAllWithClearBeforeLoadWithLocker")

inline suspend fun <K, V> KeyValueRepo<K, V>.actualizeAllWithClearBeforeLoad(locker: SmartRWLocker, getAll: () -> Map<K, V>)

inline suspend fun <K, V> KeyValueRepo<K, V>.actualizeAllWithClearBeforeLoad(locker: SmartRWLocker? = null, getAll: () -> Map<K, V>)

actualizeAllWithClearBeforeSet

inline suspend fun <K, V> KeyValueRepo<K, V>.actualizeAllWithClearBeforeSet(getAll: () -> Map<K, V>)

@JvmName(name = "actualizeAllWithClearBeforeSetWithLocker")

inline suspend fun <K, V> KeyValueRepo<K, V>.actualizeAllWithClearBeforeSet(locker: SmartRWLocker, getAll: () -> Map<K, V>)

inline suspend fun <K, V> KeyValueRepo<K, V>.actualizeAllWithClearBeforeSet(locker: SmartRWLocker? = null, getAll: () -> Map<K, V>)

actualizeAllWithoutClear

inline suspend fun <K, V> KeyValueRepo<K, V>.actualizeAllWithoutClear(getAll: () -> Map<K, V>)

@JvmName(name = "actualizeAllWithoutClearWithLocker")

inline suspend fun <K, V> KeyValueRepo<K, V>.actualizeAllWithoutClear(locker: SmartRWLocker, getAll: () -> Map<K, V>)

inline suspend fun <K, V> KeyValueRepo<K, V>.actualizeAllWithoutClear(locker: SmartRWLocker? = null, getAll: () -> Map<K, V>)

applyDiff

suspend fun <Id, Registered> KeyValueRepo<Id, Registered>.applyDiff(diff: MapDiff<Id, Registered>)

suspend fun <Id, Registered> KeyValueRepo<Id, Registered>.applyDiff(other: Map<Id, Registered>)

asKeyValuesRepo

@JvmName(name = "asListKeyValuesRepo")

fun <K, V> KeyValueRepo<K, List<V>>.asKeyValuesRepo(): KeyValuesFromKeyValueRepo<K, V, List<V>>

@JvmName(name = "asSetKeyValuesRepo")

fun <K, V> KeyValueRepo<K, Set<V>>.asKeyValuesRepo(): KeyValuesFromKeyValueRepo<K, V, Set<V>>

fun <K, V, VI : Iterable<V>> KeyValueRepo<K, VI>.asKeyValuesRepo(listToValuesIterable: suspend (List<V>) -> VI): KeyValuesFromKeyValueRepo<K, V, VI>

asReadCRUDRepo

fun <K, V> ReadKeyValueRepo<K, V>.asReadCRUDRepo(): ReadCRUDFromKeyValueRepo<V, K>

asReadKeyValuesRepo

fun <K, V, VI : Iterable<V>> ReadKeyValueRepo<K, VI>.asReadKeyValuesRepo(): ReadKeyValuesFromKeyValueRepo<K, V, VI>

cached

fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(kvCache: KVCache<Key, Value>, locker: SmartRWLocker = SmartRWLocker()): ReadKeyValueCacheRepo<Key, Value>

fun <Key, Value> KeyValueRepo<Key, Value>.cached(kvCache: KVCache<Key, Value>, scope: CoroutineScope = CoroutineScope(Dispatchers.Default), locker: SmartRWLocker = SmartRWLocker()): KeyValueCacheRepo<Key, Value>

fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(kvCache: KeyValueRepo<Key, Value>, locker: SmartRWLocker = SmartRWLocker()): FullReadKeyValueCacheRepo<Key, Value>

caching

fun <Key, Value> WriteKeyValueRepo<Key, Value>.caching(kvCache: KeyValueRepo<Key, Value>, scope: CoroutineScope = CoroutineScope(Dispatchers.Default)): FullWriteKeyValueCacheRepo<Key, Value>

clear

open suspend fun clear()

By default, will remove all the data of current repo using doAllWithCurrentPaging, keys and unset

contains

abstract suspend fun contains(key: Key): Boolean

count

abstract suspend fun count(): Long

diff

suspend fun <Id, Registered> ReadKeyValueRepo<Id, Registered>.diff(other: Map<Id, Registered>): MapDiff<Id, Registered>

directlyCached

fun <Key, Value> ReadKeyValueRepo<Key, Value>.directlyCached(kvCache: KeyValueRepo<Key, Value>, locker: SmartRWLocker = SmartRWLocker()): DirectFullReadKeyValueCacheRepo<Key, Value>

fun <Key, Value> WriteKeyValueRepo<Key, Value>.directlyCached(kvCache: KeyValueRepo<Key, Value>, scope: CoroutineScope = CoroutineScope(Dispatchers.Default)): DirectFullWriteKeyValueCacheRepo<Key, Value>

directlyFullyCached

fun <Key, Value> KeyValueRepo<Key, Value>.directlyFullyCached(kvCache: KeyValueRepo<Key, Value> = MapKeyValueRepo(), scope: CoroutineScope = CoroutineScope(Dispatchers.Default), skipStartInvalidate: Boolean = false, locker: SmartRWLocker = SmartRWLocker()): DirectFullKeyValueCacheRepo<Key, Value>

fullyCached

fun <Key, Value> KeyValueRepo<Key, Value>.fullyCached(kvCache: KeyValueRepo<Key, Value> = MapKeyValueRepo(), scope: CoroutineScope = CoroutineScope(Dispatchers.Default), skipStartInvalidate: Boolean = false, locker: SmartRWLocker = SmartRWLocker()): FullKeyValueCacheRepo<Key, Value>

get

abstract suspend fun get(k: Key): Value?

getAll

open suspend fun getAll(): Map<Key, Value>

keys

abstract suspend fun keys(pagination: Pagination, reversed: Boolean = false): PaginationResult<Key>

This method should use sorted by Keys search and return the PaginationResult. By default, it should use ascending sort for Keys

open suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean = false): PaginationResult<Key>

This method should use sorted by Keys search and return the PaginationResult. By default, it should use ascending sort for Keys.

maxPagePagination

inline suspend fun ReadKeyValueRepo<*, *>.maxPagePagination(): SimplePagination

set

abstract suspend fun set(toSet: Map<Key, Value>)

Will set as batch toSet data in current repo. Must pass the data which were successfully updated in repo to onNewValue

set

inline suspend fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(vararg toSet: Pair<Key, Value>)

inline suspend fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(toSet: List<Pair<Key, Value>>)

inline suspend fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(k: Key, v: Value)

unset

abstract suspend fun unset(toUnset: List<Key>)

Will unset as batch data with keys from toUnset. Must pass the Keys which were successfully removed in repo to onValueRemoved

unset

inline suspend fun <Key, Value> WriteKeyValueRepo<Key, Value>.unset(vararg k: Key)

unsetWithValues

open suspend override fun unsetWithValues(toUnset: List<Value>)

By default, will walk throw all the keys with Values from toUnset and run doAllWithCurrentPaging with unset of found data Keys

unsetWithValues

inline suspend fun <Key, Value> WriteKeyValueRepo<Key, Value>.unsetWithValues(vararg v: Value)

values

abstract suspend fun values(pagination: Pagination, reversed: Boolean = false): PaginationResult<Value>

This method should use sorted by Keys search and return the PaginationResult. By default, it should use ascending sort for Keys

withMapper

inline fun <FromKey, FromValue, ToKey, ToValue> KeyValueRepo<ToKey, ToValue>.withMapper(mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>): KeyValueRepo<FromKey, FromValue>

inline fun <FromKey, FromValue, ToKey, ToValue> ReadKeyValueRepo<ToKey, ToValue>.withMapper(mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>): ReadKeyValueRepo<FromKey, FromValue>

inline fun <FromKey, FromValue, ToKey, ToValue> WriteKeyValueRepo<ToKey, ToValue>.withMapper(mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>): WriteKeyValueRepo<FromKey, FromValue>

inline fun <FromKey, FromValue, ToKey, ToValue> KeyValueRepo<ToKey, ToValue>.withMapper(noinline keyFromToTo: suspend FromKey.() -> ToKey = { this as ToKey }, noinline valueFromToTo: suspend FromValue.() -> ToValue = { this as ToValue }, noinline keyToToFrom: suspend ToKey.() -> FromKey = { this as FromKey }, noinline valueToToFrom: suspend ToValue.() -> FromValue = { this as FromValue }): KeyValueRepo<FromKey, FromValue>

inline fun <FromKey, FromValue, ToKey, ToValue> ReadKeyValueRepo<ToKey, ToValue>.withMapper(noinline keyFromToTo: suspend FromKey.() -> ToKey = { this as ToKey }, noinline valueFromToTo: suspend FromValue.() -> ToValue = { this as ToValue }, noinline keyToToFrom: suspend ToKey.() -> FromKey = { this as FromKey }, noinline valueToToFrom: suspend ToValue.() -> FromValue = { this as FromValue }): ReadKeyValueRepo<FromKey, FromValue>

inline fun <FromKey, FromValue, ToKey, ToValue> WriteKeyValueRepo<ToKey, ToValue>.withMapper(noinline keyFromToTo: suspend FromKey.() -> ToKey = { this as ToKey }, noinline valueFromToTo: suspend FromValue.() -> ToValue = { this as ToValue }, noinline keyToToFrom: suspend ToKey.() -> FromKey = { this as FromKey }, noinline valueToToFrom: suspend ToValue.() -> FromValue = { this as FromValue }): WriteKeyValueRepo<FromKey, FromValue>