commons-collections/xyz.xenondevs.commons.collections

Package-level declarations

Types

CollectionUtils

object CollectionUtils

Functions

after

fun <T> List<T>.after(element: T, step: Int = 1): T

associateByNotNull

inline fun <K, V> Iterable<V>.associateByNotNull(keySelector: (V) -> K?): Map<K, V>

associateByNotNullTo

inline fun <K, V, M : MutableMap<K, V>> Iterable<V>.associateByNotNullTo(destination: M, keySelector: (V) -> K?): M

associateNotNull

inline fun <T, K, V> Iterable<T>.associateNotNull(transform: (T) -> Pair<K, V>?): Map<K, V>

associateNotNullTo

inline fun <T, K, V> Iterable<T>.associateNotNullTo(destination: MutableMap<K, V>, transform: (T) -> Pair<K, V>?): Map<K, V>

associateWithNotNull

inline fun <K, V> Iterable<K>.associateWithNotNull(valueSelector: (K) -> V?): Map<K, V>

associateWithNotNullTo

inline fun <K, V, M : MutableMap<K, V>> Iterable<K>.associateWithNotNullTo(destination: M, valueSelector: (K) -> V?): M

before

fun <T> List<T>.before(element: T, step: Int = 1): T

concurrentHashSet

fun <K> concurrentHashSet(): MutableSet<K>

concurrentHashSetOf

fun <K> concurrentHashSetOf(vararg elements: K): MutableSet<K>

contentEquals

fun <E> List<E>.contentEquals(other: List<E>): Boolean

fun <E> Set<E>.contentEquals(other: Set<E>): Boolean

eachRepeated

fun <T> List<T>.eachRepeated(times: Int): List<T>

enumMap

inline fun <K : Enum<K>, V> enumMap(): EnumMap<K, V>

inline fun <K : Enum<K>, V> enumMap(initializer: (K) -> V): EnumMap<K, V>

inline fun <K : Enum<K>, V> enumMap(map: Map<K, V>): EnumMap<K, V>

enumMapOf

inline fun <K : Enum<K>, V> enumMapOf(vararg pairs: Pair<K, V>): EnumMap<K, V>

enumSet

inline fun <E : Enum<E>> enumSet(): EnumSet<E>

enumSetOf

inline fun <E : Enum<E>> enumSetOf(vararg elements: E): EnumSet<E>

filterIsInstanceKeys

inline fun <R, K, V> Map<K, V>.filterIsInstanceKeys(): Map<R, V>

filterIsInstanceKeysTo

inline fun <R, K, V, C : MutableMap<R, V>> Map<K, V>.filterIsInstanceKeysTo(destination: C): C

filterIsInstanceValues

inline fun <R, K, V> Map<K, V>.filterIsInstanceValues(): Map<K, R>

filterIsInstanceValuesTo

inline fun <R, K, V, C : MutableMap<K, R>> Map<K, V>.filterIsInstanceValuesTo(destination: C): C

filterValuesNotNull

fun <K, V : Any> Map<K, V?>.filterValuesNotNull(): Map<K, V>

filterValuesNotNullTo

fun <K, V : Any, C : MutableMap<K, V>> Map<K, V?>.filterValuesNotNullTo(destination: C): C

findNth

inline fun <T> Iterable<T>.findNth(n: Int, predicate: (T) -> Boolean): T

findNthOfType

inline fun <R> Iterable<*>.findNthOfType(n: Int): R

findNthOfTypeOrNull

inline fun <R> Iterable<*>.findNthOfTypeOrNull(n: Int): R?

findNthOrNull

inline fun <T> Iterable<T>.findNthOrNull(n: Int, predicate: (T) -> Boolean): T?

firstInstanceOf

inline fun <R> Iterable<*>.firstInstanceOf(): R

firstInstanceOfOrNull

inline fun <R> Iterable<*>.firstInstanceOfOrNull(): R?

flatMap

inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Array<R>): List<R>

inline fun <K, V, R> Map<K, V>.flatMap(transform: (Map.Entry<K, V>) -> Array<R>): List<R>

fun <T, R> Sequence<T>.flatMap(transform: (T) -> Array<R>): Sequence<R>

flatMapTo

inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(destination: C, transform: (T) -> Array<R>): C

inline fun <K, V, R, C : MutableCollection<in R>> Map<K, V>.flatMapTo(destination: C, transform: (Map.Entry<K, V>) -> Array<R>): C

getCoerced

fun <T> Array<T>.getCoerced(index: Int): T

fun <T> List<T>.getCoerced(index: Int): T

getMod

fun <T> Array<T>.getMod(index: Int): T

fun <T> List<T>.getMod(index: Int): T

getOrSet

inline fun <T> Array<T?>.getOrSet(index: Int, lazyValue: () -> T): T

identityHashSet

fun <K> identityHashSet(): MutableSet<K>

identityHashSetOf

fun <K> identityHashSetOf(vararg elements: K): MutableSet<K>

intersects

fun <E> Collection<E>.intersects(other: Collection<E>): Boolean

isNotNullOrEmpty

fun Collection<*>?.isNotNullOrEmpty(): Boolean

fun Map<*, *>?.isNotNullOrEmpty(): Boolean

isNullOrEmpty

fun Collection<*>?.isNullOrEmpty(): Boolean

fun Map<*, *>?.isNullOrEmpty(): Boolean

mapKeysNotNull

inline fun <K, V, R> Map<K, V>.mapKeysNotNull(keySelector: (Map.Entry<K, V>) -> R?): Map<R, V>

mapKeysNotNullTo

inline fun <K, V, R, M : MutableMap<R, V>> Map<K, V>.mapKeysNotNullTo(destination: M, keySelector: (Map.Entry<K, V>) -> R?): M

mapToArray

inline fun <T, R> Array<T>.mapToArray(transform: (T) -> R): Array<R>

inline fun BooleanArray.mapToArray(transform: (Boolean) -> Any): Array<Any>

inline fun ByteArray.mapToArray(transform: (Byte) -> Any): Array<Any>

inline fun CharArray.mapToArray(transform: (Char) -> Any): Array<Any>

inline fun DoubleArray.mapToArray(transform: (Double) -> Any): Array<Any>

inline fun FloatArray.mapToArray(transform: (Float) -> Any): Array<Any>

inline fun IntArray.mapToArray(transform: (Int) -> Any): Array<Any>

inline fun LongArray.mapToArray(transform: (Long) -> Any): Array<Any>

inline fun ShortArray.mapToArray(transform: (Short) -> Any): Array<Any>

inline fun <T, R> Collection<T>.mapToArray(transform: (T) -> R): Array<R>

mapToBits

inline fun <T> Collection<T>.mapToBits(transform: (T) -> Boolean): ByteArray

mapToBitSet

inline fun <T> Collection<T>.mapToBitSet(transform: (T) -> Boolean): BitSet

mapToBooleanArray

inline fun <T> Array<T>.mapToBooleanArray(transform: (T) -> Boolean): BooleanArray

inline fun BooleanArray.mapToBooleanArray(transform: (Boolean) -> Boolean): BooleanArray

inline fun ByteArray.mapToBooleanArray(transform: (Byte) -> Boolean): BooleanArray

inline fun CharArray.mapToBooleanArray(transform: (Char) -> Boolean): BooleanArray

inline fun DoubleArray.mapToBooleanArray(transform: (Double) -> Boolean): BooleanArray

inline fun FloatArray.mapToBooleanArray(transform: (Float) -> Boolean): BooleanArray

inline fun IntArray.mapToBooleanArray(transform: (Int) -> Boolean): BooleanArray

inline fun LongArray.mapToBooleanArray(transform: (Long) -> Boolean): BooleanArray

inline fun ShortArray.mapToBooleanArray(transform: (Short) -> Boolean): BooleanArray

inline fun <T> Collection<T>.mapToBooleanArray(transform: (T) -> Boolean): BooleanArray

mapToByteArray

inline fun <T> Array<T>.mapToByteArray(transform: (T) -> Byte): ByteArray

inline fun BooleanArray.mapToByteArray(transform: (Boolean) -> Byte): ByteArray

inline fun ByteArray.mapToByteArray(transform: (Byte) -> Byte): ByteArray

inline fun CharArray.mapToByteArray(transform: (Char) -> Byte): ByteArray

inline fun DoubleArray.mapToByteArray(transform: (Double) -> Byte): ByteArray

inline fun FloatArray.mapToByteArray(transform: (Float) -> Byte): ByteArray

inline fun IntArray.mapToByteArray(transform: (Int) -> Byte): ByteArray

inline fun LongArray.mapToByteArray(transform: (Long) -> Byte): ByteArray

inline fun ShortArray.mapToByteArray(transform: (Short) -> Byte): ByteArray

inline fun <T> Collection<T>.mapToByteArray(transform: (T) -> Byte): ByteArray

mapToCharArray

inline fun <T> Array<T>.mapToCharArray(transform: (T) -> Char): CharArray

inline fun BooleanArray.mapToCharArray(transform: (Boolean) -> Char): CharArray

inline fun ByteArray.mapToCharArray(transform: (Byte) -> Char): CharArray

inline fun CharArray.mapToCharArray(transform: (Char) -> Char): CharArray

inline fun DoubleArray.mapToCharArray(transform: (Double) -> Char): CharArray

inline fun FloatArray.mapToCharArray(transform: (Float) -> Char): CharArray

inline fun IntArray.mapToCharArray(transform: (Int) -> Char): CharArray

inline fun LongArray.mapToCharArray(transform: (Long) -> Char): CharArray

inline fun ShortArray.mapToCharArray(transform: (Short) -> Char): CharArray

inline fun <T> Collection<T>.mapToCharArray(transform: (T) -> Char): CharArray

mapToDoubleArray

inline fun <T> Array<T>.mapToDoubleArray(transform: (T) -> Double): DoubleArray

inline fun BooleanArray.mapToDoubleArray(transform: (Boolean) -> Double): DoubleArray

inline fun ByteArray.mapToDoubleArray(transform: (Byte) -> Double): DoubleArray

inline fun CharArray.mapToDoubleArray(transform: (Char) -> Double): DoubleArray

inline fun DoubleArray.mapToDoubleArray(transform: (Double) -> Double): DoubleArray

inline fun FloatArray.mapToDoubleArray(transform: (Float) -> Double): DoubleArray

inline fun IntArray.mapToDoubleArray(transform: (Int) -> Double): DoubleArray

inline fun LongArray.mapToDoubleArray(transform: (Long) -> Double): DoubleArray

inline fun ShortArray.mapToDoubleArray(transform: (Short) -> Double): DoubleArray

inline fun <T> Collection<T>.mapToDoubleArray(transform: (T) -> Double): DoubleArray

mapToFloatArray

inline fun <T> Array<T>.mapToFloatArray(transform: (T) -> Float): FloatArray

inline fun BooleanArray.mapToFloatArray(transform: (Boolean) -> Float): FloatArray

inline fun ByteArray.mapToFloatArray(transform: (Byte) -> Float): FloatArray

inline fun CharArray.mapToFloatArray(transform: (Char) -> Float): FloatArray

inline fun DoubleArray.mapToFloatArray(transform: (Double) -> Float): FloatArray

inline fun FloatArray.mapToFloatArray(transform: (Float) -> Float): FloatArray

inline fun IntArray.mapToFloatArray(transform: (Int) -> Float): FloatArray

inline fun LongArray.mapToFloatArray(transform: (Long) -> Float): FloatArray

inline fun ShortArray.mapToFloatArray(transform: (Short) -> Float): FloatArray

inline fun <T> Collection<T>.mapToFloatArray(transform: (T) -> Float): FloatArray

mapToIntArray

inline fun <T> Array<T>.mapToIntArray(transform: (T) -> Int): IntArray

inline fun BooleanArray.mapToIntArray(transform: (Boolean) -> Int): IntArray

inline fun ByteArray.mapToIntArray(transform: (Byte) -> Int): IntArray

inline fun CharArray.mapToIntArray(transform: (Char) -> Int): IntArray

inline fun DoubleArray.mapToIntArray(transform: (Double) -> Int): IntArray

inline fun FloatArray.mapToIntArray(transform: (Float) -> Int): IntArray

inline fun IntArray.mapToIntArray(transform: (Int) -> Int): IntArray

inline fun LongArray.mapToIntArray(transform: (Long) -> Int): IntArray

inline fun ShortArray.mapToIntArray(transform: (Short) -> Int): IntArray

inline fun <T> Collection<T>.mapToIntArray(transform: (T) -> Int): IntArray

mapToLongArray

inline fun <T> Array<T>.mapToLongArray(transform: (T) -> Long): LongArray

inline fun BooleanArray.mapToLongArray(transform: (Boolean) -> Long): LongArray

inline fun ByteArray.mapToLongArray(transform: (Byte) -> Long): LongArray

inline fun CharArray.mapToLongArray(transform: (Char) -> Long): LongArray

inline fun DoubleArray.mapToLongArray(transform: (Double) -> Long): LongArray

inline fun FloatArray.mapToLongArray(transform: (Float) -> Long): LongArray

inline fun IntArray.mapToLongArray(transform: (Int) -> Long): LongArray

inline fun LongArray.mapToLongArray(transform: (Long) -> Long): LongArray

inline fun ShortArray.mapToLongArray(transform: (Short) -> Long): LongArray

inline fun <T> Collection<T>.mapToLongArray(transform: (T) -> Long): LongArray

mapToShortArray

inline fun <T> Array<T>.mapToShortArray(transform: (T) -> Short): ShortArray

inline fun BooleanArray.mapToShortArray(transform: (Boolean) -> Short): ShortArray

inline fun ByteArray.mapToShortArray(transform: (Byte) -> Short): ShortArray

inline fun CharArray.mapToShortArray(transform: (Char) -> Short): ShortArray

inline fun DoubleArray.mapToShortArray(transform: (Double) -> Short): ShortArray

inline fun FloatArray.mapToShortArray(transform: (Float) -> Short): ShortArray

inline fun IntArray.mapToShortArray(transform: (Int) -> Short): ShortArray

inline fun LongArray.mapToShortArray(transform: (Long) -> Short): ShortArray

inline fun ShortArray.mapToShortArray(transform: (Short) -> Short): ShortArray

inline fun <T> Collection<T>.mapToShortArray(transform: (T) -> Short): ShortArray

mapValuesNotNull

inline fun <K, V, R> Map<K, V>.mapValuesNotNull(valueSelector: (Map.Entry<K, V>) -> R?): Map<K, R>

mapValuesNotNullTo

inline fun <K, V, R, M : MutableMap<K, R>> Map<K, V>.mapValuesNotNullTo(destination: M, valueSelector: (Map.Entry<K, V>) -> R?): M

inline fun <E : Enum<E>> E.next(stepSize: Int = 1): E

Returns the enum entry stepSize after this enum entry, in declaration order. Cycles back to the first entry if the end is reached.

nextOrNull

inline fun <E : Enum<E>> E.nextOrNull(stepSize: Int = 1): E?

Returns the enum entry stepSize after this enum entry, in declaration order. Returns null if the end is reached.

poll

fun <E> MutableIterable<E>.poll(): E?

fun <K, V> MutableMap<K, V>.poll(): Map.Entry<K, V>?

pollFirstWhere

inline fun <E> MutableIterable<E>.pollFirstWhere(test: (E) -> Boolean): E?

inline fun <E : Enum<E>> E.previous(stepSize: Int = 1): E

Returns the enum entry stepSize before this enum entry, in declaration order. Cycles back to the last entry if the beginning is reached.

previousOrNull

inline fun <E : Enum<E>> E.previousOrNull(stepSize: Int = 1): E?

Returns the enum entry stepSize before this enum entry, in declaration order. Returns null if the beginning is reached.

putOrRemove

fun <K, V> MutableMap<K, V>.putOrRemove(key: K, value: V?): V?

removeFirstWhere

inline fun <E> MutableIterable<E>.removeFirstWhere(test: (E) -> Boolean): Boolean

removeIf

inline fun <K, V> MutableMap<K, V>.removeIf(predicate: (Map.Entry<K, V>) -> Boolean): MutableMap<K, V>

repeated

fun <T> List<T>.repeated(times: Int): List<T>

rotateLeft

fun <T> MutableList<T>.rotateLeft()

rotateRight

fun <T> MutableList<T>.rotateRight()

selectValues

fun <K, V> Map<K, V>.selectValues(keys: Iterable<K>): List<V>

selectValuesTo

fun <K, V, C : MutableCollection<in V>> Map<K, V>.selectValuesTo(destination: C, keys: Iterable<K>): C

sumOf

inline fun <T> Iterable<T>.sumOf(transform: (T) -> Float): Float

fun <T> Sequence<T>.sumOf(selector: (T) -> Float): Float

takeUnlessEmpty

fun <E, C : Collection<E>> C.takeUnlessEmpty(): C?

fun <K, V, M : Map<K, V>> M.takeUnlessEmpty(): M?

toEnumMap

inline fun <K : Enum<K>, V> Map<K, V>.toEnumMap(): EnumMap<K, V>

toEnumSet

inline fun <E : Enum<E>> Array<E>.toEnumSet(): EnumSet<E>

inline fun <E : Enum<E>> Collection<E>.toEnumSet(): EnumSet<E>

inline fun <E : Enum<E>> Iterable<E>.toEnumSet(): EnumSet<E>

inline fun <E : Enum<E>> Sequence<E>.toEnumSet(): EnumSet<E>

treeMapOf

fun <K, V> treeMapOf(vararg pairs: Pair<K, V>): TreeMap<K, V>

weakHashSet

fun <K> weakHashSet(): MutableSet<K>

fun <K> weakHashSet(initialCapacity: Int): MutableSet<K>

weakHashSetOf

fun <K> weakHashSetOf(vararg elements: K): MutableSet<K>