kollections-interoperable/kollections.internal/Queue

Queue

class Queue<E>(list: MutableList<E>) : AbstractCollection<E> , MutableList<E>

Constructors

Queue

constructor(vararg elms: E)

constructor(list: MutableList<E>)

Functions

add

open override fun add(element: E): Boolean

open override fun add(index: Int, element: E)

addAll

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

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

associate

open override fun <K2, V2> associate(transformer: (E) -> MapEntry<K2, V2>): Map<K2, V2>

clear

open override fun clear()

contains

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

containsAll

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

filter

open override fun filter(predicate: (E) -> Boolean): List<E>

first

open override fun first(): E

firstOrNull

open override fun firstOrNull(): E?

forEach

open override fun forEach(lambda: (item: E) -> Unit)

forEachWithIndex

open override fun forEachWithIndex(lambda: (item: E, index: Int) -> Unit)

get

open operator override fun get(index: Int): E

indexOf

open override fun indexOf(element: E): Int

isEmpty

open override fun isEmpty(): Boolean

iterator

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

lastIndexOf

open override fun lastIndexOf(element: E): Int

listIterator

open override fun listIterator(): MutableListIterator<E>

open override fun listIterator(index: Int): MutableListIterator<E>

map

open override fun <R> map(transform: (item: E) -> R): List<R>

mapToArray

open override fun <R> mapToArray(transform: (item: E) -> R): Array<R>

mapToArrayWithIndex

open override fun <R> mapToArrayWithIndex(transform: (item: E, index: Int) -> R): Array<R>

mapWithIndex

open override fun <R> mapWithIndex(transform: (item: E, index: Int) -> R): List<R>

remove

open override fun remove(element: E): Boolean

removeAll

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

removeAt

open override fun removeAt(index: Int): E

retainAll

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

set

open operator override fun set(index: Int, element: E): E

shift

fun shift(): E?

subList

open override fun subList(fromIndex: Int, toIndex: Int): MutableList<E>

toIList

inline fun <E> Collection<E>.toIList(): List<E>

toIMutableList

inline fun <E> Collection<E>.toIMutableList(): MutableList<E>

toIMutableSet

inline fun <E> Collection<E>.toIMutableSet(): MutableSet<E>

toISet

inline fun <E> Collection<E>.toISet(): Set<E>

Properties

size

open override val size: Int