InsanusMokrassar/MicroUtils
1
0
Fork 0
mirror of https://github.com/InsanusMokrassar/MicroUtils.git synced 2025-11-04 14:14:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Disallow overrides in repos

Browse Source
This commit is contained in:
InsanusMokrassar
2025-03-02 16:12:23 +06:00
parent fc6f5ae2ee
commit 7a650f5c2f
13 changed files with 101 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG.md
View File

@@ -2,6 +2,10 @@
## 0.25.0 ## 0.25.0
* `Repos`:
* `Cache`:
* All cache repos now do not have `open` vals - to avoid collisions in runtime
## 0.24.7 ## 0.24.7
* `Versions`: * `Versions`:

24
repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/CRUDCacheRepo.kt vendored
View File

@@ -12,10 +12,10 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.* import kotlinx.coroutines.flow.*
open class ReadCRUDCacheRepo<ObjectType, IdType>( open class ReadCRUDCacheRepo<ObjectType, IdType>(
protected open val parentRepo: ReadCRUDRepo<ObjectType, IdType>, protected val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
protected open val kvCache: KVCache<IdType, ObjectType>, protected val kvCache: KVCache<IdType, ObjectType>,
protected val locker: SmartRWLocker = SmartRWLocker(), protected val locker: SmartRWLocker = SmartRWLocker(),
protected open val idGetter: (ObjectType) -> IdType protected val idGetter: (ObjectType) -> IdType
) : ReadCRUDRepo<ObjectType, IdType> by parentRepo, CommonCacheRepo { ) : ReadCRUDRepo<ObjectType, IdType> by parentRepo, CommonCacheRepo {
override suspend fun getById(id: IdType): ObjectType? = locker.withReadAcquire { override suspend fun getById(id: IdType): ObjectType? = locker.withReadAcquire {
kvCache.get(id) kvCache.get(id)
@@ -51,11 +51,11 @@ fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.cached(
) = ReadCRUDCacheRepo(this, kvCache, locker, idGetter) ) = ReadCRUDCacheRepo(this, kvCache, locker, idGetter)
open class WriteCRUDCacheRepo<ObjectType, IdType, InputValueType>( open class WriteCRUDCacheRepo<ObjectType, IdType, InputValueType>(
protected open val parentRepo: WriteCRUDRepo<ObjectType, IdType, InputValueType>, protected val parentRepo: WriteCRUDRepo<ObjectType, IdType, InputValueType>,
protected open val kvCache: KeyValueRepo<IdType, ObjectType>, protected val kvCache: KeyValueRepo<IdType, ObjectType>,
protected open val scope: CoroutineScope = CoroutineScope(Dispatchers.Default), protected val scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
protected val locker: SmartRWLocker = SmartRWLocker(), protected val locker: SmartRWLocker = SmartRWLocker(),
protected open val idGetter: (ObjectType) -> IdType protected val idGetter: (ObjectType) -> IdType
) : WriteCRUDRepo<ObjectType, IdType, InputValueType>, CommonCacheRepo { ) : WriteCRUDRepo<ObjectType, IdType, InputValueType>, CommonCacheRepo {
override val newObjectsFlow: Flow<ObjectType> by parentRepo::newObjectsFlow override val newObjectsFlow: Flow<ObjectType> by parentRepo::newObjectsFlow
override val updatedObjectsFlow: Flow<ObjectType> by parentRepo::updatedObjectsFlow override val updatedObjectsFlow: Flow<ObjectType> by parentRepo::updatedObjectsFlow
@@ -131,25 +131,25 @@ fun <ObjectType, IdType, InputType> WriteCRUDRepo<ObjectType, IdType, InputType>
open class CRUDCacheRepo<ObjectType, IdType, InputValueType>( open class CRUDCacheRepo<ObjectType, IdType, InputValueType>(
override val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>, protected val crudRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
kvCache: KVCache<IdType, ObjectType>, kvCache: KVCache<IdType, ObjectType>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default), scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
locker: SmartRWLocker = SmartRWLocker(), locker: SmartRWLocker = SmartRWLocker(),
idGetter: (ObjectType) -> IdType idGetter: (ObjectType) -> IdType
) : ReadCRUDCacheRepo<ObjectType, IdType>( ) : ReadCRUDCacheRepo<ObjectType, IdType>(
parentRepo, crudRepo,
kvCache, kvCache,
locker, locker,
idGetter idGetter
), ),
WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo( WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo(
parentRepo, crudRepo,
kvCache, kvCache,
scope, scope,
locker, locker,
idGetter idGetter
), ),
CRUDRepo<ObjectType, IdType, InputValueType> { CRUDRepo<ObjectType, IdType, InputValueType> {
override suspend fun invalidate() = kvCache.actualizeAll(parentRepo, locker = locker) override suspend fun invalidate() = kvCache.actualizeAll(parentRepo, locker = locker)
} }

14
repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/KeyValueCacheRepo.kt vendored
View File

@@ -12,8 +12,8 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.* import kotlinx.coroutines.flow.*
open class ReadKeyValueCacheRepo<Key,Value>( open class ReadKeyValueCacheRepo<Key,Value>(
protected open val parentRepo: ReadKeyValueRepo<Key, Value>, protected val parentRepo: ReadKeyValueRepo<Key, Value>,
protected open val kvCache: KVCache<Key, Value>, protected val kvCache: KVCache<Key, Value>,
protected val locker: SmartRWLocker = SmartRWLocker(), protected val locker: SmartRWLocker = SmartRWLocker(),
) : ReadKeyValueRepo<Key,Value> by parentRepo, CommonCacheRepo { ) : ReadKeyValueRepo<Key,Value> by parentRepo, CommonCacheRepo {
override suspend fun get(k: Key): Value? = locker.withReadAcquire { override suspend fun get(k: Key): Value? = locker.withReadAcquire {
@@ -58,24 +58,24 @@ fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(
) = ReadKeyValueCacheRepo(this, kvCache, locker) ) = ReadKeyValueCacheRepo(this, kvCache, locker)
open class KeyValueCacheRepo<Key,Value>( open class KeyValueCacheRepo<Key,Value>(
override val parentRepo: KeyValueRepo<Key, Value>, protected val kvRepo: KeyValueRepo<Key, Value>,
kvCache: KVCache<Key, Value>, kvCache: KVCache<Key, Value>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default), scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
locker: SmartRWLocker = SmartRWLocker(), locker: SmartRWLocker = SmartRWLocker(),
) : ReadKeyValueCacheRepo<Key,Value>(parentRepo, kvCache, locker), KeyValueRepo<Key,Value>, WriteKeyValueRepo<Key, Value> by parentRepo, CommonCacheRepo { ) : ReadKeyValueCacheRepo<Key,Value>(kvRepo, kvCache, locker), KeyValueRepo<Key,Value>, WriteKeyValueRepo<Key, Value> by parentRepo, CommonCacheRepo {
protected val onNewJob = parentRepo.onNewValue.onEach { protected val onNewJob = kvRepo.onNewValue.onEach {
locker.withWriteLock { locker.withWriteLock {
kvCache.set(it.first, it.second) kvCache.set(it.first, it.second)
} }
}.launchIn(scope) }.launchIn(scope)
protected val onRemoveJob = parentRepo.onValueRemoved.onEach { protected val onRemoveJob = kvRepo.onValueRemoved.onEach {
locker.withWriteLock { locker.withWriteLock {
kvCache.unset(it) kvCache.unset(it)
} }
}.launchIn(scope) }.launchIn(scope)
override suspend fun clear() { override suspend fun clear() {
parentRepo.clear() kvRepo.clear()
locker.withWriteLock { locker.withWriteLock {
kvCache.clear() kvCache.clear()
} }

4
repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/KeyValuesCacheRepo.kt vendored
View File

@@ -13,8 +13,8 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.* import kotlinx.coroutines.flow.*
open class ReadKeyValuesCacheRepo<Key,Value>( open class ReadKeyValuesCacheRepo<Key,Value>(
protected open val parentRepo: ReadKeyValuesRepo<Key, Value>, protected val parentRepo: ReadKeyValuesRepo<Key, Value>,
protected open val kvCache: KVCache<Key, List<Value>>, protected val kvCache: KVCache<Key, List<Value>>,
protected val locker: SmartRWLocker = SmartRWLocker(), protected val locker: SmartRWLocker = SmartRWLocker(),
) : ReadKeyValuesRepo<Key,Value> by parentRepo, CommonCacheRepo { ) : ReadKeyValuesRepo<Key,Value> by parentRepo, CommonCacheRepo {
override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> { override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> {

2
repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/crud/AutoRecacheReadCRUDRepo.kt vendored
View File

@@ -18,7 +18,7 @@ import kotlinx.coroutines.launch
import kotlin.time.Duration.Companion.seconds import kotlin.time.Duration.Companion.seconds
open class AutoRecacheReadCRUDRepo<RegisteredObject, Id>( open class AutoRecacheReadCRUDRepo<RegisteredObject, Id>(
protected open val originalRepo: ReadCRUDRepo<RegisteredObject, Id>, protected val originalRepo: ReadCRUDRepo<RegisteredObject, Id>,
protected val scope: CoroutineScope, protected val scope: CoroutineScope,
protected val kvCache: KeyValueRepo<Id, RegisteredObject> = MapKeyValueRepo(), protected val kvCache: KeyValueRepo<Id, RegisteredObject> = MapKeyValueRepo(),
protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds, protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds,

2
repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalue/AutoRecacheReadKeyValueRepo.kt vendored
View File

@@ -18,7 +18,7 @@ import kotlinx.coroutines.launch
import kotlin.time.Duration.Companion.seconds import kotlin.time.Duration.Companion.seconds
open class AutoRecacheReadKeyValueRepo<Id, RegisteredObject>( open class AutoRecacheReadKeyValueRepo<Id, RegisteredObject>(
protected open val originalRepo: ReadKeyValueRepo<Id, RegisteredObject>, protected val originalRepo: ReadKeyValueRepo<Id, RegisteredObject>,
protected val scope: CoroutineScope, protected val scope: CoroutineScope,
protected val kvCache: KeyValueRepo<Id, RegisteredObject> = MapKeyValueRepo(), protected val kvCache: KeyValueRepo<Id, RegisteredObject> = MapKeyValueRepo(),
protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds, protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds,

2
repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalues/AutoRecacheReadKeyValuesRepo.kt vendored
View File

@@ -24,7 +24,7 @@ import kotlinx.coroutines.launch
import kotlin.time.Duration.Companion.seconds import kotlin.time.Duration.Companion.seconds
open class AutoRecacheReadKeyValuesRepo<Id, RegisteredObject>( open class AutoRecacheReadKeyValuesRepo<Id, RegisteredObject>(
protected open val originalRepo: ReadKeyValuesRepo<Id, RegisteredObject>, protected val originalRepo: ReadKeyValuesRepo<Id, RegisteredObject>,
protected val scope: CoroutineScope, protected val scope: CoroutineScope,
protected val kvCache: KeyValueRepo<Id, List<RegisteredObject>> = MapKeyValueRepo(), protected val kvCache: KeyValueRepo<Id, List<RegisteredObject>> = MapKeyValueRepo(),
protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds, protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds,

22
repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/FullCRUDCacheRepo.kt vendored
View File

@@ -15,10 +15,10 @@ import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Dispatchers
open class FullReadCRUDCacheRepo<ObjectType, IdType>( open class FullReadCRUDCacheRepo<ObjectType, IdType>(
protected open val parentRepo: ReadCRUDRepo<ObjectType, IdType>, protected val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
protected open val kvCache: KeyValueRepo<IdType, ObjectType>, protected val kvCache: KeyValueRepo<IdType, ObjectType>,
protected open val locker: SmartRWLocker = SmartRWLocker(), protected val locker: SmartRWLocker = SmartRWLocker(),
protected open val idGetter: (ObjectType) -> IdType protected val idGetter: (ObjectType) -> IdType
) : ReadCRUDRepo<ObjectType, IdType>, FullCacheRepo { ) : ReadCRUDRepo<ObjectType, IdType>, FullCacheRepo {
protected suspend inline fun <T> doOrTakeAndActualize( protected suspend inline fun <T> doOrTakeAndActualize(
action: KeyValueRepo<IdType, ObjectType>.() -> Optional<T>, action: KeyValueRepo<IdType, ObjectType>.() -> Optional<T>,
@@ -94,20 +94,20 @@ fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.cached(
) = FullReadCRUDCacheRepo(this, kvCache, locker, idGetter) ) = FullReadCRUDCacheRepo(this, kvCache, locker, idGetter)
open class FullCRUDCacheRepo<ObjectType, IdType, InputValueType>( open class FullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
override val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>, protected val crudRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
override val kvCache: KeyValueRepo<IdType, ObjectType>, kvCache: KeyValueRepo<IdType, ObjectType>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default), scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
skipStartInvalidate: Boolean = false, skipStartInvalidate: Boolean = false,
override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate), locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
override val idGetter: (ObjectType) -> IdType idGetter: (ObjectType) -> IdType
) : FullReadCRUDCacheRepo<ObjectType, IdType>( ) : FullReadCRUDCacheRepo<ObjectType, IdType>(
parentRepo, crudRepo,
kvCache, kvCache,
locker, locker,
idGetter idGetter
), ),
WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo( WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo(
parentRepo, crudRepo,
kvCache, kvCache,
scope, scope,
locker, locker,
@@ -128,7 +128,7 @@ open class FullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
protected open suspend fun initialInvalidate() { protected open suspend fun initialInvalidate() {
try { try {
kvCache.actualizeAll(parentRepo, locker = null) kvCache.actualizeAll(crudRepo, locker = null)
} finally { } finally {
locker.unlockWrite() locker.unlockWrite()
} }

26
repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/FullKeyValueCacheRepo.kt vendored
View File

@@ -15,9 +15,9 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.* import kotlinx.coroutines.flow.*
open class FullReadKeyValueCacheRepo<Key,Value>( open class FullReadKeyValueCacheRepo<Key,Value>(
protected open val parentRepo: ReadKeyValueRepo<Key, Value>, protected val parentRepo: ReadKeyValueRepo<Key, Value>,
protected open val kvCache: KeyValueRepo<Key, Value>, protected val kvCache: KeyValueRepo<Key, Value>,
protected open val locker: SmartRWLocker = SmartRWLocker() protected val locker: SmartRWLocker = SmartRWLocker()
) : ReadKeyValueRepo<Key, Value>, FullCacheRepo { ) : ReadKeyValueRepo<Key, Value>, FullCacheRepo {
protected suspend inline fun <T> doOrTakeAndActualize( protected suspend inline fun <T> doOrTakeAndActualize(
action: KeyValueRepo<Key, Value>.() -> Optional<T>, action: KeyValueRepo<Key, Value>.() -> Optional<T>,
@@ -98,7 +98,7 @@ fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(
open class FullWriteKeyValueCacheRepo<Key,Value>( open class FullWriteKeyValueCacheRepo<Key,Value>(
parentRepo: WriteKeyValueRepo<Key, Value>, parentRepo: WriteKeyValueRepo<Key, Value>,
protected open val kvCache: KeyValueRepo<Key, Value>, protected val kvCache: KeyValueRepo<Key, Value>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default), scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
protected val locker: SmartRWLocker = SmartRWLocker() protected val locker: SmartRWLocker = SmartRWLocker()
) : WriteKeyValueRepo<Key, Value> by parentRepo, FullCacheRepo { ) : WriteKeyValueRepo<Key, Value> by parentRepo, FullCacheRepo {
@@ -126,16 +126,16 @@ fun <Key, Value> WriteKeyValueRepo<Key, Value>.caching(
) = FullWriteKeyValueCacheRepo(this, kvCache, scope) ) = FullWriteKeyValueCacheRepo(this, kvCache, scope)
open class FullKeyValueCacheRepo<Key,Value>( open class FullKeyValueCacheRepo<Key,Value>(
override val parentRepo: KeyValueRepo<Key, Value>, protected val kvRepo: KeyValueRepo<Key, Value>,
override val kvCache: KeyValueRepo<Key, Value>, kvCache: KeyValueRepo<Key, Value>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default), scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
skipStartInvalidate: Boolean = false, skipStartInvalidate: Boolean = false,
override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate), locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
) : //FullWriteKeyValueCacheRepo<Key,Value>(parentRepo, kvCache, scope), ) : //FullWriteKeyValueCacheRepo<Key,Value>(parentRepo, kvCache, scope),
KeyValueRepo<Key,Value>, KeyValueRepo<Key,Value>,
WriteKeyValueRepo<Key,Value> by parentRepo, WriteKeyValueRepo<Key,Value> by kvRepo,
FullReadKeyValueCacheRepo<Key, Value>( FullReadKeyValueCacheRepo<Key, Value>(
parentRepo, kvRepo,
kvCache, kvCache,
locker locker
) { ) {
@@ -151,7 +151,7 @@ open class FullKeyValueCacheRepo<Key,Value>(
} }
} }
override suspend fun unsetWithValues(toUnset: List<Value>) = parentRepo.unsetWithValues(toUnset) override suspend fun unsetWithValues(toUnset: List<Value>) = kvRepo.unsetWithValues(toUnset)
protected open suspend fun initialInvalidate() { protected open suspend fun initialInvalidate() {
try { try {
@@ -165,13 +165,13 @@ open class FullKeyValueCacheRepo<Key,Value>(
} }
override suspend fun clear() { override suspend fun clear() {
parentRepo.clear() kvRepo.clear()
kvCache.clear() kvCache.clear()
} }
override suspend fun set(toSet: Map<Key, Value>) { override suspend fun set(toSet: Map<Key, Value>) {
locker.withWriteLock { locker.withWriteLock {
parentRepo.set(toSet) kvRepo.set(toSet)
kvCache.set( kvCache.set(
toSet.filter { toSet.filter {
parentRepo.contains(it.key) parentRepo.contains(it.key)
@@ -182,7 +182,7 @@ open class FullKeyValueCacheRepo<Key,Value>(
override suspend fun unset(toUnset: List<Key>) { override suspend fun unset(toUnset: List<Key>) {
locker.withWriteLock { locker.withWriteLock {
parentRepo.unset(toUnset) kvRepo.unset(toUnset)
kvCache.unset( kvCache.unset(
toUnset.filter { toUnset.filter {
!parentRepo.contains(it) !parentRepo.contains(it)

26
repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/FullKeyValuesCacheRepo.kt vendored
View File

@@ -16,9 +16,9 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.* import kotlinx.coroutines.flow.*
open class FullReadKeyValuesCacheRepo<Key,Value>( open class FullReadKeyValuesCacheRepo<Key,Value>(
protected open val parentRepo: ReadKeyValuesRepo<Key, Value>, protected val parentRepo: ReadKeyValuesRepo<Key, Value>,
protected open val kvCache: KeyValueRepo<Key, List<Value>>, protected val kvCache: KeyValueRepo<Key, List<Value>>,
protected open val locker: SmartRWLocker = SmartRWLocker(), protected val locker: SmartRWLocker = SmartRWLocker(),
) : ReadKeyValuesRepo<Key, Value>, FullCacheRepo { ) : ReadKeyValuesRepo<Key, Value>, FullCacheRepo {
protected suspend inline fun <T> doOrTakeAndActualize( protected suspend inline fun <T> doOrTakeAndActualize(
action: KeyValueRepo<Key, List<Value>>.() -> Optional<T>, action: KeyValueRepo<Key, List<Value>>.() -> Optional<T>,
@@ -165,7 +165,7 @@ fun <Key, Value> ReadKeyValuesRepo<Key, Value>.cached(
open class FullWriteKeyValuesCacheRepo<Key,Value>( open class FullWriteKeyValuesCacheRepo<Key,Value>(
parentRepo: WriteKeyValuesRepo<Key, Value>, parentRepo: WriteKeyValuesRepo<Key, Value>,
protected open val kvCache: KeyValueRepo<Key, List<Value>>, protected val kvCache: KeyValueRepo<Key, List<Value>>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default), scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
protected val locker: SmartRWLocker = SmartRWLocker(), protected val locker: SmartRWLocker = SmartRWLocker(),
) : WriteKeyValuesRepo<Key, Value> by parentRepo, FullCacheRepo { ) : WriteKeyValuesRepo<Key, Value> by parentRepo, FullCacheRepo {
@@ -200,14 +200,14 @@ fun <Key, Value> WriteKeyValuesRepo<Key, Value>.caching(
) = FullWriteKeyValuesCacheRepo(this, kvCache, scope, locker) ) = FullWriteKeyValuesCacheRepo(this, kvCache, scope, locker)
open class FullKeyValuesCacheRepo<Key,Value>( open class FullKeyValuesCacheRepo<Key,Value>(
override val parentRepo: KeyValuesRepo<Key, Value>, protected val kvsRepo: KeyValuesRepo<Key, Value>,
override val kvCache: KeyValueRepo<Key, List<Value>>, kvCache: KeyValueRepo<Key, List<Value>>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default), scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
skipStartInvalidate: Boolean = false, skipStartInvalidate: Boolean = false,
override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate), locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
) : KeyValuesRepo<Key, Value>, ) : KeyValuesRepo<Key, Value>,
FullReadKeyValuesCacheRepo<Key, Value>(parentRepo, kvCache, locker), FullReadKeyValuesCacheRepo<Key, Value>(kvsRepo, kvCache, locker),
WriteKeyValuesRepo<Key, Value> by parentRepo { WriteKeyValuesRepo<Key, Value> by kvsRepo {
init { init {
if (!skipStartInvalidate) { if (!skipStartInvalidate) {
scope.launchLoggingDropExceptions { scope.launchLoggingDropExceptions {
@@ -241,7 +241,7 @@ open class FullKeyValuesCacheRepo<Key,Value>(
override suspend fun set(toSet: Map<Key, List<Value>>) { override suspend fun set(toSet: Map<Key, List<Value>>) {
locker.withWriteLock { locker.withWriteLock {
parentRepo.set(toSet) kvsRepo.set(toSet)
kvCache.set( kvCache.set(
toSet.filter { toSet.filter {
parentRepo.contains(it.key) parentRepo.contains(it.key)
@@ -252,7 +252,7 @@ open class FullKeyValuesCacheRepo<Key,Value>(
override suspend fun add(toAdd: Map<Key, List<Value>>) { override suspend fun add(toAdd: Map<Key, List<Value>>) {
locker.withWriteLock { locker.withWriteLock {
parentRepo.add(toAdd) kvsRepo.add(toAdd)
toAdd.forEach { toAdd.forEach {
val filtered = it.value.filter { v -> val filtered = it.value.filter { v ->
parentRepo.contains(it.key, v) parentRepo.contains(it.key, v)
@@ -269,7 +269,7 @@ open class FullKeyValuesCacheRepo<Key,Value>(
override suspend fun remove(toRemove: Map<Key, List<Value>>) { override suspend fun remove(toRemove: Map<Key, List<Value>>) {
locker.withWriteLock { locker.withWriteLock {
parentRepo.remove(toRemove) kvsRepo.remove(toRemove)
toRemove.forEach { toRemove.forEach {
val filtered = it.value.filter { v -> val filtered = it.value.filter { v ->
!parentRepo.contains(it.key, v) !parentRepo.contains(it.key, v)
@@ -291,7 +291,7 @@ open class FullKeyValuesCacheRepo<Key,Value>(
override suspend fun clear(k: Key) { override suspend fun clear(k: Key) {
locker.withWriteLock { locker.withWriteLock {
parentRepo.clear(k) kvsRepo.clear(k)
if (parentRepo.contains(k)) { if (parentRepo.contains(k)) {
return@withWriteLock return@withWriteLock
} }

21
repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/direct/DirectFullCRUDCacheRepo.kt vendored
View File

@@ -1,24 +1,21 @@
package dev.inmo.micro_utils.repos.cache.full.direct package dev.inmo.micro_utils.repos.cache.full.direct
import dev.inmo.micro_utils.common.*
import dev.inmo.micro_utils.coroutines.SmartRWLocker import dev.inmo.micro_utils.coroutines.SmartRWLocker
import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
import dev.inmo.micro_utils.coroutines.withReadAcquire import dev.inmo.micro_utils.coroutines.withReadAcquire
import dev.inmo.micro_utils.coroutines.withWriteLock
import dev.inmo.micro_utils.pagination.Pagination import dev.inmo.micro_utils.pagination.Pagination
import dev.inmo.micro_utils.pagination.PaginationResult import dev.inmo.micro_utils.pagination.PaginationResult
import dev.inmo.micro_utils.repos.* import dev.inmo.micro_utils.repos.*
import dev.inmo.micro_utils.repos.cache.* import dev.inmo.micro_utils.repos.cache.*
import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
import dev.inmo.micro_utils.repos.cache.util.actualizeAll import dev.inmo.micro_utils.repos.cache.util.actualizeAll
import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Dispatchers
open class DirectFullReadCRUDCacheRepo<ObjectType, IdType>( open class DirectFullReadCRUDCacheRepo<ObjectType, IdType>(
protected open val parentRepo: ReadCRUDRepo<ObjectType, IdType>, protected val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
protected open val kvCache: KeyValueRepo<IdType, ObjectType>, protected val kvCache: KeyValueRepo<IdType, ObjectType>,
protected open val locker: SmartRWLocker = SmartRWLocker(), protected val locker: SmartRWLocker = SmartRWLocker(),
protected open val idGetter: (ObjectType) -> IdType protected val idGetter: (ObjectType) -> IdType
) : ReadCRUDRepo<ObjectType, IdType>, DirectFullCacheRepo { ) : ReadCRUDRepo<ObjectType, IdType>, DirectFullCacheRepo {
protected open suspend fun actualizeAll() { protected open suspend fun actualizeAll() {
kvCache.actualizeAll(parentRepo, locker = locker) kvCache.actualizeAll(parentRepo, locker = locker)
@@ -60,20 +57,20 @@ fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.directlyCached(
) = DirectFullReadCRUDCacheRepo(this, kvCache, locker, idGetter) ) = DirectFullReadCRUDCacheRepo(this, kvCache, locker, idGetter)
open class DirectFullCRUDCacheRepo<ObjectType, IdType, InputValueType>( open class DirectFullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
override val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>, protected val crudRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
override val kvCache: KeyValueRepo<IdType, ObjectType>, kvCache: KeyValueRepo<IdType, ObjectType>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default), scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
skipStartInvalidate: Boolean = false, skipStartInvalidate: Boolean = false,
override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate), locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
idGetter: (ObjectType) -> IdType idGetter: (ObjectType) -> IdType
) : DirectFullReadCRUDCacheRepo<ObjectType, IdType>( ) : DirectFullReadCRUDCacheRepo<ObjectType, IdType>(
parentRepo, crudRepo,
kvCache, kvCache,
locker, locker,
idGetter idGetter
), ),
WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo( WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo(
parentRepo, crudRepo,
kvCache, kvCache,
scope, scope,
locker, locker,

28
repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/direct/DirectFullKeyValueCacheRepo.kt vendored
View File

@@ -18,9 +18,9 @@ import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach import kotlinx.coroutines.flow.onEach
open class DirectFullReadKeyValueCacheRepo<Key, Value>( open class DirectFullReadKeyValueCacheRepo<Key, Value>(
protected open val parentRepo: ReadKeyValueRepo<Key, Value>, protected val parentRepo: ReadKeyValueRepo<Key, Value>,
protected open val kvCache: KeyValueRepo<Key, Value>, protected val kvCache: KeyValueRepo<Key, Value>,
protected open val locker: SmartRWLocker = SmartRWLocker() protected val locker: SmartRWLocker = SmartRWLocker()
) : DirectFullCacheRepo, ReadKeyValueRepo<Key, Value> { ) : DirectFullCacheRepo, ReadKeyValueRepo<Key, Value> {
protected open suspend fun actualizeAll() { protected open suspend fun actualizeAll() {
kvCache.actualizeAll(parentRepo, locker) kvCache.actualizeAll(parentRepo, locker)
@@ -65,8 +65,8 @@ fun <Key, Value> ReadKeyValueRepo<Key, Value>.directlyCached(
) = DirectFullReadKeyValueCacheRepo(this, kvCache, locker) ) = DirectFullReadKeyValueCacheRepo(this, kvCache, locker)
open class DirectFullWriteKeyValueCacheRepo<Key, Value>( open class DirectFullWriteKeyValueCacheRepo<Key, Value>(
protected open val parentRepo: WriteKeyValueRepo<Key, Value>, protected val parentRepo: WriteKeyValueRepo<Key, Value>,
protected open val kvCache: KeyValueRepo<Key, Value>, protected val kvCache: KeyValueRepo<Key, Value>,
protected val locker: SmartRWLocker = SmartRWLocker(), protected val locker: SmartRWLocker = SmartRWLocker(),
scope: CoroutineScope = CoroutineScope(Dispatchers.Default), scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
) : DirectFullCacheRepo, WriteKeyValueRepo<Key, Value> by parentRepo { ) : DirectFullCacheRepo, WriteKeyValueRepo<Key, Value> by parentRepo {
@@ -101,20 +101,20 @@ fun <Key, Value> WriteKeyValueRepo<Key, Value>.directlyCached(
) = DirectFullWriteKeyValueCacheRepo(this, kvCache, scope = scope) ) = DirectFullWriteKeyValueCacheRepo(this, kvCache, scope = scope)
open class DirectFullKeyValueCacheRepo<Key, Value>( open class DirectFullKeyValueCacheRepo<Key, Value>(
override val parentRepo: KeyValueRepo<Key, Value>, protected val kvRepo: KeyValueRepo<Key, Value>,
override val kvCache: KeyValueRepo<Key, Value>, kvCache: KeyValueRepo<Key, Value>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default), scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
skipStartInvalidate: Boolean = false, skipStartInvalidate: Boolean = false,
override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate), locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
) : DirectFullCacheRepo, ) : DirectFullCacheRepo,
KeyValueRepo<Key, Value> , KeyValueRepo<Key, Value> ,
WriteKeyValueRepo<Key, Value> by DirectFullWriteKeyValueCacheRepo( WriteKeyValueRepo<Key, Value> by DirectFullWriteKeyValueCacheRepo(
parentRepo, kvRepo,
kvCache, kvCache,
locker, locker,
scope scope
), ),
DirectFullReadKeyValueCacheRepo<Key, Value>(parentRepo, kvCache, locker) { DirectFullReadKeyValueCacheRepo<Key, Value>(kvRepo, kvCache, locker) {
init { init {
if (!skipStartInvalidate) { if (!skipStartInvalidate) {
scope.launchLoggingDropExceptions { scope.launchLoggingDropExceptions {
@@ -140,15 +140,15 @@ open class DirectFullKeyValueCacheRepo<Key, Value>(
} }
override suspend fun clear() { override suspend fun clear() {
parentRepo.clear() kvRepo.clear()
kvCache.clear() kvCache.clear()
} }
override suspend fun unsetWithValues(toUnset: List<Value>) = parentRepo.unsetWithValues(toUnset) override suspend fun unsetWithValues(toUnset: List<Value>) = kvRepo.unsetWithValues(toUnset)
override suspend fun set(toSet: Map<Key, Value>) { override suspend fun set(toSet: Map<Key, Value>) {
locker.withWriteLock { locker.withWriteLock {
parentRepo.set(toSet) kvRepo.set(toSet)
kvCache.set( kvCache.set(
toSet.filter { toSet.filter {
parentRepo.contains(it.key) parentRepo.contains(it.key)
@@ -159,7 +159,7 @@ open class DirectFullKeyValueCacheRepo<Key, Value>(
override suspend fun unset(toUnset: List<Key>) { override suspend fun unset(toUnset: List<Key>) {
locker.withWriteLock { locker.withWriteLock {
parentRepo.unset(toUnset) kvRepo.unset(toUnset)
kvCache.unset( kvCache.unset(
toUnset.filter { toUnset.filter {
!parentRepo.contains(it) !parentRepo.contains(it)

26
repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/direct/DirectFullKeyValuesCacheRepo.kt vendored
View File

@@ -15,9 +15,9 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.* import kotlinx.coroutines.flow.*
open class DirectFullReadKeyValuesCacheRepo<Key,Value>( open class DirectFullReadKeyValuesCacheRepo<Key,Value>(
protected open val parentRepo: ReadKeyValuesRepo<Key, Value>, protected val parentRepo: ReadKeyValuesRepo<Key, Value>,
protected open val kvCache: KeyValueRepo<Key, List<Value>>, protected val kvCache: KeyValueRepo<Key, List<Value>>,
protected open val locker: SmartRWLocker = SmartRWLocker(), protected val locker: SmartRWLocker = SmartRWLocker(),
) : ReadKeyValuesRepo<Key, Value>, DirectFullCacheRepo { ) : ReadKeyValuesRepo<Key, Value>, DirectFullCacheRepo {
protected open suspend fun actualizeKey(k: Key) { protected open suspend fun actualizeKey(k: Key) {
kvCache.actualizeAll(locker = locker, clearMode = ActualizeAllClearMode.Never) { kvCache.actualizeAll(locker = locker, clearMode = ActualizeAllClearMode.Never) {
@@ -100,7 +100,7 @@ fun <Key, Value> ReadKeyValuesRepo<Key, Value>.directlyCached(
open class DirectFullWriteKeyValuesCacheRepo<Key,Value>( open class DirectFullWriteKeyValuesCacheRepo<Key,Value>(
parentRepo: WriteKeyValuesRepo<Key, Value>, parentRepo: WriteKeyValuesRepo<Key, Value>,
protected open val kvCache: KeyValueRepo<Key, List<Value>>, protected val kvCache: KeyValueRepo<Key, List<Value>>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default), scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
protected val locker: SmartRWLocker = SmartRWLocker(), protected val locker: SmartRWLocker = SmartRWLocker(),
) : WriteKeyValuesRepo<Key, Value> by parentRepo, DirectFullCacheRepo { ) : WriteKeyValuesRepo<Key, Value> by parentRepo, DirectFullCacheRepo {
@@ -135,14 +135,14 @@ fun <Key, Value> WriteKeyValuesRepo<Key, Value>.directlyCached(
) = DirectFullWriteKeyValuesCacheRepo(this, kvCache, scope, locker) ) = DirectFullWriteKeyValuesCacheRepo(this, kvCache, scope, locker)
open class DirectFullKeyValuesCacheRepo<Key,Value>( open class DirectFullKeyValuesCacheRepo<Key,Value>(
override val parentRepo: KeyValuesRepo<Key, Value>, protected val kvsRepo: KeyValuesRepo<Key, Value>,
override val kvCache: KeyValueRepo<Key, List<Value>>, kvCache: KeyValueRepo<Key, List<Value>>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default), scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
skipStartInvalidate: Boolean = false, skipStartInvalidate: Boolean = false,
override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate), locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
) : KeyValuesRepo<Key, Value>, ) : KeyValuesRepo<Key, Value>,
DirectFullReadKeyValuesCacheRepo<Key, Value>(parentRepo, kvCache, locker), DirectFullReadKeyValuesCacheRepo<Key, Value>(kvsRepo, kvCache, locker),
WriteKeyValuesRepo<Key, Value> by parentRepo { WriteKeyValuesRepo<Key, Value> by kvsRepo {
init { init {
if (!skipStartInvalidate) { if (!skipStartInvalidate) {
scope.launchLoggingDropExceptions { scope.launchLoggingDropExceptions {
@@ -176,7 +176,7 @@ open class DirectFullKeyValuesCacheRepo<Key,Value>(
override suspend fun set(toSet: Map<Key, List<Value>>) { override suspend fun set(toSet: Map<Key, List<Value>>) {
locker.withWriteLock { locker.withWriteLock {
parentRepo.set(toSet) kvsRepo.set(toSet)
kvCache.set( kvCache.set(
toSet.filter { toSet.filter {
parentRepo.contains(it.key) parentRepo.contains(it.key)
@@ -187,7 +187,7 @@ open class DirectFullKeyValuesCacheRepo<Key,Value>(
override suspend fun add(toAdd: Map<Key, List<Value>>) { override suspend fun add(toAdd: Map<Key, List<Value>>) {
locker.withWriteLock { locker.withWriteLock {
parentRepo.add(toAdd) kvsRepo.add(toAdd)
toAdd.forEach { toAdd.forEach {
val filtered = it.value.filter { v -> val filtered = it.value.filter { v ->
parentRepo.contains(it.key, v) parentRepo.contains(it.key, v)
@@ -204,7 +204,7 @@ open class DirectFullKeyValuesCacheRepo<Key,Value>(
override suspend fun remove(toRemove: Map<Key, List<Value>>) { override suspend fun remove(toRemove: Map<Key, List<Value>>) {
locker.withWriteLock { locker.withWriteLock {
parentRepo.remove(toRemove) kvsRepo.remove(toRemove)
toRemove.forEach { toRemove.forEach {
val filtered = it.value.filter { v -> val filtered = it.value.filter { v ->
!parentRepo.contains(it.key, v) !parentRepo.contains(it.key, v)
@@ -226,7 +226,7 @@ open class DirectFullKeyValuesCacheRepo<Key,Value>(
override suspend fun clear(k: Key) { override suspend fun clear(k: Key) {
locker.withWriteLock { locker.withWriteLock {
parentRepo.clear(k) kvsRepo.clear(k)
if (parentRepo.contains(k)) { if (parentRepo.contains(k)) {
return@withWriteLock return@withWriteLock
} }