| Package | org.as3collections |
| Class | public class AbstractListMap |
| Inheritance | AbstractListMap  Object |
| Implements | IListMap |
| Subclasses | ArrayListMap, ReadOnlyArrayListMap |
IListMap interface, to minimize the effort required to implement this interface.
This class maintains two ArrayList objects as its source, one for keys and one for values.
This is an abstract class and shouldn't be instantiated directly.
This class makes guarantees as to the order of the map. The order in which elements are stored is the order in which they were inserted.
The documentation for each non-abstract method in this class describes its implementation in detail. Each of these methods may be overridden if the map being implemented admits a more efficient implementation.
IMPORTANT:
This class implements equality through org.as3coreaddendum.system.IEquatable interface in the equals method and in all methods that compares the elements inside this collection (i.e. containsKey, containsValue, put, remove, removeAll and retainAll).
In order to this map uses the equals method of its keys and/or values in comparisons (rather than default '==' operator), all keys and/or values in this map must implement the
org.as3coreaddendum.system.IEquatable
interface and also the supplied key and/or value.
For example:
myMap.containsKey(myKey);
All keys (but in this case only keys) inside myMap, and myKey, must implement the org.as3coreaddendum.system.IEquatable interface so that equals method of each key can be used in the comparison.
Otherwise '==' operator is used. The same is true for values.
The use of equality for keys and values are independent.
It's possible to use only keys that implement IEquatable, only values, both, or none.
This usage varies according to application needs.
All subclasses of this class must conform with this behavior.
See also
| Property | Defined By | ||
|---|---|---|---|
| allKeysEquatable : Boolean [read-only]
Indicates whether all keys in this map implements org.as3coreaddendum.system.IEquatable interface. | AbstractListMap | ||
| allValuesEquatable : Boolean [read-only]
Indicates whether all values in this map implements org.as3coreaddendum.system.IEquatable interface. | AbstractListMap | ||
| modCount : int [read-only]
The number of times this map has been structurally modified. | AbstractListMap | ||
| Method | Defined By | ||
|---|---|---|---|
AbstractListMap(source:IMap = null)
Constructor, creates a new AbstractListMap object. | AbstractListMap | ||
clear():void
Removes all of the mappings from this map (optional operation). | AbstractListMap | ||
clone():*
Creates and return a shallow copy of this collection. | AbstractListMap | ||
containsKey(key:*):Boolean
Returns true if this map contains a mapping for the specified key. | AbstractListMap | ||
containsValue(value:*):Boolean
Returns true if this map maps one or more keys to the specified value. | AbstractListMap | ||
Returns an ArrayList object that is a view of the mappings contained in this map (in the same order). | AbstractListMap | ||
equals(other:*):Boolean
This method uses MapUtil.equalConsideringOrder method to perform equality, sending this map and other argument. | AbstractListMap | ||
getKeyAt(index:int):*
Returns the key at the specified position in this map. | AbstractListMap | ||
Returns an ArrayList object that is a view of the keys contained in this map. | AbstractListMap | ||
getValue(key:*):*
Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key. | AbstractListMap | ||
getValueAt(index:int):*
Returns the value at the specified position in this map. | AbstractListMap | ||
Returns an ArrayList object that is a view of the values contained in this map. | AbstractListMap | ||
Returns a new IListMap object that is a view of the portion of this map whose keys are strictly less than toKey. | AbstractListMap | ||
indexOfKey(key:*):int
Returns the position of the specified key. | AbstractListMap | ||
indexOfValue(value:*):int
Returns the position of the specified value. | AbstractListMap | ||
isEmpty():Boolean
Returns true if this map contains no key-value mappings. | AbstractListMap | ||
Returns an iterator over a set of mappings. | AbstractListMap | ||
listMapIterator(index:int = 0):IListMapIterator
Returns a IListMapIterator object to iterate over the mappings in this map (in proper sequence), starting at the specified position in this map. | AbstractListMap | ||
put(key:*, value:*):*
Associates the specified value with the specified key in this map (optional operation). | AbstractListMap | ||
Copies all of the mappings from the specified map to this map (optional operation). | AbstractListMap | ||
Copies all of the mappings from the specified map to this map (optional operation). | AbstractListMap | ||
putAllByObject(o:Object):void
This implementation performs a for..in in the specified object, calling put on this map once for each iteration (optional operation). | AbstractListMap | ||
putAt(index:int, key:*, value:*):void
Associates the specified value with the specified key at the specified position in this map (optional operation). | AbstractListMap | ||
Associates the specified entry.value with the specified entry.key in this map (optional operation). | AbstractListMap | ||
remove(key:*):*
Removes the mapping for a key from this map if it is present (optional operation). | AbstractListMap | ||
removeAll(keys:ICollection):Boolean
Removes the mapping for a key from this map (if it is present) for each element in the specified collection (optional operation). | AbstractListMap | ||
Removes the mapping at the specified position in this map (optional operation). | AbstractListMap | ||
removeRange(fromIndex:int, toIndex:int):IListMap
Removes all of the mappings whose index is between fromIndex, inclusive, and toIndex, exclusive (optional operation). | AbstractListMap | ||
retainAll(keys:ICollection):Boolean
Retains only the mappings in this map that the keys are contained (as elements) in the specified collection (optional operation). | AbstractListMap | ||
reverse():void
Reverses the order of the mappings in this map. | AbstractListMap | ||
setKeyAt(index:int, key:*):*
Replaces the key at the specified position in this map with the specified key (optional operation). | AbstractListMap | ||
setValueAt(index:int, value:*):*
Replaces the value at the specified position in this map with the specified value (optional operation). | AbstractListMap | ||
size():int
Returns the number of key-value mappings in this map. | AbstractListMap | ||
Returns a new map that is a view of the portion of this map between the specified fromIndex, inclusive, and toIndex, exclusive. | AbstractListMap | ||
Returns a new IListMap object that is a view of the portion of this map whose keys are greater than or equal to fromKey. | AbstractListMap | ||
toString():String
Returns the string representation of this instance. | AbstractListMap | ||
| allKeysEquatable | property |
allKeysEquatable:Boolean [read-only]
Indicates whether all keys in this map implements org.as3coreaddendum.system.IEquatable interface.
public function get allKeysEquatable():Boolean| allValuesEquatable | property |
allValuesEquatable:Boolean [read-only]
Indicates whether all values in this map implements org.as3coreaddendum.system.IEquatable interface.
public function get allValuesEquatable():Boolean| keys | property |
keys:IList protected function get keys():IList protected function set keys(value:IList):void| modCount | property |
modCount:int [read-only] The number of times this map has been structurally modified. Structural modifications are those that change the size of the map.
This field is used by the IListMapIterator implementation returned by the listMapIterator method.
If the value of this field changes unexpectedly, the IListMapIterator object will throw a org.as3collections.errors.ConcurrentModificationError in response to the next, remove, previous or put operations.
Implementations merely has to increment this field in its put, remove and any other methods that result in structural modifications to the map.
A single call to put or remove must add no more than one to this field.
public function get modCount():int| values | property |
values:IList protected function get values():IList protected function set values(value:IList):void| AbstractListMap | () | Constructor |
public function AbstractListMap(source:IMap = null)Constructor, creates a new AbstractListMap object.
Parameterssource:IMap (default = null) |
IllegalOperationError — If this class is instantiated directly, in other words, if there is not another class extending this class.
|
| clear | () | method |
public function clear():voidRemoves all of the mappings from this map (optional operation). The map will be empty after this call returns.
This implementation always throws an UnsupportedOperationError.
org.as3coreaddendum.errors:UnsupportedOperationError — if the clear operation is not supported by this map.
|
| clone | () | method |
public function clone():*Creates and return a shallow copy of this collection.
This implementation always throws a CloneNotSupportedError.
* — A new object that is a shallow copy of this instance.
|
org.as3coreaddendum.errors:CloneNotSupportedError — if this map doesn't support clone.
|
| containsKey | () | method |
public function containsKey(key:*):Boolean
Returns true if this map contains a mapping for the specified key.
Parameters
key:* — key whose presence in this map is to be tested.
|
Boolean — true if this map contains a mapping for the specified key.
|
org.as3coreaddendum.errors:ClassCastError — if the type of the specified key is incompatible with this map (optional).
| |
ArgumentError if — the specified key is null and this map does not permit null keys (optional).
|
| containsValue | () | method |
public function containsValue(value:*):Boolean
Returns true if this map maps one or more keys to the specified value.
Parameters
value:* — value whose presence in this map is to be tested.
|
Boolean — true if this map maps one or more keys to the specified value.
|
org.as3coreaddendum.errors:ClassCastError — if the type of the specified value is incompatible with this map (optional).
| |
ArgumentError if — the specified value is null and this map does not permit null values (optional).
|
| entryCollection | () | method |
public function entryCollection():ICollection
Returns an ArrayList object that is a view of the mappings contained in this map (in the same order).
The type of the objects within the list is IMapEntry
Modifications in the ArrayList object doesn't affect this map.
ICollection — an ArrayList object that is a view of the mappings contained in this map.
|
See also
| equals | () | method |
public function equals(other:*):Boolean
This method uses MapUtil.equalConsideringOrder method to perform equality, sending this map and other argument.
Parameters
other:* — the object to be compared for equality.
|
Boolean — true if the arbitrary evaluation considers the objects equal.
|
See also
| getKeyAt | () | method |
public function getKeyAt(index:int):*Returns the key at the specified position in this map.
This implementation forwards the call to keys.getAt(index).
Parameters
index:int — index of the key to return.
|
* — the key at the specified position in this map.
|
IndexOutOfBoundsError — if the index is out of range (index < 0 || index >= size()).
|
| getKeys | () | method |
public function getKeys():ICollection
Returns an ArrayList object that is a view of the keys contained in this map.
Modifications in the ArrayList object doesn't affect this map.
ICollection — an ArrayList object that is a view of the keys contained in this map.
|
See also
| getValue | () | method |
public function getValue(key:*):*
Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
If this map permits null values, then a return value of null does not necessarily indicate that the map contains no mapping for the key.
It's possible that the map explicitly maps the key to null.
The containsKey method may be used to distinguish these two cases.
This implementation uses indexOfKey method to get the index of the key/value and then calls values.getAt method.
Parameters
key:* — the key whose associated value is to be returned.
|
* — the value to which the specified key is mapped, or null if this map contains no mapping for the key.
|
org.as3coreaddendum.errors:ClassCastError — if the type of the specified key is incompatible with this map (optional).
| |
ArgumentError — if the specified key is null and this map does not permit null keys (optional).
|
| getValueAt | () | method |
public function getValueAt(index:int):*Returns the value at the specified position in this map.
This implementation forwards the call to values.getAt(index).
Parameters
index:int — index of the value to return.
|
* — the value at the specified position in this map.
|
IndexOutOfBoundsError — if the index is out of range (index < 0 || index >= size()).
|
| getValues | () | method |
public function getValues():ICollection
Returns an ArrayList object that is a view of the values contained in this map.
Modifications in the ArrayList object doesn't affect this map.
ICollection — an ArrayList object that is a view of the values contained in this map.
|
See also
| headMap | () | method |
public function headMap(toKey:*):IListMap
Returns a new IListMap object that is a view of the portion of this map whose keys are strictly less than toKey.
The returned map supports all optional map operations that this map supports.
This implementation uses subMap(0, indexOfKey(toKey)).
Note that this implementation will throw an UnsupportedOperationError unless subMap is overridden.
Parameters
toKey:* — high endpoint (exclusive) of the keys in the returned map.
|
IListMap — a new IListMap that is a view of the portion of this map whose keys are strictly less than toKey.
|
ArgumentError — if toKey is null and this map does not permit null keys.
| |
ArgumentError — if containsKey(toKey) returns false.
|
| indexOfKey | () | method |
public function indexOfKey(key:*):intReturns the position of the specified key.
This implementation forwards the call to keys.indexOf(key).
Parameters
key:* — the key to search for.
|
int — the position of the specified key.
|
| indexOfValue | () | method |
public function indexOfValue(value:*):intReturns the position of the specified value.
This implementation forwards the call to values.indexOf(value).
Parameters
value:* — the value to search for.
|
int — the position of the specified value.
|
| isEmpty | () | method |
public function isEmpty():Boolean
Returns true if this map contains no key-value mappings.
Boolean — true if this map contains no key-value mappings.
|
| iterator | () | method |
public function iterator():IIteratorReturns an iterator over a set of mappings.
This implementation always throws an UnsupportedOperationError.
IIterator — an iterator over a set of values.
|
org.as3coreaddendum.errors:UnsupportedOperationError — this method must be overridden in subclass.
|
| listMapIterator | () | method |
public function listMapIterator(index:int = 0):IListMapIterator
Returns a IListMapIterator object to iterate over the mappings in this map (in proper sequence), starting at the specified position in this map.
The specified index indicates the first value that would be returned by an initial call to next.
An initial call to previous would return the value with the specified index minus one.
This implementation always throws an UnsupportedOperationError.
Parameters
index:int (default = 0)next method)
|
IListMapIterator — a IListMapIterator object to iterate over the mappings in this map (in proper sequence), starting at the specified position in this map.
|
| put | () | method |
public function put(key:*, value:*):*
Associates the specified value with the specified key in this map (optional operation).
If the map previously contained a mapping for the key, the old value is replaced by the specified value, and the order of the key is not affected.
(A map m is said to contain a mapping for a key k if and only if m.containsKey(k) would return true.)
This implementation always throws an UnsupportedOperationError.
Parameters
key:* — key with which the specified value is to be associated.
| |
value:* — value to be associated with the specified key.
|
* — the previous value associated with key, or null if there was no mapping for key. (A null return can also indicate that the map previously associated null with key, if the implementation supports null values.)
|
org.as3coreaddendum.errors:UnsupportedOperationError — if the put operation is not supported by this map.
| |
org.as3coreaddendum.errors:ClassCastError — if the type of the specified key or value is incompatible with this map.
| |
ArgumentError if — the specified key or value is null and this map does not permit null keys or values.
|
| putAll | () | method |
public function putAll(map:IMap):void
Copies all of the mappings from the specified map to this map (optional operation).
The effect of this call is equivalent to that of calling put(k, v) on this map once for each mapping from key k to value v in the specified map.
This implementation calls putAllAt(size(), collection).
Note that this implementation will throw an UnsupportedOperationError unless putAt is overridden (assuming the specified map is non-empty).
Parameters
map:IMap — mappings to be stored in this map.
|
org.as3coreaddendum.errors:UnsupportedOperationError — if the putAll operation is not supported by this map.
| |
org.as3coreaddendum.errors:ClassCastError — if the type of a key or value in the specified map is incompatible with this map.
| |
ArgumentError — if the specified map is null, or if this map does not permit null keys or values, and the specified map contains null keys or values.
|
| putAllAt | () | method |
public function putAllAt(index:int, map:IMap):voidCopies all of the mappings from the specified map to this map (optional operation). Shifts the entry currently at that position (if any) and any subsequent entries to the right (increases their indices). The new entries will appear in this map in the order that they are returned by the specified map's iterator.
This implementation iterates over the specified map, and calls this map's putAt operation once for each entry returned by the iteration.
Parameters
index:int — index at which to insert the first entry from the specified map.
| |
map:IMap — mappings to be stored in this map.
|
org.as3coreaddendum.errors:UnsupportedOperationError — if the putAllAt operation is not supported by this map.
| |
org.as3coreaddendum.errors:ClassCastError — if the type of a key or value in the specified map is incompatible with this map.
| |
ArgumentError — if the specified map is null, or if this map does not permit null keys or values, and the specified map contains null keys or values.
|
| putAllByObject | () | method |
public function putAllByObject(o:Object):void
This implementation performs a for..in in the specified object, calling put on this map once for each iteration (optional operation).
Parameters
o:Object — the object to retrieve the properties.
|
org.as3coreaddendum.errors:UnsupportedOperationError — if the putAllByObject operation is not supported by this map.
| |
org.as3coreaddendum.errors:ClassCastError — if the type of a key or value in the specified object is incompatible with this map.
| |
ArgumentError — if the specified object is null, or if this map does not permit null keys or values, and the specified object contains null keys or values.
|
| putAt | () | method |
public function putAt(index:int, key:*, value:*):voidAssociates the specified value with the specified key at the specified position in this map (optional operation). Shifts the entry currently at that position (if any) and any subsequent entries to the right (adds one to their indices).
This implementation always throws an UnsupportedOperationError.
Parameters
index:int — index at which the specified entry is to be inserted.
| |
key:* — key with which the specified value is to be associated.
| |
value:* — value to be associated with the specified key.
|
org.as3coreaddendum.errors:UnsupportedOperationError — if the putAt operation is not supported by this map.
| |
org.as3coreaddendum.errors:ClassCastError — if the type of the specified key or value is incompatible with this map.
| |
ArgumentError — if the specified key or value is null and this map does not permit null keys or values.
| |
ArgumentError — if this map already contains the specified key.
| |
IndexOutOfBoundsError — if the index is out of range (index < 0 || index > size()).
|
| putEntry | () | method |
public function putEntry(entry:IMapEntry):*
Associates the specified entry.value with the specified entry.key in this map (optional operation).
If the map previously contained a mapping for the entry.key, the old value is replaced by the specified entry.value. (A map m is said to contain a mapping for a key k if and only if m.containsKey(k) would return true.)
This implementation calls put(entry.key, entry.value).
Parameters
entry:IMapEntry — entry to put in this map.
|
* — the previous value associated with entry.key, or null if there was no mapping for entry.key. (A null return can also indicate that the map previously associated null with entry.key, if the implementation supports null values.)
|
org.as3coreaddendum.errors:UnsupportedOperationError — if the putEntry operation is not supported by this map.
| |
org.as3coreaddendum.errors:ClassCastError — if the type of the specified entry.key or entry.value is incompatible with this map.
| |
ArgumentError — if the specified entry is null, or if the specified entry.key or entry.value is null and this map does not permit null keys or values.
|
| remove | () | method |
public function remove(key:*):*Removes the mapping for a key from this map if it is present (optional operation).
Returns the value to which this map previously associated the key, or null if the map contained no mapping for the key.
If this map permits null values, then a return value of null does not necessarily indicate that the map contained no mapping for the key.
It's possible that the map explicitly mapped the key to null.
The map will not contain a mapping for the specified key once the call returns.
This implementation always throws an UnsupportedOperationError.
Parameters
key:* — the key whose mapping is to be removed from the map.
|
* — the previous value associated with key, or null if there was no mapping for key.
|
org.as3coreaddendum.errors:UnsupportedOperationError — if the remove operation is not supported by this map.
| |
org.as3coreaddendum.errors:ClassCastError — if the type of the specified key is incompatible with this map (optional).
| |
ArgumentError — if the specified key is null and this map does not permit null keys (optional).
|
| removeAll | () | method |
public function removeAll(keys:ICollection):BooleanRemoves the mapping for a key from this map (if it is present) for each element in the specified collection (optional operation). The elements in the specified collection are interpreted as keys.
This implementation iterates over this map, checking each key returned by the iterator in turn to see if it's contained in the specified collection.
If it's so contained, it's removed from this map with the iterator's remove method.
Note that this implementation will throw an UnsupportedOperationError if the iterator returned by the iterator method does not implement the remove method and this map contains one or more keys in common with the specified collection.
The map will not contain mappings for the elements in the specified collection once the call returns.
Parameters
keys:ICollection — the collection whose elements are interpreted as keys to be removed from the map.
|
Boolean — true if this map changed as a result of the call.
|
org.as3coreaddendum.errors:UnsupportedOperationError — if the removeAll operation is not supported by this map.
| |
org.as3coreaddendum.errors:ClassCastError — if the type of an element in the specified collection is incompatible with this map (optional).
| |
ArgumentError — if the specified collection is null, or if this map does not permit null keys, and the specified collections contains null elements (optional).
|
| removeAt | () | method |
public function removeAt(index:int):IMapEntry
Removes the mapping at the specified position in this map (optional operation).
Shifts any subsequent mappings to the left (subtracts one from their indices).
Returns an IMapEntry object containing the mapping (key/value) that was removed from the map.
This implementation always throws an UnsupportedOperationError.
Parameters
index:int — the index of the mapping to be removed.
|
IMapEntry — an IMapEntry object containing the mapping (key/value) that was removed from the map.
|
org.as3coreaddendum.errors:UnsupportedOperationError — if the removeAt operation is not supported by this map.
| |
IndexOutOfBoundsError — if the index is out of range (index < 0 || index >= size()).
|
| removeRange | () | method |
public function removeRange(fromIndex:int, toIndex:int):IListMap
Removes all of the mappings whose index is between fromIndex, inclusive, and toIndex, exclusive (optional operation).
Shifts any subsequent mappings to the left (subtracts their indices).
If toIndex == fromIndex, this operation has no effect.
This implementation always throws an UnsupportedOperationError.
Parameters
fromIndex:int — the index to start removing mappings (inclusive).
| |
toIndex:int — the index to stop removing mappings (exclusive).
|
IListMap — a new map containing all the removed mappings.
|
org.as3coreaddendum.errors:UnsupportedOperationError — if the removeRange operation is not supported by this map.
| |
IndexOutOfBoundsError — if fromIndex or toIndex is out of range (index < 0 || index > size()).
|
| retainAll | () | method |
public function retainAll(keys:ICollection):BooleanRetains only the mappings in this map that the keys are contained (as elements) in the specified collection (optional operation). In other words, removes from this map all of its mappings whose keys are not contained (as elements) in the specified collection. The elements in the specified collection are interpreted as keys.
This implementation iterates over this map and calls IIterator.remove once for each key that are not contained in the specified collection.
Note that this implementation will throw an UnsupportedOperationError if the iterator returned by the iterator method does not implement the remove method and this map contains one or more keys not present in the specified collection.
Parameters
keys:ICollection — the collection whose elements are interpreted as keys to be retained in the map.
|
Boolean — true if this map changed as a result of the call.
|
org.as3coreaddendum.errors:UnsupportedOperationError — if the retainAll operation is not supported by this map.
| |
org.as3coreaddendum.errors:ClassCastError — if the types of one or more keys in this map are incompatible with the specified collection (optional).
| |
ArgumentError — if the specified collection contains a null element and this collection does not permit null keys (optional), or if the specified collection is null.
|
| reverse | () | method |
public function reverse():voidReverses the order of the mappings in this map.
| setKeyAt | () | method |
public function setKeyAt(index:int, key:*):*Replaces the key at the specified position in this map with the specified key (optional operation).
This implementation always throws an UnsupportedOperationError.
Parameters
index:int — index of the key to replace.
| |
key:* — key to be stored at the specified position.
|
* — the key previously at the specified position.
|
org.as3coreaddendum.errors:UnsupportedOperationError — if the setKeyAt operation is not supported by this map.
| |
org.as3coreaddendum.errors:ClassCastError — if the class of the specified key prevents it from being added to this map.
| |
ArgumentError — if the specified key is null and this map does not permit null keys.
| |
ArgumentError — if this map already contains the specified key.
| |
IndexOutOfBoundsError — if the index is out of range (index < 0 || index >= size()).
|
| setValueAt | () | method |
public function setValueAt(index:int, value:*):*Replaces the value at the specified position in this map with the specified value (optional operation).
This implementation always throws an UnsupportedOperationError.
Parameters
index:int — index of the value to replace.
| |
value:* — value to be stored at the specified position.
|
* — the value previously at the specified position.
|
org.as3coreaddendum.errors:UnsupportedOperationError — if the setValueAt operation is not supported by this map.
| |
org.as3coreaddendum.errors:ClassCastError — if the class of the specified value prevents it from being added to this map.
| |
ArgumentError — if the specified value is null and this map does not permit null values.
| |
IndexOutOfBoundsError — if the index is out of range (index < 0 || index >= size()).
|
| size | () | method |
public function size():intReturns the number of key-value mappings in this map.
Returnsint — the number of key-value mappings in this map.
|
| subMap | () | method |
public function subMap(fromIndex:int, toIndex:int):IListMap
Returns a new map that is a view of the portion of this map between the specified fromIndex, inclusive, and toIndex, exclusive.
The returned map supports all of the optional map operations supported by this map.
This implementation always throws an UnsupportedOperationError.
Parameters
fromIndex:int — the index to start retrieving mappings (inclusive).
| |
toIndex:int — the index to stop retrieving mappings (exclusive).
|
IListMap — a new list that is a view of the specified range within this list.
|
org.as3coreaddendum.errors:UnsupportedOperationError — if the subMap operation is not supported by this map.
| |
IndexOutOfBoundsError — if fromIndex or toIndex is out of range (index < 0 || index > size()).
|
| tailMap | () | method |
public function tailMap(fromKey:*):IListMap
Returns a new IListMap object that is a view of the portion of this map whose keys are greater than or equal to fromKey.
The returned map supports all optional map operations that this map supports.
Parameters
fromKey:* — low endpoint (inclusive) of the keys in the returned map.
|
IListMap — a new map that is a view of the portion of this map whose keys are greater than or equal to fromKey.
|
ArgumentError — if containsKey(fromKey) returns false.
|
| toString | () | method |
public function toString():StringReturns the string representation of this instance.
ReturnsString — the string representation of this instance.
|