renetik-android-core/renetik.android.core.kotlin.collections

Package-level declarations

Properties

beforeLast

val <T> List<T>.beforeLast: T?

count

val Collection<*>.count: Int

doubled

val <T> List<T>.doubled: List<T>

first

val <T> List<T>.first: T?

hasItems

val Collection<*>.hasItems: Boolean

last

val <T> List<T>.last: T?

lastIndex

val Collection<*>.lastIndex: Int

length

val Collection<*>.length: Int

second

val <T> List<T>.second: T?

third

val <T> List<T>.third: T?

Functions

add

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

addDistinct

fun <T, ListType : MutableList<T>> ListType.addDistinct(item: T): T

fun <T, ListType : MutableList<T>> ListType.addDistinct(items: List<T>): ListType

inline fun <T> List<T>.at(index: Int): T?

beforeLast

inline fun <T> List<T>.beforeLast(): T

clone

inline fun <T> List<T>.clone(): List<T>

inline fun <T> MutableList<T>.clone(): MutableList<T>

combine

inline fun <T, A, B> combine(arrayA: Array<A>, arrayB: Array<B>, createItem: (A, B) -> T): MutableList<T>

inline fun <T, A, B> combine(collectionA: Collection<A>, collectionB: Collection<B>, createItem: (A, B) -> T): MutableList<T>

contains

inline fun <T> Iterable<T>.contains(predicate: (T) -> Boolean): Boolean

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

containsAll

infix inline fun <T> List<T>.containsAll(items: Array<T>): Boolean

infix inline fun <T> List<T>.containsAll(items: Iterable<T>): Boolean

@JvmName(name = "containsAllVararg")

inline fun <T> List<T>.containsAll(vararg items: T): Boolean

containsAny

infix inline fun <T> List<T>.containsAny(items: Array<out T>): Boolean

infix inline fun <T> List<T>.containsAny(items: Iterable<T>): Boolean

@JvmName(name = "containsAnyVararg")

inline fun <T> List<T>.containsAny(vararg items: T): Boolean

containsNone

infix inline fun <T> List<T>.containsNone(items: Array<T>): Boolean

infix inline fun <T> List<T>.containsNone(items: Iterable<T>): Boolean

@JvmName(name = "containsNoneVararg")

inline fun <T> List<T>.containsNone(vararg items: T): Boolean

delete

fun <T, ListType : MutableList<T>> ListType.delete(item: T): T

fun <T, ListType : MutableList<T>> ListType.delete(index: Int): T?

inline fun <T> MutableList<T>.delete(filter: (T) -> Boolean): T?

deleteAll

fun <T, ListType : MutableList<T>> ListType.deleteAll(): ListType

deleteFirst

fun <T, ListType : MutableList<T>> ListType.deleteFirst(): T?

inline fun <T> MutableList<T>.deleteFirst(filter: (T) -> Boolean): T?

deleteIf

inline fun <T> MutableList<T>.deleteIf(filter: (T) -> Boolean): Boolean

deleteLast

fun <T, ListType : MutableList<T>> ListType.deleteLast(): T?

fun <K, V> LinkedHashMap<K, V>.deleteLast(): V?

fun <V> MutableSet<V>.deleteLast(): V?

inline fun <T> MutableList<T>.deleteLast(filter: (T) -> Boolean): T?

fifth

inline fun <T> List<T>.fifth(): T

filter

fun List<String>.filter(constraint: CharSequence? = null): List<String>

filterIgnoreAccents

fun List<String>.filterIgnoreAccents(constraint: CharSequence? = null): List<String>

find

inline fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T?

inline fun <K, V> Map<out K, V>.find(predicate: (Map.Entry<K, V>) -> Boolean): Map.Entry<K, V>?

first

inline fun <T> List<T>.first(): T

firstIndex

fun <T> Collection<T>.firstIndex(predicate: (T) -> Boolean): Int?

firstOfType

inline fun <T> Iterable<*>.firstOfType(): T?

five

inline fun <T> List<T>.five(): T

flipRange

fun List<Int>.flipRange(count: Int): List<Int>

flipRangeInPlace

fun MutableList<Int>.flipRangeInPlace(count: Int)

forEachReverse

inline fun <T> List<T>.forEachReverse(action: (T) -> Unit)

forEachWithPrevious

inline fun <T> Iterable<T>.forEachWithPrevious(function: (item: T, previous: T?) -> Unit)

four

inline fun <T> List<T>.four(): T

fourth

inline fun <T> List<T>.fourth(): T

getValue

fun <K, V> LinkedHashMap<K, V>.getValue(index: Int): V

hasAll

infix fun <T> Collection<T>.hasAll(items: Array<out T>): Boolean

infix fun <T> Collection<T>.hasAll(items: Iterable<T>): Boolean

infix fun <T> Collection<T>.hasAll(items: List<T>): Boolean

hasKey

fun <K, V> Map<K, V>.hasKey(key: K): Boolean

hasNot

infix fun <T> Collection<T>.hasNot(element: T): Boolean

fun <T> Collection<T>.hasNot(vararg elements: T): Boolean

hasValue

fun <K, V> Map<K, V>.hasValue(value: V): Boolean

index

fun <K, V> LinkedHashMap<K, V>.index(key: K): Int

fun <T> Collection<T>.index(item: T): Int?

isLast

infix inline fun <T> List<T>.isLast(item: T): Boolean

isLastIndex

infix inline fun <T> List<T>.isLastIndex(index: Int): Boolean

join

infix inline fun <T> List<T>.join(list: List<T>): List<T>

lastIndex

fun <T> Collection<T>.lastIndex(predicate: (T) -> Boolean): Int?

linkedMap

fun <K, V> linkedMap(): LinkedHashMap<K, V>

listOf

inline fun <T> listOf(size: Int, create: (index: Int, previous: T?) -> T): List<T>

mutable

inline fun <T> Collection<T>.mutable(): MutableList<T>

mutableAdd

inline fun <T> List<T>.mutableAdd(element: T): MutableList<T>

inline fun <T> List<T>.mutableAdd(index: Int, element: T): MutableList<T>

mutableListOf

fun <T> mutableListOf(size: Int): MutableList<T>

one

inline fun <T> List<T>.one(): T

plus

operator fun <T> MutableList<T>.plus(other: T): MutableList<T>

put

fun <T, ListType : MutableList<T>> ListType.put(item: T): T

fun <K, V> MutableMap<K, V>.put(pair: Pair<K, V>): MutableMap<K, V>

fun <T, ListType : MutableList<T>> ListType.put(item: T, index: Int): T

putAll

fun <T, ListType : MutableList<T>> ListType.putAll(items: Iterable<T>): ListType

fun <T, ListType : MutableList<T>> ListType.putAll(vararg items: T): ListType

range

fun <T> List<T>.range(from: (T) -> Boolean, to: (T) -> Boolean): List<T>

fun <T> List<T>.range(fromIndex: Int, toIndex: Int): List<T>

fun <T> MutableList<T>.range(fromIndex: Int, toIndex: Int): MutableList<T>

rangeFrom

fun <T> List<T>.rangeFrom(from: (T) -> Boolean): List<T>

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

fun <T> MutableList<T>.rangeFrom(index: Int): MutableList<T>

rangeTo

fun <T> List<T>.rangeTo(to: (T) -> Boolean): List<T>

fun <T> List<T>.rangeTo(toIndex: Int): List<T>

fun <T> MutableList<T>.rangeTo(index: Int): MutableList<T>

reload

infix fun <T, ListType : MutableList<T>> ListType.reload(values: Iterable<T>): ListType

fun <K, V> MutableMap<K, V>.reload(map: Map<K, V>): MutableMap<K, V>

fun <K, V> MutableMap<K, V>.reload(map: MutableMap<K, V>): MutableMap<K, V>

removeAll

fun <T> MutableIterator<T>.removeAll(condition: (T) -> Boolean)

removeAt

fun <K, V> LinkedHashMap<K, V>.removeAt(i: Int): V?

removeFirst

fun <T> MutableCollection<T>.removeFirst(condition: (T) -> Boolean): Boolean

fun <T> MutableIterator<T>.removeFirst(condition: (T) -> Boolean): Boolean

fun <K, V> MutableMap<K, V>.removeFirst(condition: (K, V) -> Boolean): Boolean

removeKey

fun <K, V> MutableMap<K, V>.removeKey(toRemove: K): Boolean

removeRange

fun <T> MutableList<T>.removeRange(fromIndex: Int): List<T>

removeValue

fun <K, V> MutableMap<K, V>.removeValue(toRemove: V): Boolean

replace

fun <T, ListType : MutableList<T>> ListType.replace(item: T, index: Int): T

replaceEqual

fun <T, ListType : MutableList<T>> ListType.replaceEqual(item: T): T

fun <T, ListType : MutableList<T>> ListType.replaceEqual(items: List<T>): ListType

second

inline fun <T> List<T>.second(): T

set

fun <T, ListType : MutableList<T>> ListType.set(item: T, index: Int): T

seven

inline fun <T> List<T>.seven(): T

seventh

inline fun <T> List<T>.seventh(): T

six

inline fun <T> List<T>.six(): T

sixth

inline fun <T> List<T>.sixth(): T

sortedWith

inline fun <T, R : Comparable<R>> MutableList<T>.sortedWith(crossinline using: (T) -> R?): MutableList<T>

swap

fun <T> List<T>.swap(first: Int, second: Int): List<T>

fun <T> MutableList<T>.swap(first: Int, second: Int)

third

inline fun <T> List<T>.third(): T

three

inline fun <T> List<T>.three(): T

two

inline fun <T> List<T>.two(): T

value

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