diff options
Diffstat (limited to 'src/dotnet-library/scala/collection/Map.scala')
-rw-r--r-- | src/dotnet-library/scala/collection/Map.scala | 158 |
1 files changed, 158 insertions, 0 deletions
diff --git a/src/dotnet-library/scala/collection/Map.scala b/src/dotnet-library/scala/collection/Map.scala new file mode 100644 index 0000000000..45f45a110b --- /dev/null +++ b/src/dotnet-library/scala/collection/Map.scala @@ -0,0 +1,158 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2003-2007, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + +// $Id$ + + +package scala.collection + +import Predef._ + + +/** <p> + * This class defines the interface of collections that unambiguously map + * keys to values (i.e. a key is mapped to at least one value). + * </p> + * <p> + * Class <code>Map</code> may only be used for accessing elements from map + * implementations. Two different extensions of class <code>Map</code> in + * the package <code><a href="mutable$content.html" target="contentFrame"> + * scala.collection.mutable</a></code> + * and <code><a href="immutable$content.html" target="contentFrame"> + * scala.collection.immutable</a></code> provide functionality for + * adding new key/value mappings to a map. The class in the first package is + * implemented by maps that are modified destructively, whereas the class in + * the second package is used by functional map implementations that rely on + * immutable data structures. + * </p> + * + * @author Matthias Zenger + * @author Martin Odersky + * @version 1.2, 31/12/2006 + */ +trait Map[A, +B] extends PartialFunction[A, B] with Iterable[{A, B}] { + + /** Compute the number of key-to-value mappings. + * + * @return the number of mappings + */ + def size: Int + + /** Check if this map maps <code>key</code> to a value and return the + * value if it exists. + * + * @param key the key of the mapping of interest + * @return the value of the mapping, if it exists + */ + def get(key: A): Option[B] + + /** Is this an empty map? + * + * @return <code>true</code> iff the map is empty. + */ + def isEmpty: Boolean = size == 0 + + /** Retrieve the value which is associated with the given key. This + * method throws an exception if there is no mapping from the given + * key to a value. + * + * @param key the key + * @return the value associated with the given key. + */ + def apply(key: A): B = get(key) match { + case None => default(key) + case Some(value) => value + } + + /** Is the given key mapped to a value by this map? + * + * @param key the key + * @return <code>true</code> iff there is a mapping for key in this map + */ + def contains(key: A): Boolean = get(key) match { + case None => false + case Some(_) => true + } + + /** Does this map contain a mapping from the given key to a value? + * + * @param key the key + * @return <code>true</code> iff there is a mapping for key in this map + */ + def isDefinedAt(key: A) = contains(key) + + /** Creates an iterator for all keys. + * + * @return an iterator over all keys. + */ + def keys: Iterator[A] = new Iterator[A] { + val iter = Map.this.elements + def hasNext = iter.hasNext + def next = iter.next._1 + } + + /** @return the keys of this map as a set. + */ + def keySet = new Set[A] { + def size = Map.this.size + def contains(key : A) = Map.this.contains(key) + def elements = Map.this.elements.map(._1) + } + + /** Creates an iterator for a contained values. + * + * @return an iterator over all values. + */ + def values: Iterator[B] = new Iterator[B] { + val iter = Map.this.elements + def hasNext = iter.hasNext + def next = iter.next._2 + } + + /** Compares two maps structurally; i.e. checks if all mappings + * contained in this map are also contained in the other map, + * and vice versa. + * + * @param that the other map + * @return <code>true</code> iff both maps contain exactly the + * same mappings. + */ + override def equals(that: Any): Boolean = that match { + case other: Map[a, b] => + this.size == other.size && this.elements.forall { + case {key, value} => other.get(key.asInstanceOf[a]) match { + case None => false + case Some(otherval) => value == otherval + } + } + case _ => false + } + + /** A hash method compatible with <code>equals</code> + */ + override def hashCode() = + (0 /: elements) ((hash, kv) => hash + kv.hashCode) + + /** Creates a string representation for this map. + * + * @return a string showing all mappings + */ + override def toString() = + elements.toList.map(kv => kv._1 + " -> " + kv._2).mkString("Map(", ", ", ")") + + /** The default value for the map, returned when a key is not found + * The method implemented here yields an error, + * but it might be overridden in subclasses. + * + * @param key the given key value + * @throws Predef.NoSuchElementException + */ + def default(key: A): B = + throw new NoSuchElementException("key not found: " + key) + +} |