# SplayTreeMap<K, V> class

A Map of objects that can be ordered relative to each other.

The map is based on a self-balancing binary tree. It allows most operations in amortized logarithmic time.

Keys of the map are compared using the `compare` function passed in the constructor, both for ordering and for equality. If the map contains only the key `a`, then `map.containsKey(b)` will return `true` if and only if `compare(a, b) == 0`, and the value of `a == b` is not even checked. If the compare function is omitted, the objects are assumed to be Comparable, and are compared using their Comparable.compareTo method. Non-comparable objects (including `null`) will not work as keys in that case.

To allow calling operator [], remove or containsKey with objects that are not supported by the `compare` function, an extra `isValidKey` predicate function can be supplied. This function is tested before using the `compare` function on an argument value that may not be a `K` value. If omitted, the `isValidKey` function defaults to testing if the value is a `K`.

Mixed in types
  - MapMixin<K, V>

## Constructors

SplayTreeMap([int compare(K key1, K key2), bool isValidKey(dynamic potentialKey) ])
SplayTreeMap.from(Map other, [ int compare(K key1, K key2), bool isValidKey(dynamic potentialKey) ])
  Creates a SplayTreeMap that contains all key/value pairs of `other`. [...]
  factory
SplayTreeMap.fromIterable(Iterable iterable, { K key(dynamic element), V value(dynamic element), int compare(K key1, K key2), bool isValidKey(dynamic potentialKey) })
  Creates a SplayTreeMap where the keys and values are computed from the `iterable`. [...]
  factory
SplayTreeMap.fromIterables(Iterable<K> keys, Iterable<V> values, [ int compare(K key1, K key2), bool isValidKey(dynamic potentialKey) ])
  Creates a SplayTreeMap associating the given `keys` to `values`. [...]
  factory
SplayTreeMap.of(Map<K, V> other, [ int compare(K key1, K key2), bool isValidKey(dynamic potentialKey) ])
  Creates a SplayTreeMap that contains all key/value pairs of `other`.
  factory

## Properties

isEmpty → bool
  Returns true if there is no key/value pair in the map.
  read-only, override
isNotEmpty → bool
  Returns true if there is at least one key/value pair in the map.
  read-only, override
keys → Iterable<K>
  The keys of this. [...]
  read-only, override
length → int
  The number of key/value pairs in the map.
  read-only, override
values → Iterable<V>
  The values of this. [...]
  read-only, override
entries → Iterable<MapEntry<K, V>>
  The map entries of this.
  read-only, inherited
hashCode → int
  The hash code for this object. [...]
  read-only, inherited
runtimeType → Type
  A representation of the runtime type of the object.
  read-only, inherited

## Methods

addAll(Map<K, V> other) → void
  Adds all key/value pairs of `other` to this map. [...]
  override
clear() → void
  Removes all pairs from the map. [...]
  override
containsKey(Object key) → bool
  Returns true if this map contains the given `key`. [...]
  override
containsValue(Object value) → bool
  Returns true if this map contains the given `value`. [...]
  override
firstKey() → K
  Get the first key in the map. Returns `null` if the map is empty.
firstKeyAfter(K key) → K
  Get the first key in the map that is strictly larger than `key`. Returns `null` if no key was not found.
forEach(void f(K key, V value)) → void
  Applies `f` to each key/value pair of the map. [...]
  override
lastKey() → K
  Get the last key in the map. Returns `null` if the map is empty.
lastKeyBefore(K key) → K
  Get the last key in the map that is strictly smaller than `key`. Returns `null` if no key was not found.
putIfAbsent(K key, V ifAbsent()) → V
  Look up the value of `key`, or add a new value if it isn't there. [...]
  override
remove(Object key) → V
  Removes `key` and its associated value, if present, from the map. [...]
  override
addEntries(Iterable<MapEntry<K, V>> newEntries) → void
  Adds all key/value pairs of `newEntries` to this map. [...]
  inherited
cast<RK, RV>() → Map<RK, RV>
  Provides a view of this map as having `RK` keys and `RV` instances, if necessary. [...]
  inherited
map<K2, V2>(MapEntry<K2, V2> transform(K key, V value)) → Map<K2, V2>
  Returns a new map where all entries of this map are transformed by the given `f` function.
  inherited
noSuchMethod(Invocation invocation) → dynamic
  Invoked when a non-existent method or property is accessed. [...]
  inherited
removeWhere(bool test(K key, V value)) → void
  Removes all entries of this map that satisfy the given `predicate`.
  inherited
toString() → String
  Returns a string representation of this object.
  inherited
update(K key, V update(V value), { V ifAbsent() }) → V
  Updates the value for the provided `key`. [...]
  inherited
updateAll(V update(K key, V value)) → void
  Updates all values. [...]
  inherited

## Operators

operator [](Object key) → V
  Returns the value for the given `key` or null if `key` is not in the map. [...]
  override
operator []=(K key, V value) → void
  Associates the `key` with the given `value`. [...]
  override
operator ==(dynamic other) → bool
  The equality operator. [...]
  inherited