korge-foundation/korlibs.datastructure

Package-level declarations

Types

Array2

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

BaseCacheMap

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

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>

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

data class BooleanArray2(val width: Int, val height: Int, val data: BooleanArray) : IArray2<Boolean>

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

typealias BooleanIArray2 = IArray2<Boolean>

BSearchResult

inline class BSearchResult(val raw: Int)

ByteArray2

data class ByteArray2(val width: Int, val height: Int, val data: ByteArray) : IArray2<Byte>

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

typealias 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

data class CharArray2(val width: Int, val height: Int, val data: CharArray) : IArray2<Char>

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

typealias 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

data class DoubleArray2(val width: Int, val height: Int, val data: DoubleArray) : IArray2<Double>

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

typealias DoubleIArray2 = IArray2<Double>

DoubleList

interface DoubleList : Collection<Double> , IsAlmostEquals<DoubleList>

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>

Extra

interface Extra

ExtraObject

class ExtraObject : MutableMap<String, Any?>

ExtraType

typealias ExtraType = ExtraObject?

FastArrayList

expect class FastArrayList<E> : MutableListEx<E> , RandomAccess

actual open class FastArrayList<E> : AbstractMutableList<E> , MutableListEx<E> , RandomAccess

FastIdentityCacheMap

class FastIdentityCacheMap<K, V>

FastIdentityMap

expect class FastIdentityMap<K, V>

actual class FastIdentityMap<K, V>

FastIntMap

expect class FastIntMap<T>

actual typealias FastIntMap<T> = IntMap<T>

actual class FastIntMap<T>(dummy: Boolean)

FastSmallSet

class FastSmallSet<T> : AbstractMutableSet<T>

FastStringMap

expect class FastStringMap<T>

actual class FastStringMap<T>

FloatArray2

data class FloatArray2(val width: Int, val height: Int, val data: FloatArray) : IArray2<Float>

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

typealias FloatIArray2 = IArray2<Float>

FloatIntMap

class FloatIntMap

FloatList

interface FloatList : Collection<Float> , IsAlmostEqualsF<FloatList>

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>

IntArray2

data class IntArray2(val width: Int, val height: Int, val data: IntArray) : IArray2<Int>

IntArrayDeque

class IntArrayDeque(val initialBits: Int = 10)

IntArrayList

class IntArrayList(capacity: Int = 7) : Collection<Int>

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

typealias 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>

IStackedIntArray2

interface IStackedIntArray2

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

data class LongArray2(val width: Int, val height: Int, val data: LongArray) : IArray2<Long>

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

typealias 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>>

MutableListEx

interface MutableListEx<E> : MutableList<E>

MutableMapList

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

Observable

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

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

data class ShortArray2(val width: Int, val height: Int, val data: ShortArray) : IArray2<Short>

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

typealias 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>>>

SparseChunkedStackedIntArray2

class SparseChunkedStackedIntArray2(var empty: Int = -1) : IStackedIntArray2

Stack

typealias Stack<TGen> = TGenStack<TGen>

StackedIntArray2

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

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.

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

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 IStackedIntArray2.endX: Int

Shortcut for IStackedIntArray2.startX + IStackedIntArray2.width

endY

val IStackedIntArray2.endY: Int

Shortcut for IStackedIntArray2.startY + IStackedIntArray2.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

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 <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

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>

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

buildFastList

inline fun <T> buildFastList(block: FastArrayList<T>.() -> Unit): FastArrayList<T>

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

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

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

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

actual inline 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()

comparator

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

contains

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 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> 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

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)

ensureFastList

fun <T> List<T>.ensureFastList(): FastArrayList<T>

expect

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

extraCache

fun <T> Extra.extraCache(name: String, block: () -> T): T

extraProperty

inline fun <T> extraProperty(name: String? = null, noinline default: () -> T): Extra.Property<T>

extraPropertyThis

inline fun <T2 : Extra, T> extraPropertyThis(name: String? = null, noinline transform: T2.(T) -> T = { it }, noinline default: T2.() -> T): Extra.PropertyThis<T2, T>

ExtraTypeCreate

fun ExtraTypeCreate(): ExtraObject

fastArrayListOf

fun <T> fastArrayListOf(vararg values: T): FastArrayList<T>

fastCastTo

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

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

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

FastIntMap

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

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

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

fastKeyForEach

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 <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)

FastStringMap

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

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

actual 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