moshi/com.squareup.moshi/LinkedHashTreeMap

LinkedHashTreeMap

A map of comparable keys to values. Unlike {@code TreeMap} , this class uses insertion order for iteration order. Comparison order is only used as an optimization for efficient insertion and removal.

This implementation was derived from Android 4.1's TreeMap and LinkedHashMap classes.

class LinkedHashTreeMap<K, V> : AbstractMap<K, V> , Serializable

Constructors

LinkedHashTreeMap

Create a natural order, empty tree map whose keys must be mutually comparable and non-null.

open fun LinkedHashTreeMap()

LinkedHashTreeMap

Create a tree map ordered by {@code comparator} . This map's keys may only be null if {@code * comparator} permits.

open fun LinkedHashTreeMap(comparator: Comparator<out Any>)

Types

AvlBuilder

Builds AVL trees of a predetermined size by accepting nodes of increasing value. To use:

Call reset to initialize the target size size.
Call size times with increasing values.
Call root to get the root of the balanced tree.

The returned tree will satisfy the AVL constraint: for every node N, the height of N.left and N.right is different by at most 1. It accomplishes this by omitting deepest-level leaf nodes when building trees whose size isn't a power of 2 minus 1.

Unlike rebuilding a tree from scratch, this approach requires no value comparisons. Using this class to create a tree of size S is {@code O(S)} .

class AvlBuilder<K, V>

AvlIterator

Walks an AVL tree in iteration order. Once a node has been returned, its left, right and parent links are no longer used. For this reason it is safe to transform these links as you walk a tree.

Warning: this iterator is destructive. It clears the parent node of all nodes in the tree. It is an error to make a partial iteration of a tree.

open class AvlIterator<K, V>

EntrySet

class EntrySet : AbstractSet<Map.Entry<K, V>>

KeySet

class KeySet : AbstractSet<K>

LinkedTreeMapIterator

abstract class LinkedTreeMapIterator<T> : Iterator<T>

Node

class Node<K, V> : Map.Entry<K, V>

Functions

clear

open fun clear()

clone

open fun clone(): Any

compute

open fun compute(key: K, remappingFunction: BiFunction<out Any, out Any, out V>): V

computeIfAbsent

open fun computeIfAbsent(key: K, mappingFunction: Function<out Any, out V>): V

computeIfPresent

open fun computeIfPresent(key: K, remappingFunction: BiFunction<out Any, out Any, out V>): V

containsKey

open fun containsKey(key: Any): Boolean

containsValue

open fun containsValue(value: Any): Boolean

copyOf

open fun <K, V> copyOf(map: Map<out K, out V>): Map<K, V>

doubleCapacity

Returns a new array containing the same nodes as {@code oldTable} , but with twice as many trees, each of (approximately) half the previous size.

open fun <K, V> doubleCapacity(oldTable: Array<LinkedHashTreeMap.Node<K, V>>): Array<LinkedHashTreeMap.Node<K, V>>

entry

open fun <K, V> entry(k: K, v: V): Map.Entry<K, V>

entrySet

open fun entrySet(): Set<Map.Entry<K, V>>

abstract fun entrySet(): Set<Map.Entry<K, V>>

open fun eq(o1: Any, o2: Any): Boolean

equals

open fun equals(o: Any): Boolean

find

Returns the node at or adjacent to the given key, creating it if requested.

open fun find(key: K, create: Boolean): LinkedHashTreeMap.Node<K, V>

findByEntry

Returns this map's entry that has the same key and value as {@code entry} , or null if this map has no such entry.

This method uses the comparator for key equality rather than {@code equals} . If this map's comparator isn't consistent with equals (such as {@code String.CASE_INSENSITIVE_ORDER} ), then {@code remove()} and {@code contains()} will violate the collections API.