scala.collection.mutable
trait Map

[source: `scala/collection/mutable/Map.scala`]

@cloneable
`` `trait` Map[A, B]
  `extends` Map[A, B]`with` Scriptable[Message[(A, B)]]`with` CloneableCollection

  This trait represents mutable maps. Concrete map implementations just have to provide functionality for the abstract methods in `scala.collection.Map` as well as for `update`, and `-=`.

Author
  Matthias Zenger
  Martin Odersky
Version
  2.0, 31/12/2006

Direct Known Subclasses:
  Map, DefaultMapModel, HashMap, ImmutableMapAdaptor, JavaMapAdaptor, MapProxy, MultiMap, ObservableMap, SynchronizedMap

Method Summary
`def` | + (kv : (A, B)) : Map[A, B] Add a key/value pair to this map.
`def` | + (kv1 : (A, B), kv2 : (A, B), kvs : (A, B)*) : Map[A, B] Add two or more key/value pairs to this map.
`def` | ++ (kvs : Iterable[(A, B)]) : Map[A, B] Add a sequence of key/value pairs to this map.
`def` | ++ (kvs : Iterator[(A, B)]) : Map[A, B] Add a sequence of key/value pairs to this map.
`def` | ++= (kvs : Iterable[(A, B)]) : Unit Add a sequence of key/value pairs to this map.
`def` | ++= (kvs : Iterator[(A, B)]) : Unit Add a sequence of key/value pairs to this map.
`def` | += (kv : (A, B)) : Unit Add a key/value pair to this map.
`def` | += (kv1 : (A, B), kv2 : (A, B), kvs : (A, B)*) : Unit Add two or more key/value pairs to this map.
`def` | += (key : A) : MapTo This method defines syntactic sugar for adding or modifying mappings. It is typically used in the following way:
        map += key -> value;
`def` | - (key1 : A, key2 : A, keys : A*) : Map[A, B] Remove two or more keys from this map
`def` | - (key : A) : Map[A, B] Remove a key from this map
`def` | -- (keys : Iterator[A]) : Map[A, B] Remove a sequence of keys from this map
`def` | -- (keys : Iterable[A]) : Map[A, B] Remove a sequence of keys from this map
`def` | --= (keys : Iterator[A]) : Unit Remove a sequence of keys from this map
`def` | --= (keys : Iterable[A]) : Unit Remove a sequence of keys from this map
`def` | -= (key1 : A, key2 : A, keys : A*) : Unit Remove two or more keys from this map
`abstract def` | -= (key : A) : Unit Remove a key from this map, noop if key is not present.
`def` | << (cmd : Message[(A, B)]) : Unit Send a message to this scriptable object.
`def` | clear : Unit Removes all mappings from the map. After this operation is completed, the map is empty.
`override def` | clone : Map[A, B] Return a clone of this map.
`def` | excl (keys : A*) : Unit This method will remove all the mappings for the given sequence of keys from the map.
`def` | getOrElseUpdate (key : A, default : => B) : B Check if this map maps `key` to a value. Return that value if it exists, otherwise put `default` as that key's value and return it.
`def` | incl (mappings : (A, B)*) : 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` | put (key : A, elem : B) : Option[B] Map `key` to `elem` in this map and return the element that the key was previously mapped to (if any).
`def` | removeKey (key : A) : Option[B] Remove `key` from this map and return the element that the key was previously mapped to (if any).
`def` | retain (p : (A, B) => Boolean) : Unit This method retains only those mappings for which the predicate `p` returns `true`.
`def` | transform (f : (A, B) => B) : Unit This function transforms all the values of mappings contained in this map with function `f`.
`abstract def` | update (key : A, value : B) : 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.

Methods inherited from Map
size (abstract), get (abstract), getOrElse, isEmpty, apply, contains, isDefinedAt, keys, keySet, values, equals, hashCode, toString, default, projection, filterKeys, mapElements, stringPrefix

Methods inherited from Collection
toArray

Methods inherited from Iterable
elements (abstract), concat, ++, map, flatMap, filter, partition, takeWhile, dropWhile, take, drop, foreach, forall, exists, find, findIndexOf, indexOf, foldLeft, foldRight, /:, :\, reduceLeft, reduceRight, copyToBuffer, sameElements, toList, toStream, mkString, mkString, mkString, addString, addString, copyToArray, hasDefiniteSize

Methods inherited from PartialFunction
orElse, andThen

Methods inherited from Function1
compose

Methods inherited from AnyRef
getClass, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized

Methods inherited from Any
==, !=, isInstanceOf, asInstanceOf

Class Summary
`class` | MapTo (key : A)`extends` AnyRef

Method Details

`abstract` `def` update(key : A, value : B) : 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
  `value -` The new value

`` `def` +=(kv : (A, B)) : Unit

  Add a key/value pair to this map.

Parameters
  `kv -` the key/value pair.

`` `def` +=(kv1 : (A, B), kv2 : (A, B), kvs : (A, B)*) : Unit

  Add two or more key/value pairs to this map.

Parameters
  `kv1 -` the first key/value pair.
  `kv2 -` the second key/value pair.
  `kvs -` the remaining key/value pairs.

`` `def` ++=(kvs : Iterable[(A, B)]) : Unit

  Add a sequence of key/value pairs to this map.

Parameters
  `kvs -` the iterable object containing all key/value pairs.

`` `def` ++=(kvs : Iterator[(A, B)]) : Unit

  Add a sequence of key/value pairs to this map.

Parameters
  `kvs -` the iterator containing all key/value pairs.

`` `def` +(kv : (A, B)) : 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` +(kv1 : (A, B), kv2 : (A, B), kvs : (A, B)*) : Map[A, B]

  Add two or more key/value pairs to this map.

Parameters
  `kv1 -` the first key/value pair.
  `kv2 -` the second key/value pair.
  `kvs -` the remaining key/value pairs.
Returns
  The map itself with the new bindings added in place.

`` `def` ++(kvs : Iterable[(A, B)]) : 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 : Iterator[(A, B)]) : 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.

`abstract` `def` -=(key : A) : Unit

  Remove a key from this map, noop if key is not present.

Parameters
  `key -` the key to be removed

`` `def` -=(key1 : A, key2 : A, keys : A*) : Unit

  Remove two or more keys from this map

Parameters
  `key1 -` the first key to be removed
  `key2 -` the second key to be removed
  `keys -` the remaining keys to be removed

`` `def` --=(keys : Iterable[A]) : Unit

  Remove a sequence of keys from this map

Parameters
  `keys -` the keys to be removed

`` `def` --=(keys : Iterator[A]) : Unit

  Remove a sequence of keys from this map

Parameters
  `keys -` the keys to be removed

`` `def` -(key : A) : 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` removeKey(key : A) : Option[B]

  Remove `key` from this map and return the element that the key was previously mapped to (if any).

`` `def` put(key : A, elem : B) : Option[B]

  Map `key` to `elem` in this map and return the element that the key was previously mapped to (if any).

`` `def` -(key1 : A, key2 : A, keys : A*) : Map[A, B]

  Remove two or more keys from this map

Parameters
  `key1 -` the first key to be removed
  `key2 -` the second key to be removed
  `keys -` the remaining keys to be removed
Returns
  The map itself with all bindings for the given keys removed.

`` `def` --(keys : Iterable[A]) : 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 : Iterator[A]) : 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` clear : Unit

  Removes all mappings from the map. After this operation is completed, the map is empty.

`` `def` getOrElseUpdate(key : A, default : => B) : B

  Check if this map maps `key` to a value. Return that value if it exists, otherwise put `default` as that key's value and return it.

`` `def` transform(f : (A, B) => B) : Unit

  This function transforms all the values of mappings contained in this map with function `f`.

Parameters
  `f -` The transformation to apply

`` `def` retain(p : (A, B) => Boolean) : Unit

  This method retains only those mappings for which the predicate `p` returns `true`.

Parameters
  `p -` The test predicate
Deprecated
  cannot be type inferred because if retain in Iterable.

`` `def` <<(cmd : Message[(A, B)]) : Unit

  Send a message to this scriptable object.

Parameters
  `cmd -` the message to send.

Overrides
  Scriptable.<<

`override` `def` clone : Map[A, B]

  Return a clone of this map.

Returns
  a map with the same elements.

Overrides
  CloneableCollection.clone

@deprecated
`` `def` +=(key : A) : 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}`

@deprecated
`` `def` incl(mappings : (A, B)*) : 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 `+=`

@deprecated
`` `def` excl(keys : A*) : Unit

  This method will remove all the mappings for the given sequence of keys from the map.

Parameters
  `keys -`
Deprecated
  use `-=`