Added some generic wrapping functionality.

8 files changed, 286 insertions, 2 deletions

diff --git a/sources/scala/collection/MapWrapper.scala b/sources/scala/collection/MapWrapper.scala
new file mode 100644
index 0000000000..29dd53122e
--- /dev/null
+++ b/sources/scala/collection/MapWrapper.scala
@@ -0,0 +1,45 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
+package scala.collection;
+
+
+/** This is a simple wrapper class for <code>scala.collection.Map</code>.
+ *  It is most useful for assembling customized map abstractions
+ *  dynamically using object composition and forwarding.
+ *
+ *  @author  Matthias Zenger
+ *  @version 1.0, 21/07/2003
+ */
+class MapWrapper[A, +B](map: Map[A, B]) extends Map[A, B] {
+
+    def size: Int = map.size;
+
+    def get(key: A): Option[B] = map.get(key);
+
+    override def isEmpty: Boolean = map.isEmpty;
+
+    override def apply(key: A): B = map.apply(key);
+
+    override def contains(key: A): Boolean = map.contains(key);
+
+    override def isDefinedAt(key: A) = map.isDefinedAt(key);
+
+    override def keys: Iterator[A] = map.keys;
+
+    override def values: Iterator[B] = map.values;
+
+    override def foreach(f: (A, B) => Unit) = map.foreach(f);
+
+    override def toList: List[Pair[A, B]] = map.toList;
+
+    override def toString() = map.toString();
+
+    def elements: Iterator[Pair[A, B]] = map.elements;
+}
diff --git a/sources/scala/collection/SetWrapper.scala b/sources/scala/collection/SetWrapper.scala
new file mode 100644
index 0000000000..a56d6225df
--- /dev/null
+++ b/sources/scala/collection/SetWrapper.scala
@@ -0,0 +1,39 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
+package scala.collection;
+
+
+/** This is a simple wrapper class for <code>scala.collection.Set</code>.
+ *  It is most useful for assembling customized set abstractions
+ *  dynamically using object composition and forwarding.
+ *
+ *  @author  Matthias Zenger
+ *  @version 1.0, 21/07/2003
+ */
+class SetWrapper[A](set: Set[A]) extends Set[A] {
+
+    def size: Int = set.size;
+
+    override def isEmpty: Boolean = set.isEmpty;
+
+    def contains(elem: A): Boolean = set.contains(elem);
+
+    override def subsetOf(that: Set[A]): Boolean = set.subsetOf(that);
+
+    override def foreach(f: A => Unit): Unit = set.foreach(f);
+
+    override def exists(p: A => Boolean): Boolean = set.exists(p);
+
+    override def toList: List[A] = set.toList;
+
+    override def toString() = set.toString();
+
+    def elements: Iterator[A] = set.elements;
+}
diff --git a/sources/scala/collection/immutable/Map.scala b/sources/scala/collection/immutable/Map.scala
index ae1488e919..6a10702794 100644
--- a/sources/scala/collection/immutable/Map.scala
+++ b/sources/scala/collection/immutable/Map.scala
@@ -10,7 +10,7 @@
 package scala.collection.immutable;
 
 
-trait Map[A, B, This <: Map[A, B, This]]: This with scala.collection.Map[A, B] {
+trait Map[A, B, +This <: Map[A, B, This]]: This with scala.collection.Map[A, B] {
 
     def update(key: A, value: B): This;
 
diff --git a/sources/scala/collection/immutable/Set.scala b/sources/scala/collection/immutable/Set.scala
index 0b0339dc22..6fa47020ab 100644
--- a/sources/scala/collection/immutable/Set.scala
+++ b/sources/scala/collection/immutable/Set.scala
@@ -18,7 +18,7 @@ package scala.collection.immutable;
  *  @author  Matthias Zenger
  *  @version 1.0, 19/07/2003
  */
-trait Set[A, This <: Set[A, This]]: This with scala.collection.Set[A] {
+trait Set[A, +This <: Set[A, This]]: This with scala.collection.Set[A] {
 
     def +(elem: A): This;
 
diff --git a/sources/scala/collection/mutable/ImmutableMapAdaptor.scala b/sources/scala/collection/mutable/ImmutableMapAdaptor.scala
new file mode 100644
index 0000000000..ae8f941f33
--- /dev/null
+++ b/sources/scala/collection/mutable/ImmutableMapAdaptor.scala
@@ -0,0 +1,66 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
+package scala.collection.mutable;
+
+
+/** This class can be used as an adaptor to create mutable maps from
+ *  immutable map implementations. Only method <code>empty</code> has
+ *  to be redefined if the immutable map on which this mutable map is
+ *  originally based is not empty. <code>empty</code> is supposed to
+ *  return the representation of an empty map.
+ *
+ *  @author  Matthias Zenger
+ *  @version 1.0, 21/07/2003
+ */
+class ImmutableMapAdaptor[A, B, C <: scala.collection.immutable.Map[A, B, C]]
+		(m: C) extends Map[A, B] {
+
+	protected var imap = m;
+
+    def size: Int = imap.size;
+
+    def get(key: A): Option[B] = imap.get(key);
+
+    override def isEmpty: Boolean = imap.isEmpty;
+
+    override def apply(key: A): B = imap.apply(key);
+
+    override def contains(key: A): Boolean = imap.contains(key);
+
+    override def isDefinedAt(key: A) = imap.isDefinedAt(key);
+
+    override def keys: Iterator[A] = imap.keys;
+
+    override def values: Iterator[B] = imap.values;
+
+    def elements: Iterator[Pair[A, B]] = imap.elements;
+
+    override def foreach(f: (A, B) => Unit) = imap.foreach(f);
+
+    override def toList: List[Pair[A, B]] = imap.toList;
+
+    override def toString() = imap.toString();
+
+    def update(key: A, value: B): Unit = { imap = imap.update(key, value); }
+
+    def -=(key: A): Unit = { imap = imap - key; }
+
+    override def clear: Unit = { imap = empty; }
+
+    override def map(f: (A, B) => B): Unit = { imap = imap.map(f); }
+
+    override def filter(p: (A, B) => Boolean): Unit = { imap = imap.filter(p); }
+
+    override def toString() = imap.toString();
+
+    override def mappingToString(p: Pair[A, B]) = imap.mappingToString(p);
+
+    protected def empty: C = m;
+}
diff --git a/sources/scala/collection/mutable/ImmutableSetAdaptor.scala b/sources/scala/collection/mutable/ImmutableSetAdaptor.scala
new file mode 100644
index 0000000000..ef14cd2dce
--- /dev/null
+++ b/sources/scala/collection/mutable/ImmutableSetAdaptor.scala
@@ -0,0 +1,50 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
+package scala.collection.mutable;
+
+
+/** This class can be used as an adaptor to create mutable sets from
+ *  immutable set implementations. Only method <code>empty</code> has
+ *  to be redefined if the immutable set on which this mutable set is
+ *  originally based is not empty. <code>empty</code> is supposed to
+ *  return the representation of an empty set.
+ *
+ *  @author  Matthias Zenger
+ *  @version 1.0, 21/07/2003
+ */
+class ImmutableSetAdaptor[A, B <: scala.collection.immutable.Set[A, B]]
+			(s: B) extends Set[A] {
+
+    protected var set = s;
+
+    def size: Int = set.size;
+
+    override def isEmpty: Boolean = set.isEmpty;
+
+    def contains(elem: A): Boolean = set.contains(elem);
+
+    override def foreach(f: A => Unit): Unit = set.foreach(f);
+
+    override def exists(p: A => Boolean): Boolean = set.exists(p);
+
+    override def toList: List[A] = set.toList;
+
+    override def toString() = set.toString();
+
+    def elements: Iterator[A] = set.elements;
+
+    def +=(elem: A): Unit = { set = set + elem; }
+
+    def -=(elem: A): Unit = { set = set - elem; }
+
+    def clear: Unit = { set = empty; }
+
+    protected def empty: B = s;
+}
diff --git a/sources/scala/collection/mutable/MapWrapper.scala b/sources/scala/collection/mutable/MapWrapper.scala
new file mode 100644
index 0000000000..0c07b1f24a
--- /dev/null
+++ b/sources/scala/collection/mutable/MapWrapper.scala
@@ -0,0 +1,44 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
+package scala.collection.mutable;
+
+
+/** This is a simple wrapper class for <code>scala.collection.mutable.Map</code>.
+ *  It is most useful for assembling customized map abstractions
+ *  dynamically using object composition and forwarding.
+ *
+ *  @author  Matthias Zenger
+ *  @version 1.0, 21/07/2003
+ */
+class MapWrapper[A, B](m: Map[A, B]) extends Map[A, B]
+			                         with scala.collection.MapWrapper[A, B](m) {
+
+    def update(key: A, value: B): Unit = m.update(key, value);
+
+    def -=(key: A): Unit = m.-=(key);
+
+    override def incl(mappings: Pair[A, B]*): Unit = m.incl(mappings);
+
+    override def incl(map: Iterable[Pair[A, B]]): Unit = m.incl(map);
+
+    override def excl(keys: A*): Unit = m.excl(keys);
+
+    override def excl(keys: Iterable[A]): Unit = m.excl(keys);
+
+    override def clear: Unit = m.clear;
+
+    override def map(f: (A, B) => B): Unit = m.map(f);
+
+    override def filter(p: (A, B) => Boolean): Unit = m.filter(p);
+
+    override def toString() = m.toString();
+
+    override def mappingToString(p: Pair[A, B]) = m.mappingToString(p);
+}
diff --git a/sources/scala/collection/mutable/SetWrapper.scala b/sources/scala/collection/mutable/SetWrapper.scala
new file mode 100644
index 0000000000..69f62194f6
--- /dev/null
+++ b/sources/scala/collection/mutable/SetWrapper.scala
@@ -0,0 +1,40 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
+package scala.collection.mutable;
+
+
+/** This is a simple wrapper class for <code>scala.collection.mutable.Set</code>.
+ *  It is most useful for assembling customized set abstractions
+ *  dynamically using object composition and forwarding.
+ *
+ *  @author  Matthias Zenger
+ *  @version 1.0, 21/07/2003
+ */
+class SetWrapper[A](set: Set[A]) extends Set[A]
+			                     with scala.collection.SetWrapper[A](set) {
+
+    def +=(elem: A): Unit = set.+=(elem);
+
+    override def incl(elems: A*): Unit = set.incl(elems);
+
+    override def incl(that: Iterable[A]): Unit = set.incl(that);
+
+    def -=(elem: A): Unit = set.-=(elem);
+
+    override def excl(elems: A*): Unit = set.excl(elems);
+
+    override def excl(that: Iterable[A]): Unit = set.excl(that);
+
+    override def intersect(that: Set[A]): Unit = set.intersect(that);
+
+    override def clear: Unit = set.clear;
+
+    override def filter(p: A => Boolean): Unit =  set.filter(p);
+}