Added new traits to the Buffer abstraction.

4 files changed, 346 insertions, 29 deletions

diff --git a/sources/scala/collection/mutable/Buffer.scala b/sources/scala/collection/mutable/Buffer.scala
index 67cd3351ec..ddb4f65bef 100644
--- a/sources/scala/collection/mutable/Buffer.scala
+++ b/sources/scala/collection/mutable/Buffer.scala
@@ -140,6 +140,6 @@ trait Buffer[A] with Seq[A] {
     override def hashCode(): Int = error("unsuitable as hash key");
 
     /** Defines the prefix of the string representation.
-	 */
-	override protected def stringPrefix: String = "Buffer";
+     */
+    override protected def stringPrefix: String = "Buffer";
 }
diff --git a/sources/scala/collection/mutable/BufferProxy.scala b/sources/scala/collection/mutable/BufferProxy.scala
new file mode 100644
index 0000000000..06142e4028
--- /dev/null
+++ b/sources/scala/collection/mutable/BufferProxy.scala
@@ -0,0 +1,140 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
+package scala.collection.mutable;
+
+
+/** This is a simple proxy class for <code>scala.collection.mutable.Buffer</code>.
+ *  It is most useful for assembling customized set abstractions
+ *  dynamically using object composition and forwarding.
+ *
+ *  @author  Matthias Zenger
+ *  @version 1.0, 16/04/2004
+ */
+class BufferProxy[A](buf: Buffer[A]) extends Buffer[A] {
+
+    def length: Int = buf.length;
+
+    def elements: Iterator[A] = buf.elements;
+
+    def apply(n: Int): A = buf.apply(n);
+
+    /** Append a single element to this buffer and return
+     *  the identity of the buffer.
+     *
+     *  @param elem  the element to append.
+     */
+    def +(elem: A): Buffer[A] = buf.+(elem);
+
+    /** Append a single element to this buffer.
+     *
+     *  @param elem  the element to append.
+     */
+    override def +=(elem: A): Unit = buf.+=(elem);
+
+    /** Appends a number of elements provided by an iterable object
+     *  via its <code>elements</code> method. The identity of the
+     *  buffer is returned.
+     *
+     *  @param iter  the iterable object.
+     */
+    override def ++(iter: Iterable[A]): Buffer[A] = buf.++(iter);
+
+    /** Appends a number of elements provided by an iterable object
+     *  via its <code>elements</code> method.
+     *
+     *  @param iter  the iterable object.
+     */
+    override def ++=(iter: Iterable[A]): Unit = buf.++=(iter);
+
+    /** Appends a sequence of elements to this buffer.
+     *
+     *  @param elems  the elements to append.
+     */
+    override def append(elems: A*): Unit = buf.++=(elems);
+
+    /** Appends a number of elements provided by an iterable object
+     *  via its <code>elements</code> method.
+     *
+     *  @param iter  the iterable object.
+     */
+    override def appendAll(iter: Iterable[A]): Unit = buf.appendAll(iter);
+
+    /** Prepend a single element to this buffer and return
+     *  the identity of the buffer.
+     *
+     *  @param elem  the element to append.
+     */
+    def +:(elem: A): Buffer[A] = buf.+:(elem);
+
+    /** Prepends a number of elements provided by an iterable object
+     *  via its <code>elements</code> method. The identity of the
+     *  buffer is returned.
+     *
+     *  @param iter  the iterable object.
+     */
+    override def ++:(iter: Iterable[A]): Buffer[A] = buf.++:(iter);
+
+    /** Prepend an element to this list.
+     *
+     *  @param elem  the element to prepend.
+     */
+    override def prepend(elems: A*): Unit = buf.prependAll(elems);
+
+    /** Prepends a number of elements provided by an iterable object
+     *  via its <code>elements</code> method. The identity of the
+     *  buffer is returned.
+     *
+     *  @param iter  the iterable object.
+     */
+    override def prependAll(elems: Iterable[A]): Unit = buf.prependAll(elems);
+
+    /** Inserts new elements at the index <code>n</code>. Opposed to method
+     *  <code>update</code>, this method will not replace an element with a
+     *  one. Instead, it will insert the new elements at index <code>n</code>.
+     *
+     *  @param n      the index where a new element will be inserted.
+     *  @param elems  the new elements to insert.
+     */
+    override def insert(n: Int, elems: A*): Unit = buf.insertAll(n, elems);
+
+    /** Inserts new elements at the index <code>n</code>. Opposed to method
+     *  <code>update</code>, this method will not replace an element with a
+     *  one. Instead, it will insert a new element at index <code>n</code>.
+     *
+     *  @param n     the index where a new element will be inserted.
+     *  @param iter  the iterable object providing all elements to insert.
+     */
+    def insertAll(n: Int, iter: Iterable[A]): Unit = buf.insertAll(n, iter);
+
+    /** Replace element at index <code>n</code> with the new element
+     *  <code>newelem</code>.
+     *
+     *  @param n       the index of the element to replace.
+     *  @param newelem the new element.
+     */
+    def update(n: Int, newelem: A): Unit = buf.update(n, newelem);
+
+    /** Removes the element on a given index position.
+     *
+     *  @param n  the index which refers to the element to delete.
+     */
+    def remove(n: Int): A = buf.remove(n);
+
+    /** Clears the buffer contents.
+     */
+    def clear: Unit = buf.clear;
+
+    /** The hashCode method always yields an error, since it is not
+     *  safe to use buffers as keys in hash tables.
+     *
+     *  @return never.
+     */
+    override def hashCode(): Int = buf.hashCode();
+}
diff --git a/sources/scala/collection/mutable/ListBuffer.scala b/sources/scala/collection/mutable/ListBuffer.scala
index 82dbb9adc7..f8fd66ca8a 100644
--- a/sources/scala/collection/mutable/ListBuffer.scala
+++ b/sources/scala/collection/mutable/ListBuffer.scala
@@ -42,26 +42,26 @@ class ListBuffer[A] extends Buffer[A] with MutableList[A] {
      *  @param iter  the iterable object providing all elements to insert.
      */
     def insertAll(n: Int, iter: Iterable[A]): Unit = {
-    	val it = iter.elements;
-    	while (it.hasNext) {
-    		val newelem = it.next;
-    		if (n == 0)
-				prepend(newelem);
-			else if (n >= len)
-				append(newelem);
-			else {
-				var elem = first;
-				var i = n;
-				while (i > 1) {
-					elem = elem.next;
-					if (elem == null)
-						error("cannot insert element " + n + " in ListBuffer");
-					i = i - 1;
-				}
-				val old = elem.next;
-				elem.next = new LinkedList[A](newelem, old);
-			}
-    	}
+        val it = iter.elements;
+        while (it.hasNext) {
+            val newelem = it.next;
+            if (n == 0)
+                prepend(newelem);
+            else if (n >= len)
+                append(newelem);
+            else {
+                var elem = first;
+                var i = n;
+                while (i > 1) {
+                    elem = elem.next;
+                    if (elem == null)
+                        error("cannot insert element " + n + " in ListBuffer");
+                    i = i - 1;
+                }
+                val old = elem.next;
+                elem.next = new LinkedList[A](newelem, old);
+            }
+        }
     }
 
     /** Replace element at index <code>n</code> with the new element
@@ -120,14 +120,14 @@ class ListBuffer[A] extends Buffer[A] with MutableList[A] {
      *  @return true, iff both buffers contain the same sequence of elements.
      */
     override def equals(obj: Any): Boolean = obj match {
-    	case that: ListBuffer[A] =>
-    		elements.zip(that.elements).forall {
-    			case Pair(thiselem, thatelem) => thiselem == thatelem;
-    		}
-    	case _ => false
+        case that: ListBuffer[A] =>
+            elements.zip(that.elements).forall {
+                case Pair(thiselem, thatelem) => thiselem == thatelem;
+            }
+        case _ => false
     }
 
     /** Defines the prefix of the string representation.
-	 */
-	override protected def stringPrefix: String = "ListBuffer";
+     */
+    override protected def stringPrefix: String = "ListBuffer";
 }
diff --git a/sources/scala/collection/mutable/SynchronizedBuffer.scala b/sources/scala/collection/mutable/SynchronizedBuffer.scala
new file mode 100644
index 0000000000..d41da4f858
--- /dev/null
+++ b/sources/scala/collection/mutable/SynchronizedBuffer.scala
@@ -0,0 +1,177 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
+package scala.collection.mutable;
+
+
+/** This trait should be used as a mixin. It synchronizes the <code>Buffer</code>
+ *  methods of the class into which it is mixed in.
+ *
+ *  @author  Matthias Zenger
+ *  @version 1.0, 08/07/2003
+ */
+trait SynchronizedBuffer[A] extends Buffer[A] {
+
+    abstract override def length: Int = synchronized {
+        super.length;
+    }
+
+    abstract override def elements: Iterator[A] = synchronized {
+        super.elements;
+    }
+
+    abstract override def apply(n: Int): A = synchronized {
+        super.apply(n);
+    }
+
+    /** Append a single element to this buffer and return
+     *  the identity of the buffer.
+     *
+     *  @param elem  the element to append.
+     */
+    abstract override def +(elem: A): Buffer[A] = synchronized {
+        super.+(elem);
+    }
+
+    /** Append a single element to this buffer.
+     *
+     *  @param elem  the element to append.
+     */
+    override def +=(elem: A): Unit = synchronized {
+        super.+=(elem);
+    }
+
+    /** Appends a number of elements provided by an iterable object
+     *  via its <code>elements</code> method. The identity of the
+     *  buffer is returned.
+     *
+     *  @param iter  the iterable object.
+     */
+    override def ++(iter: Iterable[A]): Buffer[A] = synchronized {
+        super.++(iter);
+    }
+
+    /** Appends a number of elements provided by an iterable object
+     *  via its <code>elements</code> method.
+     *
+     *  @param iter  the iterable object.
+     */
+    override def ++=(iter: Iterable[A]): Unit = synchronized {
+        super.++=(iter);
+    }
+
+    /** Appends a sequence of elements to this buffer.
+     *
+     *  @param elems  the elements to append.
+     */
+    override def append(elems: A*): Unit = synchronized {
+        super.++=(elems);
+    }
+
+    /** Appends a number of elements provided by an iterable object
+     *  via its <code>elements</code> method.
+     *
+     *  @param iter  the iterable object.
+     */
+    override def appendAll(iter: Iterable[A]): Unit = synchronized {
+        super.appendAll(iter);
+    }
+
+    /** Prepend a single element to this buffer and return
+     *  the identity of the buffer.
+     *
+     *  @param elem  the element to append.
+     */
+    abstract override def +:(elem: A): Buffer[A] = synchronized {
+        super.+:(elem);
+    }
+
+    /** Prepends a number of elements provided by an iterable object
+     *  via its <code>elements</code> method. The identity of the
+     *  buffer is returned.
+     *
+     *  @param iter  the iterable object.
+     */
+    override def ++:(iter: Iterable[A]): Buffer[A] = synchronized {
+        super.++:(iter);
+    }
+
+    /** Prepend an element to this list.
+     *
+     *  @param elem  the element to prepend.
+     */
+    override def prepend(elems: A*): Unit = synchronized {
+        super.prependAll(elems);
+    }
+
+    /** Prepends a number of elements provided by an iterable object
+     *  via its <code>elements</code> method. The identity of the
+     *  buffer is returned.
+     *
+     *  @param iter  the iterable object.
+     */
+    override def prependAll(elems: Iterable[A]): Unit = synchronized {
+        super.prependAll(elems);
+    }
+
+    /** Inserts new elements at the index <code>n</code>. Opposed to method
+     *  <code>update</code>, this method will not replace an element with a
+     *  one. Instead, it will insert the new elements at index <code>n</code>.
+     *
+     *  @param n      the index where a new element will be inserted.
+     *  @param elems  the new elements to insert.
+     */
+    override def insert(n: Int, elems: A*): Unit = synchronized {
+        super.insertAll(n, elems);
+    }
+
+    /** Inserts new elements at the index <code>n</code>. Opposed to method
+     *  <code>update</code>, this method will not replace an element with a
+     *  one. Instead, it will insert a new element at index <code>n</code>.
+     *
+     *  @param n     the index where a new element will be inserted.
+     *  @param iter  the iterable object providing all elements to insert.
+     */
+    abstract override def insertAll(n: Int, iter: Iterable[A]): Unit = synchronized {
+        super.insertAll(n, iter);
+    }
+
+    /** Replace element at index <code>n</code> with the new element
+     *  <code>newelem</code>.
+     *
+     *  @param n       the index of the element to replace.
+     *  @param newelem the new element.
+     */
+    abstract override def update(n: Int, newelem: A): Unit = synchronized {
+        super.update(n, newelem);
+    }
+
+    /** Removes the element on a given index position.
+     *
+     *  @param n  the index which refers to the element to delete.
+     */
+    abstract override def remove(n: Int): A = synchronized {
+        super.remove(n);
+    }
+
+    /** Clears the buffer contents.
+     */
+    abstract override def clear: Unit = synchronized {
+        super.clear;
+    }
+
+    /** The hashCode method always yields an error, since it is not
+     *  safe to use buffers as keys in hash tables.
+     *
+     *  @return never.
+     */
+    override def hashCode(): Int = synchronized {
+        super.hashCode();
+    }
+}