highperfocused/amethyst
1
0
Fork 0
mirror of https://github.com/vitorpamplona/amethyst.git synced 2025-09-29 09:22:41 +02:00
Code Issues Packages Projects Releases Wiki Activity

remove duplicate colletors and Use collectors from new utility class

Browse Source
This commit is contained in:
David Kaspar
2025-08-16 10:20:52 +01:00
parent c4b71a0aea
commit eab2f96f02
2 changed files with 66 additions and 734 deletions
Download Patch File Download Diff File Expand all files Collapse all files

400
quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeCache.kt
View File

@@ -80,116 +80,116 @@ class LargeCache<K, V> {
innerForEach(consumer) innerForEach(consumer)
} }
fun filter(consumer: BiFilter<K, V>): List<V> { fun filter(consumer: CacheCollectors.BiFilter<K, V>): List<V> {
val runner = BiFilterCollector(consumer) val runner = CacheCollectors.BiFilterCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun filterIntoSet(consumer: BiFilter<K, V>): Set<V> { fun filterIntoSet(consumer: CacheCollectors.BiFilter<K, V>): Set<V> {
val runner = BiFilterUniqueCollector(consumer) val runner = CacheCollectors.BiFilterUniqueCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <R> map(consumer: BiNotNullMapper<K, V, R>): List<R> { fun <R> map(consumer: CacheCollectors.BiNotNullMapper<K, V, R>): List<R> {
val runner = BiNotNullMapCollector(consumer) val runner = CacheCollectors.BiNotNullMapCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <R> mapNotNull(consumer: BiMapper<K, V, R?>): List<R> { fun <R> mapNotNull(consumer: CacheCollectors.BiMapper<K, V, R?>): List<R> {
val runner = BiMapCollector(consumer) val runner = CacheCollectors.BiMapCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <R> mapNotNullIntoSet(consumer: BiMapper<K, V, R?>): Set<R> { fun <R> mapNotNullIntoSet(consumer: CacheCollectors.BiMapper<K, V, R?>): Set<R> {
val runner = BiMapUniqueCollector(consumer) val runner = CacheCollectors.BiMapUniqueCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <R> mapFlatten(consumer: BiMapper<K, V, Collection<R>?>): List<R> { fun <R> mapFlatten(consumer: CacheCollectors.BiMapper<K, V, Collection<R>?>): List<R> {
val runner = BiMapFlattenCollector(consumer) val runner = CacheCollectors.BiMapFlattenCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <R> mapFlattenIntoSet(consumer: BiMapper<K, V, Collection<R>?>): Set<R> { fun <R> mapFlattenIntoSet(consumer: CacheCollectors.BiMapper<K, V, Collection<R>?>): Set<R> {
val runner = BiMapFlattenUniqueCollector(consumer) val runner = CacheCollectors.BiMapFlattenUniqueCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun maxOrNullOf( fun maxOrNullOf(
filter: BiFilter<K, V>, filter: CacheCollectors.BiFilter<K, V>,
comparator: Comparator<V>, comparator: Comparator<V>,
): V? { ): V? {
val runner = BiMaxOfCollector(filter, comparator) val runner = CacheCollectors.BiMaxOfCollector(filter, comparator)
innerForEach(runner) innerForEach(runner)
return runner.maxV return runner.maxV
} }
fun sumOf(consumer: BiSumOf<K, V>): Int { fun sumOf(consumer: CacheCollectors.BiSumOf<K, V>): Int {
val runner = BiSumOfCollector(consumer) val runner = CacheCollectors.BiSumOfCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.sum return runner.sum
} }
fun sumOfLong(consumer: BiSumOfLong<K, V>): Long { fun sumOfLong(consumer: CacheCollectors.BiSumOfLong<K, V>): Long {
val runner = BiSumOfLongCollector(consumer) val runner = CacheCollectors.BiSumOfLongCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.sum return runner.sum
} }
fun <R> groupBy(consumer: BiNotNullMapper<K, V, R>): Map<R, List<V>> { fun <R> groupBy(consumer: CacheCollectors.BiNotNullMapper<K, V, R>): Map<R, List<V>> {
val runner = BiGroupByCollector(consumer) val runner = CacheCollectors.BiGroupByCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <R> countByGroup(consumer: BiNotNullMapper<K, V, R>): Map<R, Int> { fun <R> countByGroup(consumer: CacheCollectors.BiNotNullMapper<K, V, R>): Map<R, Int> {
val runner = BiCountByGroupCollector(consumer) val runner = CacheCollectors.BiCountByGroupCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <R> sumByGroup( fun <R> sumByGroup(
groupMap: BiNotNullMapper<K, V, R>, groupMap: CacheCollectors.BiNotNullMapper<K, V, R>,
sumOf: BiNotNullMapper<K, V, Long>, sumOf: CacheCollectors.BiNotNullMapper<K, V, Long>,
): Map<R, Long> { ): Map<R, Long> {
val runner = BiSumByGroupCollector(groupMap, sumOf) val runner = CacheCollectors.BiSumByGroupCollector(groupMap, sumOf)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun count(consumer: BiFilter<K, V>): Int { fun count(consumer: CacheCollectors.BiFilter<K, V>): Int {
val runner = BiCountIfCollector(consumer) val runner = CacheCollectors.BiCountIfCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.count return runner.count
} }
fun <T, U> associate(transform: (K, V) -> Pair<T, U>): Map<T, U> { 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) innerForEach(runner)
return runner.results return runner.results
} }
fun <T, U> associateNotNull(transform: (K, V) -> Pair<T, U>?): Map<T, U> { 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) innerForEach(runner)
return runner.results return runner.results
} }
fun <U> associateWith(transform: (K, V) -> U?): Map<K, U?> { fun <U> associateWith(transform: (K, V) -> U?): Map<K, U?> {
val runner = BiAssociateWithCollector(size(), transform) val runner = CacheCollectors.BiAssociateWithCollector(size(), transform)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <U> associateNotNullWith(transform: (K, V) -> U): Map<K, U> { fun <U> associateNotNullWith(transform: (K, V) -> U): Map<K, U> {
val runner = BiAssociateNotNullWithCollector(size(), transform) val runner = CacheCollectors.BiAssociateNotNullWithCollector(size(), transform)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
@@ -227,338 +227,4 @@ class LargeCache<K, V> {
buffer.append(postfix) buffer.append(postfix)
return buffer.toString() 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++
}
}
} }

400
quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeSoftCache.kt
View File

@@ -126,116 +126,116 @@ class LargeSoftCache<K, V> {
innerForEach(consumer) innerForEach(consumer)
} }
fun filter(consumer: BiFilter<K, V>): List<V> { fun filter(consumer: CacheCollectors.BiFilter<K, V>): List<V> {
val runner = BiFilterCollector(consumer) val runner = CacheCollectors.BiFilterCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun filterIntoSet(consumer: BiFilter<K, V>): Set<V> { fun filterIntoSet(consumer: CacheCollectors.BiFilter<K, V>): Set<V> {
val runner = BiFilterUniqueCollector(consumer) val runner = CacheCollectors.BiFilterUniqueCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <R> map(consumer: BiNotNullMapper<K, V, R>): List<R> { fun <R> map(consumer: CacheCollectors.BiNotNullMapper<K, V, R>): List<R> {
val runner = BiNotNullMapCollector(consumer) val runner = CacheCollectors.BiNotNullMapCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <R> mapNotNull(consumer: BiMapper<K, V, R?>): List<R> { fun <R> mapNotNull(consumer: CacheCollectors.BiMapper<K, V, R?>): List<R> {
val runner = BiMapCollector(consumer) val runner = CacheCollectors.BiMapCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <R> mapNotNullIntoSet(consumer: BiMapper<K, V, R?>): Set<R> { fun <R> mapNotNullIntoSet(consumer: CacheCollectors.BiMapper<K, V, R?>): Set<R> {
val runner = BiMapUniqueCollector(consumer) val runner = CacheCollectors.BiMapUniqueCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <R> mapFlatten(consumer: BiMapper<K, V, Collection<R>?>): List<R> { fun <R> mapFlatten(consumer: CacheCollectors.BiMapper<K, V, Collection<R>?>): List<R> {
val runner = BiMapFlattenCollector(consumer) val runner = CacheCollectors.BiMapFlattenCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <R> mapFlattenIntoSet(consumer: BiMapper<K, V, Collection<R>?>): Set<R> { fun <R> mapFlattenIntoSet(consumer: CacheCollectors.BiMapper<K, V, Collection<R>?>): Set<R> {
val runner = BiMapFlattenUniqueCollector(consumer) val runner = CacheCollectors.BiMapFlattenUniqueCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun maxOrNullOf( fun maxOrNullOf(
filter: BiFilter<K, V>, filter: CacheCollectors.BiFilter<K, V>,
comparator: Comparator<V>, comparator: Comparator<V>,
): V? { ): V? {
val runner = BiMaxOfCollector(filter, comparator) val runner = CacheCollectors.BiMaxOfCollector(filter, comparator)
innerForEach(runner) innerForEach(runner)
return runner.maxV return runner.maxV
} }
fun sumOf(consumer: BiSumOf<K, V>): Int { fun sumOf(consumer: CacheCollectors.BiSumOf<K, V>): Int {
val runner = BiSumOfCollector(consumer) val runner = CacheCollectors.BiSumOfCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.sum return runner.sum
} }
fun sumOfLong(consumer: BiSumOfLong<K, V>): Long { fun sumOfLong(consumer: CacheCollectors.BiSumOfLong<K, V>): Long {
val runner = BiSumOfLongCollector(consumer) val runner = CacheCollectors.BiSumOfLongCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.sum return runner.sum
} }
fun <R> groupBy(consumer: BiNotNullMapper<K, V, R>): Map<R, List<V>> { fun <R> groupBy(consumer: CacheCollectors.BiNotNullMapper<K, V, R>): Map<R, List<V>> {
val runner = BiGroupByCollector(consumer) val runner = CacheCollectors.BiGroupByCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <R> countByGroup(consumer: BiNotNullMapper<K, V, R>): Map<R, Int> { fun <R> countByGroup(consumer: CacheCollectors.BiNotNullMapper<K, V, R>): Map<R, Int> {
val runner = BiCountByGroupCollector(consumer) val runner = CacheCollectors.BiCountByGroupCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <R> sumByGroup( fun <R> sumByGroup(
groupMap: BiNotNullMapper<K, V, R>, groupMap: CacheCollectors.BiNotNullMapper<K, V, R>,
sumOf: BiNotNullMapper<K, V, Long>, sumOf: CacheCollectors.BiNotNullMapper<K, V, Long>,
): Map<R, Long> { ): Map<R, Long> {
val runner = BiSumByGroupCollector(groupMap, sumOf) val runner = CacheCollectors.BiSumByGroupCollector(groupMap, sumOf)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun count(consumer: BiFilter<K, V>): Int { fun count(consumer: CacheCollectors.BiFilter<K, V>): Int {
val runner = BiCountIfCollector(consumer) val runner = CacheCollectors.BiCountIfCollector(consumer)
innerForEach(runner) innerForEach(runner)
return runner.count return runner.count
} }
fun <T, U> associate(transform: (K, V) -> Pair<T, U>): Map<T, U> { 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) innerForEach(runner)
return runner.results return runner.results
} }
fun <T, U> associateNotNull(transform: (K, V) -> Pair<T, U>?): Map<T, U> { 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) innerForEach(runner)
return runner.results return runner.results
} }
fun <U> associateWith(transform: (K, V) -> U?): Map<K, U?> { fun <U> associateWith(transform: (K, V) -> U?): Map<K, U?> {
val runner = BiAssociateWithCollector(size(), transform) val runner = CacheCollectors.BiAssociateWithCollector(size(), transform)
innerForEach(runner) innerForEach(runner)
return runner.results return runner.results
} }
fun <U> associateNotNullWith(transform: (K, V) -> U): Map<K, U> { fun <U> associateNotNullWith(transform: (K, V) -> U): Map<K, U> {
val runner = BiAssociateNotNullWithCollector(size(), transform) val runner = CacheCollectors.BiAssociateNotNullWithCollector(size(), transform)
innerForEach(runner) innerForEach(runner)
return runner.results 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++
}
}
} }