commons-collections/xyz.xenondevs.commons.collections.observed/ObservableCollection

ObservableCollection

class ObservableCollection<E>(val collection: MutableCollection<E>, handleUpdate: () -> Unit) : MutableCollection<E>

Constructors

constructor(collection: MutableCollection<E>, handleUpdate: () -> Unit)

Properties

collection

val collection: MutableCollection<E>

size

open override val size: Int

Functions

add

open override fun add(element: E): Boolean

addAll

open override fun addAll(elements: Collection<E>): Boolean

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

clear

open override fun clear()

contains

open operator override fun contains(element: E): Boolean

containsAll

open override fun containsAll(elements: Collection<E>): Boolean

equals

open operator override fun equals(other: Any?): Boolean

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>

flatMapTo

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

hashCode

open override fun hashCode(): Int

intersects

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

isEmpty

open override fun isEmpty(): Boolean

isNotNullOrEmpty

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

isNullOrEmpty

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

iterator

open operator override fun iterator(): MutableIterator<E>

mapToArray

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> Collection<T>.mapToBooleanArray(transform: (T) -> Boolean): BooleanArray

mapToByteArray

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

mapToCharArray

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

mapToDoubleArray

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

mapToFloatArray

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

mapToIntArray

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

mapToLongArray

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

mapToShortArray

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

poll

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

pollFirstWhere

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

remove

open override fun remove(element: E): Boolean

removeAll

open override fun removeAll(elements: Collection<E>): Boolean

removeFirstWhere

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

removeIf

open override fun removeIf(filter: Predicate<in E>): Boolean

retainAll

open override fun retainAll(elements: Collection<E>): Boolean

sumOf

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

toEnumSet

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

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

toString

open override fun toString(): String