From eab2f96f02ae26a8ede7002327e39bb9b5c3a428 Mon Sep 17 00:00:00 2001
From: David Kaspar <david.kaspar@gmail.com>
Date: Sat, 16 Aug 2025 10:20:52 +0100
Subject: [PATCH] remove duplicate colletors and Use collectors from new
 utility class

---
 .../vitorpamplona/quartz/utils/LargeCache.kt  | 400 ++----------------
 .../quartz/utils/LargeSoftCache.kt            | 400 ++----------------
 2 files changed, 66 insertions(+), 734 deletions(-)

diff --git a/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeCache.kt b/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeCache.kt
index bd61c05d1..4254d94bf 100644
--- a/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeCache.kt
+++ b/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeCache.kt
@@ -80,116 +80,116 @@ class LargeCache<K, V> {
         innerForEach(consumer)
     }
 
-    fun filter(consumer: BiFilter<K, V>): List<V> {
-        val runner = BiFilterCollector(consumer)
+    fun filter(consumer: CacheCollectors.BiFilter<K, V>): List<V> {
+        val runner = CacheCollectors.BiFilterCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
-    fun filterIntoSet(consumer: BiFilter<K, V>): Set<V> {
-        val runner = BiFilterUniqueCollector(consumer)
+    fun filterIntoSet(consumer: CacheCollectors.BiFilter<K, V>): Set<V> {
+        val runner = CacheCollectors.BiFilterUniqueCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
-    fun <R> map(consumer: BiNotNullMapper<K, V, R>): List<R> {
-        val runner = BiNotNullMapCollector(consumer)
+    fun <R> map(consumer: CacheCollectors.BiNotNullMapper<K, V, R>): List<R> {
+        val runner = CacheCollectors.BiNotNullMapCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
-    fun <R> mapNotNull(consumer: BiMapper<K, V, R?>): List<R> {
-        val runner = BiMapCollector(consumer)
+    fun <R> mapNotNull(consumer: CacheCollectors.BiMapper<K, V, R?>): List<R> {
+        val runner = CacheCollectors.BiMapCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
-    fun <R> mapNotNullIntoSet(consumer: BiMapper<K, V, R?>): Set<R> {
-        val runner = BiMapUniqueCollector(consumer)
+    fun <R> mapNotNullIntoSet(consumer: CacheCollectors.BiMapper<K, V, R?>): Set<R> {
+        val runner = CacheCollectors.BiMapUniqueCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
-    fun <R> mapFlatten(consumer: BiMapper<K, V, Collection<R>?>): List<R> {
-        val runner = BiMapFlattenCollector(consumer)
+    fun <R> mapFlatten(consumer: CacheCollectors.BiMapper<K, V, Collection<R>?>): List<R> {
+        val runner = CacheCollectors.BiMapFlattenCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
-    fun <R> mapFlattenIntoSet(consumer: BiMapper<K, V, Collection<R>?>): Set<R> {
-        val runner = BiMapFlattenUniqueCollector(consumer)
+    fun <R> mapFlattenIntoSet(consumer: CacheCollectors.BiMapper<K, V, Collection<R>?>): Set<R> {
+        val runner = CacheCollectors.BiMapFlattenUniqueCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
     fun maxOrNullOf(
-        filter: BiFilter<K, V>,
+        filter: CacheCollectors.BiFilter<K, V>,
         comparator: Comparator<V>,
     ): V? {
-        val runner = BiMaxOfCollector(filter, comparator)
+        val runner = CacheCollectors.BiMaxOfCollector(filter, comparator)
         innerForEach(runner)
         return runner.maxV
     }
 
-    fun sumOf(consumer: BiSumOf<K, V>): Int {
-        val runner = BiSumOfCollector(consumer)
+    fun sumOf(consumer: CacheCollectors.BiSumOf<K, V>): Int {
+        val runner = CacheCollectors.BiSumOfCollector(consumer)
         innerForEach(runner)
         return runner.sum
     }
 
-    fun sumOfLong(consumer: BiSumOfLong<K, V>): Long {
-        val runner = BiSumOfLongCollector(consumer)
+    fun sumOfLong(consumer: CacheCollectors.BiSumOfLong<K, V>): Long {
+        val runner = CacheCollectors.BiSumOfLongCollector(consumer)
         innerForEach(runner)
         return runner.sum
     }
 
-    fun <R> groupBy(consumer: BiNotNullMapper<K, V, R>): Map<R, List<V>> {
-        val runner = BiGroupByCollector(consumer)
+    fun <R> groupBy(consumer: CacheCollectors.BiNotNullMapper<K, V, R>): Map<R, List<V>> {
+        val runner = CacheCollectors.BiGroupByCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
-    fun <R> countByGroup(consumer: BiNotNullMapper<K, V, R>): Map<R, Int> {
-        val runner = BiCountByGroupCollector(consumer)
+    fun <R> countByGroup(consumer: CacheCollectors.BiNotNullMapper<K, V, R>): Map<R, Int> {
+        val runner = CacheCollectors.BiCountByGroupCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
     fun <R> sumByGroup(
-        groupMap: BiNotNullMapper<K, V, R>,
-        sumOf: BiNotNullMapper<K, V, Long>,
+        groupMap: CacheCollectors.BiNotNullMapper<K, V, R>,
+        sumOf: CacheCollectors.BiNotNullMapper<K, V, Long>,
     ): Map<R, Long> {
-        val runner = BiSumByGroupCollector(groupMap, sumOf)
+        val runner = CacheCollectors.BiSumByGroupCollector(groupMap, sumOf)
         innerForEach(runner)
         return runner.results
     }
 
-    fun count(consumer: BiFilter<K, V>): Int {
-        val runner = BiCountIfCollector(consumer)
+    fun count(consumer: CacheCollectors.BiFilter<K, V>): Int {
+        val runner = CacheCollectors.BiCountIfCollector(consumer)
         innerForEach(runner)
         return runner.count
     }
 
     fun <T, U> associate(transform: (K, V) -> Pair<T, U>): Map<T, U> {
-        val runner = BiAssociateCollector(size(), transform)
+        val runner = CacheCollectors.BiAssociateCollector(size(), transform)
         innerForEach(runner)
         return runner.results
     }
 
     fun <T, U> associateNotNull(transform: (K, V) -> Pair<T, U>?): Map<T, U> {
-        val runner = BiAssociateNotNullCollector(size(), transform)
+        val runner = CacheCollectors.BiAssociateNotNullCollector(size(), transform)
         innerForEach(runner)
         return runner.results
     }
 
     fun <U> associateWith(transform: (K, V) -> U?): Map<K, U?> {
-        val runner = BiAssociateWithCollector(size(), transform)
+        val runner = CacheCollectors.BiAssociateWithCollector(size(), transform)
         innerForEach(runner)
         return runner.results
     }
 
     fun <U> associateNotNullWith(transform: (K, V) -> U): Map<K, U> {
-        val runner = BiAssociateNotNullWithCollector(size(), transform)
+        val runner = CacheCollectors.BiAssociateNotNullWithCollector(size(), transform)
         innerForEach(runner)
         return runner.results
     }
@@ -227,338 +227,4 @@ class LargeCache<K, V> {
         buffer.append(postfix)
         return buffer.toString()
     }
-
-    fun interface BiFilter<K, V> {
-        fun filter(
-            k: K,
-            v: V,
-        ): Boolean
-    }
-
-    class BiFilterCollector<K, V>(
-        val filter: BiFilter<K, V>,
-    ) : BiConsumer<K, V> {
-        var results: ArrayList<V> = ArrayList()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            if (filter.filter(k, v)) {
-                results.add(v)
-            }
-        }
-    }
-
-    class BiFilterUniqueCollector<K, V>(
-        val filter: BiFilter<K, V>,
-    ) : BiConsumer<K, V> {
-        var results: HashSet<V> = HashSet()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            if (filter.filter(k, v)) {
-                results.add(v)
-            }
-        }
-    }
-
-    fun interface BiMapper<K, V, R> {
-        fun map(
-            k: K,
-            v: V,
-        ): R?
-    }
-
-    fun interface BiMapperNotNull<K, V, R> {
-        fun map(
-            k: K,
-            v: V,
-        ): R
-    }
-
-    class BiMapCollector<K, V, R>(
-        val mapper: BiMapper<K, V, R?>,
-    ) : BiConsumer<K, V> {
-        var results: ArrayList<R> = ArrayList()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val result = mapper.map(k, v)
-            if (result != null) {
-                results.add(result)
-            }
-        }
-    }
-
-    class BiAssociateCollector<K, V, T, U>(
-        val size: Int,
-        val mapper: BiMapperNotNull<K, V, Pair<T, U>>,
-    ) : BiConsumer<K, V> {
-        var results: LinkedHashMap<T, U> = LinkedHashMap(size)
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val pair = mapper.map(k, v)
-            results.put(pair.first, pair.second)
-        }
-    }
-
-    class BiAssociateNotNullCollector<K, V, T, U>(
-        val size: Int,
-        val mapper: BiMapper<K, V, Pair<T, U>?>,
-    ) : BiConsumer<K, V> {
-        var results: LinkedHashMap<T, U> = LinkedHashMap(size)
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val pair = mapper.map(k, v)
-            if (pair != null) {
-                results.put(pair.first, pair.second)
-            }
-        }
-    }
-
-    class BiAssociateWithCollector<K, V, U>(
-        val size: Int,
-        val mapper: BiMapper<K, V, U?>,
-    ) : BiConsumer<K, V> {
-        var results: LinkedHashMap<K, U?> = LinkedHashMap(size)
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            results.put(k, mapper.map(k, v))
-        }
-    }
-
-    class BiAssociateNotNullWithCollector<K, V, U>(
-        val size: Int,
-        val mapper: BiMapper<K, V, U>,
-    ) : BiConsumer<K, V> {
-        var results: LinkedHashMap<K, U> = LinkedHashMap(size)
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val newValue = mapper.map(k, v)
-            if (newValue != null) {
-                results.put(k, newValue)
-            }
-        }
-    }
-
-    class BiMapUniqueCollector<K, V, R>(
-        val mapper: BiMapper<K, V, R?>,
-    ) : BiConsumer<K, V> {
-        var results: HashSet<R> = HashSet()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val result = mapper.map(k, v)
-            if (result != null) {
-                results.add(result)
-            }
-        }
-    }
-
-    class BiMapFlattenCollector<K, V, R>(
-        val mapper: BiMapper<K, V, Collection<R>?>,
-    ) : BiConsumer<K, V> {
-        var results: ArrayList<R> = ArrayList()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val result = mapper.map(k, v)
-            if (result != null) {
-                results.addAll(result)
-            }
-        }
-    }
-
-    class BiMapFlattenUniqueCollector<K, V, R>(
-        val mapper: BiMapper<K, V, Collection<R>?>,
-    ) : BiConsumer<K, V> {
-        var results: HashSet<R> = HashSet()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val result = mapper.map(k, v)
-            if (result != null) {
-                results.addAll(result)
-            }
-        }
-    }
-
-    fun interface BiNotNullMapper<K, V, R> {
-        fun map(
-            k: K,
-            v: V,
-        ): R
-    }
-
-    class BiNotNullMapCollector<K, V, R>(
-        val mapper: BiNotNullMapper<K, V, R>,
-    ) : BiConsumer<K, V> {
-        var results: ArrayList<R> = ArrayList()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            results.add(mapper.map(k, v))
-        }
-    }
-
-    fun interface BiSumOf<K, V> {
-        fun map(
-            k: K,
-            v: V,
-        ): Int
-    }
-
-    class BiMaxOfCollector<K, V>(
-        val filter: BiFilter<K, V>,
-        val comparator: Comparator<V>,
-    ) : BiConsumer<K, V> {
-        var maxK: K? = null
-        var maxV: V? = null
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            if (filter.filter(k, v)) {
-                if (maxK == null || comparator.compare(v, maxV) > 0) {
-                    maxK = k
-                    maxV = v
-                }
-            }
-        }
-    }
-
-    class BiSumOfCollector<K, V>(
-        val mapper: BiSumOf<K, V>,
-    ) : BiConsumer<K, V> {
-        var sum = 0
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            sum += mapper.map(k, v)
-        }
-    }
-
-    fun interface BiSumOfLong<K, V> {
-        fun map(
-            k: K,
-            v: V,
-        ): Long
-    }
-
-    class BiSumOfLongCollector<K, V>(
-        val mapper: BiSumOfLong<K, V>,
-    ) : BiConsumer<K, V> {
-        var sum = 0L
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            sum += mapper.map(k, v)
-        }
-    }
-
-    class BiGroupByCollector<K, V, R>(
-        val mapper: BiNotNullMapper<K, V, R>,
-    ) : BiConsumer<K, V> {
-        var results = HashMap<R, ArrayList<V>>()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val group = mapper.map(k, v)
-
-            val list = results[group]
-            if (list == null) {
-                val answer = ArrayList<V>()
-                answer.add(v)
-                results[group] = answer
-            } else {
-                list.add(v)
-            }
-        }
-    }
-
-    class BiCountByGroupCollector<K, V, R>(
-        val mapper: BiNotNullMapper<K, V, R>,
-    ) : BiConsumer<K, V> {
-        var results = HashMap<R, Int>()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val group = mapper.map(k, v)
-
-            val count = results[group]
-            if (count == null) {
-                results[group] = 1
-            } else {
-                results[group] = count + 1
-            }
-        }
-    }
-
-    class BiSumByGroupCollector<K, V, R>(
-        val mapper: BiNotNullMapper<K, V, R>,
-        val sumOf: BiNotNullMapper<K, V, Long>,
-    ) : BiConsumer<K, V> {
-        var results = HashMap<R, Long>()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val group = mapper.map(k, v)
-
-            val sum = results[group]
-            if (sum == null) {
-                results[group] = sumOf.map(k, v)
-            } else {
-                results[group] = sum + sumOf.map(k, v)
-            }
-        }
-    }
-
-    class BiCountIfCollector<K, V>(
-        val filter: BiFilter<K, V>,
-    ) : BiConsumer<K, V> {
-        var count = 0
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            if (filter.filter(k, v)) count++
-        }
-    }
 }
diff --git a/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeSoftCache.kt b/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeSoftCache.kt
index 50f539bd6..6f1c90c55 100644
--- a/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeSoftCache.kt
+++ b/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeSoftCache.kt
@@ -126,116 +126,116 @@ class LargeSoftCache<K, V> {
         innerForEach(consumer)
     }
 
-    fun filter(consumer: BiFilter<K, V>): List<V> {
-        val runner = BiFilterCollector(consumer)
+    fun filter(consumer: CacheCollectors.BiFilter<K, V>): List<V> {
+        val runner = CacheCollectors.BiFilterCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
-    fun filterIntoSet(consumer: BiFilter<K, V>): Set<V> {
-        val runner = BiFilterUniqueCollector(consumer)
+    fun filterIntoSet(consumer: CacheCollectors.BiFilter<K, V>): Set<V> {
+        val runner = CacheCollectors.BiFilterUniqueCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
-    fun <R> map(consumer: BiNotNullMapper<K, V, R>): List<R> {
-        val runner = BiNotNullMapCollector(consumer)
+    fun <R> map(consumer: CacheCollectors.BiNotNullMapper<K, V, R>): List<R> {
+        val runner = CacheCollectors.BiNotNullMapCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
-    fun <R> mapNotNull(consumer: BiMapper<K, V, R?>): List<R> {
-        val runner = BiMapCollector(consumer)
+    fun <R> mapNotNull(consumer: CacheCollectors.BiMapper<K, V, R?>): List<R> {
+        val runner = CacheCollectors.BiMapCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
-    fun <R> mapNotNullIntoSet(consumer: BiMapper<K, V, R?>): Set<R> {
-        val runner = BiMapUniqueCollector(consumer)
+    fun <R> mapNotNullIntoSet(consumer: CacheCollectors.BiMapper<K, V, R?>): Set<R> {
+        val runner = CacheCollectors.BiMapUniqueCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
-    fun <R> mapFlatten(consumer: BiMapper<K, V, Collection<R>?>): List<R> {
-        val runner = BiMapFlattenCollector(consumer)
+    fun <R> mapFlatten(consumer: CacheCollectors.BiMapper<K, V, Collection<R>?>): List<R> {
+        val runner = CacheCollectors.BiMapFlattenCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
-    fun <R> mapFlattenIntoSet(consumer: BiMapper<K, V, Collection<R>?>): Set<R> {
-        val runner = BiMapFlattenUniqueCollector(consumer)
+    fun <R> mapFlattenIntoSet(consumer: CacheCollectors.BiMapper<K, V, Collection<R>?>): Set<R> {
+        val runner = CacheCollectors.BiMapFlattenUniqueCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
     fun maxOrNullOf(
-        filter: BiFilter<K, V>,
+        filter: CacheCollectors.BiFilter<K, V>,
         comparator: Comparator<V>,
     ): V? {
-        val runner = BiMaxOfCollector(filter, comparator)
+        val runner = CacheCollectors.BiMaxOfCollector(filter, comparator)
         innerForEach(runner)
         return runner.maxV
     }
 
-    fun sumOf(consumer: BiSumOf<K, V>): Int {
-        val runner = BiSumOfCollector(consumer)
+    fun sumOf(consumer: CacheCollectors.BiSumOf<K, V>): Int {
+        val runner = CacheCollectors.BiSumOfCollector(consumer)
         innerForEach(runner)
         return runner.sum
     }
 
-    fun sumOfLong(consumer: BiSumOfLong<K, V>): Long {
-        val runner = BiSumOfLongCollector(consumer)
+    fun sumOfLong(consumer: CacheCollectors.BiSumOfLong<K, V>): Long {
+        val runner = CacheCollectors.BiSumOfLongCollector(consumer)
         innerForEach(runner)
         return runner.sum
     }
 
-    fun <R> groupBy(consumer: BiNotNullMapper<K, V, R>): Map<R, List<V>> {
-        val runner = BiGroupByCollector(consumer)
+    fun <R> groupBy(consumer: CacheCollectors.BiNotNullMapper<K, V, R>): Map<R, List<V>> {
+        val runner = CacheCollectors.BiGroupByCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
-    fun <R> countByGroup(consumer: BiNotNullMapper<K, V, R>): Map<R, Int> {
-        val runner = BiCountByGroupCollector(consumer)
+    fun <R> countByGroup(consumer: CacheCollectors.BiNotNullMapper<K, V, R>): Map<R, Int> {
+        val runner = CacheCollectors.BiCountByGroupCollector(consumer)
         innerForEach(runner)
         return runner.results
     }
 
     fun <R> sumByGroup(
-        groupMap: BiNotNullMapper<K, V, R>,
-        sumOf: BiNotNullMapper<K, V, Long>,
+        groupMap: CacheCollectors.BiNotNullMapper<K, V, R>,
+        sumOf: CacheCollectors.BiNotNullMapper<K, V, Long>,
     ): Map<R, Long> {
-        val runner = BiSumByGroupCollector(groupMap, sumOf)
+        val runner = CacheCollectors.BiSumByGroupCollector(groupMap, sumOf)
         innerForEach(runner)
         return runner.results
     }
 
-    fun count(consumer: BiFilter<K, V>): Int {
-        val runner = BiCountIfCollector(consumer)
+    fun count(consumer: CacheCollectors.BiFilter<K, V>): Int {
+        val runner = CacheCollectors.BiCountIfCollector(consumer)
         innerForEach(runner)
         return runner.count
     }
 
     fun <T, U> associate(transform: (K, V) -> Pair<T, U>): Map<T, U> {
-        val runner = BiAssociateCollector(size(), transform)
+        val runner = CacheCollectors.BiAssociateCollector(size(), transform)
         innerForEach(runner)
         return runner.results
     }
 
     fun <T, U> associateNotNull(transform: (K, V) -> Pair<T, U>?): Map<T, U> {
-        val runner = BiAssociateNotNullCollector(size(), transform)
+        val runner = CacheCollectors.BiAssociateNotNullCollector(size(), transform)
         innerForEach(runner)
         return runner.results
     }
 
     fun <U> associateWith(transform: (K, V) -> U?): Map<K, U?> {
-        val runner = BiAssociateWithCollector(size(), transform)
+        val runner = CacheCollectors.BiAssociateWithCollector(size(), transform)
         innerForEach(runner)
         return runner.results
     }
 
     fun <U> associateNotNullWith(transform: (K, V) -> U): Map<K, U> {
-        val runner = BiAssociateNotNullWithCollector(size(), transform)
+        val runner = CacheCollectors.BiAssociateNotNullWithCollector(size(), transform)
         innerForEach(runner)
         return runner.results
     }
@@ -290,338 +290,4 @@ class LargeSoftCache<K, V> {
             }
         }
     }
-
-    fun interface BiFilter<K, V> {
-        fun filter(
-            k: K,
-            v: V,
-        ): Boolean
-    }
-
-    class BiFilterCollector<K, V>(
-        val filter: BiFilter<K, V>,
-    ) : BiConsumer<K, V> {
-        var results: ArrayList<V> = ArrayList()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            if (filter.filter(k, v)) {
-                results.add(v)
-            }
-        }
-    }
-
-    class BiFilterUniqueCollector<K, V>(
-        val filter: BiFilter<K, V>,
-    ) : BiConsumer<K, V> {
-        var results: HashSet<V> = HashSet()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            if (filter.filter(k, v)) {
-                results.add(v)
-            }
-        }
-    }
-
-    fun interface BiMapper<K, V, R> {
-        fun map(
-            k: K,
-            v: V,
-        ): R?
-    }
-
-    fun interface BiMapperNotNull<K, V, R> {
-        fun map(
-            k: K,
-            v: V,
-        ): R
-    }
-
-    class BiMapCollector<K, V, R>(
-        val mapper: BiMapper<K, V, R?>,
-    ) : BiConsumer<K, V> {
-        var results: ArrayList<R> = ArrayList()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val result = mapper.map(k, v)
-            if (result != null) {
-                results.add(result)
-            }
-        }
-    }
-
-    class BiAssociateCollector<K, V, T, U>(
-        val size: Int,
-        val mapper: BiMapperNotNull<K, V, Pair<T, U>>,
-    ) : BiConsumer<K, V> {
-        var results: LinkedHashMap<T, U> = LinkedHashMap(size)
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val pair = mapper.map(k, v)
-            results.put(pair.first, pair.second)
-        }
-    }
-
-    class BiAssociateNotNullCollector<K, V, T, U>(
-        val size: Int,
-        val mapper: BiMapper<K, V, Pair<T, U>?>,
-    ) : BiConsumer<K, V> {
-        var results: LinkedHashMap<T, U> = LinkedHashMap(size)
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val pair = mapper.map(k, v)
-            if (pair != null) {
-                results.put(pair.first, pair.second)
-            }
-        }
-    }
-
-    class BiAssociateWithCollector<K, V, U>(
-        val size: Int,
-        val mapper: BiMapper<K, V, U?>,
-    ) : BiConsumer<K, V> {
-        var results: LinkedHashMap<K, U?> = LinkedHashMap(size)
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            results.put(k, mapper.map(k, v))
-        }
-    }
-
-    class BiAssociateNotNullWithCollector<K, V, U>(
-        val size: Int,
-        val mapper: BiMapper<K, V, U>,
-    ) : BiConsumer<K, V> {
-        var results: LinkedHashMap<K, U> = LinkedHashMap(size)
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val newValue = mapper.map(k, v)
-            if (newValue != null) {
-                results.put(k, newValue)
-            }
-        }
-    }
-
-    class BiMapUniqueCollector<K, V, R>(
-        val mapper: BiMapper<K, V, R?>,
-    ) : BiConsumer<K, V> {
-        var results: HashSet<R> = HashSet()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val result = mapper.map(k, v)
-            if (result != null) {
-                results.add(result)
-            }
-        }
-    }
-
-    class BiMapFlattenCollector<K, V, R>(
-        val mapper: BiMapper<K, V, Collection<R>?>,
-    ) : BiConsumer<K, V> {
-        var results: ArrayList<R> = ArrayList()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val result = mapper.map(k, v)
-            if (result != null) {
-                results.addAll(result)
-            }
-        }
-    }
-
-    class BiMapFlattenUniqueCollector<K, V, R>(
-        val mapper: BiMapper<K, V, Collection<R>?>,
-    ) : BiConsumer<K, V> {
-        var results: HashSet<R> = HashSet()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val result = mapper.map(k, v)
-            if (result != null) {
-                results.addAll(result)
-            }
-        }
-    }
-
-    fun interface BiNotNullMapper<K, V, R> {
-        fun map(
-            k: K,
-            v: V,
-        ): R
-    }
-
-    class BiNotNullMapCollector<K, V, R>(
-        val mapper: BiNotNullMapper<K, V, R>,
-    ) : BiConsumer<K, V> {
-        var results: ArrayList<R> = ArrayList()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            results.add(mapper.map(k, v))
-        }
-    }
-
-    fun interface BiSumOf<K, V> {
-        fun map(
-            k: K,
-            v: V,
-        ): Int
-    }
-
-    class BiMaxOfCollector<K, V>(
-        val filter: BiFilter<K, V>,
-        val comparator: Comparator<V>,
-    ) : BiConsumer<K, V> {
-        var maxK: K? = null
-        var maxV: V? = null
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            if (filter.filter(k, v)) {
-                if (maxK == null || comparator.compare(v, maxV) > 0) {
-                    maxK = k
-                    maxV = v
-                }
-            }
-        }
-    }
-
-    class BiSumOfCollector<K, V>(
-        val mapper: BiSumOf<K, V>,
-    ) : BiConsumer<K, V> {
-        var sum = 0
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            sum += mapper.map(k, v)
-        }
-    }
-
-    fun interface BiSumOfLong<K, V> {
-        fun map(
-            k: K,
-            v: V,
-        ): Long
-    }
-
-    class BiSumOfLongCollector<K, V>(
-        val mapper: BiSumOfLong<K, V>,
-    ) : BiConsumer<K, V> {
-        var sum = 0L
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            sum += mapper.map(k, v)
-        }
-    }
-
-    class BiGroupByCollector<K, V, R>(
-        val mapper: BiNotNullMapper<K, V, R>,
-    ) : BiConsumer<K, V> {
-        var results = HashMap<R, ArrayList<V>>()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val group = mapper.map(k, v)
-
-            val list = results[group]
-            if (list == null) {
-                val answer = ArrayList<V>()
-                answer.add(v)
-                results[group] = answer
-            } else {
-                list.add(v)
-            }
-        }
-    }
-
-    class BiCountByGroupCollector<K, V, R>(
-        val mapper: BiNotNullMapper<K, V, R>,
-    ) : BiConsumer<K, V> {
-        var results = HashMap<R, Int>()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val group = mapper.map(k, v)
-
-            val count = results[group]
-            if (count == null) {
-                results[group] = 1
-            } else {
-                results[group] = count + 1
-            }
-        }
-    }
-
-    class BiSumByGroupCollector<K, V, R>(
-        val mapper: BiNotNullMapper<K, V, R>,
-        val sumOf: BiNotNullMapper<K, V, Long>,
-    ) : BiConsumer<K, V> {
-        var results = HashMap<R, Long>()
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            val group = mapper.map(k, v)
-
-            val sum = results[group]
-            if (sum == null) {
-                results[group] = sumOf.map(k, v)
-            } else {
-                results[group] = sum + sumOf.map(k, v)
-            }
-        }
-    }
-
-    class BiCountIfCollector<K, V>(
-        val filter: BiFilter<K, V>,
-    ) : BiConsumer<K, V> {
-        var count = 0
-
-        override fun accept(
-            k: K,
-            v: V,
-        ) {
-            if (filter.filter(k, v)) count++
-        }
-    }
 }