interface Map<K, T>

package de.polygonal.ds

extends Collection › Hashable

implemented by HashTable, IntHashTable, IntIntHashTable

An object that maps keys to values

This map allows duplicate keys.

Methods

get (key:K):T

Returns the element that is mapped to key or a special value (see implementation) indicating that key does not exist.

has (val:T):Bool

Returns true if this map contains a mapping for val.

hasKey (key:K):Bool

Returns true if this map contains key.

keys ():Itr<K>

Creates and returns an iterator over all keys in this map.

See:

http://haxe.org/ref/iterators

remap (key:K, val:T):Bool

Remaps the first occurrence of key to val.

This is faster than this.unset(key) followed by this.set(key, val).

Returns:

true if the remapping was successful, false if key does not exist.

set (key:K, val:T):Bool

Maps val to key.

Multiple keys are stored in a First-In-First-Out (FIFO) order - there is no way to access keys which were added after the first key, other than removing the first key which unveils the second key.

Returns:

true if key was added for the first time, false if this key is not unique.

toKeySet ():Set<K>

Returns a set view of the keys contained in this map.

toValSet ():Set<T>

Returns a set view of the elements contained in this map.

unset (key:K):Bool

Removes a {key,value} pair.

Returns:

true if key was successfully removed, false if key does not exist.

Inherited Variables

Defined by Collection

read onlysize:Int

The total number of elements in this collection.

Defined by Hashable

read onlykey:Int

A unique, unsigned 32-bit integer key.

A hash table transforms this key into an index of an array element by using a hash function.

Inherited Methods

Defined by Collection

clear (?gc:Bool):Void

Removes all elements from this collection.

For performance reasons, elements are not nullified upon removal.

This means that elements won't be available for the garbage collector immediately unless gc is true.

Parameters:

gc

if true, elements are nullifies upon removal (slower).

clone (?byRef:Bool, ?copier:T ‑> T):Collection<T>

Duplicates this collection.

Supports shallow (structure only) and deep copies (structure & elements).

Example:

class Element implements de.polygonal.ds.Cloneable<Element> {
    public var val:Int;
    public function new(val:Int) {
        this.val = val;
    }
    public function clone():Element {
        return new Element(val);
    }
}

...

var c:Collection<Element> = new Array2<Element>(...);

//shallow copy
var o = c.clone(true);

//deep copy
var o = c.clone(false);

//deep copy using a custom function
var o = c.clone(false, function(x) return new Element(x.val));

If byRef is true, primitive elements are copied by value whereas objects are copied by reference.

If byRef is false, the copier function is used for copying elements. If omitted, clone() is called on each element assuming all elements implement Cloneable.

contains (val:T):Bool

Returns true if this collection contains val.

free ():Void

Disposes this collection by explicitly nullifying all internal references for GC'ing used resources.

Improves GC efficiency/performance (optional).

get_size ():Int

isEmpty ():Bool

Returns true if this collection is empty.

iterator ():Itr<T>

Iterates over all elements in this collection.

Example:

var c = new ArrayList<String>();
for (element in c) trace(element);

//or
var c = new ArrayList<String>();
var itr = c.iterator();
while (itr.hasNext()) trace(itr.next());

//inline hasNext() and next()
var c = new ArrayList<String>();
var itr:ArrayListIterator<String> = cast c.iterator();
while (itr.hasNext()) trace(itr.next());

See:

http://haxe.org/ref/iterators

remove (val:T):Bool

Removes all occurrences of val.

Returns:

true if at least one occurrence of val was removed.

toArray ():Array<T>

Returns an array storing all elements in this collection.