korge-foundation/korlibs.datastructure/SortedMap

SortedMap

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

Constructors

SortedMap

constructor(comparator: Comparator<K>)

Types

Companion

object Companion

Sorting

object Sorting : SortOps<SortedMap<Any, Any>>

Properties

comparator

val comparator: Comparator<K>

entries

open override val entries: MutableSet<MutableMap.MutableEntry<K, V>>

keys

open override val keys: MutableSet<K>

size

open override val size: Int

values

open override val values: MutableCollection<V>

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>

asFakeMutable

fun <K, V> Map<K, V>.asFakeMutable(): FakeMutableMap<K, V>

clear

open override fun clear()

containsKey

open override fun containsKey(key: K): Boolean

containsValue

open override fun containsValue(value: V): Boolean

fastForEach

inline fun fastForEach(block: (index: Int, key: K, value: V) -> Unit)

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>

get

open operator override fun get(key: K): V?

getFirst

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

getKeyAt

fun getKeyAt(index: Int): K

getLast

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

getValueAt

fun getValueAt(index: Int): V

incr

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

isEmpty

open override fun isEmpty(): Boolean

keysToList

fun keysToList(): List<K>

nearestHigh

fun nearestHigh(key: K): K?

nearestHighExcludingExact

fun nearestHighExcludingExact(key: K): K?

nearestHighIndex

fun nearestHighIndex(key: K): Int

nearestLow

fun nearestLow(key: K): K?

nearestLowExcludingExact

fun nearestLowExcludingExact(key: K): K?

nearestLowHighIndex

fun nearestLowHighIndex(key: K, doHigh: Boolean): Int

nearestLowIndex

fun nearestLowIndex(key: K): Int

put

open override fun put(key: K, value: V): V?

putAll

open override fun putAll(from: Map<out K, V>)

remove

open override fun remove(key: K): V?

removeAt

fun removeAt(index: Int)

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>

set

operator fun set(key: K, value: V)

swap

fun swap(indexL: Int, indexR: Int)

toCaseInsensitiveMap

fun <T> Map<String, T>.toCaseInsensitiveMap(): Map<String, T>

toFast

fun <T : Any> Map<String, T>.toFast(): FastStringMap<T>

toIntMap

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

toList

fun toList(): List<Pair<K, V>>

toMap

fun toMap(): Map<K, V>

valuesToList

fun valuesToList(): List<V>