From c4b71a0aeab67f7cf257f41b783d0810a425eb10 Mon Sep 17 00:00:00 2001 From: David Kaspar Date: Sat, 16 Aug 2025 10:07:04 +0100 Subject: [PATCH 1/8] Move common collectors to new utility class --- .../quartz/utils/CacheCollectors.kt | 359 ++++++++++++++++++ 1 file changed, 359 insertions(+) create mode 100644 quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheCollectors.kt diff --git a/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheCollectors.kt b/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheCollectors.kt new file mode 100644 index 000000000..ca9377a0d --- /dev/null +++ b/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheCollectors.kt @@ -0,0 +1,359 @@ +/** + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.quartz.utils + +import java.util.function.BiConsumer + +object CacheCollectors { + fun interface BiFilter { + fun filter( + k: K, + v: V, + ): Boolean + } + + class BiFilterCollector( + val filter: BiFilter, + ) : BiConsumer { + var results: ArrayList = ArrayList() + + override fun accept( + k: K, + v: V, + ) { + if (filter.filter(k, v)) { + results.add(v) + } + } + } + + class BiFilterUniqueCollector( + val filter: BiFilter, + ) : BiConsumer { + var results: HashSet = HashSet() + + override fun accept( + k: K, + v: V, + ) { + if (filter.filter(k, v)) { + results.add(v) + } + } + } + + fun interface BiMapper { + fun map( + k: K, + v: V, + ): R? + } + + fun interface BiMapperNotNull { + fun map( + k: K, + v: V, + ): R + } + + class BiMapCollector( + val mapper: BiMapper, + ) : BiConsumer { + var results: ArrayList = ArrayList() + + override fun accept( + k: K, + v: V, + ) { + val result = mapper.map(k, v) + if (result != null) { + results.add(result) + } + } + } + + class BiAssociateCollector( + val size: Int, + val mapper: BiMapperNotNull>, + ) : BiConsumer { + var results: LinkedHashMap = LinkedHashMap(size) + + override fun accept( + k: K, + v: V, + ) { + val pair = mapper.map(k, v) + results.put(pair.first, pair.second) + } + } + + class BiAssociateNotNullCollector( + val size: Int, + val mapper: BiMapper?>, + ) : BiConsumer { + var results: LinkedHashMap = 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( + val size: Int, + val mapper: BiMapper, + ) : BiConsumer { + var results: LinkedHashMap = LinkedHashMap(size) + + override fun accept( + k: K, + v: V, + ) { + results.put(k, mapper.map(k, v)) + } + } + + class BiAssociateNotNullWithCollector( + val size: Int, + val mapper: BiMapper, + ) : BiConsumer { + var results: LinkedHashMap = LinkedHashMap(size) + + override fun accept( + k: K, + v: V, + ) { + val newValue = mapper.map(k, v) + if (newValue != null) { + results.put(k, newValue) + } + } + } + + class BiMapUniqueCollector( + val mapper: BiMapper, + ) : BiConsumer { + var results: HashSet = HashSet() + + override fun accept( + k: K, + v: V, + ) { + val result = mapper.map(k, v) + if (result != null) { + results.add(result) + } + } + } + + class BiMapFlattenCollector( + val mapper: BiMapper?>, + ) : BiConsumer { + var results: ArrayList = ArrayList() + + override fun accept( + k: K, + v: V, + ) { + val result = mapper.map(k, v) + if (result != null) { + results.addAll(result) + } + } + } + + class BiMapFlattenUniqueCollector( + val mapper: BiMapper?>, + ) : BiConsumer { + var results: HashSet = HashSet() + + override fun accept( + k: K, + v: V, + ) { + val result = mapper.map(k, v) + if (result != null) { + results.addAll(result) + } + } + } + + fun interface BiNotNullMapper { + fun map( + k: K, + v: V, + ): R + } + + class BiNotNullMapCollector( + val mapper: BiNotNullMapper, + ) : BiConsumer { + var results: ArrayList = ArrayList() + + override fun accept( + k: K, + v: V, + ) { + results.add(mapper.map(k, v)) + } + } + + fun interface BiSumOf { + fun map( + k: K, + v: V, + ): Int + } + + class BiMaxOfCollector( + val filter: BiFilter, + val comparator: Comparator, + ) : BiConsumer { + 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( + val mapper: BiSumOf, + ) : BiConsumer { + var sum = 0 + + override fun accept( + k: K, + v: V, + ) { + sum += mapper.map(k, v) + } + } + + fun interface BiSumOfLong { + fun map( + k: K, + v: V, + ): Long + } + + class BiSumOfLongCollector( + val mapper: BiSumOfLong, + ) : BiConsumer { + var sum = 0L + + override fun accept( + k: K, + v: V, + ) { + sum += mapper.map(k, v) + } + } + + class BiGroupByCollector( + val mapper: BiNotNullMapper, + ) : BiConsumer { + var results = HashMap>() + + override fun accept( + k: K, + v: V, + ) { + val group = mapper.map(k, v) + + val list = results[group] + if (list == null) { + val answer = ArrayList() + answer.add(v) + results[group] = answer + } else { + list.add(v) + } + } + } + + class BiCountByGroupCollector( + val mapper: BiNotNullMapper, + ) : BiConsumer { + var results = HashMap() + + 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( + val mapper: BiNotNullMapper, + val sumOf: BiNotNullMapper, + ) : BiConsumer { + var results = HashMap() + + 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( + val filter: BiFilter, + ) : BiConsumer { + var count = 0 + + override fun accept( + k: K, + v: V, + ) { + if (filter.filter(k, v)) count++ + } + } +} From eab2f96f02ae26a8ede7002327e39bb9b5c3a428 Mon Sep 17 00:00:00 2001 From: David Kaspar Date: Sat, 16 Aug 2025 10:20:52 +0100 Subject: [PATCH 2/8] 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 { innerForEach(consumer) } - fun filter(consumer: BiFilter): List { - val runner = BiFilterCollector(consumer) + fun filter(consumer: CacheCollectors.BiFilter): List { + val runner = CacheCollectors.BiFilterCollector(consumer) innerForEach(runner) return runner.results } - fun filterIntoSet(consumer: BiFilter): Set { - val runner = BiFilterUniqueCollector(consumer) + fun filterIntoSet(consumer: CacheCollectors.BiFilter): Set { + val runner = CacheCollectors.BiFilterUniqueCollector(consumer) innerForEach(runner) return runner.results } - fun map(consumer: BiNotNullMapper): List { - val runner = BiNotNullMapCollector(consumer) + fun map(consumer: CacheCollectors.BiNotNullMapper): List { + val runner = CacheCollectors.BiNotNullMapCollector(consumer) innerForEach(runner) return runner.results } - fun mapNotNull(consumer: BiMapper): List { - val runner = BiMapCollector(consumer) + fun mapNotNull(consumer: CacheCollectors.BiMapper): List { + val runner = CacheCollectors.BiMapCollector(consumer) innerForEach(runner) return runner.results } - fun mapNotNullIntoSet(consumer: BiMapper): Set { - val runner = BiMapUniqueCollector(consumer) + fun mapNotNullIntoSet(consumer: CacheCollectors.BiMapper): Set { + val runner = CacheCollectors.BiMapUniqueCollector(consumer) innerForEach(runner) return runner.results } - fun mapFlatten(consumer: BiMapper?>): List { - val runner = BiMapFlattenCollector(consumer) + fun mapFlatten(consumer: CacheCollectors.BiMapper?>): List { + val runner = CacheCollectors.BiMapFlattenCollector(consumer) innerForEach(runner) return runner.results } - fun mapFlattenIntoSet(consumer: BiMapper?>): Set { - val runner = BiMapFlattenUniqueCollector(consumer) + fun mapFlattenIntoSet(consumer: CacheCollectors.BiMapper?>): Set { + val runner = CacheCollectors.BiMapFlattenUniqueCollector(consumer) innerForEach(runner) return runner.results } fun maxOrNullOf( - filter: BiFilter, + filter: CacheCollectors.BiFilter, comparator: Comparator, ): V? { - val runner = BiMaxOfCollector(filter, comparator) + val runner = CacheCollectors.BiMaxOfCollector(filter, comparator) innerForEach(runner) return runner.maxV } - fun sumOf(consumer: BiSumOf): Int { - val runner = BiSumOfCollector(consumer) + fun sumOf(consumer: CacheCollectors.BiSumOf): Int { + val runner = CacheCollectors.BiSumOfCollector(consumer) innerForEach(runner) return runner.sum } - fun sumOfLong(consumer: BiSumOfLong): Long { - val runner = BiSumOfLongCollector(consumer) + fun sumOfLong(consumer: CacheCollectors.BiSumOfLong): Long { + val runner = CacheCollectors.BiSumOfLongCollector(consumer) innerForEach(runner) return runner.sum } - fun groupBy(consumer: BiNotNullMapper): Map> { - val runner = BiGroupByCollector(consumer) + fun groupBy(consumer: CacheCollectors.BiNotNullMapper): Map> { + val runner = CacheCollectors.BiGroupByCollector(consumer) innerForEach(runner) return runner.results } - fun countByGroup(consumer: BiNotNullMapper): Map { - val runner = BiCountByGroupCollector(consumer) + fun countByGroup(consumer: CacheCollectors.BiNotNullMapper): Map { + val runner = CacheCollectors.BiCountByGroupCollector(consumer) innerForEach(runner) return runner.results } fun sumByGroup( - groupMap: BiNotNullMapper, - sumOf: BiNotNullMapper, + groupMap: CacheCollectors.BiNotNullMapper, + sumOf: CacheCollectors.BiNotNullMapper, ): Map { - val runner = BiSumByGroupCollector(groupMap, sumOf) + val runner = CacheCollectors.BiSumByGroupCollector(groupMap, sumOf) innerForEach(runner) return runner.results } - fun count(consumer: BiFilter): Int { - val runner = BiCountIfCollector(consumer) + fun count(consumer: CacheCollectors.BiFilter): Int { + val runner = CacheCollectors.BiCountIfCollector(consumer) innerForEach(runner) return runner.count } fun associate(transform: (K, V) -> Pair): Map { - val runner = BiAssociateCollector(size(), transform) + val runner = CacheCollectors.BiAssociateCollector(size(), transform) innerForEach(runner) return runner.results } fun associateNotNull(transform: (K, V) -> Pair?): Map { - val runner = BiAssociateNotNullCollector(size(), transform) + val runner = CacheCollectors.BiAssociateNotNullCollector(size(), transform) innerForEach(runner) return runner.results } fun associateWith(transform: (K, V) -> U?): Map { - val runner = BiAssociateWithCollector(size(), transform) + val runner = CacheCollectors.BiAssociateWithCollector(size(), transform) innerForEach(runner) return runner.results } fun associateNotNullWith(transform: (K, V) -> U): Map { - val runner = BiAssociateNotNullWithCollector(size(), transform) + val runner = CacheCollectors.BiAssociateNotNullWithCollector(size(), transform) innerForEach(runner) return runner.results } @@ -227,338 +227,4 @@ class LargeCache { buffer.append(postfix) return buffer.toString() } - - fun interface BiFilter { - fun filter( - k: K, - v: V, - ): Boolean - } - - class BiFilterCollector( - val filter: BiFilter, - ) : BiConsumer { - var results: ArrayList = ArrayList() - - override fun accept( - k: K, - v: V, - ) { - if (filter.filter(k, v)) { - results.add(v) - } - } - } - - class BiFilterUniqueCollector( - val filter: BiFilter, - ) : BiConsumer { - var results: HashSet = HashSet() - - override fun accept( - k: K, - v: V, - ) { - if (filter.filter(k, v)) { - results.add(v) - } - } - } - - fun interface BiMapper { - fun map( - k: K, - v: V, - ): R? - } - - fun interface BiMapperNotNull { - fun map( - k: K, - v: V, - ): R - } - - class BiMapCollector( - val mapper: BiMapper, - ) : BiConsumer { - var results: ArrayList = ArrayList() - - override fun accept( - k: K, - v: V, - ) { - val result = mapper.map(k, v) - if (result != null) { - results.add(result) - } - } - } - - class BiAssociateCollector( - val size: Int, - val mapper: BiMapperNotNull>, - ) : BiConsumer { - var results: LinkedHashMap = LinkedHashMap(size) - - override fun accept( - k: K, - v: V, - ) { - val pair = mapper.map(k, v) - results.put(pair.first, pair.second) - } - } - - class BiAssociateNotNullCollector( - val size: Int, - val mapper: BiMapper?>, - ) : BiConsumer { - var results: LinkedHashMap = 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( - val size: Int, - val mapper: BiMapper, - ) : BiConsumer { - var results: LinkedHashMap = LinkedHashMap(size) - - override fun accept( - k: K, - v: V, - ) { - results.put(k, mapper.map(k, v)) - } - } - - class BiAssociateNotNullWithCollector( - val size: Int, - val mapper: BiMapper, - ) : BiConsumer { - var results: LinkedHashMap = LinkedHashMap(size) - - override fun accept( - k: K, - v: V, - ) { - val newValue = mapper.map(k, v) - if (newValue != null) { - results.put(k, newValue) - } - } - } - - class BiMapUniqueCollector( - val mapper: BiMapper, - ) : BiConsumer { - var results: HashSet = HashSet() - - override fun accept( - k: K, - v: V, - ) { - val result = mapper.map(k, v) - if (result != null) { - results.add(result) - } - } - } - - class BiMapFlattenCollector( - val mapper: BiMapper?>, - ) : BiConsumer { - var results: ArrayList = ArrayList() - - override fun accept( - k: K, - v: V, - ) { - val result = mapper.map(k, v) - if (result != null) { - results.addAll(result) - } - } - } - - class BiMapFlattenUniqueCollector( - val mapper: BiMapper?>, - ) : BiConsumer { - var results: HashSet = HashSet() - - override fun accept( - k: K, - v: V, - ) { - val result = mapper.map(k, v) - if (result != null) { - results.addAll(result) - } - } - } - - fun interface BiNotNullMapper { - fun map( - k: K, - v: V, - ): R - } - - class BiNotNullMapCollector( - val mapper: BiNotNullMapper, - ) : BiConsumer { - var results: ArrayList = ArrayList() - - override fun accept( - k: K, - v: V, - ) { - results.add(mapper.map(k, v)) - } - } - - fun interface BiSumOf { - fun map( - k: K, - v: V, - ): Int - } - - class BiMaxOfCollector( - val filter: BiFilter, - val comparator: Comparator, - ) : BiConsumer { - 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( - val mapper: BiSumOf, - ) : BiConsumer { - var sum = 0 - - override fun accept( - k: K, - v: V, - ) { - sum += mapper.map(k, v) - } - } - - fun interface BiSumOfLong { - fun map( - k: K, - v: V, - ): Long - } - - class BiSumOfLongCollector( - val mapper: BiSumOfLong, - ) : BiConsumer { - var sum = 0L - - override fun accept( - k: K, - v: V, - ) { - sum += mapper.map(k, v) - } - } - - class BiGroupByCollector( - val mapper: BiNotNullMapper, - ) : BiConsumer { - var results = HashMap>() - - override fun accept( - k: K, - v: V, - ) { - val group = mapper.map(k, v) - - val list = results[group] - if (list == null) { - val answer = ArrayList() - answer.add(v) - results[group] = answer - } else { - list.add(v) - } - } - } - - class BiCountByGroupCollector( - val mapper: BiNotNullMapper, - ) : BiConsumer { - var results = HashMap() - - 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( - val mapper: BiNotNullMapper, - val sumOf: BiNotNullMapper, - ) : BiConsumer { - var results = HashMap() - - 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( - val filter: BiFilter, - ) : BiConsumer { - 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 { innerForEach(consumer) } - fun filter(consumer: BiFilter): List { - val runner = BiFilterCollector(consumer) + fun filter(consumer: CacheCollectors.BiFilter): List { + val runner = CacheCollectors.BiFilterCollector(consumer) innerForEach(runner) return runner.results } - fun filterIntoSet(consumer: BiFilter): Set { - val runner = BiFilterUniqueCollector(consumer) + fun filterIntoSet(consumer: CacheCollectors.BiFilter): Set { + val runner = CacheCollectors.BiFilterUniqueCollector(consumer) innerForEach(runner) return runner.results } - fun map(consumer: BiNotNullMapper): List { - val runner = BiNotNullMapCollector(consumer) + fun map(consumer: CacheCollectors.BiNotNullMapper): List { + val runner = CacheCollectors.BiNotNullMapCollector(consumer) innerForEach(runner) return runner.results } - fun mapNotNull(consumer: BiMapper): List { - val runner = BiMapCollector(consumer) + fun mapNotNull(consumer: CacheCollectors.BiMapper): List { + val runner = CacheCollectors.BiMapCollector(consumer) innerForEach(runner) return runner.results } - fun mapNotNullIntoSet(consumer: BiMapper): Set { - val runner = BiMapUniqueCollector(consumer) + fun mapNotNullIntoSet(consumer: CacheCollectors.BiMapper): Set { + val runner = CacheCollectors.BiMapUniqueCollector(consumer) innerForEach(runner) return runner.results } - fun mapFlatten(consumer: BiMapper?>): List { - val runner = BiMapFlattenCollector(consumer) + fun mapFlatten(consumer: CacheCollectors.BiMapper?>): List { + val runner = CacheCollectors.BiMapFlattenCollector(consumer) innerForEach(runner) return runner.results } - fun mapFlattenIntoSet(consumer: BiMapper?>): Set { - val runner = BiMapFlattenUniqueCollector(consumer) + fun mapFlattenIntoSet(consumer: CacheCollectors.BiMapper?>): Set { + val runner = CacheCollectors.BiMapFlattenUniqueCollector(consumer) innerForEach(runner) return runner.results } fun maxOrNullOf( - filter: BiFilter, + filter: CacheCollectors.BiFilter, comparator: Comparator, ): V? { - val runner = BiMaxOfCollector(filter, comparator) + val runner = CacheCollectors.BiMaxOfCollector(filter, comparator) innerForEach(runner) return runner.maxV } - fun sumOf(consumer: BiSumOf): Int { - val runner = BiSumOfCollector(consumer) + fun sumOf(consumer: CacheCollectors.BiSumOf): Int { + val runner = CacheCollectors.BiSumOfCollector(consumer) innerForEach(runner) return runner.sum } - fun sumOfLong(consumer: BiSumOfLong): Long { - val runner = BiSumOfLongCollector(consumer) + fun sumOfLong(consumer: CacheCollectors.BiSumOfLong): Long { + val runner = CacheCollectors.BiSumOfLongCollector(consumer) innerForEach(runner) return runner.sum } - fun groupBy(consumer: BiNotNullMapper): Map> { - val runner = BiGroupByCollector(consumer) + fun groupBy(consumer: CacheCollectors.BiNotNullMapper): Map> { + val runner = CacheCollectors.BiGroupByCollector(consumer) innerForEach(runner) return runner.results } - fun countByGroup(consumer: BiNotNullMapper): Map { - val runner = BiCountByGroupCollector(consumer) + fun countByGroup(consumer: CacheCollectors.BiNotNullMapper): Map { + val runner = CacheCollectors.BiCountByGroupCollector(consumer) innerForEach(runner) return runner.results } fun sumByGroup( - groupMap: BiNotNullMapper, - sumOf: BiNotNullMapper, + groupMap: CacheCollectors.BiNotNullMapper, + sumOf: CacheCollectors.BiNotNullMapper, ): Map { - val runner = BiSumByGroupCollector(groupMap, sumOf) + val runner = CacheCollectors.BiSumByGroupCollector(groupMap, sumOf) innerForEach(runner) return runner.results } - fun count(consumer: BiFilter): Int { - val runner = BiCountIfCollector(consumer) + fun count(consumer: CacheCollectors.BiFilter): Int { + val runner = CacheCollectors.BiCountIfCollector(consumer) innerForEach(runner) return runner.count } fun associate(transform: (K, V) -> Pair): Map { - val runner = BiAssociateCollector(size(), transform) + val runner = CacheCollectors.BiAssociateCollector(size(), transform) innerForEach(runner) return runner.results } fun associateNotNull(transform: (K, V) -> Pair?): Map { - val runner = BiAssociateNotNullCollector(size(), transform) + val runner = CacheCollectors.BiAssociateNotNullCollector(size(), transform) innerForEach(runner) return runner.results } fun associateWith(transform: (K, V) -> U?): Map { - val runner = BiAssociateWithCollector(size(), transform) + val runner = CacheCollectors.BiAssociateWithCollector(size(), transform) innerForEach(runner) return runner.results } fun associateNotNullWith(transform: (K, V) -> U): Map { - val runner = BiAssociateNotNullWithCollector(size(), transform) + val runner = CacheCollectors.BiAssociateNotNullWithCollector(size(), transform) innerForEach(runner) return runner.results } @@ -290,338 +290,4 @@ class LargeSoftCache { } } } - - fun interface BiFilter { - fun filter( - k: K, - v: V, - ): Boolean - } - - class BiFilterCollector( - val filter: BiFilter, - ) : BiConsumer { - var results: ArrayList = ArrayList() - - override fun accept( - k: K, - v: V, - ) { - if (filter.filter(k, v)) { - results.add(v) - } - } - } - - class BiFilterUniqueCollector( - val filter: BiFilter, - ) : BiConsumer { - var results: HashSet = HashSet() - - override fun accept( - k: K, - v: V, - ) { - if (filter.filter(k, v)) { - results.add(v) - } - } - } - - fun interface BiMapper { - fun map( - k: K, - v: V, - ): R? - } - - fun interface BiMapperNotNull { - fun map( - k: K, - v: V, - ): R - } - - class BiMapCollector( - val mapper: BiMapper, - ) : BiConsumer { - var results: ArrayList = ArrayList() - - override fun accept( - k: K, - v: V, - ) { - val result = mapper.map(k, v) - if (result != null) { - results.add(result) - } - } - } - - class BiAssociateCollector( - val size: Int, - val mapper: BiMapperNotNull>, - ) : BiConsumer { - var results: LinkedHashMap = LinkedHashMap(size) - - override fun accept( - k: K, - v: V, - ) { - val pair = mapper.map(k, v) - results.put(pair.first, pair.second) - } - } - - class BiAssociateNotNullCollector( - val size: Int, - val mapper: BiMapper?>, - ) : BiConsumer { - var results: LinkedHashMap = 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( - val size: Int, - val mapper: BiMapper, - ) : BiConsumer { - var results: LinkedHashMap = LinkedHashMap(size) - - override fun accept( - k: K, - v: V, - ) { - results.put(k, mapper.map(k, v)) - } - } - - class BiAssociateNotNullWithCollector( - val size: Int, - val mapper: BiMapper, - ) : BiConsumer { - var results: LinkedHashMap = LinkedHashMap(size) - - override fun accept( - k: K, - v: V, - ) { - val newValue = mapper.map(k, v) - if (newValue != null) { - results.put(k, newValue) - } - } - } - - class BiMapUniqueCollector( - val mapper: BiMapper, - ) : BiConsumer { - var results: HashSet = HashSet() - - override fun accept( - k: K, - v: V, - ) { - val result = mapper.map(k, v) - if (result != null) { - results.add(result) - } - } - } - - class BiMapFlattenCollector( - val mapper: BiMapper?>, - ) : BiConsumer { - var results: ArrayList = ArrayList() - - override fun accept( - k: K, - v: V, - ) { - val result = mapper.map(k, v) - if (result != null) { - results.addAll(result) - } - } - } - - class BiMapFlattenUniqueCollector( - val mapper: BiMapper?>, - ) : BiConsumer { - var results: HashSet = HashSet() - - override fun accept( - k: K, - v: V, - ) { - val result = mapper.map(k, v) - if (result != null) { - results.addAll(result) - } - } - } - - fun interface BiNotNullMapper { - fun map( - k: K, - v: V, - ): R - } - - class BiNotNullMapCollector( - val mapper: BiNotNullMapper, - ) : BiConsumer { - var results: ArrayList = ArrayList() - - override fun accept( - k: K, - v: V, - ) { - results.add(mapper.map(k, v)) - } - } - - fun interface BiSumOf { - fun map( - k: K, - v: V, - ): Int - } - - class BiMaxOfCollector( - val filter: BiFilter, - val comparator: Comparator, - ) : BiConsumer { - 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( - val mapper: BiSumOf, - ) : BiConsumer { - var sum = 0 - - override fun accept( - k: K, - v: V, - ) { - sum += mapper.map(k, v) - } - } - - fun interface BiSumOfLong { - fun map( - k: K, - v: V, - ): Long - } - - class BiSumOfLongCollector( - val mapper: BiSumOfLong, - ) : BiConsumer { - var sum = 0L - - override fun accept( - k: K, - v: V, - ) { - sum += mapper.map(k, v) - } - } - - class BiGroupByCollector( - val mapper: BiNotNullMapper, - ) : BiConsumer { - var results = HashMap>() - - override fun accept( - k: K, - v: V, - ) { - val group = mapper.map(k, v) - - val list = results[group] - if (list == null) { - val answer = ArrayList() - answer.add(v) - results[group] = answer - } else { - list.add(v) - } - } - } - - class BiCountByGroupCollector( - val mapper: BiNotNullMapper, - ) : BiConsumer { - var results = HashMap() - - 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( - val mapper: BiNotNullMapper, - val sumOf: BiNotNullMapper, - ) : BiConsumer { - var results = HashMap() - - 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( - val filter: BiFilter, - ) : BiConsumer { - var count = 0 - - override fun accept( - k: K, - v: V, - ) { - if (filter.filter(k, v)) count++ - } - } } From b069f283ac4215efe95cebc0a8c59f07b46e081c Mon Sep 17 00:00:00 2001 From: David Kaspar Date: Sat, 16 Aug 2025 10:36:10 +0100 Subject: [PATCH 3/8] Move common cache operations to new utility class --- .../quartz/utils/CacheOperations.kt | 173 ++++++++++++++++++ 1 file changed, 173 insertions(+) create mode 100644 quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheOperations.kt diff --git a/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheOperations.kt b/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheOperations.kt new file mode 100644 index 000000000..b1c9a9ccc --- /dev/null +++ b/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheOperations.kt @@ -0,0 +1,173 @@ +/** + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.quartz.utils + +import java.util.function.BiConsumer + +interface CacheOperations { + fun forEach(consumer: BiConsumer) + + fun size(): Int + + fun filter(consumer: CacheCollectors.BiFilter): List { + val runner = CacheCollectors.BiFilterCollector(consumer) + forEach(runner) + return runner.results + } + + fun filterIntoSet(consumer: CacheCollectors.BiFilter): Set { + val runner = CacheCollectors.BiFilterUniqueCollector(consumer) + forEach(runner) + return runner.results + } + + fun map(consumer: CacheCollectors.BiNotNullMapper): List { + val runner = CacheCollectors.BiNotNullMapCollector(consumer) + forEach(runner) + return runner.results + } + + fun mapNotNull(consumer: CacheCollectors.BiMapper): List { + val runner = CacheCollectors.BiMapCollector(consumer) + forEach(runner) + return runner.results + } + + fun mapNotNullIntoSet(consumer: CacheCollectors.BiMapper): Set { + val runner = CacheCollectors.BiMapUniqueCollector(consumer) + forEach(runner) + return runner.results + } + + fun mapFlatten(consumer: CacheCollectors.BiMapper?>): List { + val runner = CacheCollectors.BiMapFlattenCollector(consumer) + forEach(runner) + return runner.results + } + + fun mapFlattenIntoSet(consumer: CacheCollectors.BiMapper?>): Set { + val runner = CacheCollectors.BiMapFlattenUniqueCollector(consumer) + forEach(runner) + return runner.results + } + + fun maxOrNullOf( + filter: CacheCollectors.BiFilter, + comparator: Comparator, + ): V? { + val runner = CacheCollectors.BiMaxOfCollector(filter, comparator) + forEach(runner) + return runner.maxV + } + + fun sumOf(consumer: CacheCollectors.BiSumOf): Int { + val runner = CacheCollectors.BiSumOfCollector(consumer) + forEach(runner) + return runner.sum + } + + fun sumOfLong(consumer: CacheCollectors.BiSumOfLong): Long { + val runner = CacheCollectors.BiSumOfLongCollector(consumer) + forEach(runner) + return runner.sum + } + + fun groupBy(consumer: CacheCollectors.BiNotNullMapper): Map> { + val runner = CacheCollectors.BiGroupByCollector(consumer) + forEach(runner) + return runner.results + } + + fun countByGroup(consumer: CacheCollectors.BiNotNullMapper): Map { + val runner = CacheCollectors.BiCountByGroupCollector(consumer) + forEach(runner) + return runner.results + } + + fun sumByGroup( + groupMap: CacheCollectors.BiNotNullMapper, + sumOf: CacheCollectors.BiNotNullMapper, + ): Map { + val runner = CacheCollectors.BiSumByGroupCollector(groupMap, sumOf) + forEach(runner) + return runner.results + } + + fun count(consumer: CacheCollectors.BiFilter): Int { + val runner = CacheCollectors.BiCountIfCollector(consumer) + forEach(runner) + return runner.count + } + + fun associate(transform: (K, V) -> Pair): Map { + val runner = CacheCollectors.BiAssociateCollector(size(), transform) + forEach(runner) + return runner.results + } + + fun associateNotNull(transform: (K, V) -> Pair?): Map { + val runner = CacheCollectors.BiAssociateNotNullCollector(size(), transform) + forEach(runner) + return runner.results + } + + fun associateWith(transform: (K, V) -> U?): Map { + val runner = CacheCollectors.BiAssociateWithCollector(size(), transform) + forEach(runner) + return runner.results + } + + fun associateNotNullWith(transform: (K, V) -> U): Map { + val runner = CacheCollectors.BiAssociateNotNullWithCollector(size(), transform) + forEach(runner) + return runner.results + } + + fun joinToString( + separator: CharSequence = ", ", + prefix: CharSequence = "", + postfix: CharSequence = "", + limit: Int = -1, + truncated: CharSequence = "...", + transform: ((K, V) -> CharSequence)? = null, + ): String { + val buffer = StringBuilder() + buffer.append(prefix) + var count = 0 + forEach { key, value -> + val str = if (transform != null) transform(key, value) else "" + if (str.isNotEmpty()) { + if (++count > 1) buffer.append(separator) + if (limit < 0 || count <= limit) { + when { + transform != null -> buffer.append(str) + else -> buffer.append("$key $value") + } + } else { + return@forEach + } + } + } + if (limit >= 0 && count > limit) buffer.append(truncated) + buffer.append(postfix) + return buffer.toString() + } +} From 533d8b18f063b6df71dbd4f3c5217c3ac79b90e6 Mon Sep 17 00:00:00 2001 From: David Kaspar Date: Sat, 16 Aug 2025 10:45:37 +0100 Subject: [PATCH 4/8] Remove duplicate functionality from Cache implementations and use instead common methods in CacheOperations utility class Create override for forEach and size as they are needed internally and do slightly different things --- .../vitorpamplona/quartz/utils/LargeCache.kt | 156 +----------------- .../quartz/utils/LargeSoftCache.kt | 156 +----------------- 2 files changed, 8 insertions(+), 304 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 4254d94bf..962932c9a 100644 --- a/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeCache.kt +++ b/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeCache.kt @@ -23,7 +23,7 @@ package com.vitorpamplona.quartz.utils import java.util.concurrent.ConcurrentSkipListMap import java.util.function.BiConsumer -class LargeCache { +class LargeCache : CacheOperations { private val cache = ConcurrentSkipListMap() fun keys() = cache.keys @@ -34,7 +34,7 @@ class LargeCache { fun remove(key: K) = cache.remove(key) - fun size() = cache.size + override fun size() = cache.size fun isEmpty() = cache.isEmpty() @@ -76,155 +76,7 @@ class LargeCache { } } - fun forEach(consumer: BiConsumer) { - innerForEach(consumer) - } - - fun filter(consumer: CacheCollectors.BiFilter): List { - val runner = CacheCollectors.BiFilterCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun filterIntoSet(consumer: CacheCollectors.BiFilter): Set { - val runner = CacheCollectors.BiFilterUniqueCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun map(consumer: CacheCollectors.BiNotNullMapper): List { - val runner = CacheCollectors.BiNotNullMapCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun mapNotNull(consumer: CacheCollectors.BiMapper): List { - val runner = CacheCollectors.BiMapCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun mapNotNullIntoSet(consumer: CacheCollectors.BiMapper): Set { - val runner = CacheCollectors.BiMapUniqueCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun mapFlatten(consumer: CacheCollectors.BiMapper?>): List { - val runner = CacheCollectors.BiMapFlattenCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun mapFlattenIntoSet(consumer: CacheCollectors.BiMapper?>): Set { - val runner = CacheCollectors.BiMapFlattenUniqueCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun maxOrNullOf( - filter: CacheCollectors.BiFilter, - comparator: Comparator, - ): V? { - val runner = CacheCollectors.BiMaxOfCollector(filter, comparator) - innerForEach(runner) - return runner.maxV - } - - fun sumOf(consumer: CacheCollectors.BiSumOf): Int { - val runner = CacheCollectors.BiSumOfCollector(consumer) - innerForEach(runner) - return runner.sum - } - - fun sumOfLong(consumer: CacheCollectors.BiSumOfLong): Long { - val runner = CacheCollectors.BiSumOfLongCollector(consumer) - innerForEach(runner) - return runner.sum - } - - fun groupBy(consumer: CacheCollectors.BiNotNullMapper): Map> { - val runner = CacheCollectors.BiGroupByCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun countByGroup(consumer: CacheCollectors.BiNotNullMapper): Map { - val runner = CacheCollectors.BiCountByGroupCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun sumByGroup( - groupMap: CacheCollectors.BiNotNullMapper, - sumOf: CacheCollectors.BiNotNullMapper, - ): Map { - val runner = CacheCollectors.BiSumByGroupCollector(groupMap, sumOf) - innerForEach(runner) - return runner.results - } - - fun count(consumer: CacheCollectors.BiFilter): Int { - val runner = CacheCollectors.BiCountIfCollector(consumer) - innerForEach(runner) - return runner.count - } - - fun associate(transform: (K, V) -> Pair): Map { - val runner = CacheCollectors.BiAssociateCollector(size(), transform) - innerForEach(runner) - return runner.results - } - - fun associateNotNull(transform: (K, V) -> Pair?): Map { - val runner = CacheCollectors.BiAssociateNotNullCollector(size(), transform) - innerForEach(runner) - return runner.results - } - - fun associateWith(transform: (K, V) -> U?): Map { - val runner = CacheCollectors.BiAssociateWithCollector(size(), transform) - innerForEach(runner) - return runner.results - } - - fun associateNotNullWith(transform: (K, V) -> U): Map { - val runner = CacheCollectors.BiAssociateNotNullWithCollector(size(), transform) - innerForEach(runner) - return runner.results - } - - private fun innerForEach(runner: BiConsumer) { - cache.forEach(runner) - } - - fun joinToString( - separator: CharSequence = ", ", - prefix: CharSequence = "", - postfix: CharSequence = "", - limit: Int = -1, - truncated: CharSequence = "...", - transform: ((K, V) -> CharSequence)? = null, - ): String { - val buffer = StringBuilder() - buffer.append(prefix) - var count = 0 - forEach { key, value -> - val str = if (transform != null) transform(key, value) else "" - if (str.isNotEmpty()) { - if (++count > 1) buffer.append(separator) - if (limit < 0 || count <= limit) { - when { - transform != null -> buffer.append(str) - else -> buffer.append("$key $value") - } - } else { - return@forEach - } - } - } - if (limit >= 0 && count > limit) buffer.append(truncated) - buffer.append(postfix) - return buffer.toString() + override fun forEach(consumer: BiConsumer) { + cache.forEach(consumer) } } 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 6f1c90c55..17f9ba265 100644 --- a/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeSoftCache.kt +++ b/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeSoftCache.kt @@ -24,7 +24,7 @@ import java.lang.ref.WeakReference import java.util.concurrent.ConcurrentSkipListMap import java.util.function.BiConsumer -class LargeSoftCache { +class LargeSoftCache : CacheOperations { private val cache = ConcurrentSkipListMap>() fun keys() = cache.keys @@ -43,7 +43,7 @@ class LargeSoftCache { fun remove(key: K) = cache.remove(key) - fun size() = cache.size + override fun size() = cache.size fun isEmpty() = cache.isEmpty() @@ -122,156 +122,8 @@ class LargeSoftCache { println("Cache cleanup completed. Remaining size: ${cache.size}") } - fun forEach(consumer: BiConsumer) { - innerForEach(consumer) - } - - fun filter(consumer: CacheCollectors.BiFilter): List { - val runner = CacheCollectors.BiFilterCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun filterIntoSet(consumer: CacheCollectors.BiFilter): Set { - val runner = CacheCollectors.BiFilterUniqueCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun map(consumer: CacheCollectors.BiNotNullMapper): List { - val runner = CacheCollectors.BiNotNullMapCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun mapNotNull(consumer: CacheCollectors.BiMapper): List { - val runner = CacheCollectors.BiMapCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun mapNotNullIntoSet(consumer: CacheCollectors.BiMapper): Set { - val runner = CacheCollectors.BiMapUniqueCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun mapFlatten(consumer: CacheCollectors.BiMapper?>): List { - val runner = CacheCollectors.BiMapFlattenCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun mapFlattenIntoSet(consumer: CacheCollectors.BiMapper?>): Set { - val runner = CacheCollectors.BiMapFlattenUniqueCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun maxOrNullOf( - filter: CacheCollectors.BiFilter, - comparator: Comparator, - ): V? { - val runner = CacheCollectors.BiMaxOfCollector(filter, comparator) - innerForEach(runner) - return runner.maxV - } - - fun sumOf(consumer: CacheCollectors.BiSumOf): Int { - val runner = CacheCollectors.BiSumOfCollector(consumer) - innerForEach(runner) - return runner.sum - } - - fun sumOfLong(consumer: CacheCollectors.BiSumOfLong): Long { - val runner = CacheCollectors.BiSumOfLongCollector(consumer) - innerForEach(runner) - return runner.sum - } - - fun groupBy(consumer: CacheCollectors.BiNotNullMapper): Map> { - val runner = CacheCollectors.BiGroupByCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun countByGroup(consumer: CacheCollectors.BiNotNullMapper): Map { - val runner = CacheCollectors.BiCountByGroupCollector(consumer) - innerForEach(runner) - return runner.results - } - - fun sumByGroup( - groupMap: CacheCollectors.BiNotNullMapper, - sumOf: CacheCollectors.BiNotNullMapper, - ): Map { - val runner = CacheCollectors.BiSumByGroupCollector(groupMap, sumOf) - innerForEach(runner) - return runner.results - } - - fun count(consumer: CacheCollectors.BiFilter): Int { - val runner = CacheCollectors.BiCountIfCollector(consumer) - innerForEach(runner) - return runner.count - } - - fun associate(transform: (K, V) -> Pair): Map { - val runner = CacheCollectors.BiAssociateCollector(size(), transform) - innerForEach(runner) - return runner.results - } - - fun associateNotNull(transform: (K, V) -> Pair?): Map { - val runner = CacheCollectors.BiAssociateNotNullCollector(size(), transform) - innerForEach(runner) - return runner.results - } - - fun associateWith(transform: (K, V) -> U?): Map { - val runner = CacheCollectors.BiAssociateWithCollector(size(), transform) - innerForEach(runner) - return runner.results - } - - fun associateNotNullWith(transform: (K, V) -> U): Map { - val runner = CacheCollectors.BiAssociateNotNullWithCollector(size(), transform) - innerForEach(runner) - return runner.results - } - - private fun innerForEach(runner: BiConsumer) { - cache.forEach(BiConsumerWrapper(this, runner)) - } - - fun joinToString( - separator: CharSequence = ", ", - prefix: CharSequence = "", - postfix: CharSequence = "", - limit: Int = -1, - truncated: CharSequence = "...", - transform: ((K, V) -> CharSequence)? = null, - ): String { - val buffer = StringBuilder() - buffer.append(prefix) - var count = 0 - forEach { key, value -> - val str = if (transform != null) transform(key, value) else "" - if (str.isNotEmpty()) { - if (++count > 1) buffer.append(separator) - if (limit < 0 || count <= limit) { - when { - transform != null -> buffer.append(str) - else -> buffer.append("$key $value") - } - } else { - return@forEach - } - } - } - if (limit >= 0 && count > limit) buffer.append(truncated) - buffer.append(postfix) - return buffer.toString() + override fun forEach(consumer: BiConsumer) { + cache.forEach(BiConsumerWrapper(this, consumer)) } class BiConsumerWrapper( From f21c7bd258da2cc05315b0140256ef2e1513f4bb Mon Sep 17 00:00:00 2001 From: David Kaspar Date: Sat, 16 Aug 2025 11:20:37 +0100 Subject: [PATCH 5/8] Lint issues: remove unused methods, use indexing operator instead of .get() --- .../quartz/utils/CacheOperations.kt | 12 ------------ .../com/vitorpamplona/quartz/utils/LargeCache.kt | 2 +- .../vitorpamplona/quartz/utils/LargeSoftCache.kt | 16 +--------------- 3 files changed, 2 insertions(+), 28 deletions(-) diff --git a/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheOperations.kt b/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheOperations.kt index b1c9a9ccc..c44ff5814 100644 --- a/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheOperations.kt +++ b/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheOperations.kt @@ -123,24 +123,12 @@ interface CacheOperations { return runner.results } - fun associateNotNull(transform: (K, V) -> Pair?): Map { - val runner = CacheCollectors.BiAssociateNotNullCollector(size(), transform) - forEach(runner) - return runner.results - } - fun associateWith(transform: (K, V) -> U?): Map { val runner = CacheCollectors.BiAssociateWithCollector(size(), transform) forEach(runner) return runner.results } - fun associateNotNullWith(transform: (K, V) -> U): Map { - val runner = CacheCollectors.BiAssociateNotNullWithCollector(size(), transform) - forEach(runner) - return runner.results - } - fun joinToString( separator: CharSequence = ", ", prefix: CharSequence = "", 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 962932c9a..fe59fca30 100644 --- a/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeCache.kt +++ b/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeCache.kt @@ -67,7 +67,7 @@ class LargeCache : CacheOperations { key: K, builder: (key: K) -> V, ): Boolean { - val value = cache.get(key) + val value = cache[key] return if (value != null) { false } else { 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 17f9ba265..995c0701c 100644 --- a/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeSoftCache.kt +++ b/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeSoftCache.kt @@ -78,7 +78,7 @@ class LargeSoftCache : CacheOperations { key: K, builder: (key: K) -> V, ): V { - val softRef = cache.get(key) + val softRef = cache[key] val value = softRef?.get() return if (value != null) { @@ -89,20 +89,6 @@ class LargeSoftCache : CacheOperations { } } - fun createIfAbsent( - key: K, - builder: (key: K) -> V, - ): Boolean { - val softRef = cache.get(key) - val value = softRef?.get() - return if (value != null) { - false - } else { - val newObject = builder(key) - cache.putIfAbsent(key, WeakReference(newObject)) == null - } - } - /** * Proactively cleans up the cache by removing entries whose weakly referenced * objects have been garbage collected. While `get` handles cleanup on access, From a82f4aacbed0f39c28f708e9ff24f20269a45bbe Mon Sep 17 00:00:00 2001 From: David Kaspar Date: Sat, 16 Aug 2025 18:17:27 +0100 Subject: [PATCH 6/8] Use val for references that do not change (eg results) --- .../quartz/utils/CacheCollectors.kt | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheCollectors.kt b/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheCollectors.kt index ca9377a0d..b6203e5c9 100644 --- a/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheCollectors.kt +++ b/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheCollectors.kt @@ -33,7 +33,7 @@ object CacheCollectors { class BiFilterCollector( val filter: BiFilter, ) : BiConsumer { - var results: ArrayList = ArrayList() + val results: ArrayList = ArrayList() override fun accept( k: K, @@ -48,7 +48,7 @@ object CacheCollectors { class BiFilterUniqueCollector( val filter: BiFilter, ) : BiConsumer { - var results: HashSet = HashSet() + val results: HashSet = HashSet() override fun accept( k: K, @@ -77,7 +77,7 @@ object CacheCollectors { class BiMapCollector( val mapper: BiMapper, ) : BiConsumer { - var results: ArrayList = ArrayList() + val results: ArrayList = ArrayList() override fun accept( k: K, @@ -94,7 +94,7 @@ object CacheCollectors { val size: Int, val mapper: BiMapperNotNull>, ) : BiConsumer { - var results: LinkedHashMap = LinkedHashMap(size) + val results: LinkedHashMap = LinkedHashMap(size) override fun accept( k: K, @@ -109,7 +109,7 @@ object CacheCollectors { val size: Int, val mapper: BiMapper?>, ) : BiConsumer { - var results: LinkedHashMap = LinkedHashMap(size) + val results: LinkedHashMap = LinkedHashMap(size) override fun accept( k: K, @@ -126,7 +126,7 @@ object CacheCollectors { val size: Int, val mapper: BiMapper, ) : BiConsumer { - var results: LinkedHashMap = LinkedHashMap(size) + val results: LinkedHashMap = LinkedHashMap(size) override fun accept( k: K, @@ -140,7 +140,7 @@ object CacheCollectors { val size: Int, val mapper: BiMapper, ) : BiConsumer { - var results: LinkedHashMap = LinkedHashMap(size) + val results: LinkedHashMap = LinkedHashMap(size) override fun accept( k: K, @@ -156,7 +156,7 @@ object CacheCollectors { class BiMapUniqueCollector( val mapper: BiMapper, ) : BiConsumer { - var results: HashSet = HashSet() + val results: HashSet = HashSet() override fun accept( k: K, @@ -172,7 +172,7 @@ object CacheCollectors { class BiMapFlattenCollector( val mapper: BiMapper?>, ) : BiConsumer { - var results: ArrayList = ArrayList() + val results: ArrayList = ArrayList() override fun accept( k: K, @@ -188,7 +188,7 @@ object CacheCollectors { class BiMapFlattenUniqueCollector( val mapper: BiMapper?>, ) : BiConsumer { - var results: HashSet = HashSet() + val results: HashSet = HashSet() override fun accept( k: K, @@ -211,7 +211,7 @@ object CacheCollectors { class BiNotNullMapCollector( val mapper: BiNotNullMapper, ) : BiConsumer { - var results: ArrayList = ArrayList() + val results: ArrayList = ArrayList() override fun accept( k: K, @@ -284,7 +284,7 @@ object CacheCollectors { class BiGroupByCollector( val mapper: BiNotNullMapper, ) : BiConsumer { - var results = HashMap>() + val results = HashMap>() override fun accept( k: K, @@ -306,7 +306,7 @@ object CacheCollectors { class BiCountByGroupCollector( val mapper: BiNotNullMapper, ) : BiConsumer { - var results = HashMap() + val results = HashMap() override fun accept( k: K, @@ -327,7 +327,7 @@ object CacheCollectors { val mapper: BiNotNullMapper, val sumOf: BiNotNullMapper, ) : BiConsumer { - var results = HashMap() + val results = HashMap() override fun accept( k: K, From a72fff5f8fa611c54d589ff4151db12a5a79850a Mon Sep 17 00:00:00 2001 From: David Kaspar Date: Sat, 16 Aug 2025 18:50:01 +0100 Subject: [PATCH 7/8] Lifted out collectors from CacheCollectors object --- .../quartz/utils/CacheCollectors.kt | 592 +++++++++--------- .../quartz/utils/CacheOperations.kt | 32 +- 2 files changed, 316 insertions(+), 308 deletions(-) diff --git a/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheCollectors.kt b/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheCollectors.kt index b6203e5c9..5b54c8be7 100644 --- a/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheCollectors.kt +++ b/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheCollectors.kt @@ -20,8 +20,308 @@ */ package com.vitorpamplona.quartz.utils +import com.vitorpamplona.quartz.utils.CacheCollectors.BiFilter +import com.vitorpamplona.quartz.utils.CacheCollectors.BiMapper +import com.vitorpamplona.quartz.utils.CacheCollectors.BiMapperNotNull +import com.vitorpamplona.quartz.utils.CacheCollectors.BiNotNullMapper +import com.vitorpamplona.quartz.utils.CacheCollectors.BiSumOfLong import java.util.function.BiConsumer +class BiFilterCollector( + private val filter: BiFilter, +) : BiConsumer { + val results: ArrayList = ArrayList() + + override fun accept( + k: K, + v: V, + ) { + if (filter.filter(k, v)) { + results.add(v) + } + } +} + +class BiFilterUniqueCollector( + private val filter: BiFilter, +) : BiConsumer { + val results: HashSet = HashSet() + + override fun accept( + k: K, + v: V, + ) { + if (filter.filter(k, v)) { + results.add(v) + } + } +} + +class BiMapCollector( + private val mapper: BiMapper, +) : BiConsumer { + val results: ArrayList = ArrayList() + + override fun accept( + k: K, + v: V, + ) { + val result = mapper.map(k, v) + if (result != null) { + results.add(result) + } + } +} + +class BiMapUniqueCollector( + private val mapper: BiMapper, +) : BiConsumer { + val results: HashSet = HashSet() + + override fun accept( + k: K, + v: V, + ) { + val result = mapper.map(k, v) + if (result != null) { + results.add(result) + } + } +} + +class BiMapFlattenCollector( + private val mapper: BiMapper?>, +) : BiConsumer { + val results: ArrayList = ArrayList() + + override fun accept( + k: K, + v: V, + ) { + val result = mapper.map(k, v) + if (result != null) { + results.addAll(result) + } + } +} + +class BiMapFlattenUniqueCollector( + private val mapper: BiMapper?>, +) : BiConsumer { + val results: HashSet = HashSet() + + override fun accept( + k: K, + v: V, + ) { + val result = mapper.map(k, v) + if (result != null) { + results.addAll(result) + } + } +} + +class BiNotNullMapCollector( + private val mapper: BiNotNullMapper, +) : BiConsumer { + val results: ArrayList = ArrayList() + + override fun accept( + k: K, + v: V, + ) { + results.add(mapper.map(k, v)) + } +} + +class BiMaxOfCollector( + private val filter: BiFilter, + private val comparator: Comparator, +) : BiConsumer { + private var _maxK: K? = null + private var _maxV: V? = null + + val maxK: K? get() = _maxK + val maxV: V? get() = _maxV + + 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( + private val mapper: CacheCollectors.BiSumOf, +) : BiConsumer { + private var _sum = 0 + val sum: Int get() = _sum + + override fun accept( + k: K, + v: V, + ) { + _sum += mapper.map(k, v) + } +} + +class BiSumOfLongCollector( + private val mapper: BiSumOfLong, +) : BiConsumer { + private var _sum = 0L + val sum: Long get() = _sum + + override fun accept( + k: K, + v: V, + ) { + _sum += mapper.map(k, v) + } +} + +class BiGroupByCollector( + private val mapper: BiNotNullMapper, +) : BiConsumer { + val results = HashMap>() + + override fun accept( + k: K, + v: V, + ) { + val group = mapper.map(k, v) + val list = results[group] + if (list == null) { + val answer = ArrayList() + answer.add(v) + results[group] = answer + } else { + list.add(v) + } + } +} + +class BiCountByGroupCollector( + private val mapper: BiNotNullMapper, +) : BiConsumer { + val results = HashMap() + + 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( + private val mapper: BiNotNullMapper, + private val sumOf: BiNotNullMapper, +) : BiConsumer { + val results = HashMap() + + 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( + private val filter: BiFilter, +) : BiConsumer { + private var _count = 0 + val count: Int get() = _count + + override fun accept( + k: K, + v: V, + ) { + if (filter.filter(k, v)) _count++ + } +} + +class BiAssociateCollector( + size: Int, + private val mapper: BiMapperNotNull>, +) : BiConsumer { + val results: LinkedHashMap = LinkedHashMap(size) + + override fun accept( + k: K, + v: V, + ) { + val pair = mapper.map(k, v) + results[pair.first] = pair.second + } +} + +class BiAssociateNotNullCollector( + size: Int, + private val mapper: BiMapper?>, +) : BiConsumer { + val results: LinkedHashMap = LinkedHashMap(size) + + override fun accept( + k: K, + v: V, + ) { + val pair = mapper.map(k, v) + if (pair != null) { + results[pair.first] = pair.second + } + } +} + +class BiAssociateWithCollector( + size: Int, + private val mapper: BiMapper, +) : BiConsumer { + val results: LinkedHashMap = LinkedHashMap(size) + + override fun accept( + k: K, + v: V, + ) { + results[k] = mapper.map(k, v) + } +} + +class BiAssociateNotNullWithCollector( + size: Int, + private val mapper: BiMapper, +) : BiConsumer { + val results: LinkedHashMap = LinkedHashMap(size) + + override fun accept( + k: K, + v: V, + ) { + val newValue = mapper.map(k, v) + if (newValue != null) { + results[k] = newValue + } + } +} + object CacheCollectors { fun interface BiFilter { fun filter( @@ -30,36 +330,6 @@ object CacheCollectors { ): Boolean } - class BiFilterCollector( - val filter: BiFilter, - ) : BiConsumer { - val results: ArrayList = ArrayList() - - override fun accept( - k: K, - v: V, - ) { - if (filter.filter(k, v)) { - results.add(v) - } - } - } - - class BiFilterUniqueCollector( - val filter: BiFilter, - ) : BiConsumer { - val results: HashSet = HashSet() - - override fun accept( - k: K, - v: V, - ) { - if (filter.filter(k, v)) { - results.add(v) - } - } - } - fun interface BiMapper { fun map( k: K, @@ -74,133 +344,6 @@ object CacheCollectors { ): R } - class BiMapCollector( - val mapper: BiMapper, - ) : BiConsumer { - val results: ArrayList = ArrayList() - - override fun accept( - k: K, - v: V, - ) { - val result = mapper.map(k, v) - if (result != null) { - results.add(result) - } - } - } - - class BiAssociateCollector( - val size: Int, - val mapper: BiMapperNotNull>, - ) : BiConsumer { - val results: LinkedHashMap = LinkedHashMap(size) - - override fun accept( - k: K, - v: V, - ) { - val pair = mapper.map(k, v) - results.put(pair.first, pair.second) - } - } - - class BiAssociateNotNullCollector( - val size: Int, - val mapper: BiMapper?>, - ) : BiConsumer { - val results: LinkedHashMap = 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( - val size: Int, - val mapper: BiMapper, - ) : BiConsumer { - val results: LinkedHashMap = LinkedHashMap(size) - - override fun accept( - k: K, - v: V, - ) { - results.put(k, mapper.map(k, v)) - } - } - - class BiAssociateNotNullWithCollector( - val size: Int, - val mapper: BiMapper, - ) : BiConsumer { - val results: LinkedHashMap = LinkedHashMap(size) - - override fun accept( - k: K, - v: V, - ) { - val newValue = mapper.map(k, v) - if (newValue != null) { - results.put(k, newValue) - } - } - } - - class BiMapUniqueCollector( - val mapper: BiMapper, - ) : BiConsumer { - val results: HashSet = HashSet() - - override fun accept( - k: K, - v: V, - ) { - val result = mapper.map(k, v) - if (result != null) { - results.add(result) - } - } - } - - class BiMapFlattenCollector( - val mapper: BiMapper?>, - ) : BiConsumer { - val results: ArrayList = ArrayList() - - override fun accept( - k: K, - v: V, - ) { - val result = mapper.map(k, v) - if (result != null) { - results.addAll(result) - } - } - } - - class BiMapFlattenUniqueCollector( - val mapper: BiMapper?>, - ) : BiConsumer { - val results: HashSet = HashSet() - - override fun accept( - k: K, - v: V, - ) { - val result = mapper.map(k, v) - if (result != null) { - results.addAll(result) - } - } - } - fun interface BiNotNullMapper { fun map( k: K, @@ -208,19 +351,6 @@ object CacheCollectors { ): R } - class BiNotNullMapCollector( - val mapper: BiNotNullMapper, - ) : BiConsumer { - val results: ArrayList = ArrayList() - - override fun accept( - k: K, - v: V, - ) { - results.add(mapper.map(k, v)) - } - } - fun interface BiSumOf { fun map( k: K, @@ -228,132 +358,10 @@ object CacheCollectors { ): Int } - class BiMaxOfCollector( - val filter: BiFilter, - val comparator: Comparator, - ) : BiConsumer { - 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( - val mapper: BiSumOf, - ) : BiConsumer { - var sum = 0 - - override fun accept( - k: K, - v: V, - ) { - sum += mapper.map(k, v) - } - } - fun interface BiSumOfLong { fun map( k: K, v: V, ): Long } - - class BiSumOfLongCollector( - val mapper: BiSumOfLong, - ) : BiConsumer { - var sum = 0L - - override fun accept( - k: K, - v: V, - ) { - sum += mapper.map(k, v) - } - } - - class BiGroupByCollector( - val mapper: BiNotNullMapper, - ) : BiConsumer { - val results = HashMap>() - - override fun accept( - k: K, - v: V, - ) { - val group = mapper.map(k, v) - - val list = results[group] - if (list == null) { - val answer = ArrayList() - answer.add(v) - results[group] = answer - } else { - list.add(v) - } - } - } - - class BiCountByGroupCollector( - val mapper: BiNotNullMapper, - ) : BiConsumer { - val results = HashMap() - - 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( - val mapper: BiNotNullMapper, - val sumOf: BiNotNullMapper, - ) : BiConsumer { - val results = HashMap() - - 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( - val filter: BiFilter, - ) : BiConsumer { - 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/CacheOperations.kt b/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheOperations.kt index c44ff5814..24e057707 100644 --- a/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheOperations.kt +++ b/quartz/src/main/java/com/vitorpamplona/quartz/utils/CacheOperations.kt @@ -28,43 +28,43 @@ interface CacheOperations { fun size(): Int fun filter(consumer: CacheCollectors.BiFilter): List { - val runner = CacheCollectors.BiFilterCollector(consumer) + val runner = BiFilterCollector(consumer) forEach(runner) return runner.results } fun filterIntoSet(consumer: CacheCollectors.BiFilter): Set { - val runner = CacheCollectors.BiFilterUniqueCollector(consumer) + val runner = BiFilterUniqueCollector(consumer) forEach(runner) return runner.results } fun map(consumer: CacheCollectors.BiNotNullMapper): List { - val runner = CacheCollectors.BiNotNullMapCollector(consumer) + val runner = BiNotNullMapCollector(consumer) forEach(runner) return runner.results } fun mapNotNull(consumer: CacheCollectors.BiMapper): List { - val runner = CacheCollectors.BiMapCollector(consumer) + val runner = BiMapCollector(consumer) forEach(runner) return runner.results } fun mapNotNullIntoSet(consumer: CacheCollectors.BiMapper): Set { - val runner = CacheCollectors.BiMapUniqueCollector(consumer) + val runner = BiMapUniqueCollector(consumer) forEach(runner) return runner.results } fun mapFlatten(consumer: CacheCollectors.BiMapper?>): List { - val runner = CacheCollectors.BiMapFlattenCollector(consumer) + val runner = BiMapFlattenCollector(consumer) forEach(runner) return runner.results } fun mapFlattenIntoSet(consumer: CacheCollectors.BiMapper?>): Set { - val runner = CacheCollectors.BiMapFlattenUniqueCollector(consumer) + val runner = BiMapFlattenUniqueCollector(consumer) forEach(runner) return runner.results } @@ -73,31 +73,31 @@ interface CacheOperations { filter: CacheCollectors.BiFilter, comparator: Comparator, ): V? { - val runner = CacheCollectors.BiMaxOfCollector(filter, comparator) + val runner = BiMaxOfCollector(filter, comparator) forEach(runner) return runner.maxV } fun sumOf(consumer: CacheCollectors.BiSumOf): Int { - val runner = CacheCollectors.BiSumOfCollector(consumer) + val runner = BiSumOfCollector(consumer) forEach(runner) return runner.sum } fun sumOfLong(consumer: CacheCollectors.BiSumOfLong): Long { - val runner = CacheCollectors.BiSumOfLongCollector(consumer) + val runner = BiSumOfLongCollector(consumer) forEach(runner) return runner.sum } fun groupBy(consumer: CacheCollectors.BiNotNullMapper): Map> { - val runner = CacheCollectors.BiGroupByCollector(consumer) + val runner = BiGroupByCollector(consumer) forEach(runner) return runner.results } fun countByGroup(consumer: CacheCollectors.BiNotNullMapper): Map { - val runner = CacheCollectors.BiCountByGroupCollector(consumer) + val runner = BiCountByGroupCollector(consumer) forEach(runner) return runner.results } @@ -106,25 +106,25 @@ interface CacheOperations { groupMap: CacheCollectors.BiNotNullMapper, sumOf: CacheCollectors.BiNotNullMapper, ): Map { - val runner = CacheCollectors.BiSumByGroupCollector(groupMap, sumOf) + val runner = BiSumByGroupCollector(groupMap, sumOf) forEach(runner) return runner.results } fun count(consumer: CacheCollectors.BiFilter): Int { - val runner = CacheCollectors.BiCountIfCollector(consumer) + val runner = BiCountIfCollector(consumer) forEach(runner) return runner.count } fun associate(transform: (K, V) -> Pair): Map { - val runner = CacheCollectors.BiAssociateCollector(size(), transform) + val runner = BiAssociateCollector(size(), transform) forEach(runner) return runner.results } fun associateWith(transform: (K, V) -> U?): Map { - val runner = CacheCollectors.BiAssociateWithCollector(size(), transform) + val runner = BiAssociateWithCollector(size(), transform) forEach(runner) return runner.results } From c1004dc6433f082f606c5be2805b3b1be1fdbe47 Mon Sep 17 00:00:00 2001 From: David Kaspar Date: Sat, 16 Aug 2025 18:56:48 +0100 Subject: [PATCH 8/8] Use .get( instead of index to keep to code base coding style --- .../src/main/java/com/vitorpamplona/quartz/utils/LargeCache.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 fe59fca30..962932c9a 100644 --- a/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeCache.kt +++ b/quartz/src/main/java/com/vitorpamplona/quartz/utils/LargeCache.kt @@ -67,7 +67,7 @@ class LargeCache : CacheOperations { key: K, builder: (key: K) -> V, ): Boolean { - val value = cache[key] + val value = cache.get(key) return if (value != null) { false } else {