abstract Map<K, V>(IMap<K, V>)

Available on all platforms

Map allows key to value mapping for arbitrary value types, and many key types.


This is a multi-type abstract, it is instantiated as one of its specialization types depending on its type parameters.

A Map can be instantiated without explicit type parameters. Type inference will then determine the type parameters from the usage.

Maps can also be created with key1 => value1, key2 => value2 syntax.

Map is an abstract type, it is not available at runtime.

Class Fields

function fromIntMap<V>(map:IntMap<V>):Map<Int, V>

function fromObjectMap<K, V>(map:ObjectMap<K, V>):Map<K, V>

function fromStringMap<V>(map:StringMap<V>):Map<String, V>

Instance Fields

function new():IMap<K, V>

Creates a new Map.


This becomes a constructor call to one of the specialization types in
the output. The rules for that are as follows:

1. if K is a `String`, `haxe.ds.StringMap` is used
2. if K is an `Int`, `haxe.ds.IntMap` is used
3. if K is an `EnumValue`, `haxe.ds.EnumValueMap` is used
4. if K is any other class or structure, `haxe.ds.ObjectMap` is used
5. if K is any other type, it causes a compile-time error

(Cpp) Map does not use weak keys on ObjectMap by default.

function arrayWrite(k:K, v:V):V

function exists(key:K):Bool

Returns true if key has a mapping, false otherwise.


If `key` is null, the result is unspecified.

function get(key:K):Null<V>

Returns the current mapping of key.


If no such mapping exists, null is returned.

Note that a check like `map.get(key) == null` can hold for two reasons:

1. the map has no mapping for `key`
2. the map has a mapping with a value of `null`

If it is important to distinguish these cases, `exists()` should be
used.

If `key` is null, the result is unspecified.

function iterator():Iterator<V>

Returns an Iterator over the values of this Map.


The order of values is undefined.

function keys():Iterator<K>

Returns an Iterator over the keys of this Map.


The order of keys is undefined.

function remove(key:K):Bool

Removes the mapping of key and returns true if such a mapping existed,

false otherwise.

If `key` is null, the result is unspecified.

function set(key:K, value:V):Void

Maps key to value.


If `key` already has a mapping, the previous value disappears.

If `key` is null, the result is unspecified.

function toEnumValueMapMap<K>():EnumValueMap<K, V>

function toIntMap():IntMap<V>

function toObjectMap<K>():ObjectMap<K, V>

function toString():String

Returns a String representation of this Map.


The exact representation depends on the platform and key-type.

function toStringMap():StringMap<V>