in scala.collection.mutable
trait Map

[scala.cloneable]

abstract trait Map [A, B]
extends java.lang.Object
with scala.collection.Map[A, B]
with scala.collection.mutable.Scriptable[scala.collection.mutable.Message[scala.Tuple2[A, B]]]
with scala.ScalaObject
Direct Known Subclasses:
SynchronizedMap, ObservableMap, MultiMap, MapProxy, JavaMapAdaptor, ImmutableMapAdaptor, HashMap, DefaultMapModel, Map

Class Summary
class MapTo

Def Summary
def + (kv1: scala.Tuple2[A, B], kv2: scala.Tuple2[A, B], kvs: {A, B}*) : scala.collection.mutable.Map[A, B]
Add two or more key/value pairs to this map.
def + (kv: scala.Tuple2[A, B]) : scala.collection.mutable.Map[A, B]
Add a key/value pair to this map.
def ++ (kvs: scala.Iterable[scala.Tuple2[A, B]]) : scala.collection.mutable.Map[A, B]
Add a sequence of key/value pairs to this map.
def ++ (kvs: scala.Iterator[scala.Tuple2[A, B]]) : scala.collection.mutable.Map[A, B]
Add a sequence of key/value pairs to this map.
def ++= (kvs: scala.Iterable[scala.Tuple2[A, B]]) : scala.Unit
Add a sequence of key/value pairs to this map.
def ++= (kvs: scala.Iterator[scala.Tuple2[A, B]]) : scala.Unit
Add a sequence of key/value pairs to this map.
def += (key: A) : Map.this.MapTo
This method defines syntactic sugar for adding or modifying mappings. It is typically used in the following way:
    map += key -> value;
    

def += (kv1: scala.Tuple2[A, B], kv2: scala.Tuple2[A, B], kvs: {A, B}*) : scala.Unit
Add two or more key/value pairs to this map.
def += (kv: scala.Tuple2[A, B]) : scala.Unit
Add a key/value pair to this map.
def - (key1: A, key2: A, keys: A*) : scala.collection.mutable.Map[A, B]
Remove two or more keys from this map
def - (key: A) : scala.collection.mutable.Map[A, B]
Remove a key from this map
def -- (keys: scala.Iterable[A]) : scala.collection.mutable.Map[A, B]
Remove a sequence of keys from this map
def -- (keys: scala.Iterator[A]) : scala.collection.mutable.Map[A, B]
Remove a sequence of keys from this map
def --= (keys: scala.Iterable[A]) : scala.Unit
Remove a sequence of keys from this map
def --= (keys: scala.Iterator[A]) : scala.Unit
Remove a sequence of keys from this map
def -= (key1: A, key2: A, keys: A*) : scala.Unit
Remove two or more keys from this map
abstract def -= (key: A) : scala.Unit
Remove a key from this map, noop if key is not present.
def << (cmd: scala.collection.mutable.Message[scala.Tuple2[A, B]]) : scala.Unit
Send a message to this scriptable object.
def clear : scala.Unit
Removes all mappings from the map. After this operation is completed, the map is empty.
override def clone : scala.collection.mutable.Map[A, B]
Return a clone of this map.
def excl (keys: A*) : scala.Unit
This method will remove all the mappings for the given sequence of keys from the map.
override def filter (p: (scala.Tuple2[A, B]) => scala.Boolean) : scala.Iterable[scala.Tuple2[A, B]]
This method removes all the mappings for which the predicate p returns false.
def incl (mappings: {A, B}*) : scala.Unit
incl can be used to add many mappings at the same time to the map. The method assumes that a mapping is represented by a Pair object who's first component denotes the key, and who's second component refers to the value.
def retain (p: (A, B) => scala.Boolean) : scala.Unit
This method retains only those mappings for which the predicate p returns true.
def transform (f: (A, B) => B) : scala.Unit
This function transforms all the values of mappings contained in this map with function f.
abstract def update (key: A, value: B) : scala.Unit
This method allows one to add a new mapping from key to value to the map. If the map already contains a mapping for key, it will be overridden by this function.
Def inherited from scala.collection.Map[A, B]
apply , contains, default, equals, get, hashCode, isDefinedAt, isEmpty, keySet, keys, size, toString, values
Def inherited from scala.collection.mutable.Scriptable[scala.collection.mutable.Message[scala.Tuple2[A, B]]]
<<
Def Detail
def + (kv1: scala.Tuple2[A, B], kv2: scala.Tuple2[A, B], kvs: {A, B}*): scala.collection.mutable.Map[A, B]
Add two or more key/value pairs to this map.
Parameters:
kv1 - the first key/value pair.
Parameters:
kv2 - the second key/value pair.
Parameters:
kvs - the remaining key/value pairs.
Returns:
The map itself with the new bindings added in place.

def + (kv: scala.Tuple2[A, B]): scala.collection.mutable.Map[A, B]
Add a key/value pair to this map.
Parameters:
kv - the key/value pair.
Returns:
The map itself with the new binding added in place.

def ++ (kvs: scala.Iterable[scala.Tuple2[A, B]]): scala.collection.mutable.Map[A, B]
Add a sequence of key/value pairs to this map.
Parameters:
kvs - the iterable object containing all key/value pairs.
Returns:
The itself map with the new bindings added in place.

def ++ (kvs: scala.Iterator[scala.Tuple2[A, B]]): scala.collection.mutable.Map[A, B]
Add a sequence of key/value pairs to this map.
Parameters:
kvs - the iterator containing all key/value pairs.
Returns:
The itself map with the new bindings added in place.

def ++= (kvs: scala.Iterable[scala.Tuple2[A, B]]): scala.Unit
Add a sequence of key/value pairs to this map.
Parameters:
kvs - the iterable object containing all key/value pairs.

def ++= (kvs: scala.Iterator[scala.Tuple2[A, B]]): scala.Unit
Add a sequence of key/value pairs to this map.
Parameters:
kvs - the iterator containing all key/value pairs.

[scala.deprecated]

def += (key: A): Map.this.MapTo
This method defines syntactic sugar for adding or modifying mappings. It is typically used in the following way:
    map += key -> value;
    
Deprecated:
use +={key, value}

def += (kv1: scala.Tuple2[A, B], kv2: scala.Tuple2[A, B], kvs: {A, B}*): scala.Unit
Add two or more key/value pairs to this map.
Parameters:
kv1 - the first key/value pair.
Parameters:
kv2 - the second key/value pair.
Parameters:
kvs - the remaining key/value pairs.

def += (kv: scala.Tuple2[A, B]): scala.Unit
Add a key/value pair to this map.
Parameters:
kv - the key/value pair.

def - (key1: A, key2: A, keys: A*): scala.collection.mutable.Map[A, B]
Remove two or more keys from this map
Parameters:
key1 - the first key to be removed
Parameters:
key2 - the second key to be removed
Parameters:
keys - the remaining keys to be removed
Returns:
The map itself with all bindings for the given keys removed.

def - (key: A): scala.collection.mutable.Map[A, B]
Remove a key from this map
Parameters:
key - the key to be removed
Returns:
The map itself with the binding for key removed if it existed.

def -- (keys: scala.Iterable[A]): scala.collection.mutable.Map[A, B]
Remove a sequence of keys from this map
Parameters:
keys - the keys to be removed
Returns:
The map itself with all bindings for keys removed.

def -- (keys: scala.Iterator[A]): scala.collection.mutable.Map[A, B]
Remove a sequence of keys from this map
Parameters:
keys - the keys to be removed
Returns:
The map itself with all bindings for keys removed.

def --= (keys: scala.Iterable[A]): scala.Unit
Remove a sequence of keys from this map
Parameters:
keys - the keys to be removed

def --= (keys: scala.Iterator[A]): scala.Unit
Remove a sequence of keys from this map
Parameters:
keys - the keys to be removed

def -= (key1: A, key2: A, keys: A*): scala.Unit
Remove two or more keys from this map
Parameters:
key1 - the first key to be removed
Parameters:
key2 - the second key to be removed
Parameters:
keys - the remaining keys to be removed

abstract def -= (key: A): scala.Unit
Remove a key from this map, noop if key is not present.
Parameters:
key - the key to be removed

def << (cmd: scala.collection.mutable.Message[scala.Tuple2[A, B]]): scala.Unit
Send a message to this scriptable object.
Parameters:
cmd - the message to send.

def clear : scala.Unit
Removes all mappings from the map. After this operation is completed, the map is empty.

override def clone : scala.collection.mutable.Map[A, B]
Return a clone of this map.
Returns:
a map with the same elements.

[scala.deprecated]

def excl (keys: A*): scala.Unit
This method will remove all the mappings for the given sequence of keys from the map.
Parameters:
keys -
Deprecated:
use -=

[scala.deprecated]

override def filter (p: (scala.Tuple2[A, B]) => scala.Boolean): scala.Iterable[scala.Tuple2[A, B]]
This method removes all the mappings for which the predicate p returns false.
Deprecated:
use retain instead
Parameters:
p -

[scala.deprecated]

def incl (mappings: {A, B}*): scala.Unit
incl can be used to add many mappings at the same time to the map. The method assumes that a mapping is represented by a Pair object who's first component denotes the key, and who's second component refers to the value.
Parameters:
mappings -
Deprecated:
use +=

def retain (p: (A, B) => scala.Boolean): scala.Unit
This method retains only those mappings for which the predicate p returns true.
Parameters:
p - The test predicate

def transform (f: (A, B) => B): scala.Unit
This function transforms all the values of mappings contained in this map with function f.
Parameters:
f - The transformation to apply

abstract def update (key: A, value: B): scala.Unit
This method allows one to add a new mapping from key to value to the map. If the map already contains a mapping for key, it will be overridden by this function.
Parameters:
key - The key to update
Parameters:
value - The new value