start 0.20.2 and all main repos uses 'SmartRWLocker'

repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapCRUDRepo.kt

@@ -1,38 +1,55 @@
 package dev.inmo.micro_utils.repos
 
+import dev.inmo.micro_utils.coroutines.SmartRWLocker
+import dev.inmo.micro_utils.coroutines.withReadAcquire
+import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.*
 import kotlinx.coroutines.flow.*
 
 class ReadMapCRUDRepo<ObjectType, IdType>(
-    private val map: Map<IdType, ObjectType> = emptyMap()
+    private val map: Map<IdType, ObjectType> = emptyMap(),
+    private val locker: SmartRWLocker = SmartRWLocker()
 ) : ReadCRUDRepo<ObjectType, IdType> {
     override suspend fun getByPagination(pagination: Pagination): PaginationResult<ObjectType> {
-        return map.keys.drop(pagination.firstIndex).take(pagination.size).mapNotNull {
-            map[it]
-        }.createPaginationResult(
-            pagination,
-            count()
-        )
+        return locker.withReadAcquire {
+            map.keys.drop(pagination.firstIndex).take(pagination.size).mapNotNull {
+                map[it]
+            }.createPaginationResult(
+                pagination,
+                count()
+            )
+        }
     }
 
     override suspend fun getIdsByPagination(pagination: Pagination): PaginationResult<IdType> {
-        return map.keys.drop(pagination.firstIndex).take(pagination.size).createPaginationResult(
-            pagination,
-            count()
-        )
+        return locker.withReadAcquire {
+            map.keys.drop(pagination.firstIndex).take(pagination.size).createPaginationResult(
+                pagination,
+                count()
+            )
+        }
     }
 
-    override suspend fun getById(id: IdType): ObjectType? = map[id]
+    override suspend fun getById(id: IdType): ObjectType? = locker.withReadAcquire {
+        map[id]
+    }
 
-    override suspend fun contains(id: IdType): Boolean = map.containsKey(id)
+    override suspend fun contains(id: IdType): Boolean = locker.withReadAcquire {
+        map.containsKey(id)
+    }
 
-    override suspend fun getAll(): Map<IdType, ObjectType> = map.toMap()
+    override suspend fun getAll(): Map<IdType, ObjectType> = locker.withReadAcquire {
+        map.toMap()
+    }
 
-    override suspend fun count(): Long = map.size.toLong()
+    override suspend fun count(): Long = locker.withReadAcquire {
+        map.size.toLong()
+    }
 }
 
 abstract class WriteMapCRUDRepo<ObjectType, IdType, InputValueType>(
-    protected val map: MutableMap<IdType, ObjectType> = mutableMapOf()
+    protected val map: MutableMap<IdType, ObjectType> = mutableMapOf(),
+    protected val locker: SmartRWLocker = SmartRWLocker()
 ) : WriteCRUDRepo<ObjectType, IdType, InputValueType> {
     protected val _newObjectsFlow: MutableSharedFlow<ObjectType> = MutableSharedFlow()
     override val newObjectsFlow: Flow<ObjectType> = _newObjectsFlow.asSharedFlow()
@@ -45,21 +62,25 @@ abstract class WriteMapCRUDRepo<ObjectType, IdType, InputValueType>(
     protected abstract suspend fun createObject(newValue: InputValueType): Pair<IdType, ObjectType>
 
     override suspend fun create(values: List<InputValueType>): List<ObjectType> {
-        return values.map {
-            val (id, newObject) = createObject(it)
-            map[id] = newObject
-            newObject.also { _ ->
-                _newObjectsFlow.emit(newObject)
+        return locker.withWriteLock {
+            values.map {
+                val (id, newObject) = createObject(it)
+                map[id] = newObject
+                newObject.also { _ ->
+                    _newObjectsFlow.emit(newObject)
+                }
             }
         }
     }
 
     override suspend fun update(id: IdType, value: InputValueType): ObjectType? {
-        val newValue = updateObject(value, id, map[id] ?: return null)
+        return locker.withWriteLock {
+            val newValue = updateObject(value, id, map[id] ?: return@withWriteLock null)
 
-        return newValue.also {
-            map[id] = it
-            _updatedObjectsFlow.emit(it)
+            newValue.also {
+                map[id] = it
+                _updatedObjectsFlow.emit(it)
+            }
         }
     }
 
@@ -68,24 +89,28 @@ abstract class WriteMapCRUDRepo<ObjectType, IdType, InputValueType>(
     }
 
     override suspend fun deleteById(ids: List<IdType>) {
-        ids.forEach {
-            map.remove(it) ?.also { _ -> _deletedObjectsIdsFlow.emit(it) }
+        locker.withWriteLock {
+            ids.forEach {
+                map.remove(it) ?.also { _ -> _deletedObjectsIdsFlow.emit(it) }
+            }
         }
     }
 
 }
 
 abstract class MapCRUDRepo<ObjectType, IdType, InputValueType>(
-    map: MutableMap<IdType, ObjectType>
+    map: MutableMap<IdType, ObjectType>,
+    locker: SmartRWLocker = SmartRWLocker()
 ) : CRUDRepo<ObjectType, IdType, InputValueType>,
-    ReadCRUDRepo<ObjectType, IdType> by ReadMapCRUDRepo(map),
-    WriteMapCRUDRepo<ObjectType, IdType, InputValueType>(map)
+    ReadCRUDRepo<ObjectType, IdType> by ReadMapCRUDRepo(map, locker),
+    WriteMapCRUDRepo<ObjectType, IdType, InputValueType>(map, locker)
 
 fun <ObjectType, IdType, InputValueType> MapCRUDRepo(
     map: MutableMap<IdType, ObjectType>,
     updateCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType, id: IdType, old: ObjectType) -> ObjectType,
+    locker: SmartRWLocker = SmartRWLocker(),
     createCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType) -> Pair<IdType, ObjectType>
-) = object : MapCRUDRepo<ObjectType, IdType, InputValueType>(map) {
+) = object : MapCRUDRepo<ObjectType, IdType, InputValueType>(map, locker) {
     override suspend fun updateObject(
         newValue: InputValueType,
         id: IdType,
@@ -97,10 +122,12 @@ fun <ObjectType, IdType, InputValueType> MapCRUDRepo(
 
 fun <ObjectType, IdType, InputValueType> MapCRUDRepo(
     updateCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType, id: IdType, old: ObjectType) -> ObjectType,
+    locker: SmartRWLocker = SmartRWLocker(),
     createCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType) -> Pair<IdType, ObjectType>
-) = MapCRUDRepo(mutableMapOf(), updateCallback, createCallback)
+) = MapCRUDRepo(mutableMapOf(), updateCallback, locker, createCallback)
 
 fun <ObjectType, IdType, InputValueType> MutableMap<IdType, ObjectType>.asCrudRepo(
     updateCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType, id: IdType, old: ObjectType) -> ObjectType,
+    locker: SmartRWLocker = SmartRWLocker(),
     createCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType) -> Pair<IdType, ObjectType>
-) = MapCRUDRepo(this, updateCallback, createCallback)
+) = MapCRUDRepo(this, updateCallback, locker, createCallback)

repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapKeyValueRepo.kt

@@ -1,5 +1,8 @@
 package dev.inmo.micro_utils.repos
 
+import dev.inmo.micro_utils.coroutines.SmartRWLocker
+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.pagination.utils.paginate
@@ -8,58 +11,68 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 
 class ReadMapKeyValueRepo<Key, Value>(
-    protected val map: Map<Key, Value> = emptyMap()
+    protected val map: Map<Key, Value>,
+    private val locker: SmartRWLocker
 ) : ReadKeyValueRepo<Key, Value> {
-    override suspend fun get(k: Key): Value? = map[k]
+    constructor(map: Map<Key, Value> = emptyMap()) : this(map, SmartRWLocker())
+
+    override suspend fun get(k: Key): Value? = locker.withReadAcquire { map[k] }
 
     override suspend fun values(
         pagination: Pagination,
         reversed: Boolean
     ): PaginationResult<Value> {
-        val values = map.values
-        val actualPagination = if (reversed) pagination.reverse(values.size) else pagination
-        return values.paginate(actualPagination).let {
-            if (reversed) {
-                it.copy(results = it.results.reversed())
-            } else {
-                it
+        return locker.withReadAcquire {
+            val values = map.values
+            val actualPagination = if (reversed) pagination.reverse(values.size) else pagination
+            values.paginate(actualPagination).let {
+                if (reversed) {
+                    it.copy(results = it.results.reversed())
+                } else {
+                    it
+                }
             }
         }
     }
 
     override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> {
-        val keys = map.keys
-        val actualPagination = if (reversed) pagination.reverse(keys.size) else pagination
-        return keys.paginate(actualPagination).let {
-            if (reversed) {
-                it.copy(results = it.results.reversed())
-            } else {
-                it
+        return locker.withReadAcquire {
+            val keys = map.keys
+            val actualPagination = if (reversed) pagination.reverse(keys.size) else pagination
+            keys.paginate(actualPagination).let {
+                if (reversed) {
+                    it.copy(results = it.results.reversed())
+                } else {
+                    it
+                }
             }
         }
     }
 
     override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> {
-        val keys: List<Key> = map.mapNotNull { (k, value) -> if (v == value) k else null }
-        val actualPagination = if (reversed) pagination.reverse(keys.size) else pagination
-        return keys.paginate(actualPagination).let {
-            if (reversed) {
-                it.copy(results = it.results.reversed())
-            } else {
-                it
+        return locker.withReadAcquire {
+            val keys: List<Key> = map.mapNotNull { (k, value) -> if (v == value) k else null }
+            val actualPagination = if (reversed) pagination.reverse(keys.size) else pagination
+            keys.paginate(actualPagination).let {
+                if (reversed) {
+                    it.copy(results = it.results.reversed())
+                } else {
+                    it
+                }
             }
         }
     }
 
-    override suspend fun getAll(): Map<Key, Value> = map.toMap()
+    override suspend fun getAll(): Map<Key, Value> = locker.withReadAcquire { map.toMap() }
 
-    override suspend fun contains(key: Key): Boolean = map.containsKey(key)
+    override suspend fun contains(key: Key): Boolean = locker.withReadAcquire { map.containsKey(key) }
 
-    override suspend fun count(): Long = map.size.toLong()
+    override suspend fun count(): Long = locker.withReadAcquire { map.size.toLong() }
 }
 
 class WriteMapKeyValueRepo<Key, Value>(
-    private val map: MutableMap<Key, Value> = mutableMapOf()
+    private val map: MutableMap<Key, Value>,
+    private val locker: SmartRWLocker
 ) : WriteKeyValueRepo<Key, Value> {
     private val _onNewValue: MutableSharedFlow<Pair<Key, Value>> = MutableSharedFlow()
     override val onNewValue: Flow<Pair<Key, Value>>
@@ -67,37 +80,44 @@ class WriteMapKeyValueRepo<Key, Value>(
     private val _onValueRemoved: MutableSharedFlow<Key> = MutableSharedFlow()
     override val onValueRemoved: Flow<Key>
         get() = _onValueRemoved
+    constructor(map: MutableMap<Key, Value> = mutableMapOf()) : this(map, SmartRWLocker())
 
     override suspend fun set(toSet: Map<Key, Value>) {
-        map.putAll(toSet)
+        locker.withWriteLock { map.putAll(toSet) }
         toSet.forEach { (k, v) -> _onNewValue.emit(k to v) }
     }
 
     override suspend fun unset(toUnset: List<Key>) {
-        toUnset.forEach { k ->
-            map.remove(k) ?.also { _ -> _onValueRemoved.emit(k) }
+        locker.withWriteLock {
+            toUnset.forEach { k ->
+                map.remove(k) ?.also { _ -> _onValueRemoved.emit(k) }
+            }
         }
     }
 
     override suspend fun unsetWithValues(toUnset: List<Value>) {
-        map.mapNotNull { (k, v) ->
-            k.takeIf { v in toUnset }
-        }.forEach {
-            map.remove(it)
-            _onValueRemoved.emit(it)
+        locker.withWriteLock {
+            map.mapNotNull { (k, v) ->
+                k.takeIf { v in toUnset }
+            }.forEach {
+                map.remove(it)
+                _onValueRemoved.emit(it)
+            }
         }
     }
 }
 
 @Suppress("DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE")
 class MapKeyValueRepo<Key, Value>(
-    private val map: MutableMap<Key, Value> = mutableMapOf()
+    private val map: MutableMap<Key, Value>,
+    private val locker: SmartRWLocker
 ) : KeyValueRepo<Key, Value>,
-    ReadKeyValueRepo<Key, Value> by ReadMapKeyValueRepo(map),
-    WriteKeyValueRepo<Key, Value> by WriteMapKeyValueRepo(map) {
+    ReadKeyValueRepo<Key, Value> by ReadMapKeyValueRepo(map, locker),
+    WriteKeyValueRepo<Key, Value> by WriteMapKeyValueRepo(map, locker) {
+    constructor(map: MutableMap<Key, Value> = mutableMapOf()) : this(map, SmartRWLocker())
     override suspend fun clear() {
-        map.clear()
+        locker.withWriteLock { map.clear() }
     }
 }
 
-fun <K, V> MutableMap<K, V>.asKeyValueRepo(): KeyValueRepo<K, V> = MapKeyValueRepo(this)
+fun <K, V> MutableMap<K, V>.asKeyValueRepo(locker: SmartRWLocker = SmartRWLocker()): KeyValueRepo<K, V> = MapKeyValueRepo(this, locker)

repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapKeyValuesRepo.kt

@@ -1,15 +1,21 @@
 package dev.inmo.micro_utils.repos
 
+import dev.inmo.micro_utils.coroutines.SmartRWLocker
+import dev.inmo.micro_utils.coroutines.withReadAcquire
+import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.paginate
 import dev.inmo.micro_utils.pagination.utils.reverse
 import kotlinx.coroutines.flow.*
 
 class MapReadKeyValuesRepo<Key, Value>(
-    private val map: Map<Key, List<Value>> = emptyMap()
+    private val map: Map<Key, List<Value>> = emptyMap(),
+    private val locker: SmartRWLocker = SmartRWLocker()
 ) : ReadKeyValuesRepo<Key, Value> {
     override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> {
-        val list = map[k] ?: return emptyPaginationResult()
+        val list = locker.withReadAcquire {
+            map[k] ?: return emptyPaginationResult()
+        }
 
         return list.paginate(
             if (reversed) {
@@ -21,7 +27,9 @@ class MapReadKeyValuesRepo<Key, Value>(
     }
 
     override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> {
-        val keys = map.keys
+        val keys = locker.withReadAcquire {
+            map.keys
+        }
         val actualPagination = if (reversed) pagination.reverse(keys.size) else pagination
         return keys.paginate(actualPagination).let {
             if (reversed) {
@@ -33,7 +41,9 @@ class MapReadKeyValuesRepo<Key, Value>(
     }
 
     override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> {
-        val keys = map.keys.filter { map[it] ?.contains(v) == true }
+        val keys = locker.withReadAcquire {
+            map.keys.filter { map[it] ?.contains(v) == true }
+        }
         val actualPagination = if (reversed) pagination.reverse(keys.size) else pagination
         return keys.paginate(actualPagination).let {
             if (reversed) {
@@ -44,17 +54,18 @@ class MapReadKeyValuesRepo<Key, Value>(
         }
     }
 
-    override suspend fun contains(k: Key): Boolean = map.containsKey(k)
+    override suspend fun contains(k: Key): Boolean = locker.withReadAcquire { map.containsKey(k) }
 
-    override suspend fun contains(k: Key, v: Value): Boolean = map[k] ?.contains(v) == true
+    override suspend fun contains(k: Key, v: Value): Boolean = locker.withReadAcquire { map[k] ?.contains(v) } == true
 
-    override suspend fun count(k: Key): Long = map[k] ?.size ?.toLong() ?: 0L
+    override suspend fun count(k: Key): Long = locker.withReadAcquire { map[k] ?.size } ?.toLong() ?: 0L
 
-    override suspend fun count(): Long = map.size.toLong()
+    override suspend fun count(): Long = locker.withReadAcquire { map.size }.toLong()
 }
 
 class MapWriteKeyValuesRepo<Key, Value>(
-    private val map: MutableMap<Key, MutableList<Value>> = mutableMapOf()
+    private val map: MutableMap<Key, MutableList<Value>> = mutableMapOf(),
+    private val locker: SmartRWLocker = SmartRWLocker()
 ) : WriteKeyValuesRepo<Key, Value> {
     private val _onNewValue: MutableSharedFlow<Pair<Key, Value>> = MutableSharedFlow()
     override val onNewValue: Flow<Pair<Key, Value>> = _onNewValue.asSharedFlow()
@@ -64,49 +75,59 @@ class MapWriteKeyValuesRepo<Key, Value>(
     override val onDataCleared: Flow<Key> = _onDataCleared.asSharedFlow()
 
     override suspend fun add(toAdd: Map<Key, List<Value>>) {
-        toAdd.keys.forEach { k ->
-            if (map.getOrPut(k) { mutableListOf() }.addAll(toAdd[k] ?: return@forEach)) {
-                toAdd[k] ?.forEach { v ->
-                    _onNewValue.emit(k to v)
+        locker.withWriteLock {
+            toAdd.keys.forEach { k ->
+                if (map.getOrPut(k) { mutableListOf() }.addAll(toAdd[k] ?: return@forEach)) {
+                    toAdd[k] ?.forEach { v ->
+                        _onNewValue.emit(k to v)
+                    }
                 }
             }
         }
     }
 
     override suspend fun remove(toRemove: Map<Key, List<Value>>) {
-        toRemove.keys.forEach { k ->
-            if (map[k] ?.removeAll(toRemove[k] ?: return@forEach) == true) {
-                toRemove[k] ?.forEach { v ->
-                    _onValueRemoved.emit(k to v)
+        locker.withWriteLock {
+            toRemove.keys.forEach { k ->
+                if (map[k]?.removeAll(toRemove[k] ?: return@forEach) == true) {
+                    toRemove[k]?.forEach { v ->
+                        _onValueRemoved.emit(k to v)
+                    }
+                }
+                if (map[k]?.isEmpty() == true) {
+                    map.remove(k)
+                    _onDataCleared.emit(k)
                 }
-            }
-            if (map[k] ?.isEmpty() == true) {
-                map.remove(k)
-                _onDataCleared.emit(k)
             }
         }
     }
 
     override suspend fun removeWithValue(v: Value) {
-        map.forEach { (k, values) ->
-            if (values.remove(v)) {
-                _onValueRemoved.emit(k to v)
+        locker.withWriteLock {
+            map.forEach { (k, values) ->
+                if (values.remove(v)) {
+                    _onValueRemoved.emit(k to v)
+                }
             }
         }
     }
 
     override suspend fun clear(k: Key) {
-        map.remove(k) ?.also { _onDataCleared.emit(k) }
+        locker.withWriteLock {
+            map.remove(k) ?.also { _onDataCleared.emit(k) }
+        }
     }
 
     override suspend fun clearWithValue(v: Value) {
-        map.filter { (_, values) ->
-            values.contains(v)
-        }.forEach {
-            map.remove(it.key) ?.onEach { v ->
-                _onValueRemoved.emit(it.key to v)
-            } ?.also { _ ->
-                _onDataCleared.emit(it.key)
+        locker.withWriteLock {
+            map.filter { (_, values) ->
+                values.contains(v)
+            }.forEach {
+                map.remove(it.key)?.onEach { v ->
+                    _onValueRemoved.emit(it.key to v)
+                }?.also { _ ->
+                    _onDataCleared.emit(it.key)
+                }
             }
         }
     }
@@ -114,11 +135,13 @@ class MapWriteKeyValuesRepo<Key, Value>(
 
 @Suppress("DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE")
 class MapKeyValuesRepo<Key, Value>(
-    private val map: MutableMap<Key, MutableList<Value>> = mutableMapOf()
+    private val map: MutableMap<Key, MutableList<Value>> = mutableMapOf(),
+    private val locker: SmartRWLocker = SmartRWLocker()
 ) : KeyValuesRepo<Key, Value>,
-    ReadKeyValuesRepo<Key, Value> by MapReadKeyValuesRepo(map),
-    WriteKeyValuesRepo<Key, Value> by MapWriteKeyValuesRepo(map)
+    ReadKeyValuesRepo<Key, Value> by MapReadKeyValuesRepo(map, locker),
+    WriteKeyValuesRepo<Key, Value> by MapWriteKeyValuesRepo(map, locker)
 
-fun <K, V> MutableMap<K, List<V>>.asKeyValuesRepo(): KeyValuesRepo<K, V> = MapKeyValuesRepo(
-    map { (k, v) -> k to v.toMutableList() }.toMap().toMutableMap()
+fun <K, V> MutableMap<K, List<V>>.asKeyValuesRepo(locker: SmartRWLocker = SmartRWLocker()): KeyValuesRepo<K, V> = MapKeyValuesRepo(
+    map { (k, v) -> k to v.toMutableList() }.toMap().toMutableMap(),
+    locker
 )