InsanusMokrassar/MicroUtils
1
0
Fork 0
mirror of https://github.com/InsanusMokrassar/MicroUtils.git synced 2025-09-09 02:00:01 +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

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.*
open class ReadCRUDCacheRepo<ObjectType, IdType>(
protected open val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
protected open val kvCache: KVCache<IdType, ObjectType>,
protected val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
protected val kvCache: KVCache<IdType, ObjectType>,
protected val locker: SmartRWLocker = SmartRWLocker(),
protected open val idGetter: (ObjectType) -> IdType
protected val idGetter: (ObjectType) -> IdType
) : ReadCRUDRepo<ObjectType, IdType> by parentRepo, CommonCacheRepo {
override suspend fun getById(id: IdType): ObjectType? = locker.withReadAcquire {
kvCache.get(id)
@@ -51,11 +51,11 @@ fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.cached(
) = ReadCRUDCacheRepo(this, kvCache, locker, idGetter)
open class WriteCRUDCacheRepo<ObjectType, IdType, InputValueType>(
protected open val parentRepo: WriteCRUDRepo<ObjectType, IdType, InputValueType>,
protected open val kvCache: KeyValueRepo<IdType, ObjectType>,
protected open val scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
protected val parentRepo: WriteCRUDRepo<ObjectType, IdType, InputValueType>,
protected val kvCache: KeyValueRepo<IdType, ObjectType>,
protected val scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
protected val locker: SmartRWLocker = SmartRWLocker(),
protected open val idGetter: (ObjectType) -> IdType
protected val idGetter: (ObjectType) -> IdType
) : WriteCRUDRepo<ObjectType, IdType, InputValueType>, CommonCacheRepo {
override val newObjectsFlow: Flow<ObjectType> by parentRepo::newObjectsFlow
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>(
override val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
protected val crudRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
kvCache: KVCache<IdType, ObjectType>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
locker: SmartRWLocker = SmartRWLocker(),
idGetter: (ObjectType) -> IdType
) : ReadCRUDCacheRepo<ObjectType, IdType>(
parentRepo,
crudRepo,
kvCache,
locker,
idGetter
),
WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo(
parentRepo,
WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo(
crudRepo,
kvCache,
scope,
locker,
idGetter
),
CRUDRepo<ObjectType, IdType, InputValueType> {
CRUDRepo<ObjectType, IdType, InputValueType> {
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.*
open class ReadKeyValueCacheRepo<Key,Value>(
protected open val parentRepo: ReadKeyValueRepo<Key, Value>,
protected open val kvCache: KVCache<Key, Value>,
protected val parentRepo: ReadKeyValueRepo<Key, Value>,
protected val kvCache: KVCache<Key, Value>,
protected val locker: SmartRWLocker = SmartRWLocker(),
) : ReadKeyValueRepo<Key,Value> by parentRepo, CommonCacheRepo {
override suspend fun get(k: Key): Value? = locker.withReadAcquire {
@@ -58,24 +58,24 @@ fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(
) = ReadKeyValueCacheRepo(this, kvCache, locker)
open class KeyValueCacheRepo<Key,Value>(
override val parentRepo: KeyValueRepo<Key, Value>,
protected val kvRepo: KeyValueRepo<Key, Value>,
kvCache: KVCache<Key, Value>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
locker: SmartRWLocker = SmartRWLocker(),
) : ReadKeyValueCacheRepo<Key,Value>(parentRepo, kvCache, locker), KeyValueRepo<Key,Value>, WriteKeyValueRepo<Key, Value> by parentRepo, CommonCacheRepo {
protected val onNewJob = parentRepo.onNewValue.onEach {
) : ReadKeyValueCacheRepo<Key,Value>(kvRepo, kvCache, locker), KeyValueRepo<Key,Value>, WriteKeyValueRepo<Key, Value> by parentRepo, CommonCacheRepo {
protected val onNewJob = kvRepo.onNewValue.onEach {
locker.withWriteLock {
kvCache.set(it.first, it.second)
}
}.launchIn(scope)
protected val onRemoveJob = parentRepo.onValueRemoved.onEach {
protected val onRemoveJob = kvRepo.onValueRemoved.onEach {
locker.withWriteLock {
kvCache.unset(it)
}
}.launchIn(scope)
override suspend fun clear() {
parentRepo.clear()
kvRepo.clear()
locker.withWriteLock {
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.*
open class ReadKeyValuesCacheRepo<Key,Value>(
protected open val parentRepo: ReadKeyValuesRepo<Key, Value>,
protected open val kvCache: KVCache<Key, List<Value>>,
protected val parentRepo: ReadKeyValuesRepo<Key, Value>,
protected val kvCache: KVCache<Key, List<Value>>,
protected val locker: SmartRWLocker = SmartRWLocker(),
) : ReadKeyValuesRepo<Key,Value> by parentRepo, CommonCacheRepo {
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
open class AutoRecacheReadCRUDRepo<RegisteredObject, Id>(
protected open val originalRepo: ReadCRUDRepo<RegisteredObject, Id>,
protected val originalRepo: ReadCRUDRepo<RegisteredObject, Id>,
protected val scope: CoroutineScope,
protected val kvCache: KeyValueRepo<Id, RegisteredObject> = MapKeyValueRepo(),
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
open class AutoRecacheReadKeyValueRepo<Id, RegisteredObject>(
protected open val originalRepo: ReadKeyValueRepo<Id, RegisteredObject>,
protected val originalRepo: ReadKeyValueRepo<Id, RegisteredObject>,
protected val scope: CoroutineScope,
protected val kvCache: KeyValueRepo<Id, RegisteredObject> = MapKeyValueRepo(),
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
open class AutoRecacheReadKeyValuesRepo<Id, RegisteredObject>(
protected open val originalRepo: ReadKeyValuesRepo<Id, RegisteredObject>,
protected val originalRepo: ReadKeyValuesRepo<Id, RegisteredObject>,
protected val scope: CoroutineScope,
protected val kvCache: KeyValueRepo<Id, List<RegisteredObject>> = MapKeyValueRepo(),
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
open class FullReadCRUDCacheRepo<ObjectType, IdType>(
protected open val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
protected open val kvCache: KeyValueRepo<IdType, ObjectType>,
protected open val locker: SmartRWLocker = SmartRWLocker(),
protected open val idGetter: (ObjectType) -> IdType
protected val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
protected val kvCache: KeyValueRepo<IdType, ObjectType>,
protected val locker: SmartRWLocker = SmartRWLocker(),
protected val idGetter: (ObjectType) -> IdType
) : ReadCRUDRepo<ObjectType, IdType>, FullCacheRepo {
protected suspend inline fun <T> doOrTakeAndActualize(
action: KeyValueRepo<IdType, ObjectType>.() -> Optional<T>,
@@ -94,20 +94,20 @@ fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.cached(
) = FullReadCRUDCacheRepo(this, kvCache, locker, idGetter)
open class FullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
override val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
override val kvCache: KeyValueRepo<IdType, ObjectType>,
protected val crudRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
kvCache: KeyValueRepo<IdType, ObjectType>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
skipStartInvalidate: Boolean = false,
override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
override val idGetter: (ObjectType) -> IdType
locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
idGetter: (ObjectType) -> IdType
) : FullReadCRUDCacheRepo<ObjectType, IdType>(
parentRepo,
crudRepo,
kvCache,
locker,
idGetter
),
WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo(
parentRepo,
crudRepo,
kvCache,
scope,
locker,
@@ -128,7 +128,7 @@ open class FullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
protected open suspend fun initialInvalidate() {
try {
kvCache.actualizeAll(parentRepo, locker = null)
kvCache.actualizeAll(crudRepo, locker = null)
} finally {
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.*
open class FullReadKeyValueCacheRepo<Key,Value>(
protected open val parentRepo: ReadKeyValueRepo<Key, Value>,
protected open val kvCache: KeyValueRepo<Key, Value>,
protected open val locker: SmartRWLocker = SmartRWLocker()
protected val parentRepo: ReadKeyValueRepo<Key, Value>,
protected val kvCache: KeyValueRepo<Key, Value>,
protected val locker: SmartRWLocker = SmartRWLocker()
) : ReadKeyValueRepo<Key, Value>, FullCacheRepo {
protected suspend inline fun <T> doOrTakeAndActualize(
action: KeyValueRepo<Key, Value>.() -> Optional<T>,
@@ -98,7 +98,7 @@ fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(
open class FullWriteKeyValueCacheRepo<Key,Value>(
parentRepo: WriteKeyValueRepo<Key, Value>,
protected open val kvCache: KeyValueRepo<Key, Value>,
protected val kvCache: KeyValueRepo<Key, Value>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
protected val locker: SmartRWLocker = SmartRWLocker()
) : WriteKeyValueRepo<Key, Value> by parentRepo, FullCacheRepo {
@@ -126,16 +126,16 @@ fun <Key, Value> WriteKeyValueRepo<Key, Value>.caching(
) = FullWriteKeyValueCacheRepo(this, kvCache, scope)
open class FullKeyValueCacheRepo<Key,Value>(
override val parentRepo: KeyValueRepo<Key, Value>,
override val kvCache: KeyValueRepo<Key, Value>,
protected val kvRepo: KeyValueRepo<Key, Value>,
kvCache: KeyValueRepo<Key, Value>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
skipStartInvalidate: Boolean = false,
override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
) : //FullWriteKeyValueCacheRepo<Key,Value>(parentRepo, kvCache, scope),
KeyValueRepo<Key,Value>,
WriteKeyValueRepo<Key,Value> by parentRepo,
WriteKeyValueRepo<Key,Value> by kvRepo,
FullReadKeyValueCacheRepo<Key, Value>(
parentRepo,
kvRepo,
kvCache,
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() {
try {
@@ -165,13 +165,13 @@ open class FullKeyValueCacheRepo<Key,Value>(
}
override suspend fun clear() {
parentRepo.clear()
kvRepo.clear()
kvCache.clear()
}
override suspend fun set(toSet: Map<Key, Value>) {
locker.withWriteLock {
parentRepo.set(toSet)
kvRepo.set(toSet)
kvCache.set(
toSet.filter {
parentRepo.contains(it.key)
@@ -182,7 +182,7 @@ open class FullKeyValueCacheRepo<Key,Value>(
override suspend fun unset(toUnset: List<Key>) {
locker.withWriteLock {
parentRepo.unset(toUnset)
kvRepo.unset(toUnset)
kvCache.unset(
toUnset.filter {
!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.*
open class FullReadKeyValuesCacheRepo<Key,Value>(
protected open val parentRepo: ReadKeyValuesRepo<Key, Value>,
protected open val kvCache: KeyValueRepo<Key, List<Value>>,
protected open val locker: SmartRWLocker = SmartRWLocker(),
protected val parentRepo: ReadKeyValuesRepo<Key, Value>,
protected val kvCache: KeyValueRepo<Key, List<Value>>,
protected val locker: SmartRWLocker = SmartRWLocker(),
) : ReadKeyValuesRepo<Key, Value>, FullCacheRepo {
protected suspend inline fun <T> doOrTakeAndActualize(
action: KeyValueRepo<Key, List<Value>>.() -> Optional<T>,
@@ -165,7 +165,7 @@ fun <Key, Value> ReadKeyValuesRepo<Key, Value>.cached(
open class FullWriteKeyValuesCacheRepo<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),
protected val locker: SmartRWLocker = SmartRWLocker(),
) : WriteKeyValuesRepo<Key, Value> by parentRepo, FullCacheRepo {
@@ -200,14 +200,14 @@ fun <Key, Value> WriteKeyValuesRepo<Key, Value>.caching(
) = FullWriteKeyValuesCacheRepo(this, kvCache, scope, locker)
open class FullKeyValuesCacheRepo<Key,Value>(
override val parentRepo: KeyValuesRepo<Key, Value>,
override val kvCache: KeyValueRepo<Key, List<Value>>,
protected val kvsRepo: KeyValuesRepo<Key, Value>,
kvCache: KeyValueRepo<Key, List<Value>>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
skipStartInvalidate: Boolean = false,
override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
) : KeyValuesRepo<Key, Value>,
FullReadKeyValuesCacheRepo<Key, Value>(parentRepo, kvCache, locker),
WriteKeyValuesRepo<Key, Value> by parentRepo {
FullReadKeyValuesCacheRepo<Key, Value>(kvsRepo, kvCache, locker),
WriteKeyValuesRepo<Key, Value> by kvsRepo {
init {
if (!skipStartInvalidate) {
scope.launchLoggingDropExceptions {
@@ -241,7 +241,7 @@ open class FullKeyValuesCacheRepo<Key,Value>(
override suspend fun set(toSet: Map<Key, List<Value>>) {
locker.withWriteLock {
parentRepo.set(toSet)
kvsRepo.set(toSet)
kvCache.set(
toSet.filter {
parentRepo.contains(it.key)
@@ -252,7 +252,7 @@ open class FullKeyValuesCacheRepo<Key,Value>(
override suspend fun add(toAdd: Map<Key, List<Value>>) {
locker.withWriteLock {
parentRepo.add(toAdd)
kvsRepo.add(toAdd)
toAdd.forEach {
val filtered = it.value.filter { v ->
parentRepo.contains(it.key, v)
@@ -269,7 +269,7 @@ open class FullKeyValuesCacheRepo<Key,Value>(
override suspend fun remove(toRemove: Map<Key, List<Value>>) {
locker.withWriteLock {
parentRepo.remove(toRemove)
kvsRepo.remove(toRemove)
toRemove.forEach {
val filtered = it.value.filter { v ->
!parentRepo.contains(it.key, v)
@@ -291,7 +291,7 @@ open class FullKeyValuesCacheRepo<Key,Value>(
override suspend fun clear(k: Key) {
locker.withWriteLock {
parentRepo.clear(k)
kvsRepo.clear(k)
if (parentRepo.contains(k)) {
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
import dev.inmo.micro_utils.common.*
import dev.inmo.micro_utils.coroutines.SmartRWLocker
import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
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.PaginationResult
import dev.inmo.micro_utils.repos.*
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 kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
open class DirectFullReadCRUDCacheRepo<ObjectType, IdType>(
protected open val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
protected open val kvCache: KeyValueRepo<IdType, ObjectType>,
protected open val locker: SmartRWLocker = SmartRWLocker(),
protected open val idGetter: (ObjectType) -> IdType
protected val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
protected val kvCache: KeyValueRepo<IdType, ObjectType>,
protected val locker: SmartRWLocker = SmartRWLocker(),
protected val idGetter: (ObjectType) -> IdType
) : ReadCRUDRepo<ObjectType, IdType>, DirectFullCacheRepo {
protected open suspend fun actualizeAll() {
kvCache.actualizeAll(parentRepo, locker = locker)
@@ -60,20 +57,20 @@ fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.directlyCached(
) = DirectFullReadCRUDCacheRepo(this, kvCache, locker, idGetter)
open class DirectFullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
override val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
override val kvCache: KeyValueRepo<IdType, ObjectType>,
protected val crudRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
kvCache: KeyValueRepo<IdType, ObjectType>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
skipStartInvalidate: Boolean = false,
override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
idGetter: (ObjectType) -> IdType
) : DirectFullReadCRUDCacheRepo<ObjectType, IdType>(
parentRepo,
crudRepo,
kvCache,
locker,
idGetter
),
WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo(
parentRepo,
crudRepo,
kvCache,
scope,
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
open class DirectFullReadKeyValueCacheRepo<Key, Value>(
protected open val parentRepo: ReadKeyValueRepo<Key, Value>,
protected open val kvCache: KeyValueRepo<Key, Value>,
protected open val locker: SmartRWLocker = SmartRWLocker()
protected val parentRepo: ReadKeyValueRepo<Key, Value>,
protected val kvCache: KeyValueRepo<Key, Value>,
protected val locker: SmartRWLocker = SmartRWLocker()
) : DirectFullCacheRepo, ReadKeyValueRepo<Key, Value> {
protected open suspend fun actualizeAll() {
kvCache.actualizeAll(parentRepo, locker)
@@ -65,8 +65,8 @@ fun <Key, Value> ReadKeyValueRepo<Key, Value>.directlyCached(
) = DirectFullReadKeyValueCacheRepo(this, kvCache, locker)
open class DirectFullWriteKeyValueCacheRepo<Key, Value>(
protected open val parentRepo: WriteKeyValueRepo<Key, Value>,
protected open val kvCache: KeyValueRepo<Key, Value>,
protected val parentRepo: WriteKeyValueRepo<Key, Value>,
protected val kvCache: KeyValueRepo<Key, Value>,
protected val locker: SmartRWLocker = SmartRWLocker(),
scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
) : DirectFullCacheRepo, WriteKeyValueRepo<Key, Value> by parentRepo {
@@ -101,20 +101,20 @@ fun <Key, Value> WriteKeyValueRepo<Key, Value>.directlyCached(
) = DirectFullWriteKeyValueCacheRepo(this, kvCache, scope = scope)
open class DirectFullKeyValueCacheRepo<Key, Value>(
override val parentRepo: KeyValueRepo<Key, Value>,
override val kvCache: KeyValueRepo<Key, Value>,
protected val kvRepo: KeyValueRepo<Key, Value>,
kvCache: KeyValueRepo<Key, Value>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
skipStartInvalidate: Boolean = false,
override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
) : DirectFullCacheRepo,
KeyValueRepo<Key, Value> ,
WriteKeyValueRepo<Key, Value> by DirectFullWriteKeyValueCacheRepo(
parentRepo,
kvRepo,
kvCache,
locker,
scope
),
DirectFullReadKeyValueCacheRepo<Key, Value>(parentRepo, kvCache, locker) {
DirectFullReadKeyValueCacheRepo<Key, Value>(kvRepo, kvCache, locker) {
init {
if (!skipStartInvalidate) {
scope.launchLoggingDropExceptions {
@@ -140,15 +140,15 @@ open class DirectFullKeyValueCacheRepo<Key, Value>(
}
override suspend fun clear() {
parentRepo.clear()
kvRepo.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>) {
locker.withWriteLock {
parentRepo.set(toSet)
kvRepo.set(toSet)
kvCache.set(
toSet.filter {
parentRepo.contains(it.key)
@@ -159,7 +159,7 @@ open class DirectFullKeyValueCacheRepo<Key, Value>(
override suspend fun unset(toUnset: List<Key>) {
locker.withWriteLock {
parentRepo.unset(toUnset)
kvRepo.unset(toUnset)
kvCache.unset(
toUnset.filter {
!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.*
open class DirectFullReadKeyValuesCacheRepo<Key,Value>(
protected open val parentRepo: ReadKeyValuesRepo<Key, Value>,
protected open val kvCache: KeyValueRepo<Key, List<Value>>,
protected open val locker: SmartRWLocker = SmartRWLocker(),
protected val parentRepo: ReadKeyValuesRepo<Key, Value>,
protected val kvCache: KeyValueRepo<Key, List<Value>>,
protected val locker: SmartRWLocker = SmartRWLocker(),
) : ReadKeyValuesRepo<Key, Value>, DirectFullCacheRepo {
protected open suspend fun actualizeKey(k: Key) {
kvCache.actualizeAll(locker = locker, clearMode = ActualizeAllClearMode.Never) {
@@ -100,7 +100,7 @@ fun <Key, Value> ReadKeyValuesRepo<Key, Value>.directlyCached(
open class DirectFullWriteKeyValuesCacheRepo<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),
protected val locker: SmartRWLocker = SmartRWLocker(),
) : WriteKeyValuesRepo<Key, Value> by parentRepo, DirectFullCacheRepo {
@@ -135,14 +135,14 @@ fun <Key, Value> WriteKeyValuesRepo<Key, Value>.directlyCached(
) = DirectFullWriteKeyValuesCacheRepo(this, kvCache, scope, locker)
open class DirectFullKeyValuesCacheRepo<Key,Value>(
override val parentRepo: KeyValuesRepo<Key, Value>,
override val kvCache: KeyValueRepo<Key, List<Value>>,
protected val kvsRepo: KeyValuesRepo<Key, Value>,
kvCache: KeyValueRepo<Key, List<Value>>,
scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
skipStartInvalidate: Boolean = false,
override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
) : KeyValuesRepo<Key, Value>,
DirectFullReadKeyValuesCacheRepo<Key, Value>(parentRepo, kvCache, locker),
WriteKeyValuesRepo<Key, Value> by parentRepo {
DirectFullReadKeyValuesCacheRepo<Key, Value>(kvsRepo, kvCache, locker),
WriteKeyValuesRepo<Key, Value> by kvsRepo {
init {
if (!skipStartInvalidate) {
scope.launchLoggingDropExceptions {
@@ -176,7 +176,7 @@ open class DirectFullKeyValuesCacheRepo<Key,Value>(
override suspend fun set(toSet: Map<Key, List<Value>>) {
locker.withWriteLock {
parentRepo.set(toSet)
kvsRepo.set(toSet)
kvCache.set(
toSet.filter {
parentRepo.contains(it.key)
@@ -187,7 +187,7 @@ open class DirectFullKeyValuesCacheRepo<Key,Value>(
override suspend fun add(toAdd: Map<Key, List<Value>>) {
locker.withWriteLock {
parentRepo.add(toAdd)
kvsRepo.add(toAdd)
toAdd.forEach {
val filtered = it.value.filter { v ->
parentRepo.contains(it.key, v)
@@ -204,7 +204,7 @@ open class DirectFullKeyValuesCacheRepo<Key,Value>(
override suspend fun remove(toRemove: Map<Key, List<Value>>) {
locker.withWriteLock {
parentRepo.remove(toRemove)
kvsRepo.remove(toRemove)
toRemove.forEach {
val filtered = it.value.filter { v ->
!parentRepo.contains(it.key, v)
@@ -226,7 +226,7 @@ open class DirectFullKeyValuesCacheRepo<Key,Value>(
override suspend fun clear(k: Key) {
locker.withWriteLock {
parentRepo.clear(k)
kvsRepo.clear(k)
if (parentRepo.contains(k)) {
return@withWriteLock
}