*** empty log message ***

5 files changed, 274 insertions, 0 deletions

diff --git a/sources/scala/ImmutableMap.scala b/sources/scala/ImmutableMap.scala
new file mode 100644
index 0000000000..455c8b2458
--- /dev/null
+++ b/sources/scala/ImmutableMap.scala
@@ -0,0 +1,64 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
+package scala;
+
+trait ImmutableMap[A, B, This <: ImmutableMap[A, B, This]]: This with Map[A, B] {
+
+    def update(key: A, value: B): This;
+
+    def remove(key: A): This;
+
+    def clear: This;
+
+    def put(key: A, value: B): This = update(key, value);
+
+    def putAll(mappings: Pair[A, B]*): This = putMap(mappings);
+
+    def putMap(map: Iterable[Pair[A, B]]): This = {
+        val iter = map.elements;
+        var res = this;
+        while (iter.hasNext) {
+            val Pair(key, value) = iter.next;
+            res = res.update(key, value);
+        }
+        res;
+    }
+
+    def map(f: (A, B) => B): This = {
+        var res = this;
+        elements foreach {
+            case Pair(key, value) => res = res.update(key, f(key, value));
+        }
+        res;
+    }
+
+    def filter(p: (A, B) => Boolean): This = {
+        var res = this;
+        toList foreach {
+            case Pair(key, value) => if (p(key, value)) { res = res.remove(key); }
+        }
+        res;
+    }
+
+    override def toString() =
+        if (size == 0)
+            "{}"
+        else
+            "{" + {
+                val iter = elements;
+                var res = mappingToString(iter.next);
+                while (iter.hasNext) {
+                    res = res + ", " + mappingToString(iter.next);
+                }
+                res;
+            } + "}";
+
+    def mappingToString(p: Pair[A, B]) = p._1.toString() + " -> " + p._2;
+}
diff --git a/sources/scala/ImmutableSet.scala b/sources/scala/ImmutableSet.scala
new file mode 100644
index 0000000000..7e59d8dbaf
--- /dev/null
+++ b/sources/scala/ImmutableSet.scala
@@ -0,0 +1,46 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
+package scala;
+
+
+trait ImmutableSet[A, This <: ImmutableSet[A, This]]: This with Set[A] {
+
+    def add(elem: A): This;
+
+    def addAll(elems: A*): This = addSet(elems);
+
+    def addSet(that: Iterable[A]): This = {
+        var res = this;
+        that.elements.foreach(elem => res = res.add(elem));
+        res;
+    }
+
+    def remove(elem: A): This;
+
+    def removeAll(elems: A*): This = removeSet(elems);
+
+    def removeSet(that: Iterable[A]): This = {
+        var res = this;
+        that.elements.foreach(elem => res = res.remove(elem));
+        res;
+    }
+
+    def intersect(that: Set[A]): This = filter(that.contains);
+
+    def clear: This;
+
+    def filter(p: A => Boolean): This = {
+        var res = this;
+        toList foreach {
+            elem => if (p(elem)) { res = res.remove(elem); }
+        }
+        res;
+    }
+}
diff --git a/sources/scala/MutableSet.scala b/sources/scala/MutableSet.scala
new file mode 100644
index 0000000000..c64104989d
--- /dev/null
+++ b/sources/scala/MutableSet.scala
@@ -0,0 +1,39 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
+package scala;
+
+
+trait MutableSet[A] with Set[A] {
+
+    def add(elem: A): Unit;
+
+    def addAll(elems: A*): Unit = {
+        val ys = elems as List[A];
+        ys foreach { y => add(y); };
+    }
+
+    def addSet(that: Iterable[A]): Unit =
+        that.elements.foreach(elem => add(elem));
+
+    def remove(elem: A): Unit;
+
+    def removeAll(elems: A*): Unit = removeSet(elems);
+
+    def removeSet(that: Iterable[A]): Unit =
+        that.elements.foreach(elem => remove(elem));
+
+    def intersect(that: Set[A]): Unit = filter(that.contains);
+
+    def clear: Unit;
+
+    def filter(p: A => Boolean): Unit = toList foreach {
+        elem => if (p(elem)) remove(elem);
+    }
+}
diff --git a/sources/scala/ObservableSet.scala b/sources/scala/ObservableSet.scala
new file mode 100644
index 0000000000..c862c33648
--- /dev/null
+++ b/sources/scala/ObservableSet.scala
@@ -0,0 +1,35 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
+package scala;
+
+
+abstract class ObservableSet[A, This <: ObservableSet[A, This]]: This
+                    extends MutableSet[A]
+                    with Publisher[ObservableUpdate[A] with Undo, This] {
+
+    override def add(elem: A): Unit = if (!contains(elem)) {
+   		super.add(elem);
+   		publish(new Inclusion(elem) with Undo {
+   		            def undo = remove(elem);
+   		        });
+   	}
+
+	override def remove(elem: A): Unit = if (contains(elem)) {
+		super.remove(elem);
+		publish(new Removal(elem) with Undo {
+   		            def undo = add(elem);
+   		        });
+	}
+
+    override def clear: Unit = {
+        super.clear;
+        publish(new Reset() with Undo { def undo = error("cannot undo"); });
+    }
+}
diff --git a/sources/scala/SynchronizedMap.scala b/sources/scala/SynchronizedMap.scala
new file mode 100644
index 0000000000..7cec8c1aef
--- /dev/null
+++ b/sources/scala/SynchronizedMap.scala
@@ -0,0 +1,90 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
+package scala;
+
+
+trait SynchronizedMap[A, B] extends MutableMap[A, B] with Monitor {
+
+    override def size: Int = synchronized {
+        super.size;
+    }
+
+    override def get(key: A): Option[B] = synchronized {
+        super.get(key);
+    }
+
+    override def isEmpty: Boolean = synchronized {
+        super.isEmpty;
+    }
+
+    override def apply(key: A): B = synchronized {
+        super.apply(key);
+    }
+
+    override def contains(key: A): Boolean = synchronized {
+        super.contains(key);
+    }
+
+    override def isDefinedAt(key: A) = synchronized {
+        super.isDefinedAt(key);
+    }
+
+    override def keys: Iterator[A] = synchronized {
+        super.keys;
+    }
+
+    override def values: Iterator[B] = synchronized {
+        super.values;
+    }
+
+    override def foreach(f: (A, B) => Unit) = synchronized {
+        super.foreach(f);
+    }
+
+    override def toList: List[Pair[A, B]] = synchronized {
+        super.toList;
+    }
+
+    override def update(key: A, value: B): Unit = synchronized {
+        super.update(key, value);
+    }
+
+    override def remove(key: A): Unit = synchronized {
+        super.remove(key);
+    }
+
+    override def clear: Unit = synchronized {
+        super.clear;
+    }
+
+    override def put(key: A, value: B): B = synchronized {
+        super.put(key, value);
+    }
+
+    override def putAll(mappings: Pair[A, B]*) = synchronized {
+        super.putMap(mappings);
+    }
+
+    override def putMap(map: Iterable[Pair[A, B]]): Unit = synchronized {
+        super.putMap(map);
+    }
+
+    override def map(f: (A, B) => B): Unit = synchronized {
+        super.map(f);
+    }
+
+    override def filter(p: (A, B) => Boolean): Unit = synchronized {
+        super.filter(p);
+    }
+
+    override def toString() = synchronized {
+        super.toString();
+    }
+}