NavigableSubMap

Types

Link copied to clipboard
Link copied to clipboard
abstract inner class SubMapIterator<T>(first: TreeMap.Entry<K, V>?, fence: TreeMap.Entry<K, V>?) : MutableIterator<T>

Iterators for SubMaps

Properties

Link copied to clipboard
Link copied to clipboard
abstract override val entries: MutableSet<MutableMap.MutableEntry<K, V>>
Link copied to clipboard

Returns a Set view of the mappings contained in this map. The set's iterator returns the entries in ascending key order. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation, or through the setValue operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll and clear operations. It does not support the add or addAll operations.

Link copied to clipboard
Link copied to clipboard
val hi: K
Link copied to clipboard
Link copied to clipboard
open override val keys: NavigableSet<K>
Link copied to clipboard
open override val keySet: MutableSet<K>

Returns a Set view of the keys contained in this map. The set's iterator returns the keys in ascending order. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.

Link copied to clipboard
val lo: K

Endpoints are represented as triples (fromStart, lo, loInclusive) and (toEnd, hi, hiInclusive). If fromStart is true, then the low (absolute) bound is the start of the backing map, and the other values are ignored. Otherwise, if loInclusive is true, lo is the inclusive bound, else lo is the exclusive bound. Similarly for the upper bound.

Link copied to clipboard
Link copied to clipboard
val m: TreeMap<K, V>

The backing map.

Link copied to clipboard
open override val size: Int
Link copied to clipboard
Link copied to clipboard
abstract override val values: MutableCollection<V>

Returns a Collection view of the values contained in this map. The collection's iterator returns the values in ascending order of the corresponding keys. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Collection.remove, removeAll, retainAll and clear operations. It does not support the add or addAll operations.

Functions

Link copied to clipboard
fun absCeiling(key: K?): TreeMap.Entry<K, V>?
Link copied to clipboard
fun absFloor(key: K?): TreeMap.Entry<K, V>?
Link copied to clipboard
fun absHigher(key: K?): TreeMap.Entry<K, V>?
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun absLower(key: K?): TreeMap.Entry<K, V>?
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
open override fun ceilingEntry(key: K): Map.Entry<K, V>?

Returns a key-value mapping associated with the least key greater than or equal to the given key, or null if there is no such key.

Link copied to clipboard
open override fun ceilingKey(key: K): K?

Returns the least key greater than or equal to the given key, or null if there is no such key.

Link copied to clipboard
open override fun clear()
Link copied to clipboard
abstract fun comparator(): Comparator<K>?

Returns the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys.

Link copied to clipboard
fun compute(key: K, remappingFunction: (K, V?) -> V?): V?
Link copied to clipboard
fun computeIfAbsent(key: K, mappingFunction: (K) -> V): V?
Link copied to clipboard
fun <K, V> MutableMap<K, V>.computeIfAbsent(key: K, mappingFunction: (K) -> V): V?

ported from java.util.Map.computeIfAbsent()

Link copied to clipboard
fun computeIfPresent(key: K, remappingFunction: (K, V) -> V?): V?
Link copied to clipboard
open override fun containsKey(key: K): Boolean
Link copied to clipboard
open override fun containsValue(value: V): Boolean
Link copied to clipboard

Returns descending iterator from the perspective of this submap

Link copied to clipboard
open override fun descendingKeySet(): NavigableSet<K>

Returns a reverse order NavigableSet view of the keys contained in this map. The set's iterator returns the keys in descending order. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.

Link copied to clipboard
abstract fun descendingMap(): NavigableMap<K, V>

Returns a reverse order view of the mappings contained in this map. The descending map is backed by this map, so changes to the map are reflected in the descending map, and vice-versa. If either map is modified while an iteration over a collection view of either map is in progress (except through the iterator's own remove operation), the results of the iteration are undefined.

Link copied to clipboard
open override fun firstEntry(): Map.Entry<K, V>?

Returns a key-value mapping associated with the least key in this map, or null if the map is empty.

Link copied to clipboard
open override fun firstKey(): K

Returns the first (lowest) key currently in this map.

Link copied to clipboard
open override fun floorEntry(key: K): Map.Entry<K, V>?

Returns a key-value mapping associated with the greatest key less than or equal to the given key, or null if there is no such key.

Link copied to clipboard
open override fun floorKey(key: K): K?

Returns the greatest key less than or equal to the given key, or null if there is no such key.

Link copied to clipboard
open operator override fun get(key: K): V?
Link copied to clipboard
abstract fun headMap(toKey: K, inclusive: Boolean): SortedMap<K, V>

Returns a view of the portion of this map whose keys are less than (or equal to, if inclusive is true) toKey. The returned map is backed by this map, so changes in the returned map are reflected in this map, and vice-versa. The returned map supports all optional map operations that this map supports.

open override fun headMap(toKey: K): SortedMap<K, V>

{@inheritDoc}

Link copied to clipboard
open override fun higherEntry(key: K): Map.Entry<K, V>?

Returns a key-value mapping associated with the least key strictly greater than the given key, or null if there is no such key.

Link copied to clipboard
open override fun higherKey(key: K): K?

Returns the least key strictly greater than the given key, or null if there is no such key.

Link copied to clipboard
Link copied to clipboard
fun inRange(key: K): Boolean
fun inRange(key: K, inclusive: Boolean): Boolean
Link copied to clipboard
@JvmName(name = "isEmptyKt")
open override fun isEmpty(): Boolean
Link copied to clipboard
abstract fun keyIterator(): MutableIterator<K>

Returns ascending iterator from the perspective of this submap

Link copied to clipboard
abstract fun keySpliterator(): Spliterator<K>
Link copied to clipboard
open override fun lastEntry(): Map.Entry<K, V>?

Returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.

Link copied to clipboard
open override fun lastKey(): K

Returns the last (highest) key currently in this map.

Link copied to clipboard
open override fun lowerEntry(key: K): Map.Entry<K, V>?

Returns a key-value mapping associated with the greatest key strictly less than the given key, or null if there is no such key.

Link copied to clipboard
open override fun lowerKey(key: K): K?

Returns the greatest key strictly less than the given key, or null if there is no such key.

Link copied to clipboard
fun merge(key: K, value: V, remappingFunction: (V?, V?) -> V?): V?
Link copied to clipboard
open override fun navigableKeySet(): NavigableSet<K>

Returns a NavigableSet view of the keys contained in this map. The set's iterator returns the keys in ascending order. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.

Link copied to clipboard
open override fun pollFirstEntry(): Map.Entry<K, V>?

Removes and returns a key-value mapping associated with the least key in this map, or null if the map is empty (optional operation).

Link copied to clipboard
open override fun pollLastEntry(): Map.Entry<K, V>?

Removes and returns a key-value mapping associated with the greatest key in this map, or null if the map is empty (optional operation).

Link copied to clipboard
open override fun put(key: K, value: V): V?
Link copied to clipboard
open override fun putAll(toPut: Map<out K, V>)
Link copied to clipboard
open override fun putFirst(k: K, v: V): V

Throws UnsupportedOperationException. The encounter order induced by this map's comparison method determines the position of mappings, so explicit positioning is not supported.

Link copied to clipboard
fun putIfAbsent(key: K, value: V): V?
Link copied to clipboard
fun <K, V> MutableMap<K, V>.putIfAbsent(key: K, value: V): V?

ported from java.util.Map.putIfAbsent()

Link copied to clipboard
open override fun putLast(k: K, v: V): V

Throws UnsupportedOperationException. The encounter order induced by this map's comparison method determines the position of mappings, so explicit positioning is not supported.

Link copied to clipboard
open override fun remove(key: K): V?
Link copied to clipboard
fun <K, V> MutableMap<K, V>.remove(key: K, value: V): Boolean

ported from java.util.Map.remove()

Link copied to clipboard
fun <K, V> MutableMap<K, V>.replace(key: K, value: V): V?

ported from java.util.Map.replace()

Link copied to clipboard
open override fun reversed(): NavigableMap<K, V>

{@inheritDoc}

Link copied to clipboard
abstract fun subCeiling(key: K?): TreeMap.Entry<K, V>?
Link copied to clipboard
abstract fun subFloor(key: K?): TreeMap.Entry<K, V>?
Link copied to clipboard
abstract fun subHigher(key: K?): TreeMap.Entry<K, V>?
Link copied to clipboard
abstract fun subHighest(): TreeMap.Entry<K, V>?
Link copied to clipboard
abstract fun subLower(key: K?): TreeMap.Entry<K, V>?
Link copied to clipboard
abstract fun subLowest(): TreeMap.Entry<K, V>?
Link copied to clipboard
abstract fun subMap(fromKey: K, fromInclusive: Boolean, toKey: K, toInclusive: Boolean): SortedMap<K, V>

Returns a view of the portion of this map whose keys range from fromKey to toKey. If fromKey and toKey are equal, the returned map is empty unless fromInclusive and toInclusive are both true. The returned map is backed by this map, so changes in the returned map are reflected in this map, and vice-versa. The returned map supports all optional map operations that this map supports.

open override fun subMap(fromKey: K, toKey: K): SortedMap<K, V>

{@inheritDoc}

Link copied to clipboard
abstract fun tailMap(fromKey: K, inclusive: Boolean): SortedMap<K, V>

Returns a view of the portion of this map whose keys are greater than (or equal to, if inclusive is true) fromKey. The returned map is backed by this map, so changes in the returned map are reflected in this map, and vice-versa. The returned map supports all optional map operations that this map supports.

open override fun tailMap(fromKey: K): SortedMap<K, V>

{@inheritDoc}

Link copied to clipboard
fun tooHigh(key: K): Boolean
Link copied to clipboard
fun tooLow(key: K): Boolean