korlibs-datastructure/korlibs.datastructure/BaseSubMutableList

BaseSubMutableList

open class BaseSubMutableList<T>(val mlist: MutableList<T>, start: Int, end: Int) : BaseSubList<T> , BaseMutableList<T>

Constructors

BaseSubMutableList

constructor(mlist: MutableList<T>, start: Int, end: Int)

Properties

end

var end: Int

list

val list: List<T>

mlist

val mlist: MutableList<T>

size

open override val size: Int

start

var start: Int

Functions

add

open override fun add(element: T): Boolean

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

addAll

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

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

asFakeMutable

fun <K> Collection<K>.asFakeMutable(): FakeMutableCollection<K>

associateByInt

fun <T> Iterable<T>.associateByInt(block: (index: Int, value: T) -> Int): IntMap<T>

checkIndex

fun checkIndex(index: Int): Int

clear

open override fun clear()

contains

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

containsAll

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

countMap

fun <T> List<T>.countMap(): Map<T, Int>

fastForEach

inline fun <T> List<T>.fastForEach(callback: (T) -> Unit)

fastForEachReverse

inline fun <T> List<T>.fastForEachReverse(callback: (T) -> Unit)

fastForEachWithIndex

inline fun <T> List<T>.fastForEachWithIndex(callback: (index: Int, value: T) -> Unit)

fastForEachWithTemp

inline fun <T> List<T>.fastForEachWithTemp(temp: FastArrayList<T>, callback: (T) -> Unit)

fastIterateRemove

inline fun <T> MutableList<T>.fastIterateRemove(callback: (T) -> Boolean): MutableList<T>

fastRandom

inline fun <T> Collection<T>.fastRandom(): T

flatten

fun List<PointList>.flatten(): PointList

genericSort

fun <T : Comparable<T>> MutableList<T>.genericSort(left: Int = 0, right: Int = size - 1): MutableList<T>

genericSorted

fun <T : Comparable<T>> List<T>.genericSorted(left: Int = 0, right: Int = size - 1): List<T>

get

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

getCyclic

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

getCyclicOrNull

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

indexOf

open override fun indexOf(element: T): Int

isEmpty

open override fun isEmpty(): Boolean

iterator

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

lastIndexOf

open override fun lastIndexOf(element: T): Int

listIterator

open override fun listIterator(): MutableListIterator<T>

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

mapDouble

inline fun <T> Iterable<T>.mapDouble(callback: (T) -> Double): DoubleArrayList

mapFloat

inline fun <T> Iterable<T>.mapFloat(callback: (T) -> Float): FloatArrayList

mapInt

inline fun <T> Iterable<T>.mapInt(callback: (T) -> Int): IntArrayList

multisorted

fun <T> Iterable<T>.multisorted(vararg props: KProperty1<T, Comparable<*>>): List<T>

parallelMap

inline fun <T, R> List<T>.parallelMap(crossinline transform: (T) -> R): List<R>

parallelMapInt

inline fun <T> List<T>.parallelMapInt(crossinline transform: (T) -> Int): IntArray

reader

fun <T> List<T>.reader(): ListReader<T>

remove

open override fun remove(element: T): Boolean

removeAll

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

removeAt

open override fun removeAt(index: Int): T

retainAll

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

reverse

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

rotated

fun <T> List<T>.rotated(offset: Int): List<T>

rotatedLeft

fun <T> List<T>.rotatedLeft(offset: Int = +1): List<T>

rotatedRight

fun <T> List<T>.rotatedRight(offset: Int = +1): List<T>

rotateLeft

fun <T> MutableList<T>.rotateLeft(offset: Int = +1)

rotateRight

fun <T> MutableList<T>.rotateRight(offset: Int = +1)

set

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

subList

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

sumOfDouble

@JvmName(name = "sumOfFloat")

inline fun <T> Iterable<T>.sumOfDouble(selector: (T) -> Double): Double

sumOfFloat

@JvmName(name = "sumOfFloat")

inline fun <T> Iterable<T>.sumOfFloat(selector: (T) -> Float): Float

swap

fun <T> MutableList<T>.swap(lIndex: Int, rIndex: Int)

timSort

fun <T : Comparable<T>> MutableList<T>.timSort(left: Int = 0, right: Int = size - 1): MutableList<T>

timSorted

fun <T : Comparable<T>> List<T>.timSorted(): List<T>

toDeque

fun <T> Collection<T>.toDeque(): Deque<T>

toDoubleList

inline fun Iterable<Double>.toDoubleList(): DoubleArrayList

toFloatList

inline fun Iterable<Float>.toFloatList(): FloatArrayList

toIntList

inline fun Iterable<Int>.toIntList(): IntArrayList

toIntMap

fun <T> Collection<Pair<Int, T>>.toIntMap(): IntMap<T>

toLinkedMap

fun <K, V> Iterable<Pair<K, V>>.toLinkedMap(): LinkedHashMap<K, V>

toPointArrayList

fun List<Point>.toPointArrayList(): PointArrayList

withoutSortedDuplicates

fun <T> List<T>.withoutSortedDuplicates(out: ArrayList<T> = arrayListOf()): List<T>