Merge branch 'master' into 0.25.0

0.24.9

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.25.0
+
+* `Repos`:
+  * `Cache`:
+    * All cache repos now do not have `open` vals - to avoid collisions in runtime
+
 ## 0.24.9
 
 * `Pagination`:

gradle.properties

@@ -15,5 +15,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.24.9
+version=0.25.0
-android_code_version=289
+android_code_version=290

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/CRUDCacheRepo.kt

@@ -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 val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
-    protected open val kvCache: KVCache<IdType, ObjectType>,
+    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 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 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,19 +131,19 @@ 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,
+    crudRepo,
     kvCache,
     scope,
     locker,

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/KeyValueCacheRepo.kt

@@ -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 val parentRepo: ReadKeyValueRepo<Key, Value>,
-    protected open val kvCache: KVCache<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 {
+) : ReadKeyValueCacheRepo<Key,Value>(kvRepo, kvCache, locker), KeyValueRepo<Key,Value>, WriteKeyValueRepo<Key, Value> by kvRepo, CommonCacheRepo {
-    protected val onNewJob = parentRepo.onNewValue.onEach {
+    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()
         }

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/KeyValuesCacheRepo.kt

@@ -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 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(),
 ) : ReadKeyValuesRepo<Key,Value> by parentRepo, CommonCacheRepo {
     override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> {

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/crud/AutoRecacheReadCRUDRepo.kt

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

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalue/AutoRecacheKeyValueRepo.kt

@@ -8,21 +8,21 @@ import kotlinx.coroutines.CoroutineScope
 import kotlin.time.Duration.Companion.seconds
 
 open class AutoRecacheKeyValueRepo<Id, RegisteredObject>(
-    override val originalRepo: KeyValueRepo<Id, RegisteredObject>,
+    protected val kvRepo: KeyValueRepo<Id, RegisteredObject>,
     scope: CoroutineScope,
     kvCache: KeyValueRepo<Id, RegisteredObject> = MapKeyValueRepo(),
     recacheDelay: Long = 60.seconds.inWholeMilliseconds,
     actionWrapper: ActionWrapper = ActionWrapper.Direct,
     idGetter: (RegisteredObject) -> Id
 ) : AutoRecacheReadKeyValueRepo<Id, RegisteredObject> (
-    originalRepo,
+    kvRepo,
     scope,
     kvCache,
     recacheDelay,
     actionWrapper,
     idGetter
 ),
-    WriteKeyValueRepo<Id, RegisteredObject> by AutoRecacheWriteKeyValueRepo(originalRepo, scope, kvCache),
+    WriteKeyValueRepo<Id, RegisteredObject> by AutoRecacheWriteKeyValueRepo(kvRepo, scope, kvCache),
     KeyValueRepo<Id, RegisteredObject> {
 
     constructor(
@@ -34,14 +34,14 @@ open class AutoRecacheKeyValueRepo<Id, RegisteredObject>(
         idGetter: (RegisteredObject) -> Id
     ) : this(originalRepo, scope, kvCache, recacheDelay, ActionWrapper.Timeouted(originalCallTimeoutMillis), idGetter)
 
-    override suspend fun unsetWithValues(toUnset: List<RegisteredObject>) = originalRepo.unsetWithValues(
+    override suspend fun unsetWithValues(toUnset: List<RegisteredObject>) = kvRepo.unsetWithValues(
         toUnset
     ).also {
         kvCache.unsetWithValues(toUnset)
     }
 
     override suspend fun clear() {
-        originalRepo.clear()
+        kvRepo.clear()
         kvCache.clear()
     }
 }

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalue/AutoRecacheReadKeyValueRepo.kt

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

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalues/AutoRecacheKeyValueRepo.kt

@@ -9,19 +9,19 @@ import kotlinx.coroutines.CoroutineScope
 import kotlin.time.Duration.Companion.seconds
 
 open class AutoRecacheKeyValuesRepo<Id, RegisteredObject>(
-    override val originalRepo: KeyValuesRepo<Id, RegisteredObject>,
+    protected val kvsRepo: KeyValuesRepo<Id, RegisteredObject>,
     scope: CoroutineScope,
     kvCache: KeyValueRepo<Id, List<RegisteredObject>> = MapKeyValueRepo(),
     recacheDelay: Long = 60.seconds.inWholeMilliseconds,
     actionWrapper: ActionWrapper = ActionWrapper.Direct
 ) : AutoRecacheReadKeyValuesRepo<Id, RegisteredObject> (
-    originalRepo,
+    kvsRepo,
     scope,
     kvCache,
     recacheDelay,
     actionWrapper
 ),
-    WriteKeyValuesRepo<Id, RegisteredObject> by AutoRecacheWriteKeyValuesRepo(originalRepo, scope, kvCache),
+    WriteKeyValuesRepo<Id, RegisteredObject> by AutoRecacheWriteKeyValuesRepo(kvsRepo, scope, kvCache),
     KeyValuesRepo<Id, RegisteredObject> {
 
     constructor(

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalues/AutoRecacheReadKeyValuesRepo.kt

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

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/FullCRUDCacheRepo.kt

@@ -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 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 {
     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>,
+    protected val crudRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
-    override val kvCache: KeyValueRepo<IdType, ObjectType>,
+    kvCache: KeyValueRepo<IdType, ObjectType>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     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>(
-    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()
         }

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/FullKeyValueCacheRepo.kt

@@ -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 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 {
     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>,
+    protected val kvRepo: KeyValueRepo<Key, Value>,
-    override val kvCache: 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)

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/FullKeyValuesCacheRepo.kt

@@ -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 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 {
     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>,
+    protected val kvsRepo: KeyValuesRepo<Key, Value>,
-    override val kvCache: KeyValueRepo<Key, List<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),
+    FullReadKeyValuesCacheRepo<Key, Value>(kvsRepo, kvCache, locker),
-    WriteKeyValuesRepo<Key, Value> by parentRepo {
+    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
             }

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/direct/DirectFullCRUDCacheRepo.kt

@@ -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 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 {
     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>,
+    protected val crudRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
-    override val kvCache: KeyValueRepo<IdType, ObjectType>,
+    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,

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/direct/DirectFullKeyValueCacheRepo.kt

@@ -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 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> {
     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 val parentRepo: WriteKeyValueRepo<Key, Value>,
-    protected open val kvCache: KeyValueRepo<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>,
+    protected val kvRepo: KeyValueRepo<Key, Value>,
-    override val kvCache: 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)

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/direct/DirectFullKeyValuesCacheRepo.kt

@@ -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 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 {
     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>,
+    protected val kvsRepo: KeyValuesRepo<Key, Value>,
-    override val kvCache: KeyValueRepo<Key, List<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),
+    DirectFullReadKeyValuesCacheRepo<Key, Value>(kvsRepo, kvCache, locker),
-    WriteKeyValuesRepo<Key, Value> by parentRepo {
+    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
             }