korlibs-datastructure/korlibs.datastructure

Package-level declarations

Types

Array2

open class Array2<TGen>(val width: Int, val height: Int, val data: Array<TGen>) : TGenIArray2<TGen>

BaseCacheMap

open class BaseCacheMap<K, V> : BaseMutableMap<K, V>

BaseDelegatedStackedArray2

open class BaseDelegatedStackedArray2(val other: IStackedArray2Base) : IStackedArray2Base

BaseList

interface BaseList<T> : List<T>

BaseListIterator

open class BaseListIterator<T>(val list: List<T>, var index: Int) : ListIterator<T>

BaseMap

interface BaseMap<K, V> : Map<K, V>

BaseMutableList

interface BaseMutableList<T> : BaseList<T> , MutableList<T>

BaseMutableListIterator

open class BaseMutableListIterator<T>(val mlist: MutableList<T>, index: Int) : BaseListIterator<T> , MutableListIterator<T>

BaseMutableMap

interface BaseMutableMap<K, V> : BaseMap<K, V> , MutableMap<K, V>

BaseObservableArray

abstract class BaseObservableArray<E>

BaseObservableArray1

abstract class BaseObservableArray1<T, E>(val updated: T.(IntRange) -> Unit) : BaseObservableArray<E>

BaseObservableArray2

abstract class BaseObservableArray2<T, E>(val base: IArray2<E>, val updated: T.(RectangleInt) -> Unit) : BaseObservableArray<E> , IArray2<E>

BaseSubList

open class BaseSubList<T>(val list: List<T>, start: Int, end: Int) : BaseList<T>

BaseSubMutableList

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

BitArray

class BitArray : AbstractList<Boolean> , Collection<Boolean>

Equivalent to BooleanArray but tightly packed to consume less memory, at the cost of being ~3-4x slower.

BitSet

class BitSet(val size: Int) : Collection<Boolean>

Fixed size BitSet. Similar to a BooleanArray but tightly packed to reduce memory usage.

BooleanArray2

open class BooleanArray2(val width: Int, val height: Int, val data: BooleanArray) : BooleanIArray2

BooleanArrayList

class BooleanArrayList(initialCapacity: Int = 7)

BooleanDeque

open class BooleanDeque(initialCapacity: Int) : MutableCollection<Boolean>

Deque structure supporting constant time of appending/removing from the start or the end of the list when there is room in the underlying array.

BooleanIArray2

interface BooleanIArray2 : IArray2<Boolean>

BSearchResult

inline class BSearchResult(val raw: Int)

ByteArray2

open class ByteArray2(val width: Int, val height: Int, val data: ByteArray) : ByteIArray2

ByteArrayDeque

class ByteArrayDeque(val initialBits: Int = 10, val allowGrow: Boolean = true)

ByteDeque

open class ByteDeque(initialCapacity: Int) : MutableCollection<Byte>

Deque structure supporting constant time of appending/removing from the start or the end of the list when there is room in the underlying array.

ByteIArray2

interface ByteIArray2 : IArray2<Byte>

ByteRingBuffer

open class ByteRingBuffer(val bits: Int)

CacheMap

open class CacheMap<K, V>(val maxSize: Int = 16) : BaseCacheMap<K, V>

CaseInsensitiveStringMap

class CaseInsensitiveStringMap<T> : MutableMap<String, T>

Map with String keys that are treated in a insensitive manner.

CharArray2

open class CharArray2(val width: Int, val height: Int, val data: CharArray) : CharIArray2

CharDeque

open class CharDeque(initialCapacity: Int) : MutableCollection<Char>

Deque structure supporting constant time of appending/removing from the start or the end of the list when there is room in the underlying array.

CharIArray2

interface CharIArray2 : IArray2<Char>

ChunkedByteDeque

class ChunkedByteDeque

CircularList

typealias CircularList<TGen> = TGenDeque<TGen>

Computed

class Computed<K : Computed.WithParent<K>, T>(val prop: KProperty1<K, T?>, val default: () -> T)

ConcurrentPool

open class ConcurrentPool<T : Any>(reset: (T) -> Unit = {}, preallocate: Int = 0, gen: (Int) -> T) : Pool<T>

CustomHashMap

open class CustomHashMap<K, V>(val hasher: (key: K) -> Int, val equalKey: (a: K, b: K) -> Boolean, val equalValue: (a: V, b: V) -> Boolean, val initialCapacity: Int = 16) : MutableMap<K, V>

Deque

typealias Deque<TGen> = TGenDeque<TGen>

DoubleArray2

open class DoubleArray2(val width: Int, val height: Int, val data: DoubleArray) : DoubleIArray2

DoubleArrayList

class DoubleArrayList(capacity: Int = 7) : DoubleList

Double growable ArrayList without boxing.

DoubleComparator

typealias DoubleComparator = Comparator<Double>

DoubleDeque

open class DoubleDeque(initialCapacity: Int) : MutableCollection<Double>

Deque structure supporting constant time of appending/removing from the start or the end of the list when there is room in the underlying array.

DoubleIArray2

interface DoubleIArray2 : IArray2<Double>

DoublePriorityQueue

class DoublePriorityQueue : MutableCollection<Double>

DoubleQueue

class DoubleQueue : Collection<Double>

A FIFO (First In First Out) structure.

DoubleStack

inline class DoubleStack(items: DoubleArrayList = DoubleArrayList()) : Collection<Double>

FastIdentityCacheMap

class FastIdentityCacheMap<K, V>

FastIdentityMap

actual class FastIdentityMap<K, V>

expect class FastIdentityMap<K, V>

actual class FastIdentityMap<K, V>

FastIntMap

actual typealias FastIntMap<T> = IntMap<T>

expect class FastIntMap<T>

actual class FastIntMap<T>(dummy: Boolean)

actual typealias FastIntMap<T> = IntMap<T>

FastSmallSet

class FastSmallSet<T> : AbstractMutableSet<T>

FastStringMap

actual class FastStringMap<T>

expect class FastStringMap<T>

actual class FastStringMap<T>

FloatArray2

open class FloatArray2(val width: Int, val height: Int, val data: FloatArray) : FloatIArray2

FloatArrayDeque

class FloatArrayDeque(val initialBits: Int = 10)

FloatArrayList

class FloatArrayList(capacity: Int = 7) : FloatList

Float growable ArrayList without boxing.

FloatComparator

typealias FloatComparator = Comparator<Float>

FloatDeque

open class FloatDeque(initialCapacity: Int) : MutableCollection<Float>

Deque structure supporting constant time of appending/removing from the start or the end of the list when there is room in the underlying array.

FloatFloatMap

class FloatFloatMap

FloatIArray2

interface FloatIArray2 : IArray2<Float>

FloatIntMap

class FloatIntMap

FloatMap

class FloatMap<T>

FloatPriorityQueue

class FloatPriorityQueue : MutableCollection<Float>

FloatQueue

class FloatQueue : Collection<Float>

A FIFO (First In First Out) structure.

FloatRingBuffer

class FloatRingBuffer(val bits: Int)

FloatStack

inline class FloatStack(items: FloatArrayList = FloatArrayList()) : Collection<Float>

GenericListIterator

class GenericListIterator<T>(val list: List<T>, val iindex: Int = 0) : ListIterator<T>

GenericSubList

class GenericSubList<T>(val base: List<T>, val start: Int, val end: Int) : List<T>

HistoryStack

class HistoryStack<T>(var maxLength: Int = Int.MAX_VALUE - 10, initialCapacity: Int = 7)

IArray2

interface IArray2<E> : Iterable<E>

IDoubleArrayList

typealias ~~IDoubleArrayList~~ = DoubleList

IFloatArrayList

typealias ~~IFloatArrayList~~ = FloatList

IndexedTable

class IndexedTable<T> : Iterable<T>

InfiniteGridStackedDoubleArray2

class InfiniteGridStackedDoubleArray2(val grid: SizeInt = SizeInt(16, 16), var empty: Double = StackedDoubleArray2.EMPTY) : SparseChunkedStackedDoubleArray2

A SparseChunkedStackedDoubleArray2 that uses a grid size to create new chunks as required

InfiniteGridStackedInt53Array2

class InfiniteGridStackedInt53Array2(val grid: SizeInt = SizeInt(16, 16), var empty: Int53 = StackedInt53Array2.EMPTY) : SparseChunkedStackedInt53Array2

InfiniteGridStackedInt64Array2

class InfiniteGridStackedInt64Array2(val grid: SizeInt = SizeInt(16, 16), var empty: Int64 = StackedInt64Array2.EMPTY) : SparseChunkedStackedInt64Array2

InfiniteGridStackedIntArray2

class InfiniteGridStackedIntArray2(val grid: SizeInt = SizeInt(16, 16), var empty: Int = StackedIntArray2.EMPTY) : SparseChunkedStackedIntArray2

InfiniteGridStackedLongArray2

class InfiniteGridStackedLongArray2(val grid: SizeInt = SizeInt(16, 16), var empty: Long = StackedLongArray2.EMPTY) : SparseChunkedStackedLongArray2

Int53Array2

open class Int53Array2(val width: Int, val height: Int, val data: Int53Array) : Int53IArray2

Int53IArray2

interface Int53IArray2 : IArray2<Int53>

Int64Array2

open class Int64Array2(val width: Int, val height: Int, val data: Int64Array) : Int64IArray2

Int64IArray2

interface Int64IArray2 : IArray2<Int64>

IntArray2

open class IntArray2(val width: Int, val height: Int, val data: IntArray) : IntIArray2

IntArrayDeque

class IntArrayDeque(val initialBits: Int = 10)

IntArrayList

class IntArrayList(capacity: Int = 7) : IntList

Int growable ArrayList without boxing.

IntComparator

typealias IntComparator = Comparator<Int>

IntDeque

open class IntDeque(initialCapacity: Int) : MutableCollection<Int>

Deque structure supporting constant time of appending/removing from the start or the end of the list when there is room in the underlying array.

IntFloatMap

class IntFloatMap

IntIArray2

interface IntIArray2 : IArray2<Int>

IntIntMap

class IntIntMap

IntMap

class IntMap<T>

IntPriorityQueue

class IntPriorityQueue : MutableCollection<Int>

IntQueue

class IntQueue : Collection<Int>

A FIFO (First In First Out) structure.

IntRingBuffer

class IntRingBuffer(val bits: Int)

IntSet

class IntSet : MutableSet<Int>

A Set structure representing a set of Int without boxing.

IntStack

inline class IntStack(items: IntArrayList = IntArrayList()) : Collection<Int>

IStackedArray2

interface IStackedArray2<T> : IStackedArray2Base

IStackedArray2Base

interface IStackedArray2Base

IStackedDoubleArray2

interface IStackedDoubleArray2 : IStackedArray2<Double>

IStackedInt53Array2

interface IStackedInt53Array2 : IStackedArray2<Int53>

IStackedInt64Array2

interface IStackedInt64Array2 : IStackedArray2<Int64>

IStackedIntArray2

interface IStackedIntArray2 : IStackedArray2<Int>

IStackedLongArray2

interface IStackedLongArray2 : IStackedArray2<Long>

LazyDelegate

class LazyDelegate<T>(val propRef: () -> KMutableProperty0<T>)

LinkedHashMapList

typealias LinkedHashMapList<K, V> = LinkedHashMap<K, ArrayList<V>>

ListReader

class ListReader<T>(val list: List<T>)

A utility to read List.

LongArray2

open class LongArray2(val width: Int, val height: Int, val data: LongArray) : LongIArray2

LongDeque

open class LongDeque(initialCapacity: Int) : MutableCollection<Long>

Deque structure supporting constant time of appending/removing from the start or the end of the list when there is room in the underlying array.

LongIArray2

interface LongIArray2 : IArray2<Long>

LRUCache

open class LRUCache<K, V>(val maxSize: Int = Int.MAX_VALUE, val maxMemory: Long = Long.MAX_VALUE, val atLeastOne: Boolean = true, val getElementMemory: (V) -> Int = { 1 }) : BaseCacheMap<K, V>

MapList

typealias MapList<K, V> = Map<K, List<V>>

MutableMapList

typealias MutableMapList<K, V> = MutableMap<K, ArrayList<V>>

Observable

class Observable<T>(val initial: T, val before: (T) -> Unit = {}, val after: (T) -> Unit = {})

ObservableArray

class ObservableArray<T>(val base: Array<T>, updated: ObservableArray<T>.(IntRange) -> Unit) : BaseObservableArray1<ObservableArray<T>, Int>

ObservableArray2

open class ObservableArray2<T>(val base: IArray2<T>, updated: ObservableArray2<T>.(RectangleInt) -> Unit) : BaseObservableArray2<ObservableArray2<T>, T> , IArray2<T>

ObservableDoubleArray2

open class ObservableDoubleArray2(val base: DoubleIArray2, updated: ObservableDoubleArray2.(RectangleInt) -> Unit) : BaseObservableArray2<ObservableDoubleArray2, Double> , DoubleIArray2

ObservableIntArray

class ObservableIntArray(val base: IntArray, updated: ObservableIntArray.(IntRange) -> Unit) : BaseObservableArray1<ObservableIntArray, Int>

ObservableIntArray2

open class ObservableIntArray2(val base: IntIArray2, updated: ObservableIntArray2.(RectangleInt) -> Unit) : BaseObservableArray2<ObservableIntArray2, Int> , IntIArray2

ObservableLongArray2

open class ObservableLongArray2(val base: LongIArray2, updated: ObservableLongArray2.(RectangleInt) -> Unit) : BaseObservableArray2<ObservableLongArray2, Long> , LongIArray2

Pool

open class Pool<T : Any>(reset: (T) -> Unit = {}, preallocate: Int = 0, gen: (Int) -> T)

Structure containing a set of reusable objects.

PriorityQueue

typealias PriorityQueue<TGen> = TGenPriorityQueue<TGen>

Queue

typealias Queue<TGen> = TGenQueue<TGen>

Ref

interface Ref<T : Any>

ReturnablePool

class ReturnablePool<T : Any>(_reset: (T) -> Unit = { }, gen: (index: Int) -> T)

RingBuffer

class RingBuffer(val bits: Int) : ByteRingBuffer

ShortArray2

open class ShortArray2(val width: Int, val height: Int, val data: ShortArray) : ShortIArray2

ShortArrayDeque

class ShortArrayDeque(val initialBits: Int = 10)

ShortArrayList

class ShortArrayList(initialCapacity: Int = 7)

ShortDeque

open class ShortDeque(initialCapacity: Int) : MutableCollection<Short>

Deque structure supporting constant time of appending/removing from the start or the end of the list when there is room in the underlying array.

ShortIArray2

interface ShortIArray2 : IArray2<Short>

ShortRingBuffer

class ShortRingBuffer(val bits: Int)

SlowIdentityHashMap

open class SlowIdentityHashMap<K, V>(initialCapacity: Int = 16) : CustomHashMap<K, V>

SortedMap

open class SortedMap<K, V>(val comparator: Comparator<K>) : MutableMapExt<K, V>

SortOps

abstract class SortOps<T>

SortOpsComparable

object SortOpsComparable : SortOps<MutableList<Comparable<Any>>>

SparseChunkedStackedArray2

abstract class SparseChunkedStackedArray2<TStackedArray2 : IStackedArray2Base> : IStackedArray2Base

SparseChunkedStackedDoubleArray2

open class SparseChunkedStackedDoubleArray2(var empty: Double = StackedDoubleArray2.EMPTY) : SparseChunkedStackedArray2<IStackedDoubleArray2> , IStackedDoubleArray2

SparseChunkedStackedInt53Array2

open class SparseChunkedStackedInt53Array2(var empty: Int53 = StackedInt53Array2.EMPTY) : SparseChunkedStackedArray2<IStackedInt53Array2> , IStackedInt53Array2

SparseChunkedStackedInt64Array2

open class SparseChunkedStackedInt64Array2(var empty: Int64 = StackedInt64Array2.EMPTY) : SparseChunkedStackedArray2<IStackedInt64Array2> , IStackedInt64Array2

SparseChunkedStackedIntArray2

open class SparseChunkedStackedIntArray2(var empty: Int = StackedIntArray2.EMPTY) : SparseChunkedStackedArray2<IStackedIntArray2> , IStackedIntArray2

SparseChunkedStackedLongArray2

open class SparseChunkedStackedLongArray2(var empty: Long = StackedLongArray2.EMPTY) : SparseChunkedStackedArray2<IStackedLongArray2> , IStackedLongArray2

Stack

typealias Stack<TGen> = TGenStack<TGen>

StackedDoubleArray2

class StackedDoubleArray2(val width: Int, val height: Int, val empty: Double = EMPTY, val startX: Int = 0, val startY: Int = 0) : IStackedDoubleArray2

StackedInt53Array2

class StackedInt53Array2(val width: Int, val height: Int, val empty: Int53 = EMPTY, val startX: Int = 0, val startY: Int = 0) : IStackedInt53Array2

StackedInt53Array2FromIStackedIntArray2

class StackedInt53Array2FromIStackedIntArray2(val data: IStackedIntArray2) : BaseDelegatedStackedArray2, IStackedInt53Array2

StackedInt64Array2

class StackedInt64Array2(val width: Int, val height: Int, val empty: Int64 = EMPTY, val startX: Int = 0, val startY: Int = 0) : IStackedInt64Array2

StackedInt64Array2FromIStackedIntArray2

class StackedInt64Array2FromIStackedIntArray2(val data: IStackedIntArray2) : BaseDelegatedStackedArray2, IStackedInt64Array2

StackedIntArray2

class StackedIntArray2(val width: Int, val height: Int, val empty: Int = EMPTY, val startX: Int = 0, val startY: Int = 0) : IStackedIntArray2

StackedIntArray2FromIStackedInt53Array2

class StackedIntArray2FromIStackedInt53Array2(val data: IStackedInt53Array2) : BaseDelegatedStackedArray2, IStackedIntArray2

StackedIntArray2FromIStackedInt64Array2

class StackedIntArray2FromIStackedInt64Array2(val data: IStackedInt64Array2) : BaseDelegatedStackedArray2, IStackedIntArray2

StackedIntArray2FromIStackedLongArray2

class StackedIntArray2FromIStackedLongArray2(val data: IStackedLongArray2) : BaseDelegatedStackedArray2, IStackedIntArray2

StackedLongArray2

class StackedLongArray2(val width: Int, val height: Int, val empty: Long = EMPTY, val startX: Int = 0, val startY: Int = 0) : IStackedLongArray2

StackedLongArray2FromIStackedIntArray2

class StackedLongArray2FromIStackedIntArray2(val data: IStackedIntArray2) : BaseDelegatedStackedArray2, IStackedLongArray2

TemporalPool

class TemporalPool<T : Any>(reset: (T) -> Unit = {}, preallocate: Int = 0, gen: (Int) -> T)

TGenDeque

open class TGenDeque<TGen>(initialCapacity: Int) : MutableCollection<TGen>

Deque structure supporting constant time of appending/removing from the start or the end of the list when there is room in the underlying array.

TGenIArray2

interface TGenIArray2<TGen> : IArray2<TGen>

TGenPriorityQueue

class TGenPriorityQueue<TGen> : MutableCollection<TGen>

TGenQueue

class TGenQueue<TGen> : Collection<TGen>

A FIFO (First In First Out) structure.

TGenStack

inline class TGenStack<TGen>(items: FastArrayList<TGen> = FastArrayList<TGen>()) : Collection<TGen>

WeakMap

actual class WeakMap<K : Any, V>

expect class WeakMap<K : Any, V>

actual class WeakMap<K : Any, V>

WeakProperty

class WeakProperty<V>(val gen: () -> V)

WeakPropertyThis

class WeakPropertyThis<T : Any, V>(val gen: T.() -> V)

Properties

endX

val IStackedDoubleArray2.endX: Int

Shortcut for IStackedDoubleArray2.startX + IStackedDoubleArray2.width

val IStackedInt53Array2.endX: Int

Shortcut for IStackedInt53Array2.startX + IStackedInt53Array2.width

val IStackedInt64Array2.endX: Int

Shortcut for IStackedInt64Array2.startX + IStackedInt64Array2.width

val IStackedLongArray2.endX: Int

Shortcut for IStackedLongArray2.startX + IStackedLongArray2.width

endY

val IStackedDoubleArray2.endY: Int

Shortcut for IStackedDoubleArray2.startY + IStackedDoubleArray2.height

val IStackedInt53Array2.endY: Int

Shortcut for IStackedInt53Array2.startY + IStackedInt53Array2.height

val IStackedInt64Array2.endY: Int

Shortcut for IStackedInt64Array2.startY + IStackedInt64Array2.height

val IStackedLongArray2.endY: Int

Shortcut for IStackedLongArray2.startY + IStackedLongArray2.height

keys

val <K, V> FastIdentityMap<K, V>.keys: List<K>

val <T> FastIntMap<T>.keys: List<Int>

val <T> FastStringMap<T>.keys: List<String>

size

actual val <K, V> FastIdentityMap<K, V>.size: Int

actual val <T> FastStringMap<T>.size: Int

expect val <K, V> FastIdentityMap<K, V>.size: Int

expect val <T> FastIntMap<T>.size: Int

expect val <T> FastStringMap<T>.size: Int

actual val <K, V> FastIdentityMap<K, V>.size: Int

actual val <T> FastIntMap<T>.size: Int

actual val <T> FastStringMap<T>.size: Int

actual val <K, V> FastIdentityMap<K, V>.size: Int

actual val <T> FastStringMap<T>.size: Int

actual val <K, V> FastIdentityMap<K, V>.size: Int

actual val <T> FastStringMap<T>.size: Int

actual val <K, V> FastIdentityMap<K, V>.size: Int

actual val <T> FastStringMap<T>.size: Int

values

val <K, V> FastIdentityMap<K, V>.values: List<V>

val <T> FastIntMap<T>.values: List<T>

val <T> FastStringMap<T>.values: List<T>

Functions

append

fun <K, V> MutableMapList<K, V>.append(key: K, value: V): MutableMapList<K, V>

appendAll

fun <K, V> MutableMapList<K, V>.appendAll(vararg items: Pair<K, V>): MutableMapList<K, V>

asInt

fun IStackedInt53Array2.asInt(): IStackedIntArray2

fun IStackedInt64Array2.asInt(): IStackedIntArray2

fun IStackedLongArray2.asInt(): IStackedIntArray2

asInt53

fun IStackedIntArray2.asInt53(): IStackedInt53Array2

asInt64

fun IStackedIntArray2.asInt64(): IStackedInt64Array2

asLong

fun IStackedIntArray2.asLong(): IStackedLongArray2

associateByInt

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

binarySearch

fun DoubleArrayList.binarySearch(v: Double, fromIndex: Int = 0, toIndex: Int = size): BSearchResult

fun FloatArrayList.binarySearch(v: Float, fromIndex: Int = 0, toIndex: Int = size): BSearchResult

fun IntArrayList.binarySearch(v: Int, fromIndex: Int = 0, toIndex: Int = size): BSearchResult

fun DoubleArray.binarySearch(v: Double, fromIndex: Int = 0, toIndex: Int = size): BSearchResult

fun FloatArray.binarySearch(v: Float, fromIndex: Int = 0, toIndex: Int = size): BSearchResult

fun IntArray.binarySearch(v: Int, fromIndex: Int = 0, toIndex: Int = size): BSearchResult

Returns the index of an item or a negative number in the case the item is not found. The negative index represents the nearest position after negating + 1.

binarySearchLeft

fun DoubleArrayList.binarySearchLeft(v: Double, fromIndex: Int = 0, toIndex: Int = size): Int

fun FloatArrayList.binarySearchLeft(v: Float, fromIndex: Int = 0, toIndex: Int = size): Int

fun IntArrayList.binarySearchLeft(v: Int, fromIndex: Int = 0, toIndex: Int = size): Int

fun DoubleArray.binarySearchLeft(v: Double, fromIndex: Int = 0, toIndex: Int = size): Int

fun FloatArray.binarySearchLeft(v: Float, fromIndex: Int = 0, toIndex: Int = size): Int

fun IntArray.binarySearchLeft(v: Int, fromIndex: Int = 0, toIndex: Int = size): Int

binarySearchRight

fun DoubleArrayList.binarySearchRight(v: Double, fromIndex: Int = 0, toIndex: Int = size): Int

fun FloatArrayList.binarySearchRight(v: Float, fromIndex: Int = 0, toIndex: Int = size): Int

fun IntArrayList.binarySearchRight(v: Int, fromIndex: Int = 0, toIndex: Int = size): Int

fun DoubleArray.binarySearchRight(v: Double, fromIndex: Int = 0, toIndex: Int = size): Int

fun FloatArray.binarySearchRight(v: Float, fromIndex: Int = 0, toIndex: Int = size): Int

fun IntArray.binarySearchRight(v: Int, fromIndex: Int = 0, toIndex: Int = size): Int

bitArrayOf

fun bitArrayOf(vararg values: Boolean): BitArray

buildFloatArray

fun buildFloatArray(block: FloatArrayList.() -> Unit): FloatArray

buildIntArray

fun buildIntArray(block: IntArrayList.() -> Unit): IntArray

cacheLazyNullable

inline fun <T> cacheLazyNullable(field: KMutableProperty0<T?>, gen: () -> T): T

clear

actual fun <K, V> FastIdentityMap<K, V>.clear()

actual inline fun <T> FastStringMap<T>.clear()

expect fun <K, V> FastIdentityMap<K, V>.clear()

expect fun <T> FastIntMap<T>.clear()

expect fun <T> FastStringMap<T>.clear()

actual fun <K, V> FastIdentityMap<K, V>.clear()

actual inline fun <T> FastIntMap<T>.clear()

actual inline fun <T> FastStringMap<T>.clear()

actual fun <K, V> FastIdentityMap<K, V>.clear()

actual inline fun <T> FastStringMap<T>.clear()

actual fun <K, V> FastIdentityMap<K, V>.clear()

actual inline fun <T> FastStringMap<T>.clear()

actual fun <K, V> FastIdentityMap<K, V>.clear()

actual inline fun <T> FastStringMap<T>.clear()

comparator

fun <T : Comparable<T>> comparator(): Comparator<T>

contains

actual operator fun <K, V> FastIdentityMap<K, V>.contains(key: K): Boolean

actual inline operator fun <T> FastStringMap<T>.contains(key: String): Boolean

expect operator fun <K, V> FastIdentityMap<K, V>.contains(key: K): Boolean

expect operator fun <T> FastIntMap<T>.contains(key: Int): Boolean

expect operator fun <T> FastStringMap<T>.contains(key: String): Boolean

actual operator fun <K, V> FastIdentityMap<K, V>.contains(key: K): Boolean

actual inline operator fun <T> FastIntMap<T>.contains(key: Int): Boolean

actual inline operator fun <T> FastStringMap<T>.contains(key: String): Boolean

actual operator fun <K, V> FastIdentityMap<K, V>.contains(key: K): Boolean

actual inline operator fun <T> FastStringMap<T>.contains(key: String): Boolean

actual operator fun <K, V> FastIdentityMap<K, V>.contains(key: K): Boolean

actual inline operator fun <T> FastStringMap<T>.contains(key: String): Boolean

actual operator fun <K, V> FastIdentityMap<K, V>.contains(key: K): Boolean

actual inline operator fun <T> FastStringMap<T>.contains(key: String): Boolean

count

inline fun count(cond: (index: Int) -> Boolean): Int

countMap

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

Deque

fun <T> Deque(other: Collection<T>): Deque<T>

doubleArrayListOf

fun doubleArrayListOf(vararg values: Double): DoubleArrayList

dump

fun <T> ListReader<T>.dump()

each

inline fun <E> IArray2<E>.each(callback: (x: Int, y: Int, v: E) -> Unit)

expect

fun <T> ListReader<T>.expect(value: T): T

fastCastTo

actual inline fun <T> Any?.fastCastTo(): T

expect inline fun <T> Any?.fastCastTo(): T

actual inline fun <T> Any?.fastCastTo(): T

fastForEach

inline fun <K, V : Any> FastIdentityMap<K, V>.fastForEach(callback: (key: K, value: V) -> Unit)

inline fun <T : Any> FastIntMap<T>.fastForEach(callback: (key: Int, value: T) -> Unit)

inline fun <T : Any> FastStringMap<T>.fastForEach(callback: (key: String, value: T) -> Unit)

fastForEachNullable

inline fun <K, V> FastIdentityMap<K, V>.fastForEachNullable(callback: (key: K, value: V?) -> Unit)

inline fun <T> FastIntMap<T>.fastForEachNullable(callback: (key: Int, value: T?) -> Unit)

inline fun <T> FastStringMap<T>.fastForEachNullable(callback: (key: String, value: T?) -> Unit)

FastIdentityMap

actual fun <K, V> FastIdentityMap(): FastIdentityMap<K, V>

expect fun <K, V> FastIdentityMap(): FastIdentityMap<K, V>

actual fun <K, V> FastIdentityMap(): FastIdentityMap<K, V>

FastIntMap

actual inline fun <T> FastIntMap(): FastIntMap<T>

expect fun <T> FastIntMap(): FastIntMap<T>

actual fun <T> FastIntMap(): FastIntMap<T>

actual inline fun <T> FastIntMap(): FastIntMap<T>

fastKeyForEach

actual inline fun <K, V> FastIdentityMap<K, V>.fastKeyForEach(callback: (key: K) -> Unit)

actual inline fun <T> FastStringMap<T>.fastKeyForEach(callback: (key: String) -> Unit)

expect inline fun <K, V> FastIdentityMap<K, V>.fastKeyForEach(callback: (key: K) -> Unit)

expect inline fun <T> FastIntMap<T>.fastKeyForEach(callback: (key: Int) -> Unit)

expect inline fun <T> FastStringMap<T>.fastKeyForEach(callback: (key: String) -> Unit)

actual inline fun <K, V> FastIdentityMap<K, V>.fastKeyForEach(callback: (key: K) -> Unit)

actual inline fun <T> FastIntMap<T>.fastKeyForEach(callback: (key: Int) -> Unit)

actual inline fun <T> FastStringMap<T>.fastKeyForEach(callback: (key: String) -> Unit)

actual inline fun <K, V> FastIdentityMap<K, V>.fastKeyForEach(callback: (key: K) -> Unit)

actual inline fun <T> FastStringMap<T>.fastKeyForEach(callback: (key: String) -> Unit)

actual inline fun <K, V> FastIdentityMap<K, V>.fastKeyForEach(callback: (key: K) -> Unit)

actual inline fun <T> FastStringMap<T>.fastKeyForEach(callback: (key: String) -> Unit)

actual inline fun <K, V> FastIdentityMap<K, V>.fastKeyForEach(callback: (key: K) -> Unit)

actual inline fun <T> FastStringMap<T>.fastKeyForEach(callback: (key: String) -> Unit)

FastStringMap

actual inline fun <T> FastStringMap(): FastStringMap<T>

expect fun <T> FastStringMap(): FastStringMap<T>

actual fun <T> FastStringMap(): FastStringMap<T>

actual inline fun <T> FastStringMap(): FastStringMap<T>

fastValueForEach

inline fun <K, V : Any> FastIdentityMap<K, V>.fastValueForEach(callback: (value: V) -> Unit)

inline fun <T : Any> FastIntMap<T>.fastValueForEach(callback: (value: T) -> Unit)

inline fun <T : Any> FastStringMap<T>.fastValueForEach(callback: (value: T) -> Unit)

fastValueForEachNullable

inline fun <K, V> FastIdentityMap<K, V>.fastValueForEachNullable(callback: (value: V?) -> Unit)

inline fun <T> FastIntMap<T>.fastValueForEachNullable(callback: (value: T?) -> Unit)

inline fun <T> FastStringMap<T>.fastValueForEachNullable(callback: (value: T?) -> Unit)

fill

inline fun <E> IArray2<E>.fill(gen: (old: E) -> E)

filter

inline fun DoubleArrayList.filter(callback: (Double) -> Boolean): DoubleArrayList

inline fun FloatArrayList.filter(callback: (Float) -> Boolean): FloatArrayList

inline fun IntArrayList.filter(callback: (Int) -> Boolean): IntArrayList

flatMapIterable

fun <K, V> MapList<K, V>.flatMapIterable(): Iterable<Pair<K, V>>

flatMapIterator

fun <K, V> MapList<K, V>.flatMapIterator(): Iterator<Pair<K, V>>

flatten

fun <K, V> MapList<K, V>.flatten(): List<Pair<K, V>>

flip

fun <K, V> Map<K, V>.flip(): Map<V, K>

floatArrayListOf

fun floatArrayListOf(vararg values: Float): FloatArrayList

genericBinarySearch

inline fun genericBinarySearch(fromIndex: Int, toIndex: Int, invalid: (from: Int, to: Int, low: Int, high: Int) -> Int = { from, to, low, high -> -low - 1 }, check: (value: Int) -> Int): Int

genericBinarySearchLeft

inline fun genericBinarySearchLeft(fromIndex: Int, toIndex: Int, check: (value: Int) -> Int): Int

genericBinarySearchResult

inline fun genericBinarySearchResult(fromIndex: Int, toIndex: Int, check: (value: Int) -> Int): BSearchResult

genericBinarySearchRight

inline fun genericBinarySearchRight(fromIndex: Int, toIndex: Int, check: (value: Int) -> Int): Int

genericRemoveSortedDuplicates

inline fun genericRemoveSortedDuplicates(size: Int, equals: (x: Int, y: Int) -> Boolean, copy: (src: Int, dst: Int) -> Unit, resize: (size: Int) -> Unit)

genericSort

fun <T> genericSort(subject: T, left: Int, right: Int, ops: SortOps<T>): T

fun <T> genericSort(subject: T, left: Int, right: Int, ops: SortOps<T>, reversed: Boolean): T

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

actual operator fun <K, V> FastIdentityMap<K, V>.get(key: K): V?

actual inline operator fun <T> FastStringMap<T>.get(key: String): T?

expect operator fun <K, V> FastIdentityMap<K, V>.get(key: K): V?

expect operator fun <T> FastIntMap<T>.get(key: Int): T?

expect operator fun <T> FastStringMap<T>.get(key: String): T?

fun IStackedDoubleArray2.get(p: PointInt, level: Int): Double

fun IStackedInt53Array2.get(p: PointInt, level: Int): Int53

fun IStackedInt64Array2.get(p: PointInt, level: Int): Int64

fun IStackedIntArray2.get(p: PointInt, level: Int): Int

fun IStackedLongArray2.get(p: PointInt, level: Int): Long

actual operator fun <K, V> FastIdentityMap<K, V>.get(key: K): V?

actual inline operator fun <T> FastIntMap<T>.get(key: Int): T?

actual inline operator fun <T> FastStringMap<T>.get(key: String): T?

actual operator fun <K, V> FastIdentityMap<K, V>.get(key: K): V?

actual inline operator fun <T> FastStringMap<T>.get(key: String): T?

actual operator fun <K, V> FastIdentityMap<K, V>.get(key: K): V?

actual inline operator fun <T> FastStringMap<T>.get(key: String): T?

actual operator fun <K, V> FastIdentityMap<K, V>.get(key: K): V?

actual inline operator fun <T> FastStringMap<T>.get(key: String): T?

getAndRemove

fun <K, V> FastIdentityMap<K, V>.getAndRemove(key: K): V?

getAt

fun <E> IArray2<E>.getAt(p: PointInt): E

getCyclic

fun DoubleArrayList.getCyclic(index: Int): Double

fun FloatArrayList.getCyclic(index: Int): Float

fun IntArrayList.getCyclic(index: Int): Int

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

fun DoubleArray.getCyclic(index: Int): Double

fun FloatArray.getCyclic(index: Int): Float

fun IntArray.getCyclic(index: Int): Int

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

fun <T> Array2<T>.getCyclic(x: Int, y: Int): T

fun DoubleArray2.getCyclic(x: Int, y: Int): Double

fun FloatArray2.getCyclic(x: Int, y: Int): Float

fun IntArray2.getCyclic(x: Int, y: Int): Int

getCyclicOrNull

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

getFirst

fun <K, V> MapList<K, V>.getFirst(key: K): V?

getLast

fun IStackedDoubleArray2.getLast(p: PointInt): Double

fun IStackedInt53Array2.getLast(p: PointInt): Int53

fun IStackedInt64Array2.getLast(p: PointInt): Int64

fun IStackedIntArray2.getLast(p: PointInt): Int

fun IStackedLongArray2.getLast(p: PointInt): Long

fun <K, V> MapList<K, V>.getLast(key: K): V?

getNull

inline fun <K, V> FastIdentityMap<K, V>.getNull(key: K?): V?

inline fun <T> FastIntMap<T>.getNull(key: Int?): T?

inline fun <T> FastStringMap<T>.getNull(key: String?): T?

getOrPut

inline fun <K, V> FastIdentityMap<K, V>.getOrPut(key: K, callback: (K) -> V): V

inline fun <T> FastIntMap<T>.getOrPut(key: Int, callback: () -> T): T

inline fun <T> FastStringMap<T>.getOrPut(key: String, callback: () -> T): T

inline fun <K : Any, V> WeakMap<K, V>.getOrPut(key: K, value: (K) -> V): V

getStackLevel

fun IStackedDoubleArray2.getStackLevel(p: PointInt): Int

fun IStackedInt53Array2.getStackLevel(p: PointInt): Int

fun IStackedInt64Array2.getStackLevel(p: PointInt): Int

fun IStackedIntArray2.getStackLevel(p: PointInt): Int

fun IStackedLongArray2.getStackLevel(p: PointInt): Int

hashCode

inline fun <T1> hashCode(v1: T1): Int

inline fun <T1, T2> hashCode(v1: T1, v2: T2): Int

inline fun <T1, T2, T3> hashCode(v1: T1, v2: T2, v3: T3): Int

inline fun <T1, T2, T3, T4> hashCode(v1: T1, v2: T2, v3: T3, v4: T4): Int

inline fun <T1, T2, T3, T4, T5> hashCode(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5): Int

inline fun <T1, T2, T3, T4, T5, T6> hashCode(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6): Int

identityHashCode

fun Any?.identityHashCode(): Int

incr

fun <K> MutableMap<K, Int>.incr(key: K, delta: Int = +1): Int

index

fun <E> IArray2<E>.~~index~~(x: Int, y: Int): Int

indexOr

fun <E> IArray2<E>.indexOr(x: Int, y: Int, invalid: Int = -1): Int

indexOrThrow

fun <E> IArray2<E>.indexOrThrow(x: Int, y: Int): Int

intArrayListOf

fun intArrayListOf(vararg values: Int): IntArrayList

intIntMapOf

fun intIntMapOf(vararg pairs: Pair<Int, Int>): IntIntMap

intMapOf

fun <T> intMapOf(vararg pairs: Pair<Int, T>): IntMap<T>

intSetOf

fun intSetOf(vararg values: Int): IntSet

Iterator

fun <T> Iterator(hasNext: () -> Boolean, next: () -> T): Iterator<T>

keep

inline fun <T, R> keep(mut: KMutableProperty0<T>, block: () -> R): R

keys

actual fun <K, V> FastIdentityMap<K, V>.keys(): List<K>

actual fun <T> FastStringMap<T>.keys(): List<String>

expect fun <K, V> FastIdentityMap<K, V>.keys(): List<K>

expect fun <T> FastIntMap<T>.keys(): List<Int>

expect fun <T> FastStringMap<T>.keys(): List<String>

actual fun <K, V> FastIdentityMap<K, V>.keys(): List<K>

actual fun <T> FastIntMap<T>.keys(): List<Int>

actual fun <T> FastStringMap<T>.keys(): List<String>

actual fun <K, V> FastIdentityMap<K, V>.keys(): List<K>

actual fun <T> FastStringMap<T>.keys(): List<String>

actual fun <K, V> FastIdentityMap<K, V>.keys(): List<K>

actual fun <T> FastStringMap<T>.keys(): List<String>

actual fun <K, V> FastIdentityMap<K, V>.keys(): List<K>

actual fun <T> FastStringMap<T>.keys(): List<String>

LinkedHashMapList

fun <K, V> LinkedHashMapList(items: List<Pair<K, V>>): MutableMapList<K, V>

fun <K, V> LinkedHashMapList(items: MapList<K, V>): MutableMapList<K, V>

linkedHashMapListOf

fun <K, V> linkedHashMapListOf(vararg items: Pair<K, V>): MutableMapList<K, V>

linkedHashMapOf

fun <K, V> linkedHashMapOf(vararg pairs: Pair<K, V>): LinkedHashMap<K, V>

map2

inline fun DoubleArray2.map2(gen: (x: Int, y: Int, v: Double) -> Double): DoubleArray2

inline fun FloatArray2.map2(gen: (x: Int, y: Int, v: Float) -> Float): FloatArray2

inline fun <TGen : Any, RGen : Any> IArray2<TGen>.map2(gen: (x: Int, y: Int, v: TGen) -> RGen): Array2<RGen>

inline fun IntArray2.map2(gen: (x: Int, y: Int, v: Int) -> Int): IntArray2

mapDouble

inline fun <T> Array<T>.mapDouble(callback: (T) -> Double): DoubleArray

inline fun BooleanArray.mapDouble(callback: (Boolean) -> Double): DoubleArray

inline fun ByteArray.mapDouble(callback: (Byte) -> Double): DoubleArray

inline fun CharArray.mapDouble(callback: (Char) -> Double): DoubleArray

inline fun DoubleArray.mapDouble(callback: (Double) -> Double): DoubleArray

inline fun FloatArray.mapDouble(callback: (Float) -> Double): DoubleArray

inline fun IntArray.mapDouble(callback: (Int) -> Double): DoubleArray

inline fun ShortArray.mapDouble(callback: (Short) -> Double): DoubleArray

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

mapFloat

inline fun <T> Array<T>.mapFloat(callback: (T) -> Float): FloatArray

inline fun BooleanArray.mapFloat(callback: (Boolean) -> Float): FloatArray

inline fun ByteArray.mapFloat(callback: (Byte) -> Float): FloatArray

inline fun CharArray.mapFloat(callback: (Char) -> Float): FloatArray

inline fun DoubleArray.mapFloat(callback: (Double) -> Float): FloatArray

inline fun FloatArray.mapFloat(callback: (Float) -> Float): FloatArray

inline fun IntArray.mapFloat(callback: (Int) -> Float): FloatArray

inline fun ShortArray.mapFloat(callback: (Short) -> Float): FloatArray

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

mapInt

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

inline fun <T> Array<T>.mapInt(callback: (T) -> Int): IntArray

inline fun BooleanArray.mapInt(callback: (Boolean) -> Int): IntArray

inline fun ByteArray.mapInt(callback: (Byte) -> Int): IntArray

inline fun CharArray.mapInt(callback: (Char) -> Int): IntArray

inline fun DoubleArray.mapInt(callback: (Double) -> Int): IntArray

inline fun FloatArray.mapInt(callback: (Float) -> Int): IntArray

inline fun IntArray.mapInt(callback: (Int) -> Int): IntArray

inline fun ShortArray.mapInt(callback: (Short) -> Int): IntArray

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

inline fun IntRange.mapInt(callback: (Int) -> Int): IntArrayList

mapWhile

inline fun <T> mapWhile(cond: (index: Int) -> Boolean, gen: (Int) -> T): List<T>

mapWhileArray

inline fun <T> mapWhileArray(cond: (index: Int) -> Boolean, gen: (Int) -> T): Array<T>

mapWhileCheck

inline fun <T> mapWhileCheck(check: (T) -> Boolean, gen: (Int) -> T): List<T>

mapWhileDouble

inline fun mapWhileDouble(cond: (index: Int) -> Boolean, gen: (Int) -> Double): DoubleArray

mapWhileFloat

inline fun mapWhileFloat(cond: (index: Int) -> Boolean, gen: (Int) -> Float): FloatArray

mapWhileInt

inline fun mapWhileInt(cond: (index: Int) -> Boolean, gen: (Int) -> Int): IntArray

mapWhileNotNull

inline fun <T> mapWhileNotNull(gen: (Int) -> T?): List<T>

memoize

fun <T : Any> () -> T.memoize(): () -> T

This acts as a lazy delegate but for functions.

multisorted

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

observe

fun DoubleIArray2.observe(updated: ObservableDoubleArray2.(RectangleInt) -> Unit): ObservableDoubleArray2

fun <T> IArray2<T>.observe(updated: ObservableArray2<T>.(RectangleInt) -> Unit): ObservableArray2<T>

fun IntIArray2.observe(updated: ObservableIntArray2.(RectangleInt) -> Unit): ObservableIntArray2

fun LongIArray2.observe(updated: ObservableLongArray2.(RectangleInt) -> Unit): ObservableLongArray2

fun <T> Array<T>.observe(updated: ObservableArray<T>.(IntRange) -> Unit): ObservableArray<T>

fun IntArray.observe(updated: ObservableIntArray.(IntRange) -> Unit): ObservableIntArray

pop

fun IStackedDoubleArray2.pop(p: PointInt): Double

fun IStackedInt53Array2.pop(p: PointInt): Int53

fun IStackedInt64Array2.pop(p: PointInt): Int64

fun IStackedIntArray2.pop(p: PointInt): Int

fun IStackedLongArray2.pop(p: PointInt): Long

push

fun IStackedDoubleArray2.push(p: PointInt, value: Double)

fun IStackedInt53Array2.push(p: PointInt, value: Int53)

fun IStackedInt64Array2.push(p: PointInt, value: Int64)

fun IStackedIntArray2.push(p: PointInt, value: Int)

fun IStackedLongArray2.push(p: PointInt, value: Long)

putAll

actual fun <T> FastStringMap<T>.putAll(other: FastStringMap<T>)

expect fun <T> FastStringMap<T>.putAll(other: FastStringMap<T>)

actual fun <T> FastStringMap<T>.putAll(other: FastStringMap<T>)

radixSortGeneric

inline fun <T> radixSortGeneric(start: Int, end: Int, stepStart: Int, stepEnd: Int, get: (index: Int) -> T, setTemp: (index: Int, v: T) -> Unit, flip: () -> Unit, getRadix: (index: Int, v: T) -> Int, noffsets: Int)

reader

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

Ref

fun <T : Any> Ref(): Ref<T>

fun <T : Any> Ref(value: T): Ref<T>

fun <T : Any> Ref(prop: KMutableProperty0<T>): Ref<T>

remove

actual fun <K, V> FastIdentityMap<K, V>.remove(key: K)

actual inline fun <T> FastStringMap<T>.remove(key: String)

expect fun <K, V> FastIdentityMap<K, V>.remove(key: K)

expect fun <T> FastIntMap<T>.remove(key: Int)

expect fun <T> FastStringMap<T>.remove(key: String)

actual fun <K, V> FastIdentityMap<K, V>.remove(key: K)

actual inline fun <T> FastIntMap<T>.remove(key: Int)

actual inline fun <T> FastStringMap<T>.remove(key: String)

actual fun <K, V> FastIdentityMap<K, V>.remove(key: K)

actual inline fun <T> FastStringMap<T>.remove(key: String)

actual fun <K, V> FastIdentityMap<K, V>.remove(key: K)

actual inline fun <T> FastStringMap<T>.remove(key: String)

actual fun <K, V> FastIdentityMap<K, V>.remove(key: K)

actual inline fun <T> FastStringMap<T>.remove(key: String)

removeAll

fun IStackedDoubleArray2.removeAll(p: PointInt): Boolean

fun IStackedInt53Array2.removeAll(p: PointInt): Boolean

fun IStackedInt64Array2.removeAll(p: PointInt): Boolean

fun IStackedIntArray2.removeAll(p: PointInt): Boolean

fun IStackedLongArray2.removeAll(p: PointInt): Boolean

removeAt

fun IStackedDoubleArray2.removeAt(p: PointInt, level: Int): Boolean

fun IStackedInt53Array2.removeAt(p: PointInt, level: Int): Boolean

fun IStackedInt64Array2.removeAt(p: PointInt, level: Int): Boolean

fun IStackedIntArray2.removeAt(p: PointInt, level: Int): Boolean

fun IStackedLongArray2.removeAt(p: PointInt, level: Int): Boolean

removeFirst

fun IStackedDoubleArray2.removeFirst(p: PointInt): Boolean

fun IStackedInt53Array2.removeFirst(p: PointInt): Boolean

fun IStackedInt64Array2.removeFirst(p: PointInt): Boolean

fun IStackedIntArray2.removeFirst(p: PointInt): Boolean

fun IStackedLongArray2.removeFirst(p: PointInt): Boolean

removeLast

fun IStackedDoubleArray2.removeLast(p: PointInt): Boolean

fun IStackedInt53Array2.removeLast(p: PointInt): Boolean

fun IStackedInt64Array2.removeLast(p: PointInt): Boolean

fun IStackedIntArray2.removeLast(p: PointInt): Boolean

fun IStackedLongArray2.removeLast(p: PointInt): Boolean

removeRange

expect fun <T> FastIntMap<T>.removeRange(src: Int, dst: Int)

actual inline fun <T> FastIntMap<T>.removeRange(src: Int, dst: Int)

removeSortedDuplicates

fun <T> ArrayList<T>.removeSortedDuplicates(): ArrayList<T>

replace

fun <K, V> MutableMapList<K, V>.replace(key: K, value: V): MutableMapList<K, V>

replaceAll

fun <K, V> MutableMapList<K, V>.replaceAll(vararg items: Pair<K, V>): MutableMapList<K, V>

reverse

fun DoubleArrayList.reverse(start: Int = 0, end: Int = size)

fun FloatArrayList.reverse(start: Int = 0, end: Int = size)

fun IntArrayList.reverse(start: Int = 0, end: Int = size)

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

revIndexX

fun <E> IArray2<E>.revIndexX(index: Int): Int

revIndexY

fun <E> IArray2<E>.revIndexY(index: Int): Int

rotated

fun DoubleArrayList.rotated(offset: Int): DoubleArrayList

fun FloatArrayList.rotated(offset: Int): FloatArrayList

fun IntArrayList.rotated(offset: Int): IntArrayList

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

rotatedLeft

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

fun BooleanArray.rotatedLeft(offset: Int = +1): BooleanArray

fun ByteArray.rotatedLeft(offset: Int = +1): ByteArray

fun CharArray.rotatedLeft(offset: Int = +1): CharArray

fun DoubleArray.rotatedLeft(offset: Int = +1): DoubleArray

fun FloatArray.rotatedLeft(offset: Int = +1): FloatArray

fun IntArray.rotatedLeft(offset: Int = +1): IntArray

fun LongArray.rotatedLeft(offset: Int = +1): LongArray

fun ShortArray.rotatedLeft(offset: Int = +1): ShortArray

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

rotatedRight

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

fun BooleanArray.rotatedRight(offset: Int = +1): BooleanArray

fun ByteArray.rotatedRight(offset: Int = +1): ByteArray

fun CharArray.rotatedRight(offset: Int = +1): CharArray

fun DoubleArray.rotatedRight(offset: Int = +1): DoubleArray

fun FloatArray.rotatedRight(offset: Int = +1): FloatArray

fun IntArray.rotatedRight(offset: Int = +1): IntArray

fun LongArray.rotatedRight(offset: Int = +1): LongArray

fun ShortArray.rotatedRight(offset: Int = +1): ShortArray

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

rotateLeft

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

fun BooleanArray.rotateLeft(offset: Int = +1)

fun ByteArray.rotateLeft(offset: Int = +1)

fun CharArray.rotateLeft(offset: Int = +1)

fun DoubleArray.rotateLeft(offset: Int = +1)

fun FloatArray.rotateLeft(offset: Int = +1)

fun IntArray.rotateLeft(offset: Int = +1)

fun LongArray.rotateLeft(offset: Int = +1)

fun ShortArray.rotateLeft(offset: Int = +1)

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

rotateRight

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

fun BooleanArray.rotateRight(offset: Int = +1)

fun ByteArray.rotateRight(offset: Int = +1)

fun CharArray.rotateRight(offset: Int = +1)

fun DoubleArray.rotateRight(offset: Int = +1)

fun FloatArray.rotateRight(offset: Int = +1)

fun IntArray.rotateRight(offset: Int = +1)

fun LongArray.rotateRight(offset: Int = +1)

fun ShortArray.rotateRight(offset: Int = +1)

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

set

actual operator fun <K, V> FastIdentityMap<K, V>.set(key: K, value: V)

actual inline operator fun <T> FastStringMap<T>.set(key: String, value: T)

expect operator fun <K, V> FastIdentityMap<K, V>.set(key: K, value: V)

expect operator fun <T> FastIntMap<T>.set(key: Int, value: T)

expect operator fun <T> FastStringMap<T>.set(key: String, value: T)

fun IStackedDoubleArray2.set(p: PointInt, level: Int, value: Double)

fun IStackedInt53Array2.set(p: PointInt, level: Int, value: Int53)

fun IStackedInt64Array2.set(p: PointInt, level: Int, value: Int64)

fun IStackedIntArray2.set(p: PointInt, level: Int, value: Int)

fun IStackedLongArray2.set(p: PointInt, level: Int, value: Long)

actual operator fun <K, V> FastIdentityMap<K, V>.set(key: K, value: V)

actual inline operator fun <T> FastIntMap<T>.set(key: Int, value: T)

actual inline operator fun <T> FastStringMap<T>.set(key: String, value: T)

actual operator fun <K, V> FastIdentityMap<K, V>.set(key: K, value: V)

actual inline operator fun <T> FastStringMap<T>.set(key: String, value: T)

actual operator fun <K, V> FastIdentityMap<K, V>.set(key: K, value: V)

actual inline operator fun <T> FastStringMap<T>.set(key: String, value: T)

actual operator fun <K, V> FastIdentityMap<K, V>.set(key: K, value: V)

actual inline operator fun <T> FastStringMap<T>.set(key: String, value: T)

setAt

fun <E> IArray2<E>.setAt(p: PointInt, v: E)

sleepUntil

fun NativeThread.Companion.sleepUntil(date: DateTime, exact: Boolean = true)

slowIdentityHashMapOf

fun <K, V> slowIdentityHashMapOf(vararg pairs: Pair<K, V>): SlowIdentityHashMap<K, V>

sort

fun DoubleArrayList.sort(start: Int = 0, end: Int = size, reversed: Boolean = false): DoubleArrayList

fun FloatArrayList.sort(start: Int = 0, end: Int = size, reversed: Boolean = false): FloatArrayList

fun IntArrayList.sort(start: Int = 0, end: Int = size, reversed: Boolean = false): IntArrayList

sortedArrayRadix

fun IntArray.sortedArrayRadix(start: Int = 0, end: Int = this.size, bits: Int = 16): IntArray

sortedMapOf

fun <K : Comparable<K>, V> sortedMapOf(vararg values: Pair<K, V>): SortedMap<K, V>

fun <K, V> sortedMapOf(comparator: Comparator<K>, vararg values: Pair<K, V>): SortedMap<K, V>

sortedRadix

fun <T : CharSequence> Array<T>.sortedRadix(start: Int = 0, end: Int = this.size, default: Char = '\u0000', transform: (Char) -> Char = { it }): Array<T>

sortRadix