polyui/org.polyfrost.polyui.utils/LinkedList

LinkedList

class LinkedList<T> : MutableList<T> , Cloneable

Implementation of the MutableList interface for PolyUI.

This is a doubly-linked list, with special "fast" methods:

these methods are all designed to avoid the allocation of an Iterator object, as otherwise PolyUI would create a lot of garbage.

this collection, unlike most of the collections in the Java Collections Framework, does not make any effort to check against concurrent modification. this allows you to do some "quirky" things, such as iterating over the list and removing elements at the same time.

Being a linked list, the random get and put operations are not the best. However, this operation is rare in PolyUI, so it's okay to use this.

Since

1.0.0

See also

Constructors

constructor(elements: Collection<T>)

constructor(vararg elements: T)

constructor()

Types

class LLIterator<T>(it: LinkedList<T>, startIndex: Int) : MutableListIterator<T>

iterator for LinkedList.

@ApiStatus.Internal

class Node<T>(var value: T, var next: LinkedList.Node<T>? = null, var prev: LinkedList.Node<T>? = null)

Properties

var end: LinkedList.Node<T>?

open override var size: Int

var start: LinkedList.Node<T>?

Functions

@ApiStatus.Internal

fun _remove(node: LinkedList.Node<T>)

Remove a node from a LinkedList. Note that if the node does not belong in this list, the behaviour is undefined.

open override fun add(element: T): Boolean

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

fun addAll(elements: Array<out T>)

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

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

fun addIfAbsent(element: T & Any): Boolean

fun addOrReplace(element: T & Any): T?

Adds or replaces an element in the list. If the element is already in the list (using equals), it will be replaced, otherwise it will be added.

inline fun allAre(predicate: (T) -> Boolean): Boolean

Returns true if all elements match the given predicate.

inline fun <T> Collection<T>.asLinkedList(): LinkedList<T>

Return this collection as an LinkedList. Note: if it is already a LinkedList, it will be returned as-is.

open override fun clear()

fun clear(unlink: Boolean)

inline fun clearing(function: (T) -> Unit): Boolean

open override fun clone(): LinkedList<T>

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

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

fun copy(): LinkedList<T>

fun cut(from: Int, to: Int)

Sublist this list in the range of from to to, discarding any elements outside of that range.

fun <T> MutableList<T>.ensureSize(size: Int, initializer: (Int) -> T): MutableList<T>

Ensure that this list is at least size elements long, and if it is not, add elements to it using the given initializer.

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

inline fun fastEach(action: (T) -> Unit)

fastEachIndexed

inline fun fastEachIndexed(action: (Int, T) -> Unit)

fastEachReversed

inline fun fastEachReversed(action: (T) -> Unit)

inline fun fastRemoveIf(predicate: (T) -> Boolean): Boolean

fastRemoveIfIndexed

inline fun fastRemoveIfIndexed(predicate: (Int, T) -> Boolean): Boolean

fastRemoveIfReversed

inline fun fastRemoveIfReversed(predicate: (T) -> Boolean): Boolean

inline fun first(): T

inline fun first(predicate: (T) -> Boolean): T

inline fun firstOrNull(): T?

open fun forEach(p0: Consumer<in T>)

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

open override fun hashCode(): Int

open override fun indexOf(element: T): Int

open override fun isEmpty(): Boolean

open operator override fun ~~iterator~~(): MutableListIterator<T>

inline fun last(): T

open override fun lastIndexOf(element: T): Int

inline fun lastOrNull(): T?

open override fun ~~listIterator~~(): MutableListIterator<T>

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

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

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

Perform the given transform on every element in this list, and return a new array with the results.

open fun parallelStream(): Stream<T>

open override fun remove(element: T): Boolean

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

open override fun removeAt(index: Int): T

open fun removeIf(p0: Predicate<in T>): Boolean

open fun replaceAll(p0: UnaryOperator<T>)

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

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

open fun sort(p0: Comparator<in T>)

open override fun spliterator(): Spliterator<T>

open fun stream(): Stream<T>

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

open fun <T : Any> ~~toArray~~(p0: IntFunction<Array<T>>): Array<T>

open override fun toString(): String