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