micro_utils.dokka/dev.inmo.micro_utils.repos.cache.fallback.keyvalue/AutoRecacheKeyValueRepo

AutoRecacheKeyValueRepo

open class AutoRecacheKeyValueRepo<Id, RegisteredObject>(originalRepo: KeyValueRepo<Id, RegisteredObject>, scope: CoroutineScope, kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(), recacheDelay: Long = 60.seconds.inWholeMilliseconds, actionWrapper: ActionWrapper = ActionWrapper.Direct, idGetter: (RegisteredObject) -> Id) : AutoRecacheReadKeyValueRepo<Id, RegisteredObject> , WriteKeyValueRepo<Id, RegisteredObject> , KeyValueRepo<Id, RegisteredObject>

Constructors

fun <Id, RegisteredObject> AutoRecacheKeyValueRepo(originalRepo: KeyValueRepo<Id, RegisteredObject>, scope: CoroutineScope, originalCallTimeoutMillis: Long, kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(), recacheDelay: Long = 60.seconds.inWholeMilliseconds, idGetter: (RegisteredObject) -> Id)

AutoRecacheKeyValueRepo

fun <Id, RegisteredObject> AutoRecacheKeyValueRepo(originalRepo: KeyValueRepo<Id, RegisteredObject>, scope: CoroutineScope, kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(), recacheDelay: Long = 60.seconds.inWholeMilliseconds, actionWrapper: ActionWrapper = ActionWrapper.Direct, idGetter: (RegisteredObject) -> Id)

Functions

clear

open suspend fun clear()

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

contains

open suspend override fun contains(key: Id): Boolean

count

open suspend override fun count(): Long

get

open suspend override fun get(k: Id): RegisteredObject?

invalidate

open suspend override fun invalidate()

keys

open suspend override fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Id>

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

open suspend override fun keys(v: RegisteredObject, pagination: Pagination, reversed: Boolean): PaginationResult<Id>

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

set

open suspend override fun set(toSet: Map<Id, RegisteredObject>)

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

unset

open suspend override fun unset(toUnset: List<Id>)

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

unsetWithValues

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

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

values

open suspend override fun values(pagination: Pagination, reversed: Boolean): PaginationResult<RegisteredObject>

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

Properties

autoUpdateJob

val autoUpdateJob: Job

onNewValue

open override val onNewValue: Flow<Pair<Id, RegisteredObject>>

onValueRemoved

open override val onValueRemoved: Flow<Id>

Extensions

asKeyValuesRepo

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

@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>>

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>): ReadKeyValueCacheRepo<Key, Value>

fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(kvCache: FullKVCache<Key, Value>): FullReadKeyValueCacheRepo<Key, Value>

fun <Key, Value> KeyValueRepo<Key, Value>.cached(kvCache: FullKVCache<Key, Value>, scope: CoroutineScope = CoroutineScope(Dispatchers.Default)): FullKeyValueCacheRepo<Key, Value>

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

caching

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

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

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

unsetWithValues

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

withMapper

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> 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(mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>): WriteKeyValueRepo<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>

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> 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>