removed leading/trailing tabs/blanks in collect...

removed leading/trailing tabs/blanks in collection/mutable/*.scala

1 files changed, 72 insertions, 72 deletions

diff --git a/src/library/scala/collection/mutable/SynchronizedQueue.scala b/src/library/scala/collection/mutable/SynchronizedQueue.scala
index f7625c2cc4..dece14cd5b 100644
--- a/src/library/scala/collection/mutable/SynchronizedQueue.scala
+++ b/src/library/scala/collection/mutable/SynchronizedQueue.scala
@@ -9,7 +9,7 @@
 // $Id$
 
 
-package scala.collection.mutable;
+package scala.collection.mutable
 
 
 /** This is a synchronized version of the <code>Queue[T]</code> class. It
@@ -21,75 +21,75 @@ package scala.collection.mutable;
  */
 class SynchronizedQueue[A] extends Queue[A] {
 
-    /** Checks if the queue is empty.
-     *
-     *  @return true, iff there is no element in the queue.
-     */
-    override def isEmpty: Boolean = synchronized { super.isEmpty; }
-
-    /** Inserts a single element at the end of the queue.
-     *
-     *  @param  elem        the element to insert
-     */
-    override def +=(elem: A): Unit = synchronized { super.+=(elem); }
-
-    /** Adds all elements provided by an <code>Iterable</code> object
-     *  at the end of the queue. The elements are prepended in the order they
-     *  are given out by the iterator.
-     *
-     *  @param  iter        an iterable object
-     */
-    override def ++=(iter: Iterable[A]): Unit = synchronized { super.++=(iter); }
-
-    /** Adds all elements provided by an iterator
-     *  at the end of the queue. The elements are prepended in the order they
-     *  are given out by the iterator.
-     *
-     *  @param  it        an iterator
-     */
-    override def ++=(it: Iterator[A]): Unit = synchronized { super.++=(it); }
-
-    /** Adds all elements to the queue.
-     *
-     *  @param  elems       the elements to add.
-     */
-    override def enqueue(elems: A*): Unit = synchronized { super.++=(elems); }
-
-    /** Returns the first element in the queue, and removes this element
-     *  from the queue.
-     *
-     *  @return the first element of the queue.
-     */
-    override def dequeue: A = synchronized { super.dequeue; }
-
-    /** Returns the first element in the queue, or throws an error if there
-     *  is no element contained in the queue.
-     *
-     *  @return the first element.
-     */
-    override def front: A = synchronized { super.front; }
-
-    /** Removes all elements from the queue. After this operation is completed,
-     *  the queue will be empty.
-     */
-    override def clear: Unit = synchronized { super.clear; }
-
-    /** Checks if two queues are structurally identical.
-     *
-     *  @return true, iff both queues contain the same sequence of elements.
-     */
-    override def equals(that: Any): Boolean = synchronized { super.equals(that); }
-
-    /** The hashCode method always yields an error, since it is not
-     *  safe to use mutable queues as keys in hash tables.
-     *
-     *  @return never.
-     */
-    override def hashCode(): Int = synchronized { super.hashCode(); }
-
-    /** Returns a textual representation of a queue as a string.
-     *
-     *  @return the string representation of this queue.
-     */
-    override def toString() = synchronized { super.toString(); }
+  /** Checks if the queue is empty.
+   *
+   *  @return true, iff there is no element in the queue.
+   */
+  override def isEmpty: Boolean = synchronized { super.isEmpty }
+
+  /** Inserts a single element at the end of the queue.
+   *
+   *  @param  elem        the element to insert
+   */
+  override def +=(elem: A): Unit = synchronized { super.+=(elem) }
+
+  /** Adds all elements provided by an <code>Iterable</code> object
+   *  at the end of the queue. The elements are prepended in the order they
+   *  are given out by the iterator.
+   *
+   *  @param  iter        an iterable object
+   */
+  override def ++=(iter: Iterable[A]): Unit = synchronized { super.++=(iter) }
+
+  /** Adds all elements provided by an iterator
+   *  at the end of the queue. The elements are prepended in the order they
+   *  are given out by the iterator.
+   *
+   *  @param  it        an iterator
+   */
+  override def ++=(it: Iterator[A]): Unit = synchronized { super.++=(it) }
+
+  /** Adds all elements to the queue.
+   *
+   *  @param  elems       the elements to add.
+   */
+  override def enqueue(elems: A*): Unit = synchronized { super.++=(elems) }
+
+  /** Returns the first element in the queue, and removes this element
+   *  from the queue.
+   *
+   *  @return the first element of the queue.
+   */
+  override def dequeue: A = synchronized { super.dequeue }
+
+  /** Returns the first element in the queue, or throws an error if there
+   *  is no element contained in the queue.
+   *
+   *  @return the first element.
+   */
+  override def front: A = synchronized { super.front }
+
+  /** Removes all elements from the queue. After this operation is completed,
+   *  the queue will be empty.
+   */
+  override def clear: Unit = synchronized { super.clear }
+
+  /** Checks if two queues are structurally identical.
+   *
+   *  @return true, iff both queues contain the same sequence of elements.
+   */
+  override def equals(that: Any): Boolean = synchronized { super.equals(that) }
+
+  /** The hashCode method always yields an error, since it is not
+   *  safe to use mutable queues as keys in hash tables.
+   *
+   *  @return never.
+   */
+  override def hashCode(): Int = synchronized { super.hashCode() }
+
+  /** Returns a textual representation of a queue as a string.
+   *
+   *  @return the string representation of this queue.
+   */
+  override def toString() = synchronized { super.toString() }
 }