diff options
author | Matthias Zenger <mzenger@gmail.com> | 2003-07-01 13:50:54 +0000 |
---|---|---|
committer | Matthias Zenger <mzenger@gmail.com> | 2003-07-01 13:50:54 +0000 |
commit | ad92319573a2c51bea7ecc3b1f7572400216a1f0 (patch) | |
tree | 9f26abf7e11b8cd4cc593d1d5f2d4d20c48522a2 /sources | |
parent | ec3b6d9bbc638051bbfe3170f371301f082aee7c (diff) | |
download | scala-ad92319573a2c51bea7ecc3b1f7572400216a1f0.tar.gz scala-ad92319573a2c51bea7ecc3b1f7572400216a1f0.tar.bz2 scala-ad92319573a2c51bea7ecc3b1f7572400216a1f0.zip |
*** empty log message ***
Diffstat (limited to 'sources')
-rw-r--r-- | sources/scala/ImmutableMap.scala | 64 | ||||
-rw-r--r-- | sources/scala/ImmutableSet.scala | 46 | ||||
-rw-r--r-- | sources/scala/MutableSet.scala | 39 | ||||
-rw-r--r-- | sources/scala/ObservableSet.scala | 35 | ||||
-rw-r--r-- | sources/scala/SynchronizedMap.scala | 90 |
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(); + } +} |