kone.collections/dev.lounres.kone.collections.list.implementations/KoneArrayFixedCapacityLinkedNoddedList

KoneArrayFixedCapacityLinkedNoddedList

@Serializable(with = KoneArrayFixedCapacityLinkedNoddedListSerializer::class)
class KoneArrayFixedCapacityLinkedNoddedList<Element> : KoneMutableNoddedList<Element> , Disposable(source)

Represents a doubly linked nodded list that is laid out on three arrays of the same fixed capacity instead of using object nodes.

Implementation details

Usual doubly linked list consists of nodes that store elements and references to the next and the previous nodes. In case of this implementation the three jobs are spread between the three arrays data, nextNodeIndex, and previousNodeIndex.

Actually, there are two types of nodes, nodes with elements and nodes without them. All the nodes have their own "actual" indices from 0 to capacity exclusive. They are connected in a (oriented) cycle in a such way that element-containing and empty nodes form two separate connected components. (I.e. at first element-containing nodes are placed in the cycle and then empty nodes are placed in the cycle.) For each node with actual index i, ith elements in nextNodeIndex and previousNodeIndex are actual indices of the next and the previous nodes correspondingly. As a corollary,

nextNodeIndex[previousNodeIndex[i]] == i
previousNodeIndex[nextNodeIndex[i]] == i
Content copied to clipboard

There are also two references, start and end that are pointing to the first and the last element-containing nodes. But if all the nodes are empty, then start and end are pointing on any two consequent nodes, where end's node is going after start's node.

Then all element-containing nodes are consequently numbered by "virtual" indices from 0 to size exclusive. This virtual indices are exposed as the list's indices.

Finally, the data array contains the ith actual node in its ith position. Actual node is an object that is returned by getNode and addNode.

After each operation the structure is preserved in a state that meets the invariants above.

Time complexity of operations

It's obvious that getting actual index corresponding to the list's index takes \(\Theta(\mathrm{size})\) time (both in worst case and in average). Thus, all operations that involve getting actual index take (both in worst case and in average) at least \(\Theta(\mathrm{size})\) time. Other operations that reuse already computed actual indices (including all iterator's and node's operations) take constant time.

OperationWorst caseAverage
size\(\Theta(1)\)\(\Theta(1)\)
get\(\Theta(\mathrm{size})\)\(\Theta(\mathrm{size})\)
set\(\Theta(\mathrm{size})\)\(\Theta(\mathrm{size})\)
add\(\Theta(1)\)\(\Theta(1)\)
addAt\(\Theta(\mathrm{size})\)\(\Theta(\mathrm{size})\)
addSeveral\(\Theta(\mathrm{number})\)\(\Theta(\mathrm{number})\)
addSeveralAt\(\Theta(\mathrm{size} + \mathrm{number})\)\(\Theta(\mathrm{size} + \mathrm{number})\)
removeAt\(\Theta(\mathrm{size})\)\(\Theta(\mathrm{size})\)
removeAllThat\(\Theta(\mathrm{size})\)\(\Theta(\mathrm{size})\)
removeAllThatIndexed\(\Theta(\mathrm{size})\)\(\Theta(\mathrm{size})\)
removeAll\(\Theta(\mathrm{size})\)\(\Theta(\mathrm{size})\)
iterator\(\Theta(1)\)\(\Theta(1)\)
iteratorFrom\(\Theta(\mathrm{size})\)\(\Theta(\mathrm{size})\)
KoneSettableLinearIterator.hasNext\(\Theta(1)\)\(\Theta(1)\)
KoneSettableLinearIterator.hasPrevious\(\Theta(1)\)\(\Theta(1)\)
KoneSettableLinearIterator.getNext\(\Theta(1)\)\(\Theta(1)\)
KoneSettableLinearIterator.getPrevious\(\Theta(1)\)\(\Theta(1)\)
KoneSettableLinearIterator.moveNext\(\Theta(1)\)\(\Theta(1)\)
KoneSettableLinearIterator.movePrevious\(\Theta(1)\)\(\Theta(1)\)
KoneSettableLinearIterator.setNext\(\Theta(1)\)\(\Theta(1)\)
KoneSettableLinearIterator.setPrevious\(\Theta(1)\)\(\Theta(1)\)
KoneSettableLinearIterator.setNext\(\Theta(1)\)\(\Theta(1)\)
KoneSettableLinearIterator.setPrevious\(\Theta(1)\)\(\Theta(1)\)
KoneSettableLinearIterator.setNext\(\Theta(1)\)\(\Theta(1)\)
KoneSettableLinearIterator.setPrevious\(\Theta(1)\)\(\Theta(1)\)
KoneSettableLinearIterator.nextIndex\(\Theta(1)\)\(\Theta(1)\)
KoneSettableLinearIterator.previousIndex\(\Theta(1)\)\(\Theta(1)\)
node.element\(\Theta(1)\)\(\Theta(1)\)
node.index\(\Theta(\mathrm{size})\)\(\Theta(\mathrm{size})\)
node.remove\(\Theta(1)\)\(\Theta(1)\)
node.nextNode\(\Theta(1)\)\(\Theta(1)\)
node.previousNode\(\Theta(1)\)\(\Theta(1)\)
node.iteratorFromBeforeHere\(\Theta(\mathrm{size})\) (for now)\(\Theta(\mathrm{size})\) (for now)
node.iteratorFromAfterHere\(\Theta(\mathrm{size})\) (for now)\(\Theta(\mathrm{size})\) (for now)

Properties

Link copied to clipboard
val KoneList<*>.indices: UIntRange

Returns the list's indices range.

Link copied to clipboard
open override var isDisposed: Boolean

Flag of being disposed.

Link copied to clipboard
val KoneList<*>.lastIndex: UInt

Returns the last index of elements in the list.

Link copied to clipboard
open override var size: UInt

Number of elements in the collection.

Functions

Link copied to clipboard
open override fun add(element: Element)

Adds provided element at the end of the ordered collection.

Link copied to clipboard
fun <Element> KoneMutableList<Element>.addAllFrom(elements: KoneIterable<Element>)

Adds provided elements at the end of the ordered collection.

Link copied to clipboard
fun <Element> KoneMutableList<Element>.addAllFromAt(index: UInt, elements: KoneIterable<Element>)

Adds provided elements before element with index index.

Link copied to clipboard
open override fun addAt(index: UInt, element: Element)

Adds provided element before element with index index.

Link copied to clipboard
open override fun addNode(element: Element): KoneMutableListNode<Element>

Adds provided element at the end of the ordered collection and returns its corresponding node.

Link copied to clipboard
open override fun addNodeAt(index: UInt, element: Element): KoneMutableListNode<Element>

Adds provided element before element with index index and returns its corresponding node.

Link copied to clipboard
open override fun addSeveral(number: UInt, builder: (UInt) -> Element)

Adds provided number of elements at the end of the ordered collection. ith new element is a result of builder(i). The builder is consecutively called on indices from 0 to number exclusive.

Link copied to clipboard
open override fun addSeveralAt(index: UInt, number: UInt, builder: (UInt) -> Element)

Adds provided number of elements before element with index index. ith new element is a result of builder(i). The builder is consecutively called on indices from 0 to number exclusive.

Link copied to clipboard
inline fun <E> KoneIterable<E>.all(block: (value: E) -> Boolean): Boolean
Link copied to clipboard
inline fun <E> KoneIterable<E>.allIndexed(block: (index: UInt, value: E) -> Boolean): Boolean
Link copied to clipboard
inline fun <E> KoneIterable<E>.any(block: (value: E) -> Boolean): Boolean
Link copied to clipboard
inline fun <E> KoneIterable<E>.anyIndexed(block: (index: UInt, value: E) -> Boolean): Boolean
Link copied to clipboard
Link copied to clipboard
inline fun <Element, Key, Value> KoneIterable<Element>.associate(keyEquality: Equality<Key> = defaultEquality(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, transform: (Element) -> KoneMapEntry<Key, Value>): KoneMap<Key, Value>
inline fun <T, K, V> KoneIterable<T>.associate(keyEquality: Equality<K> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, transform: (T) -> Pair<K, V>, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneMap<K, V>
Link copied to clipboard
inline fun <Element, Key> KoneIterable<Element>.associateBy(keyEquality: Equality<Key> = defaultEquality(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key): KoneMap<Key, Element>
inline fun <Element, Key, Value> KoneIterable<Element>.associateBy(keyEquality: Equality<Key> = defaultEquality(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key, valueTransform: (Element) -> Value): KoneMap<Key, Value>
inline fun <T, K> KoneIterable<T>.associateBy(keyEquality: Equality<K> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, resolve: (key: K, currentValue: T, newValue: T) -> T): KoneMap<K, T>
inline fun <T, K, V> KoneIterable<T>.associateBy(keyEquality: Equality<K> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, valueTransform: (T) -> V, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneMap<K, V>
Link copied to clipboard
inline fun <Element, Key> KoneIterable<Element>.associateByReified(keyEquality: Equality<Key> = defaultEquality(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key): KoneReifiedMap<Key, Element>
inline fun <Element, Key, Value> KoneIterable<Element>.associateByReified(keyEquality: Equality<Key> = defaultEquality(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key, valueTransform: (Element) -> Value): KoneReifiedMap<Key, Value>
inline fun <Element, Key> KoneIterable<Element>.associateByReified(keyReification: Reification<Key>, keyEquality: Equality<Key> = defaultEquality(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key): KoneReifiedMap<Key, Element>
inline fun <Element, Key, Value> KoneIterable<Element>.associateByReified(keyReification: Reification<Key>, keyEquality: Equality<Key> = defaultEquality(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key, valueTransform: (Element) -> Value): KoneReifiedMap<Key, Value>
inline fun <T, K> KoneIterable<T>.associateByReified(keyEquality: Equality<K> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, resolve: (key: K, currentValue: T, newValue: T) -> T): KoneReifiedMap<K, T>
inline fun <T, K, V> KoneIterable<T>.associateByReified(keyEquality: Equality<K> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, valueTransform: (T) -> V, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneReifiedMap<K, V>
inline fun <T, K> KoneIterable<T>.associateByReified(keyReification: Reification<K>, keyEquality: Equality<K> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, resolve: (key: K, currentValue: T, newValue: T) -> T): KoneReifiedMap<K, T>
inline fun <T, K, V> KoneIterable<T>.associateByReified(keyReification: Reification<K>, keyEquality: Equality<K> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, valueTransform: (T) -> V, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneReifiedMap<K, V>
Link copied to clipboard
inline fun <Element, Key, Destination : KoneMutableMap<in Key, in Element>> KoneIterable<Element>.associateByTo(destination: Destination, keySelector: (Element) -> Key): Destination
inline fun <Element, Key, Value, Destination : KoneMutableMap<in Key, in Value>> KoneIterable<Element>.associateByTo(destination: Destination, keySelector: (Element) -> Key, valueTransform: (Element) -> Value): Destination
inline fun <T, K, D : KoneMutableMap<K, T>> KoneIterable<T>.associateByTo(destination: D, keySelector: (T) -> K, resolve: (key: K, currentValue: T, newValue: T) -> T): D
inline fun <T, K, V, D : KoneMutableMap<in K, V>> KoneIterable<T>.associateByTo(destination: D, keySelector: (T) -> K, valueTransform: (T) -> V, resolve: (key: K, currentValue: V, newValue: V) -> V): D
Link copied to clipboard
inline fun <Element, Key, Value> KoneIterable<Element>.associateReified(keyEquality: Equality<Key> = defaultEquality(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, transform: (Element) -> KoneMapEntry<Key, Value>): KoneReifiedMap<Key, Value>
inline fun <Element, Key, Value> KoneIterable<Element>.associateReified(keyReification: Reification<Key>, keyEquality: Equality<Key> = defaultEquality(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, transform: (Element) -> KoneMapEntry<Key, Value>): KoneReifiedMap<Key, Value>
inline fun <T, K, V> KoneIterable<T>.associateReified(keyEquality: Equality<K> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, transform: (T) -> Pair<K, V>, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneReifiedMap<K, V>
inline fun <T, K, V> KoneIterable<T>.associateReified(keyReification: Reification<K>, keyEquality: Equality<K> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, transform: (T) -> Pair<K, V>, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneReifiedMap<K, V>
Link copied to clipboard
inline fun <Element, Key, Value, Destination : KoneMutableMap<in Key, in Value>> KoneIterable<Element>.associateTo(destination: Destination, transform: (Element) -> KoneMapEntry<Key, Value>): Destination
inline fun <T, K, V, D : KoneMutableMap<K, V>> KoneIterable<T>.associateTo(destination: D, transform: (T) -> Pair<K, V>, resolve: (key: K, currentValue: V, newValue: V) -> V): D
Link copied to clipboard
inline fun <Key, Value> KoneIterable<Key>.associateWith(keyEquality: Equality<Key> = defaultEquality(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, valueSelector: (Key) -> Value): KoneMap<Key, Value>
Link copied to clipboard
inline fun <Key, Value> KoneIterable<Key>.associateWithReified(keyEquality: Equality<Key> = defaultEquality(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, valueSelector: (Key) -> Value): KoneReifiedMap<Key, Value>
inline fun <Key, Value> KoneIterable<Key>.associateWithReified(keyReification: Reification<Key>, keyEquality: Equality<Key> = defaultEquality(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, valueSelector: (Key) -> Value): KoneReifiedMap<Key, Value>
Link copied to clipboard
inline fun <Key, Value, Destination : KoneMutableMap<in Key, in Value>> KoneIterable<Key>.associateWithTo(destination: Destination, valueSelector: (Key) -> Value): Destination
Link copied to clipboard
operator fun <E> KoneList<E>.component1(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component10(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component11(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component12(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component13(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component14(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component15(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component2(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component3(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component4(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component5(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component6(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component7(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component8(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component9(): E
Link copied to clipboard
operator fun <Element> KoneIterable<Element>.contains(element: Element): Boolean
Link copied to clipboard
Link copied to clipboard
fun <E, D : KoneMutableList<in E>> KoneIterable<E>.copyTo(destination: D): D
fun <E, D : KoneMutableSet<in E>> KoneIterable<E>.copyTo(destination: D): D
Link copied to clipboard
inline fun <E> KoneIterable<E>.count(predicate: (value: E) -> Boolean): UInt
Link copied to clipboard
inline fun <E> KoneIterable<E>.countIndexed(predicate: (index: UInt, value: E) -> Boolean): UInt
Link copied to clipboard
open override fun dispose()

Disposes the structure and its dependent ones.

Link copied to clipboard
fun <E> KoneIterable<E>.drop(n: UInt): KoneList<E>
fun <E> KoneList<E>.drop(n: UInt): KoneList<E>
Link copied to clipboard
Link copied to clipboard
open operator override fun equals(other: Any?): Boolean
Link copied to clipboard
inline fun <E> KoneIterable<E>.filter(predicate: (E) -> Boolean): KoneList<E>
Link copied to clipboard
inline fun <E, D : KoneMutableList<in E>> KoneIterable<E>.filterTo(destination: D, predicate: (E) -> Boolean): D
inline fun <E, D : KoneMutableSet<in E>> KoneIterable<E>.filterTo(destination: D, predicate: (E) -> Boolean): D
Link copied to clipboard
fun <E> KoneIterable<E>.first(): E
Link copied to clipboard
fun <E> KoneList<E>.firstIndexOf(element: E): UInt
Link copied to clipboard
inline fun <E> KoneList<E>.firstIndexThat(predicate: (index: UInt, element: E) -> Boolean): UInt
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.firstOfThat(transform: (E) -> R, predicate: (R) -> Boolean): R
Link copied to clipboard
inline fun <E, R> KoneList<E>.firstOfThatIndexed(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): R
Link copied to clipboard
inline fun <E, R> KoneList<E>.firstOfThatIndexedMaybe(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): Maybe<R>
Link copied to clipboard
inline fun <E, R> KoneList<E>.firstOfThatIndexedOrNull(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): R?
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.firstOfThatMaybe(transform: (E) -> R, predicate: (R) -> Boolean): Maybe<R>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.firstOfThatOrNull(transform: (E) -> R, predicate: (R) -> Boolean): R?
Link copied to clipboard
inline fun <E> KoneIterable<E>.firstThat(predicate: (E) -> Boolean): E
Link copied to clipboard
inline fun <E> KoneList<E>.firstThatIndexed(predicate: (index: UInt, E) -> Boolean): E
Link copied to clipboard
inline fun <E> KoneList<E>.firstThatIndexedMaybe(predicate: (index: UInt, E) -> Boolean): Maybe<E>
Link copied to clipboard
inline fun <E> KoneList<E>.firstThatIndexedOrNull(predicate: (index: UInt, E) -> Boolean): E?
Link copied to clipboard
inline fun <E> KoneIterable<E>.firstThatMaybe(predicate: (E) -> Boolean): Maybe<E>
Link copied to clipboard
inline fun <E> KoneIterable<E>.firstThatOrNull(predicate: (E) -> Boolean): E?
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.flatMap(transform: (E) -> KoneIterable<R>): KoneList<R>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.flatMapIndexed(transform: (index: UInt, E) -> KoneIterable<R>): KoneList<R>
Link copied to clipboard
inline fun <E, R, D : KoneMutableList<in R>> KoneIterable<E>.flatMapIndexedTo(destination: D, transform: (index: UInt, E) -> KoneIterable<R>): D
inline fun <E, R, D : KoneMutableSet<in R>> KoneIterable<E>.flatMapIndexedTo(destination: D, transform: (index: UInt, E) -> KoneIterable<R>): D
Link copied to clipboard
inline fun <E, R, D : KoneMutableList<in R>> KoneIterable<E>.flatMapTo(destination: D, transform: (E) -> KoneIterable<R>): D
inline fun <E, R, D : KoneMutableSet<in R>> KoneIterable<E>.flatMapTo(destination: D, transform: (E) -> KoneIterable<R>): D
Link copied to clipboard
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.fold(initial: R, operation: (acc: R, E) -> R): R
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.foldIndexed(initial: R, operation: (index: UInt, acc: R, E) -> R): R
Link copied to clipboard
inline fun <E, R> KoneList<E>.foldRight(initial: R, operation: (acc: R, E) -> R): R
Link copied to clipboard
inline fun <E, R> KoneList<E>.foldRightIndexed(initial: R, operation: (index: UInt, acc: R, E) -> R): R
Link copied to clipboard
inline fun <E> KoneIterable<E>.forEach(block: (value: E) -> Unit)
Link copied to clipboard
inline fun <E> KoneIterable<E>.forEachIndexed(block: (index: UInt, value: E) -> Unit)
Link copied to clipboard
open operator override fun get(index: UInt): Element

Returns element that is placed at the provided index.

Link copied to clipboard
fun <Element> KoneList<Element>.getMaybe(index: UInt): Maybe<Element>

Returns the element at the provided index wrapped in Some or None if index is out of bounds.

Link copied to clipboard
open override fun getNode(index: UInt): KoneMutableListNode<Element>

Returns node that corresponds to the place with the provided index.

Link copied to clipboard
fun <Element> KoneList<Element>.getOrElse(index: UInt, block: () -> Element): Element
Link copied to clipboard
fun <Element> KoneList<Element>.getOrNull(index: UInt): Element?

Returns the element at the provided index or null if index is out of bounds.

Link copied to clipboard
inline fun <E, K> KoneIterable<E>.groupBy(keyEquality: Equality<K> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (E) -> K): KoneMap<K, KoneList<E>>
inline fun <E, K, V> KoneIterable<E>.groupBy(keyEquality: Equality<K> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (E) -> K, valueTransform: (E) -> V): KoneMap<K, KoneList<V>>
Link copied to clipboard
inline fun <E, K, D : KoneMutableMap<in K, KoneMutableList<E>>> KoneIterable<E>.groupByTo(destination: D, keySelector: (E) -> K): D
inline fun <E, K, V, D : KoneMutableMap<in K, KoneMutableList<V>>> KoneIterable<E>.groupByTo(destination: D, keySelector: (E) -> K, valueTransform: (E) -> V): D
Link copied to clipboard
inline fun <E, K> KoneIterable<E>.groupContextualBy(keyType: SuppliedType<K>, keySelector: (E) -> K): KoneMap<K, KoneList<E>>
inline fun <E, K, V> KoneIterable<E>.groupContextualBy(keyType: SuppliedType<K>, keySelector: (E) -> K, valueTransform: (E) -> V): KoneMap<K, KoneList<V>>
Link copied to clipboard
fun <E> KoneIterable<E>.hasDuplicates(elementEquality: Equality<E> = defaultEquality(), elementHashing: Hashing<E>? = null, elementOrder: Order<E>? = null): Boolean
Link copied to clipboard
Link copied to clipboard
open override fun hashCode(): Int
Link copied to clipboard
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.heapsortBy(selector: (E) -> R)
inline fun <E, R : Comparable<R>> KoneSettableList<E>.heapsortBy(selector: (E) -> R)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.heapsortByDescending(selector: (E) -> R)
inline fun <E, R : Comparable<R>> KoneSettableList<E>.heapsortByDescending(selector: (E) -> R)
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.heapsortedBy(selector: (E) -> R): KoneList<E>
inline fun <E, R : Comparable<R>> KoneIterable<E>.heapsortedBy(selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.heapsortedByDescending(selector: (E) -> R): KoneList<E>
inline fun <E, R : Comparable<R>> KoneIterable<E>.heapsortedByDescending(selector: (E) -> R): KoneList<E>
Link copied to clipboard
Link copied to clipboard
fun <E> KoneIterable<E>.heapsortedWith(comparator: Comparator<E>): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.heapsortedWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.heapsortedWithByDescending(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
Link copied to clipboard
fun <E> KoneSettableList<E>.heapsortWith(comparator: Comparator<E>)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.heapsortWithBy(comparator: Comparator<R>, selector: (E) -> R)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.heapsortWithByDescending(comparator: Comparator<R>, selector: (E) -> R)
Link copied to clipboard
Link copied to clipboard
fun <Element> KoneIterable<Element>.isEmpty(): Boolean

Checks if the iterable is empty.

Link copied to clipboard
fun <Element> KoneIterable<Element>.isNotEmpty(): Boolean

Checks if the iterable is not empty.

Link copied to clipboard
open operator override fun iterator(): KoneMutableNoddedListIterator<Element>

Initiates an iterator over the collection's elements with pointer before the first element.

Link copied to clipboard
open override fun iteratorFrom(index: UInt): KoneMutableNoddedListIterator<Element>

Initiates an iterator over the collection's elements with pointer between elements with indices index - 1 and index correspondingly.

Link copied to clipboard
fun <E, A : Appendable> KoneIterable<E>.joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: UInt = UInt.MAX_VALUE, truncated: CharSequence = "...", transform: (E) -> CharSequence? = null): A
Link copied to clipboard
fun <E> KoneIterable<E>.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: UInt = UInt.MAX_VALUE, truncated: CharSequence = "...", transform: (E) -> CharSequence? = null): String
Link copied to clipboard
fun <E> KoneList<E>.last(): E
Link copied to clipboard
fun <E> KoneList<E>.lastIndexOf(element: E): UInt
Link copied to clipboard
inline fun <E> KoneList<E>.lastIndexThat(predicate: (index: UInt, element: E) -> Boolean): UInt
Link copied to clipboard
inline fun <E, R> KoneList<E>.lastOfThat(transform: (E) -> R, predicate: (R) -> Boolean): R
Link copied to clipboard
inline fun <E, R> KoneList<E>.lastOfThatIndexed(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): R
Link copied to clipboard
inline fun <E, R> KoneList<E>.lastOfThatIndexedMaybe(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): Maybe<R>
Link copied to clipboard
inline fun <E, R> KoneList<E>.lastOfThatIndexedOrNull(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): R?
Link copied to clipboard
inline fun <E, R> KoneList<E>.lastOfThatMaybe(transform: (E) -> R, predicate: (R) -> Boolean): Maybe<R>
Link copied to clipboard
inline fun <E, R> KoneList<E>.lastOfThatOrNull(transform: (E) -> R, predicate: (R) -> Boolean): R?
Link copied to clipboard
inline fun <E> KoneList<E>.lastThat(predicate: (E) -> Boolean): E
Link copied to clipboard
inline fun <E> KoneList<E>.lastThatIndexed(predicate: (index: UInt, E) -> Boolean): E
Link copied to clipboard
inline fun <E> KoneList<E>.lastThatIndexedMaybe(predicate: (index: UInt, E) -> Boolean): Maybe<E>
Link copied to clipboard
inline fun <E> KoneList<E>.lastThatIndexedOrNull(predicate: (index: UInt, E) -> Boolean): E?
Link copied to clipboard
inline fun <E> KoneList<E>.lastThatMaybe(predicate: (E) -> Boolean): Maybe<E>
Link copied to clipboard
inline fun <E> KoneList<E>.lastThatOrNull(predicate: (E) -> Boolean): E?
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.map(transform: (E) -> R): KoneList<R>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.mapIndexed(transform: (index: UInt, E) -> R): KoneList<R>
Link copied to clipboard
inline fun <E, R, D : KoneMutableList<in R>> KoneIterable<E>.mapIndexedTo(destination: D, transform: (index: UInt, E) -> R): D
inline fun <E, R, D : KoneMutableSet<in R>> KoneIterable<E>.mapIndexedTo(destination: D, transform: (index: UInt, E) -> R): D
Link copied to clipboard
inline fun <E, R, D : KoneMutableList<in R>> KoneIterable<E>.mapTo(destination: D, transform: (E) -> R): D
inline fun <E, R, D : KoneMutableSet<in R>> KoneIterable<E>.mapTo(destination: D, transform: (E) -> R): D
Link copied to clipboard
fun <E> KoneIterable<E>.max(): E
fun <E : Comparable<E>> KoneIterable<E>.max(): E
Link copied to clipboard
fun <E, R> KoneIterable<E>.maxBy(selector: (E) -> R): E
fun <E, R : Comparable<R>> KoneIterable<E>.maxBy(selector: (E) -> R): E
Link copied to clipboard
Link copied to clipboard
fun <E, R> KoneIterable<E>.maxListBy(selector: (E) -> R): KoneList<E>
fun <E, R : Comparable<R>> KoneIterable<E>.maxListBy(selector: (E) -> R): KoneList<E>
Link copied to clipboard
fun <E, R> KoneIterable<E>.maxListOf(selector: (E) -> R): KoneList<R>
fun <E, R : Comparable<R>> KoneIterable<E>.maxListOf(selector: (E) -> R): KoneList<R>
Link copied to clipboard
fun <E> KoneIterable<E>.maxListWith(comparator: Comparator<E>): KoneList<E>
Link copied to clipboard
fun <E, R> KoneIterable<E>.maxListWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
fun <E, R> KoneIterable<E>.maxListWithOf(comparator: Comparator<R>, selector: (E) -> R): KoneList<R>
Link copied to clipboard
fun <E, R> KoneIterable<E>.maxOf(selector: (E) -> R): R
fun <E, R : Comparable<R>> KoneIterable<E>.maxOf(selector: (E) -> R): R
Link copied to clipboard
fun <E, R : Comparable<R>> KoneIterable<E>.maxOfOrNull(selector: (E) -> R): R?
Link copied to clipboard
fun <E> KoneIterable<E>.maxWith(comparator: Comparator<E>): E
Link copied to clipboard
fun <E, R> KoneIterable<E>.maxWithBy(comparator: Comparator<R>, selector: (E) -> R): E
Link copied to clipboard
fun <E, R> KoneIterable<E>.maxWithOf(comparator: Comparator<R>, selector: (E) -> R): R
Link copied to clipboard
fun <E> KoneIterable<E>.min(): E
fun <E : Comparable<E>> KoneIterable<E>.min(): E
Link copied to clipboard
fun <E, R> KoneIterable<E>.minBy(selector: (E) -> R): E
fun <E, R : Comparable<R>> KoneIterable<E>.minBy(selector: (E) -> R): E
Link copied to clipboard
Link copied to clipboard
fun <E, R> KoneIterable<E>.minListBy(selector: (E) -> R): KoneList<E>
fun <E, R : Comparable<R>> KoneIterable<E>.minListBy(selector: (E) -> R): KoneList<E>
Link copied to clipboard
fun <E, R> KoneIterable<E>.minListOf(selector: (E) -> R): KoneList<R>
fun <E, R : Comparable<R>> KoneIterable<E>.minListOf(selector: (E) -> R): KoneList<R>
Link copied to clipboard
fun <E> KoneIterable<E>.minListWith(comparator: Comparator<E>): KoneList<E>
Link copied to clipboard
fun <E, R> KoneIterable<E>.minListWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
fun <E, R> KoneIterable<E>.minListWithOf(comparator: Comparator<R>, selector: (E) -> R): KoneList<R>
Link copied to clipboard
fun <E, R> KoneIterable<E>.minOf(selector: (E) -> R): R
fun <E, R : Comparable<R>> KoneIterable<E>.minOf(selector: (E) -> R): R
Link copied to clipboard
fun <E> KoneIterable<E>.minWith(comparator: Comparator<E>): E
Link copied to clipboard
fun <E, R> KoneIterable<E>.minWithBy(comparator: Comparator<R>, selector: (E) -> R): E
Link copied to clipboard
fun <E, R> KoneIterable<E>.minWithOf(comparator: Comparator<R>, selector: (E) -> R): R
Link copied to clipboard
inline fun <E> KoneIterable<E>.none(block: (value: E) -> Boolean): Boolean
Link copied to clipboard
inline fun <E> KoneIterable<E>.noneIndexed(block: (index: UInt, value: E) -> Boolean): Boolean
Link copied to clipboard
operator fun <E> KoneMutableList<E>.plusAssign(element: E)
operator fun <E> KoneMutableList<E>.plusAssign(elements: KoneIterable<E>)
Link copied to clipboard
fun <E> KoneIterable<E>.product(): E
Link copied to clipboard
fun <E, N> KoneIterable<E>.productOf(selector: (E) -> N): N
Link copied to clipboard
inline fun <E, N> KoneIterable<E>.productOfIndexed(selector: (index: UInt, E) -> N): N
Link copied to clipboard
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.quicksortBy(selector: (E) -> R)
inline fun <E, R : Comparable<R>> KoneSettableList<E>.quicksortBy(selector: (E) -> R)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.quicksortByDescending(selector: (E) -> R)
inline fun <E, R : Comparable<R>> KoneSettableList<E>.quicksortByDescending(selector: (E) -> R)
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.quicksortedBy(selector: (E) -> R): KoneList<E>
inline fun <E, R : Comparable<R>> KoneIterable<E>.quicksortedBy(selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.quicksortedByDescending(selector: (E) -> R): KoneList<E>
inline fun <E, R : Comparable<R>> KoneIterable<E>.quicksortedByDescending(selector: (E) -> R): KoneList<E>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.quicksortedWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.quicksortedWithByDescending(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
Link copied to clipboard
fun <E> KoneSettableList<E>.quicksortWith(comparator: Comparator<E>)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.quicksortWithBy(comparator: Comparator<R>, selector: (E) -> R)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.quicksortWithByDescending(comparator: Comparator<R>, selector: (E) -> R)
Link copied to clipboard
Link copied to clipboard
fun <E> KoneIterable<E>.random(random: Random): E
Link copied to clipboard
inline fun <E : R, R> KoneIterable<E>.reduce(operation: (acc: R, E) -> R): R
Link copied to clipboard
inline fun <E : R, R> KoneIterable<E>.reduceIndexed(operation: (index: UInt, acc: R, E) -> R): R
Link copied to clipboard
inline fun <E : R, R> KoneIterable<E>.reduceIndexedMaybe(operation: (index: UInt, acc: R, E) -> R): Maybe<R>
Link copied to clipboard
inline fun <E : R, R> KoneIterable<E>.reduceIndexedOrNull(operation: (index: UInt, acc: R, E) -> R): R?
Link copied to clipboard
inline fun <E : R, R> KoneIterable<E>.reduceMaybe(operation: (acc: R, E) -> R): Maybe<R>
Link copied to clipboard
inline fun <E : R, R> KoneIterable<E>.reduceOrNull(operation: (acc: R, E) -> R): R?
Link copied to clipboard
Link copied to clipboard
open override fun removeAll()

Removes all elements and their places from the collection.

Link copied to clipboard
open fun removeAllThat(predicate: (element: Element) -> Boolean)

Removes elements that satisfy the provided predicate.

Link copied to clipboard
open override fun removeAllThatIndexed(predicate: (index: UInt, element: Element) -> Boolean)

Removes elements that satisfy the provided predicate.

Link copied to clipboard
open override fun removeAt(index: UInt)

Removes element with the provided index.

Link copied to clipboard
inline fun <Element> KoneMutableList<Element>.retainAllThat(crossinline predicate: (element: Element) -> Boolean)

Iterates over the collection and retains only the elements matching the predicate.

Link copied to clipboard
inline fun <Element> KoneMutableList<Element>.retainAllThatIndexed(crossinline predicate: (index: UInt, element: Element) -> Boolean)

Iterates over the collection and retains only the elements matching the predicate.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.runningFold(initial: R, operation: (acc: R, E) -> R): KoneList<R>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.runningFoldIndexed(initial: R, operation: (index: UInt, acc: R, E) -> R): KoneList<R>
Link copied to clipboard
open operator override fun set(index: UInt, element: Element)

Sets another value at the place with the provided index with respect to inner order of elements.

Link copied to clipboard
fun <E> KoneSettableList<E>.shuffle(random: Random = Random)
Link copied to clipboard
fun <E> KoneIterable<E>.shuffled(random: Random = Random): KoneList<E>
Link copied to clipboard
fun <E> KoneIterable<E>.single(): E
Link copied to clipboard
fun <E> KoneList<E>.slice(fromIndex: UInt, toIndex: UInt): KoneList<E>
Link copied to clipboard
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.sortBy(selector: (E) -> R)
inline fun <E, R : Comparable<R>> KoneSettableList<E>.sortBy(selector: (E) -> R)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.sortByDescending(selector: (E) -> R)
inline fun <E, R : Comparable<R>> KoneSettableList<E>.sortByDescending(selector: (E) -> R)
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.sortedBy(selector: (E) -> R): KoneList<E>
inline fun <E, R : Comparable<R>> KoneIterable<E>.sortedBy(selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.sortedByDescending(selector: (E) -> R): KoneList<E>
inline fun <E, R : Comparable<R>> KoneIterable<E>.sortedByDescending(selector: (E) -> R): KoneList<E>
Link copied to clipboard
Link copied to clipboard
fun <E> KoneIterable<E>.sortedWith(comparator: Comparator<E>): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.sortedWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.sortedWithByDescending(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
Link copied to clipboard
fun <E> KoneSettableList<E>.sortWith(comparator: Comparator<E>)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.sortWithBy(comparator: Comparator<R>, selector: (E) -> R)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.sortWithByDescending(comparator: Comparator<R>, selector: (E) -> R)
Link copied to clipboard
Link copied to clipboard
fun <E> KoneIterable<E>.sum(): E
Link copied to clipboard
fun <E, N> KoneIterable<E>.sumOf(selector: (E) -> N): N
Link copied to clipboard
inline fun <E, N> KoneIterable<E>.sumOfIndexed(selector: (index: UInt, E) -> N): N
Link copied to clipboard
fun <E> KoneIterable<E>.take(n: UInt): KoneList<E>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <Element> KoneIterable<Element>.toKoneMutableReifiedSet(elementEquality: Equality<Element> = defaultEquality(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneMutableReifiedSet<Element>
fun <Element> KoneIterable<Element>.toKoneMutableReifiedSet(elementReification: Reification<Element>, elementEquality: Equality<Element> = defaultEquality(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneMutableReifiedSet<Element>
Link copied to clipboard
fun <Element> KoneIterable<Element>.toKoneMutableSet(elementEquality: Equality<Element> = defaultEquality(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneMutableSet<Element>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <Element> KoneIterable<Element>.toKoneReifiedSet(elementEquality: Equality<Element> = defaultEquality(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneReifiedSet<Element>
fun <Element> KoneIterable<Element>.toKoneReifiedSet(elementReification: Reification<Element>, elementEquality: Equality<Element> = defaultEquality(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneReifiedSet<Element>
Link copied to clipboard
fun <Element> KoneIterable<Element>.toKoneSet(elementEquality: Equality<Element> = defaultEquality(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneSet<Element>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
open override fun toString(): String
Link copied to clipboard
inline fun <E> KoneIterable<E>.withEach(block: E.() -> Unit)
Link copied to clipboard
inline fun <E> KoneIterable<E>.withEachIndexed(block: E.(index: UInt) -> Unit)
Link copied to clipboard