scala.collection.mutable

trait MapProxy

[source: scala/collection/mutable/MapProxy.scala]

trait MapProxy[A, B]
extends Map[A, B] with MapProxyTemplate[A, B, Map[A, B]]

This is a simple wrapper class for scala.collection.mutable.Map.

It is most useful for assembling customized map abstractions dynamically using object composition and forwarding.

Author
Matthias Zenger, Martin Odersky
Version
2.0, 31/12/2006
Method Summary
override def + [B1 >: B](elem1 : (A, B1), elem2 : (A, B1), elems : (A, B1)*) : MapProxy[A, B]
Adds two or more elements to this collection and returns a new collection.
override def + (kv : (A, B)) : MapProxy[A, B]
Add a new key/value mapping and return the map itself.
override def += (kv : (A, B)) : MapProxy[A, B]
Add a new key/value mapping this map.
override def - (key : A) : MapProxy[A, B]
Delete a key from this map if it is present and return the map itself.
override def -= (key : A) : MapProxy[A, B]
Delete a key from this map if it is present.
override def empty : MapProxy[A, B]
override def thisCollection : MapProxy[A, B]
Methods inherited from MapProxyTemplate
get, iterator, isEmpty, getOrElse, apply, contains, isDefinedAt, keySet, keysIterator, keys, valueIterable, valuesIterator, values, default, filterKeys, mapValues, addString
Methods inherited from IterableProxyTemplate
foreach, foldRight, reduceRight, toIterable, head, takeRight, dropRight, sameElements, toStream, view, view
Methods inherited from TraversableProxyTemplate
self (abstract), nonEmpty, size, hasDefiniteSize, ++, ++, map, flatMap, filter, filterNot, remove, partition, groupBy, forall, exists, count, find, foldLeft, /:, :\, reduceLeft, reduceLeftOption, reduceRightOption, headOption, tail, last, lastOption, init, take, drop, slice, takeWhile, dropWhile, span, splitAt, copyToBuffer, copyToArray, copyToArray, toArray, toList, toSequence, toSet, mkString, mkString, mkString, addString, addString, stringPrefix
Methods inherited from Proxy
hashCode, equals, toString
Methods inherited from Unhashable
identityHashCode
Methods inherited from MutableMapTemplate
newBuilder, put, update, updated, cached, +, ++, ++, remove, removeKey, clear, getOrElseUpdate, transform, retain, clone, result, -, --, --
Methods inherited from Shrinkable
-=, --=, --=
Methods inherited from Builder
sizeHint, mapResult
Methods inherited from Growable
+=, ++=, ++=
Methods inherited from MutableMapTemplateBase
+
Methods inherited from MapTemplate
mapElements, ++, ++
Methods inherited from PartialFunction
orElse, andThen
Methods inherited from Function1
compose
Methods inherited from Iterable
companion
Methods inherited from IterableTemplate
elements, first, firstOption, toSeq, projection
Methods inherited from TraversableClass
genericBuilder, unzip, flatten, transpose
Methods inherited from TraversableTemplate
filterMap
Methods inherited from AnyRef
getClass, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized
Methods inherited from Any
==, !=, isInstanceOf, asInstanceOf
Method Details
override def thisCollection : MapProxy[A, B]

The proper way to do this would be to make self of type This. But unfortunately this makes this to be of type Traversable[A]. Since Traversable is a subtype of TraversableTemplate, all methods of this are taken from Traversable. In particular the newBuilder method is taken from Traversable, which means it yields a Traversable[A] instead of a This.

The right way out of this is to change Scala's member selection rules, so that always the most specific type will be selected, no matter whether a member is abstract or concrete. I tried to fake this by having a method thisTemplate which returns this at the Template type. But unfortunately that does not work, because we need to call newBuilder on this at the Template type (so that we get back a This) and newBuilder has to be a protected[this] because of variance.
The less appealing alternative is implemented now: Forget the self type and introduce a thisCollection which is this seen as an instance of This. We should go back to this once we have ameliorated Scala's member selection rules.


override def empty : MapProxy[A, B]
Overrides
Map.empty

override def +(kv : (A, B)) : MapProxy[A, B]
Add a new key/value mapping and return the map itself.
Parameters
kv - the key/value mapping to be added

override def +[B1 >: B](elem1 : (A, B1), elem2 : (A, B1), elems : (A, B1)*) : MapProxy[A, B]
Adds two or more elements to this collection and returns a new collection.
Parameters
elem1 - the first element to add.
elem2 - the second element to add.
elems - the remaining elements to add.

override def -(key : A) : MapProxy[A, B]
Delete a key from this map if it is present and return the map itself.
Parameters
key - the key to be removed

override def +=(kv : (A, B)) : MapProxy[A, B]
Add a new key/value mapping this map.
Parameters
kv - the key/value pair.
Returns
the map itself

override def -=(key : A) : MapProxy[A, B]
Delete a key from this map if it is present.
Parameters
key - the key to be removed
Notes
same as `delete`.