change order of functions in read one to many interface

0.2.1

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.2.2
+
+* `Repos`
+    * `Common`
+        * Several new methods `ReadOneToManyKeyValueRepo#getAll`
+        * Several new method `WriteOneToManyKeyValueRepo#add` and several extensions
+        * Several new method `WriteOneToManyKeyValueRepo#remove` and several extensions
+
 ## 0.2.1
 
 * `Pagination`
@@ -7,6 +15,7 @@
         * Extension `Pagination#reverse` has been added
         * Factory `PaginationByIndexes`
         * Shortcut `calculatePagesNumber` with reversed parameters
+        * Value `emptyPagination` for empty `SimplePagination` cases
 
 ## 0.2.0
 

gradle.properties

@@ -19,4 +19,4 @@ github_release_plugin_version=2.2.12
 uuidVersion=0.2.2
 
 group=dev.inmo
-version=0.2.1
+version=0.2.2

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/SimplePagination.kt

@@ -14,6 +14,8 @@ inline fun FirstPagePagination(size: Int = defaultMediumPageSize) =
         size = size
     )
 
+val emptyPagination = Pagination(0, 0)
+
 @Suppress("NOTHING_TO_INLINE")
 inline fun Pagination.nextPage() =
     SimplePagination(

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/utils/PaginationReversing.kt

@@ -10,22 +10,16 @@ import dev.inmo.micro_utils.pagination.*
  *
  * @return Reversed version of this [Pagination]
  */
-fun Pagination.reverse(objectsCount: Long): SimplePagination {
+fun Pagination.reverse(datasetSize: Long): SimplePagination {
-    val firstIndex = (objectsCount - (this.lastIndex + 1)).let {
+    val pagesNumber = calculatePagesNumber(size, datasetSize)
-        when {
+    val newPage = pagesNumber - page - 1
-            it < 0 -> it
+    return when {
-            it > objectsCount -> objectsCount
+        page < 0 || page >= pagesNumber -> emptyPagination
-            else -> it
+        else -> Pagination(
-        }
+            newPage,
-    }.toInt()
+            size
-    val lastIndex = (objectsCount - (this.firstIndex + 1)).let {
+        )
-        when {
+    }
-            it < 0 -> it
-            it > objectsCount -> objectsCount
-            else -> it
-        }
-    }.toInt()
-    return PaginationByIndexes(firstIndex, lastIndex)
 }
 
 /**

pagination/common/src/commonTest/kotlin/dev/inmo/micro_utils/pagination/utils/PaginationReversing.kt

@@ -7,18 +7,18 @@ import kotlin.test.assertEquals
 class PaginationReversingTests {
     @Test
     fun testThatCommonCaseWorksOk() {
-        val pageSize = 2
+        val pageSize = 3
-        val collectionSize = 8
+        val collectionSize = 9
-        val pages = calculatePage(collectionSize, pageSize)
 
-        doWithPagination(FirstPagePagination(pageSize)) {
+        assertEquals(Pagination(-1, pageSize).reverse(collectionSize), Pagination(0, 0))
-            val reversed = it.reverse(collectionSize.toLong())
+
-            assertEquals(Pagination(calculatePage(collectionSize - it.firstIndex - it.size, it.size), it.size), reversed)
+        val middleFirstIndex = collectionSize / 2 - pageSize / 2
-            if (it.page < pages) {
+        val middleLastIndex = middleFirstIndex + pageSize - 1
-                it.nextPage()
+        assertEquals(
-            } else {
+            PaginationByIndexes(middleFirstIndex, middleLastIndex).reverse(collectionSize),
-                null
+            PaginationByIndexes(middleFirstIndex, middleLastIndex)
-            }
+        )
-        }
+
+        assertEquals(Pagination(calculatePagesNumber(collectionSize, pageSize), pageSize).reverse(collectionSize), Pagination(0, 0))
     }
 }

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/OneToManyKeyValueRepo.kt

@@ -1,7 +1,6 @@
 package dev.inmo.micro_utils.repos
 
-import dev.inmo.micro_utils.pagination.Pagination
+import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.pagination.PaginationResult
 import kotlinx.coroutines.flow.Flow
 
 interface ReadOneToManyKeyValueRepo<Key, Value> : Repo {
@@ -11,6 +10,30 @@ interface ReadOneToManyKeyValueRepo<Key, Value> : Repo {
     suspend fun contains(k: Key, v: Value): Boolean
     suspend fun count(k: Key): Long
     suspend fun count(): Long
+
+    suspend fun getAll(k: Key, reversed: Boolean = false): List<Value> = mutableListOf<Value>().also { list ->
+        doWithPagination {
+            get(k, it).also {
+                list.addAll(it.results)
+            }.nextPageIfNotEmpty()
+        }
+        if (reversed) {
+            list.reverse()
+        }
+    }
+
+    /**
+     * WARNING!!! THIS METHOD PROBABLY IS NOT EFFICIENT, USE WITH CAUTION
+     */
+    suspend fun getAll(reverseLists: Boolean = false): Map<Key, List<Value>> = mutableMapOf<Key, List<Value>>().also { map ->
+        doWithPagination {
+            keys(it).also { paginationResult ->
+                paginationResult.results.forEach { k ->
+                    map[k] = getAll(k, reverseLists)
+                }
+            }.nextPageIfNotEmpty()
+        }
+    }
 }
 @Deprecated("Renamed", ReplaceWith("ReadOneToManyKeyValueRepo", "dev.inmo.micro_utils.repos.ReadOneToManyKeyValueRepo"))
 typealias OneToManyReadKeyValueRepo<Key, Value> = ReadOneToManyKeyValueRepo<Key, Value>
@@ -20,11 +43,51 @@ interface WriteOneToManyKeyValueRepo<Key, Value> : Repo {
     val onValueRemoved: Flow<Pair<Key, Value>>
     val onDataCleared: Flow<Key>
 
+    suspend fun add(toAdd: Map<Key, List<Value>>) = toAdd.forEach { (k, values) ->
+        values.forEach { v ->
+            add(k, v)
+        }
+    }
+    @Deprecated("Will be extracted as extension for other add method")
     suspend fun add(k: Key, v: Value)
+
+    suspend fun remove(toRemove: Map<Key, List<Value>>) = toRemove.forEach { (k, values) ->
+        values.forEach { v ->
+            remove(k, v)
+        }
+    }
+    @Deprecated("Will be extracted as extension for other remove method")
     suspend fun remove(k: Key, v: Value)
+
     suspend fun clear(k: Key)
 }
 @Deprecated("Renamed", ReplaceWith("WriteOneToManyKeyValueRepo", "dev.inmo.micro_utils.repos.WriteOneToManyKeyValueRepo"))
 typealias OneToManyWriteKeyValueRepo<Key, Value> = WriteOneToManyKeyValueRepo<Key, Value>
 
-interface OneToManyKeyValueRepo<Key, Value> : ReadOneToManyKeyValueRepo<Key, Value>, WriteOneToManyKeyValueRepo<Key, Value>
+interface OneToManyKeyValueRepo<Key, Value> : ReadOneToManyKeyValueRepo<Key, Value>, WriteOneToManyKeyValueRepo<Key, Value>
+
+suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.add(
+    k: Key,
+    vararg v: Value
+) = add(mapOf(k to v.toList()))
+
+suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.add(
+    keysAndValues: List<Pair<Key, List<Value>>>
+) = add(keysAndValues.toMap())
+
+suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.add(
+    vararg keysAndValues: Pair<Key, List<Value>>
+) = add(keysAndValues.toMap())
+
+suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.remove(
+    k: Key,
+    vararg v: Value
+) = remove(mapOf(k to v.toList()))
+
+suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.remove(
+    keysAndValues: List<Pair<Key, List<Value>>>
+) = remove(keysAndValues.toMap())
+
+suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.remove(
+    vararg keysAndValues: Pair<Key, List<Value>>
+) = remove(keysAndValues.toMap())

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/pagination/KeyValuePaginationExtensions.kt

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.repos.pagination
 
 import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
 
 suspend inline fun <Key, Value, REPO : ReadStandardKeyValueRepo<Key, Value>> REPO.doForAll(
     @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/pagination/OneToManyPaginationExtensions.kt

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.repos.pagination
 
 import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.ReadOneToManyKeyValueRepo
 
 suspend inline fun <Key, Value, REPO : ReadOneToManyKeyValueRepo<Key, Value>> REPO.doForAll(
     @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")