micro_utils.dokka/dev.inmo.micro_utils.repos.mappers/MapperKeyValuesRepo

MapperKeyValuesRepo

open class MapperKeyValuesRepo<FromKey, FromValue, ToKey, ToValue>(to: KeyValuesRepo<ToKey, ToValue>, mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>) : KeyValuesRepo<FromKey, FromValue> , MapperRepo<FromKey, FromValue, ToKey, ToValue> , ReadKeyValuesRepo<FromKey, FromValue> , WriteKeyValuesRepo<FromKey, FromValue> (source)

Full one-to-many key-values repository adapter that applies type mapping via MapperRepo. Composes MapperReadKeyValuesRepo and MapperWriteKeyValuesRepo for read and write delegation.

Parameters

The underlying KeyValuesRepo to delegate operations to

mapper

The MapperRepo providing bidirectional key/value type conversions

Type Parameters

FromKey

The outer key type exposed by this repo

FromValue

The outer value type exposed by this repo

ToKey

The inner key type used by the underlying to repo

ToValue

The inner value type used by the underlying to repo

Constructors

MapperKeyValuesRepo

constructor(to: KeyValuesRepo<ToKey, ToValue>, mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>)

Properties

keyMapper

open override val keyMapper: SimpleSuspendableMapper<FromKey, ToKey>

Provides a mapper for converting keys between inner and outer types.

onDataCleared

open override val onDataCleared: Flow<FromKey>

Flow that emits when all data for a key is cleared.

onNewValue

open override val onNewValue: Flow<Pair<FromKey, FromValue>>

Flow that emits when a new value is added to a key.

onValueRemoved

open override val onValueRemoved: Flow<Pair<FromKey, FromValue>>

Flow that emits when a value is removed from a key.

valueMapper

open override val valueMapper: SimpleSuspendableMapper<FromValue, ToValue>

Provides a mapper for converting values between inner and outer types.

Functions

add

open suspend override fun add(toAdd: Map<FromKey, List<FromValue>>)

Adds values to the specified keys.

add

inline suspend fun <Key, Value> WriteKeyValuesRepo<Key, Value>.add(k: Key, v: List<Value>)

Single-key overload of WriteKeyValuesRepo.add accepting a list of values.

inline suspend fun <Key, Value> WriteKeyValuesRepo<Key, Value>.add(k: Key, vararg v: Value)

Single-key vararg overload of WriteKeyValuesRepo.add.

applyDiff

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

Applies the given diff to this KeyValuesRepo: clears keys in MapDiff.removed, sets entries in MapDiff.changed and MapDiff.added.

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

Computes the diff between this KeyValuesRepo and other, then applies the diff to this repo.

asKeyValueRepo

fun <K, V> KeyValuesRepo<K, V>.asKeyValueRepo(): KeyValueFromKeyValuesRepo<K, V>

Wraps this KeyValuesRepo as a KeyValueFromKeyValuesRepo, exposing a full read-write key-value interface where each key maps to a List of values.

asReadKeyValueRepo

fun <K, V> ReadKeyValuesRepo<K, V>.asReadKeyValueRepo(): ReadKeyValueFromKeyValuesRepo<K, V>

Wraps this ReadKeyValuesRepo as a ReadKeyValueFromKeyValuesRepo, exposing each key mapped to a List of all associated values.

cached

fun <Key, Value> ReadKeyValuesRepo<Key, Value>.cached(kvCache: KVCache<Key, List<Value>>, locker: SmartRWLocker = SmartRWLocker()): ReadKeyValuesCacheRepo<Key, Value>

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

fun <Key, Value> ReadKeyValuesRepo<Key, Value>.cached(kvCache: KeyValueRepo<Key, List<Value>>, locker: SmartRWLocker = SmartRWLocker()): FullReadKeyValuesCacheRepo<Key, Value>

caching

fun <Key, Value> WriteKeyValuesRepo<Key, Value>.caching(kvCache: KeyValueRepo<Key, List<Value>>, scope: CoroutineScope = CoroutineScope(Dispatchers.Default), locker: SmartRWLocker = SmartRWLocker()): FullWriteKeyValuesCacheRepo<Key, Value>

clear

open suspend override fun clear(k: FromKey)

Fully clears all data associated with the specified key.

clearWithValue

open suspend override fun clearWithValue(v: FromValue)

Clears a specific value from all keys and removes those keys if they become empty.

contains

open suspend override fun contains(k: FromKey): Boolean

Checks if the specified key exists in the repository.

open suspend override fun contains(k: FromKey, v: FromValue): Boolean

Checks if the specified key-value pair exists in the repository.

count

open suspend override fun count(): Long

Returns the total count of key-value pairs in the repository.

open suspend override fun count(k: FromKey): Long

Returns the count of values associated with the specified key.

diff

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

Computes the difference between all entries in this ReadKeyValuesRepo and the given other map.

directlyCached

fun <Key, Value> ReadKeyValuesRepo<Key, Value>.directlyCached(kvCache: KeyValueRepo<Key, List<Value>>, locker: SmartRWLocker = SmartRWLocker()): DirectFullReadKeyValuesCacheRepo<Key, Value>

fun <Key, Value> WriteKeyValuesRepo<Key, Value>.directlyCached(kvCache: KeyValueRepo<Key, List<Value>>, scope: CoroutineScope = CoroutineScope(Dispatchers.Default), locker: SmartRWLocker = SmartRWLocker()): DirectFullWriteKeyValuesCacheRepo<Key, Value>

directlyFullyCached

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

fullyCached

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

get

open suspend override fun get(k: FromKey, pagination: Pagination, reversed: Boolean = false): PaginationResult<FromValue>

Retrieves a paginated list of values associated with the given key.

getAll

open suspend override fun getAll(reverseLists: Boolean = false): Map<FromKey, List<FromValue>>

WARNING!!! THIS METHOD PROBABLY IS NOT EFFICIENT, USE WITH CAUTION

open suspend override fun getAll(k: FromKey, reversed: Boolean = false): List<FromValue>

keys

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

Retrieves a paginated list of keys.

open suspend override fun keys(v: FromValue, pagination: Pagination, reversed: Boolean = false): PaginationResult<FromKey>

Retrieves keys that have the specified value associated with them.

maxPagePagination

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

Creates a pagination starting from the first page with size equal to the total count of items in this ReadKeyValuesRepo. This effectively creates a single page containing all items.

remove

open suspend override fun remove(toRemove: Map<FromKey, List<FromValue>>)

Removes specific values from keys without clearing all data for those keys.

remove

inline suspend fun <Key, Value> WriteKeyValuesRepo<Key, Value>.remove(keysAndValues: List<Pair<Key, List<Value>>>)

List-of-pairs overload of WriteKeyValuesRepo.remove.

inline suspend fun <Key, Value> WriteKeyValuesRepo<Key, Value>.remove(vararg keysAndValues: Pair<Key, List<Value>>)

Vararg overload of WriteKeyValuesRepo.remove.

inline suspend fun <Key, Value> WriteKeyValuesRepo<Key, Value>.remove(k: Key, v: List<Value>)

Single-key overload of WriteKeyValuesRepo.remove accepting a list of values.

inline suspend fun <Key, Value> WriteKeyValuesRepo<Key, Value>.remove(k: Key, vararg v: Value)

Single-key vararg overload of WriteKeyValuesRepo.remove.

removeWithValue

open suspend override fun removeWithValue(v: FromValue)

Removes a specific value from all keys that contain it, without clearing all data for those keys.

set

open suspend override fun set(toSet: Map<FromKey, List<FromValue>>)

Sets the values for specified keys, clearing any existing values first.

set

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

Single-key overload of WriteKeyValuesRepo.set accepting a list of values.

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

Single-key vararg overload of WriteKeyValuesRepo.set.

toInnerKey

open suspend override fun ToKey.toInnerKey(): FromKey

Converts a key from the outer type to the inner type.

toInnerValue

open suspend override fun ToValue.toInnerValue(): FromValue

Converts a value from the outer type to the inner type.

toOutKey

open suspend override fun FromKey.toOutKey(): ToKey

Converts a key from the inner type to the outer type.

toOutValue

open suspend override fun FromValue.toOutValue(): ToValue

Converts a value from the inner type to the outer type.

withMapper

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

Wraps this KeyValuesRepo with a MapperRepo to expose a mapped KeyValuesRepo.

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

Wraps this ReadKeyValuesRepo with a MapperRepo to expose a mapped ReadKeyValuesRepo.

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

Wraps this WriteKeyValuesRepo with a MapperRepo to expose a mapped WriteKeyValuesRepo.

inline fun <FromKey, FromValue, ToKey, ToValue> KeyValuesRepo<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 }): KeyValuesRepo<FromKey, FromValue>

Wraps this KeyValuesRepo with inline conversion lambdas to expose a mapped KeyValuesRepo.

inline fun <FromKey, FromValue, ToKey, ToValue> ReadKeyValuesRepo<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 }): ReadKeyValuesRepo<FromKey, FromValue>

Wraps this ReadKeyValuesRepo with inline conversion lambdas to expose a mapped ReadKeyValuesRepo.

inline fun <FromKey, FromValue, ToKey, ToValue> WriteKeyValuesRepo<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 }): WriteKeyValuesRepo<FromKey, FromValue>

Wraps this WriteKeyValuesRepo with inline conversion lambdas to expose a mapped WriteKeyValuesRepo.