diff options
author | Gilles Dubochet <gilles.dubochet@epfl.ch> | 2009-05-27 19:35:02 +0000 |
---|---|---|
committer | Gilles Dubochet <gilles.dubochet@epfl.ch> | 2009-05-27 19:35:02 +0000 |
commit | cc5e79c9ec9cea8d0f22020b528877d8f6e00153 (patch) | |
tree | 94e43f77c7b7271b3d0b6f9fb7372ae83b39360d /src/library | |
parent | 4b8be5d8bec86358276407d6521c41702ccda835 (diff) | |
download | scala-cc5e79c9ec9cea8d0f22020b528877d8f6e00153.tar.gz scala-cc5e79c9ec9cea8d0f22020b528877d8f6e00153.tar.bz2 scala-cc5e79c9ec9cea8d0f22020b528877d8f6e00153.zip |
In "Iterable" and in all its subclasses, "itera...
In "Iterable" and in all its subclasses, "iterator" replaces "elements"
(and assorted changes).
Diffstat (limited to 'src/library')
121 files changed, 470 insertions, 391 deletions
diff --git a/src/library/scala/Array.scala b/src/library/scala/Array.scala index 820195be3c..0ea2b9f972 100644 --- a/src/library/scala/Array.scala +++ b/src/library/scala/Array.scala @@ -92,70 +92,70 @@ object Array extends SequenceFactory[Array] { override def apply[A](xs: A*): Array[A] = { val array = new Array[A](xs.length) var i = 0 - for (x <- xs.elements) { array(i) = x; i += 1 } + for (x <- xs.iterator) { array(i) = x; i += 1 } array } def apply(xs: Boolean*): Array[Boolean] = { val array = new Array[Boolean](xs.length) var i = 0 - for (x <- xs.elements) { array(i) = x; i += 1 } + for (x <- xs.iterator) { array(i) = x; i += 1 } array } def apply(xs: Byte*): Array[Byte] = { val array = new Array[Byte](xs.length) var i = 0 - for (x <- xs.elements) { array(i) = x; i += 1 } + for (x <- xs.iterator) { array(i) = x; i += 1 } array } def apply(xs: Short*): Array[Short] = { val array = new Array[Short](xs.length) var i = 0 - for (x <- xs.elements) { array(i) = x; i += 1 } + for (x <- xs.iterator) { array(i) = x; i += 1 } array } def apply(xs: Char*): Array[Char] = { val array = new Array[Char](xs.length) var i = 0 - for (x <- xs.elements) { array(i) = x; i += 1 } + for (x <- xs.iterator) { array(i) = x; i += 1 } array } def apply(xs: Int*): Array[Int] = { val array = new Array[Int](xs.length) var i = 0 - for (x <- xs.elements) { array(i) = x; i += 1 } + for (x <- xs.iterator) { array(i) = x; i += 1 } array } def apply(xs: Long*): Array[Long] = { val array = new Array[Long](xs.length) var i = 0 - for (x <- xs.elements) { array(i) = x; i += 1 } + for (x <- xs.iterator) { array(i) = x; i += 1 } array } def apply(xs: Float*): Array[Float] = { val array = new Array[Float](xs.length) var i = 0 - for (x <- xs.elements) { array(i) = x; i += 1 } + for (x <- xs.iterator) { array(i) = x; i += 1 } array } def apply(xs: Double*): Array[Double] = { val array = new Array[Double](xs.length) var i = 0 - for (x <- xs.elements) { array(i) = x; i += 1 } + for (x <- xs.iterator) { array(i) = x; i += 1 } array } def apply(xs: Unit*): Array[Unit] = { val array = new Array[Unit](xs.length) var i = 0 - for (x <- xs.elements) { array(i) = x; i += 1 } + for (x <- xs.iterator) { array(i) = x; i += 1 } array } diff --git a/src/library/scala/Console.scala b/src/library/scala/Console.scala index f22c272e4e..31672ac8e6 100644 --- a/src/library/scala/Console.scala +++ b/src/library/scala/Console.scala @@ -406,7 +406,7 @@ object Console { private def textParams(s: Seq[Any]): Array[AnyRef] = { val res = new Array[AnyRef](s.length) var i: Int = 0 - val iter = s.elements + val iter = s.iterator while (iter.hasNext) { res(i) = iter.next match { case x: Boolean => java.lang.Boolean.valueOf(x) diff --git a/src/library/scala/Either.scala b/src/library/scala/Either.scala index 0f0105b482..9fbb4b71ba 100644 --- a/src/library/scala/Either.scala +++ b/src/library/scala/Either.scala @@ -189,7 +189,7 @@ object Either { * <code>Seq</code> if this is a <code>Right</code>. */ def toSeq = e match { - case Left(a) => Seq.singleton(a) + case Left(a) => Seq(a) case Right(_) => Seq.empty } @@ -291,7 +291,7 @@ object Either { */ def toSeq = e match { case Left(_) => Seq.empty - case Right(b) => Seq.singleton(b) + case Right(b) => Seq(b) } /** diff --git a/src/library/scala/Enumeration.scala b/src/library/scala/Enumeration.scala index d91e59f867..e5800a209e 100644 --- a/src/library/scala/Enumeration.scala +++ b/src/library/scala/Enumeration.scala @@ -44,7 +44,7 @@ import scala.collection.generic.{Builder, BuilderFactory, AddingBuilder, SetTemp * * <b>def</b> isWorkingDay(d: WeekDay) = ! (d == Sat || d == Sun) * - * WeekDay.elements filter isWorkingDay foreach println + * WeekDay.iterator filter isWorkingDay foreach println * }</pre> * * @param initial The initial value from which to count the integers that @@ -95,7 +95,7 @@ abstract class Enumeration(initial: Int, names: String*) { protected var nextId = initial /** The string to use to name the next created value. */ - protected var nextName = names.elements + protected var nextName = names.iterator /** The highest integer amongst those used to identify values in this * enumeration. */ @@ -219,7 +219,7 @@ abstract class Enumeration(initial: Int, names: String*) { def contains(v: Value) = ids contains (v.id) def + (value: Value) = new ValueSet(ids + value.id) def - (value: Value) = new ValueSet(ids - value.id) - def elements = ids.elements map Enumeration.this.apply + def iterator = ids.iterator map Enumeration.this.apply override def stringPrefix = Enumeration.this + ".ValueSet" } @@ -249,42 +249,42 @@ abstract class Enumeration(initial: Int, names: String*) { @deprecated def valueOf(s: String) = values.find(_.toString == s) /** A new iterator over all values of this enumeration. - * @deprecated use values.elements instead + * @deprecated use values.iterator instead */ - @deprecated final def elements: Iterator[Value] = values.elements + @deprecated final def iterator: Iterator[Value] = values.iterator /** Apply a function f to all values of this enumeration. * @deprecated use values.foreach instead */ - @deprecated def foreach(f: Value => Unit): Unit = elements foreach f + @deprecated def foreach(f: Value => Unit): Unit = this.iterator foreach f /** Apply a predicate p to all values of this enumeration and return * true, iff the predicate yields true for all values. * @deprecated use values.forall instead */ - @deprecated def forall(p: Value => Boolean): Boolean = elements forall p + @deprecated def forall(p: Value => Boolean): Boolean = this.iterator forall p /** Apply a predicate p to all values of this enumeration and return * true, iff there is at least one value for which p yields true. * @deprecated use values.exists instead */ - @deprecated def exists(p: Value => Boolean): Boolean = elements exists p + @deprecated def exists(p: Value => Boolean): Boolean = this.iterator exists p /** Returns an iterator resulting from applying the given function f to each * value of this enumeration. * @deprecated use values.map instead */ - @deprecated def map[B](f: Value => B): Iterator[B] = elements map f + @deprecated def map[B](f: Value => B): Iterator[B] = this.iterator map f /** Applies the given function f to each value of this enumeration, then * concatenates the results. * @deprecated use values.flatMap instead */ - @deprecated def flatMap[B](f: Value => Iterator[B]): Iterator[B] = elements flatMap f + @deprecated def flatMap[B](f: Value => Iterator[B]): Iterator[B] = this.iterator flatMap f /** Returns all values of this enumeration that satisfy the predicate p. * The order of values is preserved. * @deprecated use values.filter instead */ - @deprecated def filter(p: Value => Boolean): Iterator[Value] = elements filter p + @deprecated def filter(p: Value => Boolean): Iterator[Value] = this.iterator filter p } diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala index a1fe76c074..f6cbd94748 100644 --- a/src/library/scala/Option.scala +++ b/src/library/scala/Option.scala @@ -104,8 +104,8 @@ sealed abstract class Option[+A] extends Product { /** An singleton iterator returning the option's value if it is nonempty * or the empty iterator if the option is empty. */ - def elements: Iterator[A] = - if (isEmpty) Iterator.empty else Iterator.fromValues(this.get) + def iterator: Iterator[A] = + if (isEmpty) Iterator.empty else Iterator.single(this.get) /** A singleton list containing the option's value if it is nonempty * or the empty list if the option is empty. diff --git a/src/library/scala/Ordering.scala b/src/library/scala/Ordering.scala index 663af258dd..467a46f724 100644 --- a/src/library/scala/Ordering.scala +++ b/src/library/scala/Ordering.scala @@ -160,8 +160,8 @@ object Ordering implicit def Iterable[T](implicit ord : Ordering[T]) : Ordering[Iterable[T]] = new Ordering[Iterable[T]] { def compare(x : Iterable[T], y : Iterable[T]) : Int = { - val xe = x.elements; - val ye = y.elements; + val xe = x.iterator; + val ye = y.iterator; while (xe.hasNext && ye.hasNext){ val res = ord.compare(xe.next, ye.next); diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala index c1a7024117..2c11c9a106 100644 --- a/src/library/scala/Predef.scala +++ b/src/library/scala/Predef.scala @@ -161,7 +161,7 @@ object Predef { def println() = Console.println() def println(x: Any) = Console.println(x) def printf(text: String, xs: Any*) = Console.printf(text, xs: _*) - def format(text: String, xs: Any*) = Console.format(text, xs: _*) + def format(text: String, xs: Any*) = stringWrapper(text).format(xs: _*) def readLine(): String = Console.readLine() def readLine(text: String, args: Any*) = Console.readLine(text, args) @@ -209,8 +209,8 @@ object Predef { val self = xs def compare(that: Iterable[A]): Int = { var res = 0 - val these = xs.elements - val those = that.elements + val these = xs.iterator + val those = that.iterator while (res == 0 && these.hasNext) res = if (those.hasNext) these.next compare those.next else 1 if (res == 0) { diff --git a/src/library/scala/Product.scala b/src/library/scala/Product.scala index fd310f8fcf..b9a60e4c95 100644 --- a/src/library/scala/Product.scala +++ b/src/library/scala/Product.scala @@ -32,13 +32,17 @@ trait Product extends AnyRef { */ def productArity: Int - def productElements: Iterator[Any] = new Iterator[Any] { + def productIterator: Iterator[Any] = new Iterator[Any] { private var c: Int = 0 private val cmax = productArity def hasNext = c < cmax def next() = { val result = productElement(c); c += 1; result } } + /** @deprecated use productIterator instead + */ + @deprecated def productElements: Iterator[Any] = productIterator + /** * By default the empty string. Implementations may override this * method in order to prepend a string prefix to the result of the diff --git a/src/library/scala/Tuple2.scala b/src/library/scala/Tuple2.scala index 4d8d64702d..89cf68b3b0 100644 --- a/src/library/scala/Tuple2.scala +++ b/src/library/scala/Tuple2.scala @@ -21,8 +21,8 @@ object Tuple2 { /* !!! todo: enable class IterableOps[CC[+B] <: Iterable[B] with IterableTemplate[CC, B @uncheckedVariance], A1, A2](tuple: (CC[A1], Iterable[A2])) { def zip: CC[(A1, A2)] = { - val elems1 = tuple._1.elements - val elems2 = tuple._2.elements + val elems1 = tuple._1.iterator + val elems2 = tuple._2.iterator val b = (tuple._1: IterableTemplate[CC, A1]).newBuilder[(A1, A2)] // : needed because otherwise it picks Iterable's builder. while (elems1.hasNext && elems2.hasNext) @@ -30,37 +30,37 @@ object Tuple2 { b.result } def map[B](f: (A1, A2) => B): CC[B] = { - val elems1 = tuple._1.elements - val elems2 = tuple._2.elements + val elems1 = tuple._1.iterator + val elems2 = tuple._2.iterator val b = (tuple._1: IterableTemplate[CC, A1]).newBuilder[B] while (elems1.hasNext && elems2.hasNext) b += f(elems1.next, elems2.next) b.result } def flatMap[B](f: (A1, A2) => CC[B]): CC[B] = { - val elems1 = tuple._1.elements - val elems2 = tuple._2.elements + val elems1 = tuple._1.iterator + val elems2 = tuple._2.iterator val b = (tuple._1: IterableTemplate[CC, A1]).newBuilder[B] while (elems1.hasNext && elems2.hasNext) b ++= f(elems1.next, elems2.next) b.result } def foreach[U](f: (A1, A2) => U) { - val elems1 = tuple._1.elements - val elems2 = tuple._2.elements + val elems1 = tuple._1.iterator + val elems2 = tuple._2.iterator while (elems1.hasNext && elems2.hasNext) f(elems1.next, elems2.next) } def forall(p: (A1, A2) => Boolean): Boolean = { - val elems1 = tuple._1.elements - val elems2 = tuple._2.elements + val elems1 = tuple._1.iterator + val elems2 = tuple._2.iterator while (elems1.hasNext && elems2.hasNext) if (!p(elems1.next, elems2.next)) return false true } def exists(p: (A1, A2) => Boolean): Boolean = { - val elems1 = tuple._1.elements - val elems2 = tuple._2.elements + val elems1 = tuple._1.iterator + val elems2 = tuple._2.iterator while (elems1.hasNext && elems2.hasNext) if (p(elems1.next, elems2.next)) return true false diff --git a/src/library/scala/Tuple2.scala.notyet b/src/library/scala/Tuple2.scala.notyet index bed6bd3a9a..050a8d2536 100644 --- a/src/library/scala/Tuple2.scala.notyet +++ b/src/library/scala/Tuple2.scala.notyet @@ -16,45 +16,45 @@ package scala object Tuple2 { class IterableOps[CC[+B] <: Iterable[B], A1, A2](tuple: (CC[A1], Iterable[A2])) { def zip: CC[(A1, A2)] = { - val elems1 = tuple._1.elements - val elems2 = tuple._2.elements + val elems1 = tuple._1.iterator + val elems2 = tuple._2.iterator val b = tuple._1.newBuilder[B] while (elems1.hasNext && elems2.hasNext) b += ((elems1.next, elems2.next)) b.result } def map[B](f: (A1, A2) => B): CC[B] = { - val elems1 = tuple._1.elements - val elems2 = tuple._2.elements + val elems1 = tuple._1.iterator + val elems2 = tuple._2.iterator val b = tuple._1.newBuilder[B] while (elems1.hasNext && elems2.hasNext) b += f(elems1.next, elems2.next) b.result } def flatMap[B](f: (A1, A2) => CC[B]) CC[B] = { - val elems1 = tuple._1.elements - val elems2 = tuple._2.elements + val elems1 = tuple._1.iterator + val elems2 = tuple._2.iterator val b = tuple._1.newBuilder[B] while (elems1.hasNext && elems2.hasNext) b ++= f(elems1.next, elems2.next) b.result } def foreach(f: (A1, A2) => Unit) { - val elems1 = tuple._1.elements - val elems2 = tuple._2.elements + val elems1 = tuple._1.iterator + val elems2 = tuple._2.iterator while (elems1.hasNext && elems2.hasNext) f(elems1.next, elems2.next) } def forall(p: (A1, A2) => Boolean): Boolean = { - val elems1 = tuple._1.elements - val elems2 = tuple._2.elements + val elems1 = tuple._1.iterator + val elems2 = tuple._2.iterator while (elems1.hasNext && elems2.hasNext) if (!p(elems1.next, elems2.next)) return false true } def exists(p: (A1, A2) => Boolean): Boolean = { - val elems1 = tuple._1.elements - val elems2 = tuple._2.elements + val elems1 = tuple._1.iterator + val elems2 = tuple._2.iterator while (elems1.hasNext && elems2.hasNext) if (p(elems1.next, elems2.next)) return true false diff --git a/src/library/scala/collection/DefaultMap.scala b/src/library/scala/collection/DefaultMap.scala index fe5b7a2c1b..bb3a0defa0 100644 --- a/src/library/scala/collection/DefaultMap.scala +++ b/src/library/scala/collection/DefaultMap.scala @@ -17,7 +17,7 @@ import generic._ * Instances that inherit from DefaultMap[A, B] still have to define: * * def get(key: A): Option[B] - * def elements: Iterator[(A, B)] + * def iterator: Iterator[(A, B)] * * It refers back to the original map. * diff --git a/src/library/scala/collection/Iterable.scala b/src/library/scala/collection/Iterable.scala index 1ec5dccd7c..179ff99d92 100644 --- a/src/library/scala/collection/Iterable.scala +++ b/src/library/scala/collection/Iterable.scala @@ -38,7 +38,7 @@ trait Iterable[+A] extends Traversable[A] /* The following methods are inherited from trait IterableTemplate * - override def elements: Iterator[A] + override def iterator: Iterator[A] override def takeRight(n: Int): Iterable[A] override def dropRight(n: Int): Iterable[A] override def sameElements[B >: A](that: Iterable[B]): Boolean @@ -58,7 +58,7 @@ object Iterable extends TraversableFactory[Iterable] { * @deprecated use seq.min instead */ @deprecated def min[A <% Ordered[A]](seq: Iterable[A]): A = { - val xs = seq.elements + val xs = seq.iterator if (!xs.hasNext) throw new IllegalArgumentException("min(<empty>)") var min = xs.next while (xs.hasNext) { @@ -72,7 +72,7 @@ object Iterable extends TraversableFactory[Iterable] { * @deprecated use seq.max iConstead */ @deprecated def max[A <% Ordered[A]](seq: Iterable[A]): A = { - val xs = seq.elements + val xs = seq.iterator if (!xs.hasNext) throw new IllegalArgumentException("max(<empty>)") var max = xs.next while (xs.hasNext) { diff --git a/src/library/scala/collection/Iterator.scala b/src/library/scala/collection/Iterator.scala index a38cc6f360..5ebe0df11e 100644 --- a/src/library/scala/collection/Iterator.scala +++ b/src/library/scala/collection/Iterator.scala @@ -43,14 +43,14 @@ object Iterator { /** Creates an iterator with given elements * @param elems The elements returned one-by-one from the iterator */ - def apply[A](elems: A*): Iterator[A] = elems.elements + def apply[A](elems: A*): Iterator[A] = elems.iterator /** Concatenates the given argument iterators into a single iterator. * * @param its the argument iterators that are to be concatenated * @return the concatenation of all the argument iterators */ - @deprecated def concat[A](xss: Iterator[A]*): Iterator[A] = xss.elements.flatten + @deprecated def concat[A](xss: Iterator[A]*): Iterator[A] = xss.iterator.flatten /** An iterator that returns the results of some element computation a number of times. * @param len The number of elements returned @@ -165,14 +165,14 @@ object Iterator { implicit def iteratorIteratorWrapper[A](its: Iterator[Iterator[A]]): IteratorIteratorOps[A] = new IteratorIteratorOps[A](its) - /** @deprecated use `xs.elements` instead + /** @deprecated use `xs.iterator` or `Iterator(xs)` instead */ - @deprecated def fromValues[a](xs: a*) = xs.elements + @deprecated def fromValues[a](xs: a*) = xs.iterator /** * @param xs the array of elements - * @see also: Vector.elements and slice - * @deprecated use `xs.elements` instead + * @see also: Vector.iterator and slice + * @deprecated use `xs.iterator` instead */ @deprecated def fromArray[a](xs: Array[a]): Iterator[a] = fromArray(xs, 0, xs.length) @@ -181,23 +181,23 @@ object Iterator { * @param xs the array of elements * @param start the start index * @param length the length - * @see also: Vector.elements and slice - * @deprecated use `xs.slice(start, start + length).elements` instead + * @see also: Vector.iterator and slice + * @deprecated use `xs.slice(start, start + length).iterator` instead */ @deprecated def fromArray[a](xs: Array[a], start: Int, length: Int): Iterator[a] = - xs.slice(start, start + length).elements + xs.slice(start, start + length).iterator /** * @param str the given string * @return the iterator on <code>str</code> - * @deprecated replaced by <code>str.elements</code> + * @deprecated replaced by <code>str.iterator</code> */ - @deprecated def fromString(str: String): Iterator[Char] = str.elements + @deprecated def fromString(str: String): Iterator[Char] = str.iterator /** * @param n the product arity * @return the iterator on <code>Product<n></code>. - * @deprecated use product.productElements instead + * @deprecated use product.productIterator instead */ @deprecated def fromProduct(n: Product): Iterator[Any] = new Iterator[Any] { private var c: Int = 0 diff --git a/src/library/scala/collection/JavaConversions.scala b/src/library/scala/collection/JavaConversions.scala index 3509d13373..968329614c 100644 --- a/src/library/scala/collection/JavaConversions.scala +++ b/src/library/scala/collection/JavaConversions.scala @@ -323,18 +323,21 @@ object JavaConversions { } case class IterableWrapper[A](underlying : Iterable[A]) extends ju.AbstractCollection[A] { - def iterator = underlying.elements + def iterator = underlying.iterator + @deprecated def elements = iterator def size = underlying.size override def isEmpty = underlying.isEmpty } case class JIterableWrapper[A](underlying : jl.Iterable[A]) extends Iterable[A] { - def elements = underlying.iterator + def iterator = underlying.iterator + @deprecated def elements = iterator def newBuilder[B] = new mutable.ArrayBuffer[B] } case class JCollectionWrapper[A](underlying : ju.Collection[A]) extends Iterable[A] { - def elements = underlying.iterator + def iterator = underlying.iterator + @deprecated def elements = iterator override def size = underlying.size override def isEmpty = underlying.isEmpty def newBuilder[B] = new mutable.ArrayBuffer[B] @@ -351,7 +354,8 @@ object JavaConversions { case class JListWrapper[A](val underlying : ju.List[A]) extends mutable.Buffer[A] { def length = underlying.size override def isEmpty = underlying.isEmpty - override def elements : Iterator[A] = underlying.iterator + override def iterator : Iterator[A] = underlying.iterator + @deprecated def elements = iterator def apply(i : Int) = underlying.get(i) def update(i : Int, elem : A) = underlying.set(i, elem) def +:(elem : A) = { underlying.subList(0, 0).add(elem) ; this } @@ -374,7 +378,7 @@ object JavaConversions { } } def iterator = new ju.Iterator[A] { - val ui = underlying.elements + val ui = underlying.iterator var prev : Option[A] = None def hasNext = ui.hasNext @@ -384,12 +388,15 @@ object JavaConversions { case _ => throw new IllegalStateException("next must be called at least once before remove") } } + + @deprecated def elements = iterator } case class JSetWrapper[A](underlying : ju.Set[A]) extends mutable.Set[A] with generic.MutableSetTemplate[A, JSetWrapper[A]] { override def size = underlying.size - def elements = underlying.iterator + def iterator = underlying.iterator + @deprecated def elements = iterator def contains(elem: A): Boolean = underlying.contains(elem) @@ -429,7 +436,7 @@ object JavaConversions { def size = self.size def iterator = new ju.Iterator[ju.Map.Entry[A, B]] { - val ui = underlying.elements + val ui = underlying.iterator var prev : Option[A] = None def hasNext = ui.hasNext @@ -448,6 +455,8 @@ object JavaConversions { } } + @deprecated def elements = iterator + def remove = prev match { case Some(k) => val v = self.remove(k.asInstanceOf[AnyRef]) ; prev = None ; v case _ => throw new IllegalStateException("next must be called at least once before remove") @@ -484,7 +493,7 @@ object JavaConversions { if (r != null) Some(r) else None } - def elements = new Iterator[(A, B)] { + def iterator = new Iterator[(A, B)] { val ui = underlying.entrySet.iterator def hasNext = ui.hasNext def next = { val e = ui.next ; (e.getKey, e.getValue) } diff --git a/src/library/scala/collection/Map.scala b/src/library/scala/collection/Map.scala index 0cc1f33404..72afa218c2 100644 --- a/src/library/scala/collection/Map.scala +++ b/src/library/scala/collection/Map.scala @@ -18,7 +18,7 @@ import generic._ * (where This is the type of the map in question): * * def get(key: A): Option[B] - * def elements: Iterator[(A, B)] + * def iterator: Iterator[(A, B)] * def + [B1 >: B](kv: (A, B1)): This * def -(key: A): This * diff --git a/src/library/scala/collection/RollbackIterator.scala.disabled b/src/library/scala/collection/RollbackIterator.scala.disabled index 09ef4b6c3e..2dc011deee 100644 --- a/src/library/scala/collection/RollbackIterator.scala.disabled +++ b/src/library/scala/collection/RollbackIterator.scala.disabled @@ -46,7 +46,7 @@ class RollbackIterator[+A](underlying: Iterator[A]) extends BufferedIterator.Def if (g.isEmpty) { //putBack(rollback(0)) val sz = oldLength.getOrElse(0) - val i = rollback.drop(sz).reverse.elements + val i = rollback.drop(sz).reverse.iterator while (i.hasNext) putBack(i.next) if (oldLength.isEmpty) rollback = null else rollback.reduceToSize(sz) diff --git a/src/library/scala/collection/Sequence.scala b/src/library/scala/collection/Sequence.scala index c5853355d4..d85ae1c306 100644 --- a/src/library/scala/collection/Sequence.scala +++ b/src/library/scala/collection/Sequence.scala @@ -20,7 +20,7 @@ import util.control.Breaks._ * of type <code>A</code>. * It adds the following methods to class Iterable: * `length`, `lengthCompare`, `apply`, `isDefinedAt`, `segmentLength`, `prefixLengh`, - * `indexWhere`, `indexOf`, `lastIndexWhere`, `lastIndexOf`, `reverse`, `reversedElements`, + * `indexWhere`, `indexOf`, `lastIndexWhere`, `lastIndexOf`, `reverse`, `reverseIterator`, * `startsWith`, `endsWith`, `indexOfSeq`. * * diff --git a/src/library/scala/collection/generic/BitSetTemplate.scala b/src/library/scala/collection/generic/BitSetTemplate.scala index f5c5a64d4e..e7fa26534c 100644 --- a/src/library/scala/collection/generic/BitSetTemplate.scala +++ b/src/library/scala/collection/generic/BitSetTemplate.scala @@ -33,7 +33,7 @@ trait BitSetTemplate[+This <: BitSetTemplate[This] with Set[Int]] extends SetTem s } - def elements = new Iterator[Int] { + def iterator = new Iterator[Int] { private var current = 0 private val end = nwords * WordLength def hasNext: Boolean = { @@ -45,6 +45,8 @@ trait BitSetTemplate[+This <: BitSetTemplate[This] with Set[Int]] extends SetTem else Iterator.empty.next } + @deprecated def elements = iterator + override def foreach[B](f: Int => B) { for (i <- 0 until nwords) { val w = word(i) @@ -136,7 +138,7 @@ object BitSetTemplate { private val pc1: Array[Int] = { def countBits(x: Int): Int = if (x == 0) 0 else x % 2 + countBits(x >>> 1) - Array.fromFunction(countBits _)(256) + Array.tabulate(256)(countBits _) } private def popCount(w: Long): Int = { diff --git a/src/library/scala/collection/generic/BufferTemplate.scala b/src/library/scala/collection/generic/BufferTemplate.scala index 74f61870d3..53d74a2d45 100644 --- a/src/library/scala/collection/generic/BufferTemplate.scala +++ b/src/library/scala/collection/generic/BufferTemplate.scala @@ -116,7 +116,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]] } /** Prepends a number of elements provided by an iterable object - * via its <code>elements</code> method. The identity of the + * via its <code>iterator</code> method. The identity of the * buffer is returned.(thisCollection /: elems) (_ plus _) * * @param iter the iterable object. @@ -138,7 +138,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]] def append(elems: A*) { this ++= elems } /** Appends a number of elements provided by an iterable object - * via its <code>elements</code> method. + * via its <code>iterator</code> method. * * @param iter the iterable object. */ @@ -151,7 +151,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]] def prepend(elems: A*) { elems ++: this } /** Prepends a number of elements provided by an iterable object - * via its <code>elements</code> method. The identity of the + * via its <code>iterator</code> method. The identity of the * buffer is returned. * * @param iter the iterable object. @@ -159,7 +159,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]] def prependAll(iter: Traversable[A]) { iter ++: this } /** Prepends a number of elements provided by an iterable object - * via its <code>elements</code> method. The identity of the + * via its <code>iterator</code> method. The identity of the * buffer is returned. * * @param iter the iterable object. @@ -209,7 +209,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]] case Remove(NoLo, x) => this -= x case Reset() => clear - case s: Script[_] => s.elements foreach << + case s: Script[_] => s.iterator foreach << case _ => throw new UnsupportedOperationException("message " + cmd + " not understood") } diff --git a/src/library/scala/collection/generic/ImmutableMapTemplate.scala b/src/library/scala/collection/generic/ImmutableMapTemplate.scala index b001e72a08..6c5331689e 100644 --- a/src/library/scala/collection/generic/ImmutableMapTemplate.scala +++ b/src/library/scala/collection/generic/ImmutableMapTemplate.scala @@ -16,7 +16,7 @@ package scala.collection.generic * (where This is the type of the map in question): * * def get(key: A): Option[B] - * def elements: Iterator[(A, B)] + * def iterator: Iterator[(A, B)] * def + [B1 >: B](kv: (A, B)): Map[A, B1] * def - (key: A): This * diff --git a/src/library/scala/collection/generic/IterableForwarder.scala b/src/library/scala/collection/generic/IterableForwarder.scala index 142edbf509..5593f1a4f5 100644 --- a/src/library/scala/collection/generic/IterableForwarder.scala +++ b/src/library/scala/collection/generic/IterableForwarder.scala @@ -33,6 +33,6 @@ trait IterableForwarder[+A] extends Iterable[A] with TraversableForwarder[A] { // Iterable delegates // Iterable methods could be printed by cat IterableTemplate.scala | sed -n '/trait Iterable/,$ p' | egrep '^ (override )?def' - override def elements = underlying.elements + override def iterator = underlying.iterator override def sameElements[B >: A](that: Iterable[B]): Boolean = underlying.sameElements(that) } diff --git a/src/library/scala/collection/generic/IterableProxyTemplate.scala b/src/library/scala/collection/generic/IterableProxyTemplate.scala index 646cdbee11..d154d33621 100644 --- a/src/library/scala/collection/generic/IterableProxyTemplate.scala +++ b/src/library/scala/collection/generic/IterableProxyTemplate.scala @@ -23,7 +23,7 @@ import collection.mutable.Buffer * @version 2.8 */ trait IterableProxyTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] extends IterableTemplate[A, This] with TraversableProxyTemplate[A, This] { - override def elements: Iterator[A] = self.elements + override def iterator: Iterator[A] = self.iterator override def takeRight(n: Int): This = self.takeRight(n) override def dropRight(n: Int): This = self.dropRight(n) override def sameElements[B >: A](that: Iterable[B]): Boolean = self.sameElements(that) diff --git a/src/library/scala/collection/generic/IterableTemplate.scala b/src/library/scala/collection/generic/IterableTemplate.scala index c540f5d3c9..7a0fb122f1 100644 --- a/src/library/scala/collection/generic/IterableTemplate.scala +++ b/src/library/scala/collection/generic/IterableTemplate.scala @@ -16,7 +16,7 @@ import util.control.Breaks._ /** A template trait for iterable collections. * * Collection classes mixing in this trait provide a method - * <code>elements</code> which returns an iterator over all the + * <code>iterator</code> which returns an iterator over all the * elements contained in the collection. They also provide a method `newBuilder` * which creates a builder for collections of the same kind. * @@ -24,7 +24,7 @@ import util.control.Breaks._ * all elements. Subclasses of `Iterable` should re-implement `foreach` with * something more efficient, if possible. * - * This trait adds methods `elements`, `sameElements`, + * This trait adds methods `iterator`, `sameElements`, * `takeRight`, `dropRight` to the methods inherited from trait `Traversable`. * * @author Martin Odersky @@ -37,7 +37,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] * * @return the new iterator */ - def elements: Iterator[A] + def iterator: Iterator[A] /** Apply a function <code>f</code> to all elements of this * traversable object. @@ -46,15 +46,15 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] * The result (of arbitrary type U) of function `f` is discarded. * * @note This method underlies the implementation of most other bulk operations. - * Implementing `foreach` with `elements` is often suboptimal. + * Implementing `foreach` with `iterator` is often suboptimal. * So `foreach` should be overridden in concrete collection classes if a more * efficient implementation is available. */ - def foreach[U](f: A => U): Unit = elements.foreach(f) + def foreach[U](f: A => U): Unit = this.iterator.foreach(f) /** Does this iterable contain no elements? */ - override def isEmpty: Boolean = !elements.hasNext + override def isEmpty: Boolean = !this.iterator.hasNext /** Combines the elements of this iterable together using the binary * function <code>f</code>, from right to left, and starting with @@ -67,7 +67,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] * if the iterable is <code>[a<sub>0</sub>, a1, ..., a<sub>n</sub>]</code>. */ override def foldRight[B](z: B)(op: (A, B) => B): B = - elements.foldRight(z)(op) + this.iterator.foldRight(z)(op) /** Combines the elements of this iterable object together using the binary * operator <code>op</code>, from right to left @@ -83,7 +83,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] * @throws Predef.UnsupportedOperationException if the iterator is empty. */ override def reduceRight[B >: A](op: (A, B) => B): B = - elements.reduceRight(op) + this.iterator.reduceRight(op) /** The iterable itself */ override def toIterable: Iterable[A] = thisCollection @@ -93,7 +93,11 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] * @note Might return different results for different runs, unless this iterable is ordered * @throws Predef.NoSuchElementException if the iterable is empty. */ - override def head: A = if (isEmpty) throw new NoSuchElementException else elements.next + override def head: A = + if (isEmpty) + throw new NoSuchElementException + else + this.iterator.next /** Returns the rightmost <code>n</code> elements from this iterable. * @@ -102,7 +106,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] */ def takeRight(n: Int): This = { val b = newBuilder - val lead = elements drop n + val lead = this.iterator drop n var go = false for (x <- this) { if (lead.hasNext) lead.next @@ -119,7 +123,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] */ def dropRight(n: Int): This = { val b = newBuilder - val lead = elements drop n + val lead = iterator drop n breakable { for (x <- this) { if (!lead.hasNext) break @@ -138,8 +142,8 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] * @note Might return different results for different runs, unless this iterable is ordered */ def sameElements[B >: A](that: Iterable[B]): Boolean = { - val these = this.elements - val those = that.elements + val these = this.iterator + val those = that.iterator var res = true while (res && these.hasNext && those.hasNext) { res = (these.next == those.next) @@ -149,13 +153,13 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] /** Returns a stream with all elements in this traversable object. */ - override def toStream: Stream[A] = elements.toStream + override def toStream: Stream[A] = iterator.toStream /** Creates a view of this iterable @see IterableView */ override def view = new IterableView[A, This] { protected lazy val underlying = self.thisCollection - override def elements = self.elements + override def iterator = self.iterator } /** A sub-iterable view starting at index `from` diff --git a/src/library/scala/collection/generic/IterableViewTemplate.scala b/src/library/scala/collection/generic/IterableViewTemplate.scala index f120e97ac4..950f8bb52a 100644 --- a/src/library/scala/collection/generic/IterableViewTemplate.scala +++ b/src/library/scala/collection/generic/IterableViewTemplate.scala @@ -23,31 +23,31 @@ extends Iterable[A] with IterableTemplate[A, This] with TraversableView[A, Coll] trait Transformed[+B] extends IterableView[B, Coll] with super.Transformed[B] trait Sliced extends Transformed[A] with super.Sliced { - override def elements = self.elements slice (from, until) + override def iterator = self.iterator slice (from, until) } trait Mapped[B] extends Transformed[B] with super.Mapped[B] { - override def elements = self.elements map mapping + override def iterator = self.iterator map mapping } trait FlatMapped[B] extends Transformed[B] with super.FlatMapped[B] { - override def elements = self.elements flatMap (mapping(_).toIterable.elements) + override def iterator = self.iterator flatMap (mapping(_).toIterable.iterator) } trait Appended[B >: A] extends Transformed[B] with super.Appended[B] { - override def elements = self.elements ++ rest.toIterable.elements + override def iterator = self.iterator ++ rest.toIterable.iterator } trait Filtered extends Transformed[A] with super.Filtered { - override def elements = self.elements filter pred + override def iterator = self.iterator filter pred } trait TakenWhile extends Transformed[A] with super.TakenWhile { - override def elements = self.elements takeWhile pred + override def iterator = self.iterator takeWhile pred } trait DroppedWhile extends Transformed[A] with super.DroppedWhile { - override def elements = self.elements dropWhile pred + override def iterator = self.iterator dropWhile pred } /** Boilerplate method, to override in each subclass diff --git a/src/library/scala/collection/generic/LinearSequenceTemplate.scala b/src/library/scala/collection/generic/LinearSequenceTemplate.scala index 6c13e71beb..b87a417fd7 100644 --- a/src/library/scala/collection/generic/LinearSequenceTemplate.scala +++ b/src/library/scala/collection/generic/LinearSequenceTemplate.scala @@ -60,7 +60,7 @@ trait LinearSequenceTemplate[+A, +This <: LinearSequenceTemplate[A, This] with L /** Returns the elements in the sequence as an iterator */ - override def elements: Iterator[A] = new Iterator[A] { + override def iterator: Iterator[A] = new Iterator[A] { var these = self def hasNext: Boolean = !these.isEmpty def next: A = @@ -70,6 +70,8 @@ trait LinearSequenceTemplate[+A, +This <: LinearSequenceTemplate[A, This] with L override def toList: List[A] = these.toList } + @deprecated def elements = iterator + /** Apply the given function <code>f</code> to each element of this linear sequence * (while respecting the order of the elements). * diff --git a/src/library/scala/collection/generic/LinkedListTemplate.scala b/src/library/scala/collection/generic/LinkedListTemplate.scala index 0be2562996..e3de5031a9 100644 --- a/src/library/scala/collection/generic/LinkedListTemplate.scala +++ b/src/library/scala/collection/generic/LinkedListTemplate.scala @@ -69,7 +69,7 @@ trait LinkedListTemplate[A, This >: Null <: Sequence[A] with LinkedListTemplate[ else None } - override def elements: Iterator[A] = new Iterator[A] { + override def iterator: Iterator[A] = new Iterator[A] { var elems = self def hasNext = (elems ne null) def next = { diff --git a/src/library/scala/collection/generic/MapTemplate.scala b/src/library/scala/collection/generic/MapTemplate.scala index 0af8543370..ff67a1a379 100644 --- a/src/library/scala/collection/generic/MapTemplate.scala +++ b/src/library/scala/collection/generic/MapTemplate.scala @@ -16,7 +16,7 @@ package scala.collection.generic * (where `This` is the type of the map in question): * * def get(key: A): Option[B] - * def elements: Iterator[(A, B)] + * def iterator: Iterator[(A, B)] * def + [B1 >: B](kv: (A, B1)): This * def -(key: A): This * @@ -50,7 +50,9 @@ self => def get(key: A): Option[B] /** An iterator yielding all key/value mappings of this map. */ - def elements: Iterator[(A, B)] + def iterator: Iterator[(A, B)] + + @deprecated def elements = iterator /** Add a key/value pair to this map, returning a new map. * @param kv the key/value pair @@ -110,44 +112,52 @@ self => */ def isDefinedAt(key: A) = contains(key) - /** Creates an iterator for all keys. - * - * @return an iterator over all keys. + /** + * @return the keys of this map as a set. */ - def keys: Iterator[A] = new Iterator[A] { - val iter = self.elements - def hasNext = iter.hasNext - def next = iter.next._1 - } + def keys: Set[A] = new DefaultKeySet protected class DefaultKeySet extends Set[A] { def contains(key : A) = self.contains(key) - def elements = self.elements.map(_._1) + def iterator = self.iterator.map(_._1) + @deprecated def elements = iterator def + (elem: A): Set[A] = (Set[A]() ++ this + elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem def - (elem: A): Set[A] = (Set[A]() ++ this - elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem override def size = self.size override def foreach[B](f: A => B) = for ((k, v) <- self) f(k) } - /** @return the keys of this map as a set. + /** @deprecated use `keys` instead + * + * @return the keys of this map as a set. */ - def keySet: Set[A] = new DefaultKeySet + @deprecated def keySet: collection.Set[A] = new DefaultKeySet - /** Creates an iterator for a contained values. + /** Creates an iterator for all keys. * - * @return an iterator over all values. + * @return an iterator over all keys. */ - def values: Iterator[B] = new Iterator[B] { - val iter = self.elements + def keysIterator: Iterator[A] = new Iterator[A] { + val iter = self.iterator def hasNext = iter.hasNext - def next = iter.next._2 + def next = iter.next._1 } /** @return the values of this map as a set. * @note Can't return a Set[B] here because sets are non-variant. * The operation is overridden with the sharper type in MutableMapTemplate. */ - def valueSet: immutable.Set[_ <: B] = immutable.Set.empty[B] ++ (self map (_._2)) + def values: collection.Set[_ <: B] = immutable.Set.empty[B] ++ (self map (_._2)) + + /** Creates an iterator for a contained values. + * + * @return an iterator over all values. + */ + def valuesIterator: Iterator[B] = new Iterator[B] { + val iter = self.iterator + def hasNext = iter.hasNext + def next = iter.next._2 + } /** The default value for the map, returned when a key is not found * The method implemented here yields an error, @@ -164,7 +174,7 @@ self => */ def filterKeys(p: A => Boolean) = new DefaultMap[A, B] { override def foreach[C](f: ((A, B)) => C): Unit = for (kv <- self) if (p(kv._1)) f(kv) - def elements = self.elements.filter(kv => p(kv._1)) + def iterator = self.iterator.filter(kv => p(kv._1)) override def contains(key: A) = self.contains(key) && p(key) def get(key: A) = if (!p(key)) None else self.get(key) } @@ -174,7 +184,7 @@ self => */ def mapValues[C](f: B => C) = new DefaultMap[A, C] { override def foreach[D](g: ((A, C)) => D): Unit = for ((k, v) <- self) g((k, f(v))) - def elements = for ((k, v) <- self.elements) yield (k, f(v)) + def iterator = for ((k, v) <- self.iterator) yield (k, f(v)) override def size = self.size override def contains(key: A) = self.contains(key) def get(key: A) = self.get(key).map(f) @@ -226,7 +236,7 @@ self => * @return a string showing all mappings */ override def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder = - elements.map { case (k, v) => k+" -> "+v }.addString(b, start, sep, end) + this.iterator.map { case (k, v) => k+" -> "+v }.addString(b, start, sep, end) /** Compares two maps structurally; i.e. checks if all mappings * contained in this map are also contained in the other map, diff --git a/src/library/scala/collection/generic/MutableMapTemplate.scala b/src/library/scala/collection/generic/MutableMapTemplate.scala index 9ccb13787b..6d6d05a119 100644 --- a/src/library/scala/collection/generic/MutableMapTemplate.scala +++ b/src/library/scala/collection/generic/MutableMapTemplate.scala @@ -15,7 +15,7 @@ package scala.collection.generic * To implement a concrete mutable map, you need to provide implementations of the following methods: * * def get(key: A): Option[B] - * def elements: Iterator[(A, B)] + * def iterator: Iterator[(A, B)] * def += (kv: (A, B)): this.type * def -= (key: A): this.type * @@ -104,7 +104,7 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta this += elem1 += elem2 ++= elems /** Adds a number of elements provided by a traversable object - * via its <code>elements</code> method and returns + * via its <code>iterator</code> method and returns * either the collection itself (if it is mutable), or a new collection * with the added elements. * @deprecated This operation will create a new map in the future. To add @@ -116,7 +116,7 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta @deprecated def ++(iter: Traversable[(A, B)]): this.type = { for (elem <- iter) +=(elem); this } /** Adds a number of elements provided by an iterator - * via its <code>elements</code> method and returns + * via its <code>iterator</code> method and returns * the collection itself. * @deprecated This operation will create a new map in the future. To add * elements as a side effect to an existing map and return @@ -163,7 +163,7 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta /** Removes all elements from the set. After this operation is completed, * the set will be empty. */ - def clear() { for ((k, v) <- elements) -=(k) } + def clear() { for ((k, v) <- this.iterator) -=(k) } /** Check if this map maps <code>key</code> to a value. * Return that value if it exists, otherwise put <code>default</code> @@ -181,7 +181,7 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta * @param f The transformation to apply */ def transform(f: (A, B) => B): this.type = { - elements foreach { + this.iterator foreach { case (key, value) => update(key, f(key, value)) } this @@ -199,10 +199,10 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta } /** @return the values of this map as a set */ - override def valueSet: immutable.Set[B] = immutable.Set.empty[B] ++ (self map (_._2)) + override def values: collection.immutable.Set[B] = immutable.Set.empty[B] ++ (self map (_._2)) override def clone(): This = - empty ++ thisCollection + empty ++= thisCollection /** The result when this map is used as a builder */ def result: This = thisCollection diff --git a/src/library/scala/collection/generic/MutableSetTemplate.scala b/src/library/scala/collection/generic/MutableSetTemplate.scala index bd2a094c96..40386fe27b 100644 --- a/src/library/scala/collection/generic/MutableSetTemplate.scala +++ b/src/library/scala/collection/generic/MutableSetTemplate.scala @@ -17,7 +17,7 @@ import script._ * To implement a concrete mutable set, you need to provide implementations of the following methods: * * def contains(elem: A): Boolean - * def elements: Iterator[A] + * def iterator: Iterator[A] * def += (elem: A): this.type * def -= (elem: A): this.type * @@ -204,7 +204,7 @@ trait MutableSetTemplate[A, +This <: MutableSetTemplate[A, This] with mutable.Se case Include(_, x) => this += x case Remove(_, x) => this -= x case Reset() => clear - case s: Script[_] => s.elements foreach << + case s: Script[_] => s.iterator foreach << case _ => throw new UnsupportedOperationException("message " + cmd + " not understood") } }
\ No newline at end of file diff --git a/src/library/scala/collection/generic/MutableVectorTemplate.scala b/src/library/scala/collection/generic/MutableVectorTemplate.scala index cfc65de9ec..a0cdfb0765 100644 --- a/src/library/scala/collection/generic/MutableVectorTemplate.scala +++ b/src/library/scala/collection/generic/MutableVectorTemplate.scala @@ -18,7 +18,7 @@ trait MutableVectorTemplate[A, +This <: MutableVectorTemplate[A, This] with muta */ override def view = new MutableVectorView[A, This] { protected lazy val underlying = self.thisCollection - override def elements = self.elements + override def iterator = self.iterator override def length = self.length override def apply(idx: Int) = self.apply(idx) override def update(idx: Int, elem: A) = self.update(idx, elem) diff --git a/src/library/scala/collection/generic/SequenceForwarder.scala b/src/library/scala/collection/generic/SequenceForwarder.scala index bf92128d41..354509da13 100644 --- a/src/library/scala/collection/generic/SequenceForwarder.scala +++ b/src/library/scala/collection/generic/SequenceForwarder.scala @@ -41,7 +41,7 @@ trait SequenceForwarder[+A] extends Sequence[A] with IterableForwarder[A] { override def prefixLength(p: A => Boolean) = underlying.prefixLength(p) override def indexWhere(p: A => Boolean, from: Int): Int = underlying.indexWhere(p, from) override def indexOf[B >: A](elem: B, from: Int): Int = underlying.indexOf(elem, from) - override def reversedElements: Iterator[A] = underlying.reversedElements + override def reverseIterator: Iterator[A] = underlying.reverseIterator override def startsWith[B](that: Sequence[B], offset: Int): Boolean = underlying.startsWith(that, offset) override def endsWith[B](that: Sequence[B]): Boolean = underlying.endsWith(that) override def indexOfSeq[B >: A](that: Sequence[B]): Int = underlying.indexOfSeq(that) diff --git a/src/library/scala/collection/generic/SequenceProxyTemplate.scala b/src/library/scala/collection/generic/SequenceProxyTemplate.scala index 1854267ad8..f6fed763b5 100644 --- a/src/library/scala/collection/generic/SequenceProxyTemplate.scala +++ b/src/library/scala/collection/generic/SequenceProxyTemplate.scala @@ -41,7 +41,7 @@ trait SequenceProxyTemplate[+A, +This <: SequenceTemplate[A, This] with Sequence override def lastIndexWhere(p: A => Boolean): Int = self.lastIndexWhere(p, length - 1) override def lastIndexWhere(p: A => Boolean, end: Int): Int = self.lastIndexWhere(p) override def reverse: This = self.reverse - override def reversedElements: Iterator[A] = self.reversedElements + override def reverseIterator: Iterator[A] = self.reverseIterator override def startsWith[B](that: Sequence[B], offset: Int): Boolean = self.startsWith(that, offset) override def startsWith[B](that: Sequence[B]): Boolean = self.startsWith(that) override def endsWith[B](that: Sequence[B]): Boolean = self.endsWith(that) diff --git a/src/library/scala/collection/generic/SequenceTemplate.scala b/src/library/scala/collection/generic/SequenceTemplate.scala index 8efbe9ebb8..736a230613 100644 --- a/src/library/scala/collection/generic/SequenceTemplate.scala +++ b/src/library/scala/collection/generic/SequenceTemplate.scala @@ -20,7 +20,7 @@ import generic._ * of type <code>A</code>. * It adds the following methods to class Iterable: * `length`, `lengthCompare`, `apply`, `isDefinedAt`, `segmentLength`, `prefixLengh`, - * `indexWhere`, `indexOf`, `lastIndexWhere`, `lastIndexOf`, `reverse`, `reversedElements`, + * `indexWhere`, `indexOf`, `lastIndexWhere`, `lastIndexOf`, `reverse`, `reverseIterator`, * `startsWith`, `endsWith`, `indexOfSeq`, , `zip`, `zipAll`, `zipWithIndex`. * * @@ -77,8 +77,8 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]] */ def zip[A1 >: A, B, That](that: Sequence[B])(implicit bf: BuilderFactory[(A1, B), That, This]): That = { val b = bf(thisCollection) - val these = this.elements - val those = that.elements + val these = this.iterator + val those = that.iterator while (these.hasNext && those.hasNext) b += ((these.next, those.next)) b.result @@ -106,8 +106,8 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]] */ def zipAll[B, A1 >: A, That](that: Sequence[B], thisElem: A1, thatElem: B)(implicit bf: BuilderFactory[(A1, B), That, This]): That = { val b = bf(thisCollection) - val these = this.elements - val those = that.elements + val these = this.iterator + val those = that.iterator while (these.hasNext && those.hasNext) b += ((these.next, those.next)) while (these.hasNext) @@ -242,7 +242,7 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]] */ def lastIndexWhere(p: A => Boolean, end: Int): Int = { var i = length - 1 - val it = reversedElements + val it = reverseIterator while (it.hasNext && { val elem = it.next; (i > end || !p(elem)) }) i -= 1 i } @@ -266,7 +266,10 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]] /** The elements of this sequence in reversed order */ - def reversedElements: Iterator[A] = reverse.elements + def reverseIterator: Iterator[A] = reverse.iterator + + /** @deprecated use `reverseIterator` instead */ + @deprecated def reversedElements = reverseIterator /** * Checks whether the argument sequence is contained at the @@ -282,8 +285,8 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]] * @see String.startsWith */ def startsWith[B](that: Sequence[B], offset: Int): Boolean = { - val i = elements.drop(offset) - val j = that.elements + val i = this.iterator.drop(offset) + val j = that.iterator while (j.hasNext && i.hasNext) { if (i.next != j.next) return false } @@ -302,8 +305,8 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]] * @see String.endsWith */ def endsWith[B](that: Sequence[B]): Boolean = { - val i = this.elements.drop(length - that.length) - val j = that.elements + val i = this.iterator.drop(length - that.length) + val j = that.iterator while (i.hasNext && j.hasNext && i.next == j.next) () !j.hasNext } @@ -467,7 +470,7 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]] override def view = new SequenceView[A, This] { protected lazy val underlying = self.thisCollection - override def elements = self.elements + override def iterator = self.iterator override def length = self.length override def apply(idx: Int) = self.apply(idx) } @@ -476,8 +479,8 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]] override def equals(that: Any): Boolean = that match { case that1: Sequence[a] => - val these = this.elements - val those = that1.elements + val these = this.iterator + val those = that1.iterator while (these.hasNext && those.hasNext && these.next() == those.next()) {} !these.hasNext && !those.hasNext case _ => @@ -507,8 +510,8 @@ trait SequenceTemplate[+A, +This <: IterableTemplate[A, This] with Sequence[A]] * <code>(s1, s2) forall { case (x, y) => f(x, y) }</code> */ @deprecated def equalsWith[B](that: Sequence[B])(f: (A,B) => Boolean): Boolean = { - val i = this.elements - val j = that.elements + val i = this.iterator + val j = that.iterator while (i.hasNext && j.hasNext && f(i.next, j.next)) () !i.hasNext && !j.hasNext } diff --git a/src/library/scala/collection/generic/SequenceViewTemplate.scala b/src/library/scala/collection/generic/SequenceViewTemplate.scala index 943fd9a80e..b11696ebaf 100644 --- a/src/library/scala/collection/generic/SequenceViewTemplate.scala +++ b/src/library/scala/collection/generic/SequenceViewTemplate.scala @@ -102,7 +102,7 @@ trait SequenceViewTemplate[+A, } trait Reversed extends Transformed[A] { - override def elements: Iterator[A] = self.reversedElements + override def iterator: Iterator[A] = self.reverseIterator override def length: Int = self.length override def apply(idx: Int): A = self.apply(length - 1 - idx) override def stringPrefix = super.stringPrefix+"R" @@ -113,7 +113,7 @@ trait SequenceViewTemplate[+A, protected[this] val patch: Sequence[B] protected[this] val replaced: Int private val plen = patch.length - override def elements: Iterator[B] = self.elements patch (from, patch.elements, replaced) + override def iterator: Iterator[B] = self.iterator patch (from, patch.iterator, replaced) override def length: Int = self.length + plen - replaced override def apply(idx: Int): B = if (idx < from) self.apply(idx) @@ -124,7 +124,7 @@ trait SequenceViewTemplate[+A, trait Zipped[B] extends Transformed[(A, B)] { protected[this] val other: Sequence[B] - override def elements: Iterator[(A, B)] = self.elements zip other.elements + override def iterator: Iterator[(A, B)] = self.iterator zip other.iterator override def length = self.length min other.length override def apply(idx: Int): (A, B) = (self.apply(idx), other.apply(idx)) override def stringPrefix = super.stringPrefix+"Z" diff --git a/src/library/scala/collection/generic/SetTemplate.scala b/src/library/scala/collection/generic/SetTemplate.scala index 4556f81976..cce6ec4229 100644 --- a/src/library/scala/collection/generic/SetTemplate.scala +++ b/src/library/scala/collection/generic/SetTemplate.scala @@ -15,7 +15,7 @@ package scala.collection.generic * (where `This` is the type of the set in question): * * def contains(key: A): Boolean - * def elements: Iterator[A] + * def iterator: Iterator[A] * def +(elem: A): This * def -(elem: A): This * diff --git a/src/library/scala/collection/generic/Sorted.scala b/src/library/scala/collection/generic/Sorted.scala index 007629811f..a8e45cc3a4 100644 --- a/src/library/scala/collection/generic/Sorted.scala +++ b/src/library/scala/collection/generic/Sorted.scala @@ -27,7 +27,7 @@ trait Sorted[K, +This <: Sorted[K, This]] extends Ranged[K, This] { */ def to(to: K): This = { // tough! - val i = keySet.from(to).elements; + val i = keySet.from(to).iterator; if (!i.hasNext) return thisCollection val next = i.next; if (next == to) { @@ -37,7 +37,7 @@ trait Sorted[K, +This <: Sorted[K, This]] extends Ranged[K, This] { } protected def hasAll(j: Iterator[K]): Boolean = { - val i = keySet.elements; + val i = keySet.iterator; if (!i.hasNext) return !j.hasNext; var in = i.next; while (j.hasNext) { diff --git a/src/library/scala/collection/generic/SortedSetTemplate.scala b/src/library/scala/collection/generic/SortedSetTemplate.scala index 4d02e93ba0..189131173b 100644 --- a/src/library/scala/collection/generic/SortedSetTemplate.scala +++ b/src/library/scala/collection/generic/SortedSetTemplate.scala @@ -32,7 +32,7 @@ self => override def range(from: A, until: A): This = rangeImpl(Some(from), Some(until)) override def subsetOf(that: Set[A]): Boolean = that match { - case that: SortedSet[_] => that.hasAll(elements) + case that: SortedSet[_] => that.hasAll(this.iterator) case that => super.subsetOf(that) } } diff --git a/src/library/scala/collection/generic/TraversableTemplate.scala b/src/library/scala/collection/generic/TraversableTemplate.scala index 721ee16df4..32402217c8 100644 --- a/src/library/scala/collection/generic/TraversableTemplate.scala +++ b/src/library/scala/collection/generic/TraversableTemplate.scala @@ -657,7 +657,7 @@ self => /** Returns a list with all elements of this traversable object. * @note Will not terminate for infinite-sized collections. */ - def toList: List[A] = (new ListBuffer[A] ++ thisCollection).toList + def toList: List[A] = (new ListBuffer[A] ++= thisCollection).toList /** Returns an iterable with all elements in this traversable object. * @note Will not terminate for infinite-sized collections. diff --git a/src/library/scala/collection/generic/TraversableView.scala b/src/library/scala/collection/generic/TraversableView.scala index c89639bab1..deacb1b5bb 100644 --- a/src/library/scala/collection/generic/TraversableView.scala +++ b/src/library/scala/collection/generic/TraversableView.scala @@ -20,7 +20,8 @@ trait TraversableView[+A, +Coll <: Traversable[_]] extends TraversableViewTempla object TraversableView { class NoBuilder[A] extends Builder[A, Nothing] { def +=(elem: A): this.type = this - def elements: Iterator[A] = Iterator.empty + def iterator: Iterator[A] = Iterator.empty + @deprecated def elements = iterator def result() = throw new UnsupportedOperationException("TraversableView.Builder.result") def clear() {} } diff --git a/src/library/scala/collection/generic/TraversableView.scala.1 b/src/library/scala/collection/generic/TraversableView.scala.1 index a080c816fe..916f1182ff 100755 --- a/src/library/scala/collection/generic/TraversableView.scala.1 +++ b/src/library/scala/collection/generic/TraversableView.scala.1 @@ -137,7 +137,8 @@ self => object TraversableView { class NoBuilder[A] extends Builder[A, Nothing, TraversableView[_, _]] { def +=(elem: A) {} - def elements: Iterator[A] = Iterator.empty + def iterator: Iterator[A] = Iterator.empty + @deprecated def elements = iterator def result() = throw new UnsupportedOperationException("TraversableView.Builder.result") def clear() {} } diff --git a/src/library/scala/collection/generic/VectorTemplate.scala b/src/library/scala/collection/generic/VectorTemplate.scala index 2c1d8496d5..549485ed40 100644 --- a/src/library/scala/collection/generic/VectorTemplate.scala +++ b/src/library/scala/collection/generic/VectorTemplate.scala @@ -24,7 +24,7 @@ trait VectorTemplate[+A, +This <: VectorTemplate[A, This] with Vector[A]] extend // Overridden methods from IterableTemplate - /** The iterator returned by the elements method + /** The iterator returned by the iterator method */ protected class Elements(start: Int, end: Int) extends scala.collection.BufferedIterator[A] { private var i = start @@ -52,7 +52,7 @@ trait VectorTemplate[+A, +This <: VectorTemplate[A, This] with Vector[A]] extend else this } - override def elements: Iterator[A] = new Elements(0, length) + override def iterator: Iterator[A] = new Elements(0, length) override def isEmpty: Boolean = { length == 0 } @@ -205,7 +205,7 @@ trait VectorTemplate[+A, +This <: VectorTemplate[A, This] with Vector[A]] extend b.result } - override def reversedElements: Iterator[A] = new Iterator[A] { + override def reverseIterator: Iterator[A] = new Iterator[A] { private var i = self.length def hasNext: Boolean = 0 < i def next: A = @@ -229,7 +229,7 @@ trait VectorTemplate[+A, +This <: VectorTemplate[A, This] with Vector[A]] extend case _ => var i = offset val thisLen = length - val thatElems = that.elements + val thatElems = that.iterator while (i < thisLen && thatElems.hasNext && this(i) == thatElems.next()) { i += 1 } @@ -272,7 +272,7 @@ trait VectorTemplate[+A, +This <: VectorTemplate[A, This] with Vector[A]] extend override def view = new VectorView[A, This] { protected lazy val underlying = self.thisCollection - override def elements = self.elements + override def iterator = self.iterator override def length = self.length override def apply(idx: Int) = self.apply(idx) } diff --git a/src/library/scala/collection/immutable/HashMap.scala b/src/library/scala/collection/immutable/HashMap.scala index 351cbf60d8..c20dc017f8 100644 --- a/src/library/scala/collection/immutable/HashMap.scala +++ b/src/library/scala/collection/immutable/HashMap.scala @@ -107,9 +107,9 @@ class HashMap[A, +B] extends Map[A,B] with ImmutableMapTemplate[A, B, HashMap[A, s } - def elements = synchronized { + def iterator = synchronized { makeCopyIfUpdated() - entries map {e => (e.key, getValue(e))} + entriesIterator map {e => (e.key, getValue(e))} } private def getValue(e: Entry) = diff --git a/src/library/scala/collection/immutable/HashSet.scala b/src/library/scala/collection/immutable/HashSet.scala index 86efa9c6c6..215fe80914 100644 --- a/src/library/scala/collection/immutable/HashSet.scala +++ b/src/library/scala/collection/immutable/HashSet.scala @@ -81,11 +81,11 @@ class HashSet[A] extends Set[A] s } - override def elements = synchronized { + override def iterator = synchronized { makeCopyIfUpdated() // note need to cache because (later versions of) set might be mutated while elements are traversed. - val cached = new mutable.ArrayBuffer() ++ super.elements - cached.elements + val cached = new mutable.ArrayBuffer() ++= super.iterator + cached.iterator } private def logLimit: Int = Math.sqrt(table.length).toInt diff --git a/src/library/scala/collection/immutable/ImmutableIterator.scala.disabled b/src/library/scala/collection/immutable/ImmutableIterator.scala.disabled index 7733c17bec..0cdfc4a988 100644 --- a/src/library/scala/collection/immutable/ImmutableIterator.scala.disabled +++ b/src/library/scala/collection/immutable/ImmutableIterator.scala.disabled @@ -104,7 +104,10 @@ sealed abstract class ImmutableIterator[+A] { /** Converts this immutable iterator into a conventional iterator. */ - def elements: Iterator[A] = new Elements + def iterator: Iterator[A] = new Elements + + @deprecated def elements = iterator + } diff --git a/src/library/scala/collection/immutable/IntMap.scala b/src/library/scala/collection/immutable/IntMap.scala index a7b66628bb..32ad7fca42 100644 --- a/src/library/scala/collection/immutable/IntMap.scala +++ b/src/library/scala/collection/immutable/IntMap.scala @@ -145,7 +145,7 @@ sealed abstract class IntMap[+T] extends scala.collection.immutable.Map[Int, T] /** * Iterator over key, value pairs of the map in unsigned order of the keys. */ - def elements : Iterator[(Int, T)] = this match { + def iterator : Iterator[(Int, T)] = this match { case IntMap.Nil => Iterator.empty; case _ => new IntMapEntryIterator(this); } @@ -159,7 +159,7 @@ sealed abstract class IntMap[+T] extends scala.collection.immutable.Map[Int, T] case IntMap.Nil => {}; } - override def keys : Iterator[Int] = this match { + override def keysIterator : Iterator[Int] = this match { case IntMap.Nil => Iterator.empty; case _ => new IntMapKeyIterator(this); } @@ -176,7 +176,7 @@ sealed abstract class IntMap[+T] extends scala.collection.immutable.Map[Int, T] case IntMap.Nil => {} } - override def values : Iterator[T] = this match { + override def valuesIterator : Iterator[T] = this match { case IntMap.Nil => Iterator.empty; case _ => new IntMapValueIterator(this); } diff --git a/src/library/scala/collection/immutable/List.scala b/src/library/scala/collection/immutable/List.scala index 9a205e97c4..38ddfee8b5 100644 --- a/src/library/scala/collection/immutable/List.scala +++ b/src/library/scala/collection/immutable/List.scala @@ -74,7 +74,7 @@ sealed abstract class List[+A] extends LinearSequence[A] */ def :::[B >: A](prefix: List[B]): List[B] = if (isEmpty) prefix - else (new ListBuffer[B] ++ prefix).prependToList(this) + else (new ListBuffer[B] ++= prefix).prependToList(this) /** Reverse the given prefix and append the current list to that. * This function is equivalent to an application of <code>reverse</code> @@ -807,7 +807,7 @@ object List extends SequenceFactory[List] { * <code>[a<sub>0</sub>, ..., a<sub>k</sub>]</code>, * <code>[b<sub>0</sub>, ..., b<sub>l</sub>]</code> and * <code>n = min(k,l)</code> - * @deprecated use (xs, ys).forall(f) instead + * @deprecated use (xs, ys).exists(f) instead */ @deprecated def exists2[A,B](xs: List[A], ys: List[B])(f: (A, B) => Boolean): Boolean = { var xc = xs diff --git a/src/library/scala/collection/immutable/ListMap.scala b/src/library/scala/collection/immutable/ListMap.scala index 5c57715409..816018bf28 100644 --- a/src/library/scala/collection/immutable/ListMap.scala +++ b/src/library/scala/collection/immutable/ListMap.scala @@ -86,14 +86,14 @@ class ListMap[A, +B] extends Map[A, B] with ImmutableMapTemplate[A, B, ListMap[A /** Returns an iterator over key-value pairs. */ - def elements: Iterator[(A,B)] = + def iterator: Iterator[(A,B)] = new Iterator[(A,B)] { var self: ListMap[A,B] = ListMap.this def hasNext = !self.isEmpty def next: (A,B) = if (!hasNext) throw new NoSuchElementException("next on empty iterator") else { val res = (self.key, self.value); self = self.next; res } - }.toList.reverse.elements + }.toList.reverseIterator protected def key: A = throw new NoSuchElementException("empty map") protected def value: B = throw new NoSuchElementException("empty map") diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala index 210413171b..8dc961a308 100644 --- a/src/library/scala/collection/immutable/ListSet.scala +++ b/src/library/scala/collection/immutable/ListSet.scala @@ -62,7 +62,7 @@ class ListSet[A] extends Set[A] * @throws Predef.NoSuchElementException * @return the new iterator */ - def elements: Iterator[A] = new Iterator[A] { + def iterator: Iterator[A] = new Iterator[A] { var that: ListSet[A] = self; def hasNext = !that.isEmpty; def next: A = @@ -70,6 +70,8 @@ class ListSet[A] extends Set[A] else { val res = that.elem; that = that.next; res } } + @deprecated def elements = iterator + /** * @throws Predef.NoSuchElementException */ diff --git a/src/library/scala/collection/immutable/LongMap.scala b/src/library/scala/collection/immutable/LongMap.scala index f30f9eb17d..346e97345f 100644 --- a/src/library/scala/collection/immutable/LongMap.scala +++ b/src/library/scala/collection/immutable/LongMap.scala @@ -146,7 +146,7 @@ sealed abstract class LongMap[+T] extends scala.collection.immutable.Map[Long, T /** * Iterator over key, value pairs of the map in unsigned order of the keys. */ - def elements : Iterator[(Long, T)] = this match { + def iterator: Iterator[(Long, T)] = this match { case LongMap.Nil => Iterator.empty; case _ => new LongMapEntryIterator(this); } @@ -160,7 +160,7 @@ sealed abstract class LongMap[+T] extends scala.collection.immutable.Map[Long, T case LongMap.Nil => {}; } - override def keys : Iterator[Long] = this match { + override def keysIterator : Iterator[Long] = this match { case LongMap.Nil => Iterator.empty; case _ => new LongMapKeyIterator(this); } @@ -177,7 +177,7 @@ sealed abstract class LongMap[+T] extends scala.collection.immutable.Map[Long, T case LongMap.Nil => {} } - override def values : Iterator[T] = this match { + override def valuesIterator : Iterator[T] = this match { case LongMap.Nil => Iterator.empty; case _ => new LongMapValueIterator(this); } diff --git a/src/library/scala/collection/immutable/Map.scala b/src/library/scala/collection/immutable/Map.scala index 103d8f3d5a..ef3c3006f0 100644 --- a/src/library/scala/collection/immutable/Map.scala +++ b/src/library/scala/collection/immutable/Map.scala @@ -48,7 +48,7 @@ object Map extends ImmutableMapFactory[Map] { class WithDefault[A, +B](underlying: Map[A, B], d: A => B) extends Map[A, B] { override def size = underlying.size def get(key: A) = underlying.get(key) - def elements = underlying.elements + def iterator = underlying.iterator override def empty = new WithDefault(underlying.empty, d) override def updated[B1 >: B](key: A, value: B1): WithDefault[A, B1] = new WithDefault[A, B1](underlying.updated[B1](key, value), d) def + [B1 >: B](kv: (A, B1)): WithDefault[A, B1] = updated(kv._1, kv._2) @@ -60,7 +60,7 @@ object Map extends ImmutableMapFactory[Map] { class EmptyMap[A, +B] extends Map[A, B] { override def size: Int = 0 def get(key: A): Option[B] = None - def elements: Iterator[(A, B)] = Iterator.empty + def iterator: Iterator[(A, B)] = Iterator.empty override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] = new Map1(key, value) def + [B1 >: B](kv: (A, B1)): Map[A, B1] = updated(kv._1, kv._2) def - (key: A): Map[A, B] = this @@ -71,7 +71,7 @@ object Map extends ImmutableMapFactory[Map] { override def size = 1 def get(key: A): Option[B] = if (key == key1) Some(value1) else None - def elements = Iterator((key1, value1)) + def iterator = Iterator((key1, value1)) override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] = if (key == key1) new Map1(key1, value) else new Map2(key1, value1, key, value) @@ -90,7 +90,7 @@ object Map extends ImmutableMapFactory[Map] { if (key == key1) Some(value1) else if (key == key2) Some(value2) else None - def elements = Iterator((key1, value1), (key2, value2)) + def iterator = Iterator((key1, value1), (key2, value2)) override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] = if (key == key1) new Map2(key1, value, key2, value2) else if (key == key2) new Map2(key1, value1, key2, value) @@ -113,7 +113,7 @@ object Map extends ImmutableMapFactory[Map] { else if (key == key2) Some(value2) else if (key == key3) Some(value3) else None - def elements = Iterator((key1, value1), (key2, value2), (key3, value3)) + def iterator = Iterator((key1, value1), (key2, value2), (key3, value3)) override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] = if (key == key1) new Map3(key1, value, key2, value2, key3, value3) else if (key == key2) new Map3(key1, value1, key2, value, key3, value3) @@ -139,7 +139,7 @@ object Map extends ImmutableMapFactory[Map] { else if (key == key3) Some(value3) else if (key == key4) Some(value4) else None - def elements = Iterator((key1, value1), (key2, value2), (key3, value3), (key4, value4)) + def iterator = Iterator((key1, value1), (key2, value2), (key3, value3), (key4, value4)) override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] = if (key == key1) new Map4(key1, value, key2, value2, key3, value3, key4, value4) else if (key == key2) new Map4(key1, value1, key2, value, key3, value3, key4, value4) diff --git a/src/library/scala/collection/immutable/PagedSeq.scala b/src/library/scala/collection/immutable/PagedSeq.scala index 85eca5777b..fe34195238 100644 --- a/src/library/scala/collection/immutable/PagedSeq.scala +++ b/src/library/scala/collection/immutable/PagedSeq.scala @@ -34,7 +34,7 @@ object PagedSeq { /** Constructs a character sequence from a character iterable */ def fromIterable[T](source: Iterable[T]): PagedSeq[T] = - fromIterator(source.elements) + fromIterator(source.iterator) /** Constructs a character sequence from a string iterator */ def fromStrings(source: Iterator[String]): PagedSeq[Char] = { @@ -55,7 +55,7 @@ object PagedSeq { /** Constructs a character sequence from a string iterable */ def fromStrings(source: Iterable[String]): PagedSeq[Char] = - fromStrings(source.elements) + fromStrings(source.iterator) /** Constructs a character sequence from a line iterator * Lines do not contain trailing `\n' characters; The method inserts @@ -77,7 +77,7 @@ object PagedSeq { * a line separator `\n' between any two lines in the sequence. */ def fromLines(source: Iterable[String]): PagedSeq[Char] = - fromLines(source.elements) + fromLines(source.iterator) /** Constructs a character sequence from an input reader */ @@ -180,7 +180,7 @@ class PagedSeq[T] protected (more: (Array[T], Int, Int) => Int, /** Convert sequence to string */ override def toString = { val buf = new StringBuilder - for (ch <- elements) buf append ch + for (ch <- PagedSeq.this.iterator) buf append ch buf.toString } } diff --git a/src/library/scala/collection/immutable/Queue.scala b/src/library/scala/collection/immutable/Queue.scala index f7d2da9a09..dd61c2271c 100644 --- a/src/library/scala/collection/immutable/Queue.scala +++ b/src/library/scala/collection/immutable/Queue.scala @@ -29,7 +29,7 @@ object Queue { class Queue[+A](elem: A*) extends Seq[A] { protected val in: List[A] = Nil - protected val out: List[A] = elem.elements.toList + protected val out: List[A] = elem.iterator.toList protected def mkQueue[A](i: List[A], o: List[A]): Queue[A] = new Queue[A]() { @@ -56,7 +56,7 @@ class Queue[+A](elem: A*) extends Seq[A] { /** Returns the elements in the list as an iterator */ - override def elements: Iterator[A] = (out ::: in.reverse).elements + override def iterator: Iterator[A] = (out ::: in.reverse).iterator /** Checks if the queue is empty. * @@ -96,7 +96,7 @@ class Queue[+A](elem: A*) extends Seq[A] { */ @deprecated def +[B >: A](iter: Iterable[B]) = { var q: List[B] = in - iter.elements.foreach(e => q = e :: q) + iter.iterator.foreach(e => q = e :: q) mkQueue(q, out) } @@ -110,7 +110,7 @@ class Queue[+A](elem: A*) extends Seq[A] { */ def enqueue[B >: A](iter: Iterable[B]) = { var q: List[B] = in - iter.elements.foreach(e => q = e :: q) + iter.iterator.foreach(e => q = e :: q) mkQueue(q, out) } diff --git a/src/library/scala/collection/immutable/RedBlack.scala b/src/library/scala/collection/immutable/RedBlack.scala index c50dba65f5..a13250363d 100644 --- a/src/library/scala/collection/immutable/RedBlack.scala +++ b/src/library/scala/collection/immutable/RedBlack.scala @@ -32,7 +32,8 @@ abstract class RedBlack[A] { /** @deprecated use foreach instead */ @deprecated def visit[T](input : T)(f : (T,A,B) => Tuple2[Boolean,T]) : Tuple2[Boolean,T]; def toStream: Stream[(A,B)] - def elements: Iterator[Pair[A, B]] + def iterator: Iterator[(A, B)] + @deprecated def elements = iterator def upd[B1 >: B](k: A, v: B1): Tree[B1] def del(k: A): Tree[B] def smallest: NonEmpty[B] @@ -87,8 +88,8 @@ abstract class RedBlack[A] { def toStream: Stream[(A,B)] = left.toStream append Stream((key,value)) append right.toStream - def elements: Iterator[Pair[A, B]] = - left.elements append Iterator.single(Pair(key, value)) append right.elements + def iterator: Iterator[(A, B)] = + left.iterator append Iterator.single(Pair(key, value)) append right.iterator def foreach[U](f: (A, B) => U) { left foreach f @@ -129,7 +130,7 @@ abstract class RedBlack[A] { def upd[B](k: A, v: B): Tree[B] = RedTree(k, v, Empty, Empty) def del(k: A): Tree[Nothing] = this def smallest: NonEmpty[Nothing] = throw new NoSuchElementException("empty map") - def elements: Iterator[Pair[A, Nothing]] = Iterator.empty + def iterator: Iterator[(A, Nothing)] = Iterator.empty def toStream: Stream[(A,Nothing)] = Stream.empty def foreach[U](f: (A, Nothing) => U) {} diff --git a/src/library/scala/collection/immutable/Set.scala b/src/library/scala/collection/immutable/Set.scala index 78aaa54f1c..8acf786358 100644 --- a/src/library/scala/collection/immutable/Set.scala +++ b/src/library/scala/collection/immutable/Set.scala @@ -17,7 +17,7 @@ import generic._ * have to provide functionality for the abstract methods in Set: * * def contains(elem: A): Boolean - * def elements: Iterator[A] + * def iterator: Iterator[A] * def + (elem: A): This * def - (elem: A): This * @@ -48,7 +48,8 @@ object Set extends SetFactory[Set] { def contains(elem: A): Boolean = false def + (elem: A): Set[A] = new Set1(elem) def - (elem: A): Set[A] = this - def elements: Iterator[A] = Iterator.empty + def iterator: Iterator[A] = Iterator.empty + @deprecated def elements = iterator override def foreach[U](f: A => U): Unit = {} } @@ -64,8 +65,9 @@ object Set extends SetFactory[Set] { def - (elem: A): Set[A] = if (elem == elem1) new EmptySet[A] else this - def elements: Iterator[A] = + def iterator: Iterator[A] = Iterator(elem1) + @deprecated def elements = iterator override def foreach[U](f: A => U): Unit = { f(elem1) } @@ -84,8 +86,9 @@ object Set extends SetFactory[Set] { if (elem == elem1) new Set1(elem2) else if (elem == elem2) new Set1(elem1) else this - def elements: Iterator[A] = + def iterator: Iterator[A] = Iterator(elem1, elem2) + @deprecated def elements = iterator override def foreach[U](f: A => U): Unit = { f(elem1); f(elem2) } @@ -105,8 +108,9 @@ object Set extends SetFactory[Set] { else if (elem == elem2) new Set2(elem1, elem3) else if (elem == elem3) new Set2(elem1, elem2) else this - def elements: Iterator[A] = + def iterator: Iterator[A] = Iterator(elem1, elem2, elem3) + @deprecated def elements = iterator override def foreach[U](f: A => U): Unit = { f(elem1); f(elem2); f(elem3) } @@ -127,8 +131,9 @@ object Set extends SetFactory[Set] { else if (elem == elem3) new Set3(elem1, elem2, elem4) else if (elem == elem4) new Set3(elem1, elem2, elem3) else this - def elements: Iterator[A] = + def iterator: Iterator[A] = Iterator(elem1, elem2, elem3, elem4) + @deprecated def elements = iterator override def foreach[U](f: A => U): Unit = { f(elem1); f(elem2); f(elem3); f(elem4) } diff --git a/src/library/scala/collection/immutable/Stack.scala b/src/library/scala/collection/immutable/Stack.scala index 7be6635853..04e9251bec 100644 --- a/src/library/scala/collection/immutable/Stack.scala +++ b/src/library/scala/collection/immutable/Stack.scala @@ -105,7 +105,7 @@ class Stack[+A] extends Sequence[A] { * * @return an iterator over all stack elements. */ - override def elements: Iterator[A] = new Iterator[A] { + override def iterator: Iterator[A] = new Iterator[A] { private var cur = Stack.this def hasNext: Boolean = !cur.isEmpty def next: A = { val r = top; cur = cur.pop; r } diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala index 7b5e3f7659..538e9d85fe 100644 --- a/src/library/scala/collection/immutable/Stream.scala +++ b/src/library/scala/collection/immutable/Stream.scala @@ -184,7 +184,7 @@ self => * @param p the predicate used to filter the stream. * @return the elements of this stream satisfying <code>p</code>. */ - override def partition(p: A => Boolean): (Stream[A], Stream[A]) = (filter(p(_)), remove(p(_))) + override def partition(p: A => Boolean): (Stream[A], Stream[A]) = (filter(p(_)), filterNot(p(_))) /** Returns a stream formed from this stream and the specified stream * <code>that</code> by associating each element of the former with @@ -200,7 +200,7 @@ self => def loop(these: Stream[A], elems2: Iterator[B]): Stream[(A1, B)] = if (these.isEmpty || !elems2.hasNext) Stream.Empty else new Stream.Cons((these.head, elems2.next), loop(these.tail, elems2)) - if (bf.isInstanceOf[Stream.StreamBuilderFactory[_]]) loop(this, that.elements).asInstanceOf[That] + if (bf.isInstanceOf[Stream.StreamBuilderFactory[_]]) loop(this, that.iterator).asInstanceOf[That] else super.zip[A1, B, That](that) } @@ -378,7 +378,7 @@ object Stream extends SequenceFactory[Stream] { * this builder should be bypassed. */ class StreamBuilder[A] extends LazyBuilder[A, Stream[A]] { - def result: Stream[A] = (for (xs <- parts.elements; x <- xs.toIterable.elements) yield x).toStream + def result: Stream[A] = (for (xs <- parts.iterator; x <- xs.toIterable.iterator) yield x).toStream } object Empty extends Stream[Nothing] { @@ -507,7 +507,7 @@ object Stream extends SequenceFactory[Stream] { /** The concatenation of a sequence of streams * @deprecated use xs.flatten instead */ - def concat[A](xs: Iterable[Stream[A]]): Stream[A] = concat(xs.elements) + def concat[A](xs: Iterable[Stream[A]]): Stream[A] = concat(xs.iterator) /** The concatenation of all streams returned by an iterator * @deprecated use xs.toStream.flatten instead diff --git a/src/library/scala/collection/immutable/TreeHashMap.scala b/src/library/scala/collection/immutable/TreeHashMap.scala index 780a69dfde..1b45a8b5b8 100644 --- a/src/library/scala/collection/immutable/TreeHashMap.scala +++ b/src/library/scala/collection/immutable/TreeHashMap.scala @@ -36,7 +36,7 @@ object TreeHashMap { * @author David MacIver */ class TreeHashMap[Key, +Value] private (private val underlying : IntMap[AssocMap[Key, Value]]) extends scala.collection.immutable.Map[Key, Value]{ - def elements : Iterator[(Key, Value)] = new Iterator[(Key, Value)]{ + def iterator : Iterator[(Key, Value)] = new Iterator[(Key, Value)]{ val assocIt = new AssocMapIterator(AssocMap.empty[Key, Value]); val intIterator = underlying.values; @@ -182,7 +182,9 @@ private[collection] sealed abstract class AssocMap[Key, +Value] extends immutabl case Nil() => AssocMap.empty; } - def elements : Iterator[(Key, Value)] = new AssocMapIterator(this); + def iterator : Iterator[(Key, Value)] = new AssocMapIterator(this) + + @deprecated def elements = iterator override final def foreach[U](f : ((Key, Value)) => U) = this match { case Cons(key, value, tail) => { f((key, value)); tail.foreach(f); } diff --git a/src/library/scala/collection/immutable/TreeMap.scala b/src/library/scala/collection/immutable/TreeMap.scala index 2298a64ba7..cff70586ab 100644 --- a/src/library/scala/collection/immutable/TreeMap.scala +++ b/src/library/scala/collection/immutable/TreeMap.scala @@ -112,7 +112,7 @@ class TreeMap[A, +B](override val size: Int, t: RedBlack[A]#Tree[B])(implicit va * * @return the new iterator */ - def elements: Iterator[(A, B)] = tree.toStream.elements + def iterator: Iterator[(A, B)] = tree.toStream.iterator override def toStream: Stream[(A, B)] = tree.toStream diff --git a/src/library/scala/collection/immutable/TreeSet.scala b/src/library/scala/collection/immutable/TreeSet.scala index 0f352356b8..93faa59b45 100644 --- a/src/library/scala/collection/immutable/TreeSet.scala +++ b/src/library/scala/collection/immutable/TreeSet.scala @@ -82,7 +82,9 @@ class TreeSet[A <% Ordered[A]](override val size: Int, t: RedBlack[A]#Tree[Unit] * * @return the new iterator */ - def elements: Iterator[A] = tree.toStream.elements map (_._1) + def iterator: Iterator[A] = tree.toStream.iterator map (_._1) + + @deprecated def elements = iterator override def toStream: Stream[A] = tree.toStream map (_._1) diff --git a/src/library/scala/collection/mutable/ArrayBuffer.scala b/src/library/scala/collection/mutable/ArrayBuffer.scala index ae17cc33b4..d25c55f4af 100644 --- a/src/library/scala/collection/mutable/ArrayBuffer.scala +++ b/src/library/scala/collection/mutable/ArrayBuffer.scala @@ -58,7 +58,7 @@ class ArrayBuffer[A](override protected val initialSize: Int) } /** Appends a number of elements provided by an iterable object - * via its <code>elements</code> method. The identity of the + * via its <code>iterator</code> method. The identity of the * buffer is returned. * * @param iter the iterfable object. @@ -91,7 +91,7 @@ class ArrayBuffer[A](override protected val initialSize: Int) } /** Prepends a number of elements provided by an iterable object - * via its <code>elements</code> method. The identity of the + * via its <code>iterator</code> method. The identity of the * buffer is returned. * * @param iter the iterable object. @@ -148,7 +148,7 @@ class ArrayBuffer[A](override protected val initialSize: Int) * * @return an <code>ArrayBuffer</code> with the same elements. */ - override def clone(): ArrayBuffer[A] = new ArrayBuffer[A] ++ this + override def clone(): ArrayBuffer[A] = new ArrayBuffer[A] ++= this def result: ArrayBuffer[A] = this diff --git a/src/library/scala/collection/mutable/ArrayStack.scala b/src/library/scala/collection/mutable/ArrayStack.scala index 8461191ff8..cae18452f3 100644 --- a/src/library/scala/collection/mutable/ArrayStack.scala +++ b/src/library/scala/collection/mutable/ArrayStack.scala @@ -153,7 +153,7 @@ class ArrayStack[T] private(private var table : Array[AnyRef], /** * Iterates over the stack in fifo order. */ - def elements = new Iterator[T]{ + def iterator: Iterator[T] = new Iterator[T]{ var currentIndex = index; def hasNext = currentIndex > 0; def next = { @@ -162,6 +162,8 @@ class ArrayStack[T] private(private var table : Array[AnyRef], } } + @deprecated def elements = iterator + override def foreach[U](f : T => U){ var currentIndex = index; while(currentIndex > 0){ diff --git a/src/library/scala/collection/mutable/BufferProxy.scala b/src/library/scala/collection/mutable/BufferProxy.scala index f430cae83d..b45e151da9 100644 --- a/src/library/scala/collection/mutable/BufferProxy.scala +++ b/src/library/scala/collection/mutable/BufferProxy.scala @@ -27,7 +27,7 @@ trait BufferProxy[A] extends Buffer[A] with Proxy { def length: Int = self.length - override def elements: Iterator[A] = self.elements + override def iterator: Iterator[A] = self.iterator def apply(n: Int): A = self.apply(n) @@ -48,7 +48,7 @@ trait BufferProxy[A] extends Buffer[A] with Proxy { override def readOnly = self.readOnly /** Appends a number of elements provided by an iterable object - * via its <code>elements</code> method. The identity of the + * via its <code>iterator</code> method. The identity of the * buffer is returned. * * @param iter the iterable object. @@ -57,7 +57,7 @@ trait BufferProxy[A] extends Buffer[A] with Proxy { override def ++(iter: Iterable[A]): Buffer[A] = self.++(iter) /** Appends a number of elements provided by an iterable object - * via its <code>elements</code> method. + * via its <code>iterator</code> method. * * @param iter the iterable object. */ @@ -70,7 +70,7 @@ trait BufferProxy[A] extends Buffer[A] with Proxy { override def append(elems: A*): Unit = self.++=(elems) /** Appends a number of elements provided by an iterable object - * via its <code>elements</code> method. + * via its <code>iterator</code> method. * * @param iter the iterable object. */ @@ -84,7 +84,7 @@ trait BufferProxy[A] extends Buffer[A] with Proxy { def +:(elem: A): Buffer[A] = self.+:(elem) /** Prepends a number of elements provided by an iterable object - * via its <code>elements</code> method. The identity of the + * via its <code>iterator</code> method. The identity of the * buffer is returned. * * @param iter the iterable object. @@ -98,7 +98,7 @@ trait BufferProxy[A] extends Buffer[A] with Proxy { override def prepend(elems: A*): Unit = self.prependAll(elems) /** Prepends a number of elements provided by an iterable object - * via its <code>elements</code> method. The identity of the + * via its <code>iterator</code> method. The identity of the * buffer is returned. * * @param iter the iterable object. diff --git a/src/library/scala/collection/mutable/DefaultMapModel.scala b/src/library/scala/collection/mutable/DefaultMapModel.scala index 9acf089506..f76a54c739 100644 --- a/src/library/scala/collection/mutable/DefaultMapModel.scala +++ b/src/library/scala/collection/mutable/DefaultMapModel.scala @@ -40,6 +40,7 @@ trait DefaultMapModel[A, B] extends Map[A, B] { def += (kv: (A, B)): this.type = { put(kv._1, kv._2); this } - def elements = entries map {e => (e.key, e.value)} + def iterator = entries map {e => (e.key, e.value)} + } diff --git a/src/library/scala/collection/mutable/FlatHashTable.scala b/src/library/scala/collection/mutable/FlatHashTable.scala index dd09af381e..de926e8108 100644 --- a/src/library/scala/collection/mutable/FlatHashTable.scala +++ b/src/library/scala/collection/mutable/FlatHashTable.scala @@ -113,7 +113,7 @@ trait FlatHashTable[A] { None } - def elements = new Iterator[A] { + def iterator = new Iterator[A] { private var i = 0 def hasNext: Boolean = { while (i < table.length && (null == table(i))) i += 1 @@ -124,6 +124,8 @@ trait FlatHashTable[A] { else Iterator.empty.next } + @deprecated def elements = iterator + private def growTable() { val oldtable = table table = new Array[AnyRef](table.length * 2) diff --git a/src/library/scala/collection/mutable/HashMap.scala b/src/library/scala/collection/mutable/HashMap.scala index f8ba594d4c..255358ae1f 100644 --- a/src/library/scala/collection/mutable/HashMap.scala +++ b/src/library/scala/collection/mutable/HashMap.scala @@ -54,7 +54,7 @@ class HashMap[A, B] extends Map[A, B] def -=(key: A): this.type = { removeEntry(key); this } - def elements = entries map {e => (e.key, e.value)} + def iterator = entriesIterator map {e => (e.key, e.value)} } /** This class implements mutable maps using a hashtable. diff --git a/src/library/scala/collection/mutable/HashSet.scala b/src/library/scala/collection/mutable/HashSet.scala index d5eba30552..20e5a1e6b5 100644 --- a/src/library/scala/collection/mutable/HashSet.scala +++ b/src/library/scala/collection/mutable/HashSet.scala @@ -48,7 +48,7 @@ class HashSet[A] extends Set[A] } } - override def clone(): HashSet[A] = new HashSet[A] ++ this + override def clone(): HashSet[A] = new HashSet[A] ++= this } /** Factory object for `HashSet` class */ diff --git a/src/library/scala/collection/mutable/HashTable.scala b/src/library/scala/collection/mutable/HashTable.scala index ada2df83b3..be0a84bd41 100644 --- a/src/library/scala/collection/mutable/HashTable.scala +++ b/src/library/scala/collection/mutable/HashTable.scala @@ -111,7 +111,7 @@ trait HashTable[A] extends AnyRef { /** An iterator returning all entries */ - protected def entries: Iterator[Entry] = new Iterator[Entry] { + protected def entriesIterator: Iterator[Entry] = new Iterator[Entry] { val iterTable = table var idx = table.length - 1 var es = iterTable(idx).asInstanceOf[Entry] @@ -131,6 +131,11 @@ trait HashTable[A] extends AnyRef { } } + /** An iterator returning all entries + * @deprecated use entriesIterator instead + */ + @deprecated protected def entries: Iterator[Entry] = entriesIterator + /** Remove all entries from table */ def clear() { diff --git a/src/library/scala/collection/mutable/History.scala b/src/library/scala/collection/mutable/History.scala index 6f2ab4b160..25fe640c2a 100644 --- a/src/library/scala/collection/mutable/History.scala +++ b/src/library/scala/collection/mutable/History.scala @@ -38,8 +38,8 @@ class History[A, B] extends AnyRef with Subscriber[A, B] with Collection[(B, A)] } override def size: Int = log.length - def elements: Iterator[(B, A)] = log.elements - def events: Iterator[A] = log.elements.map { case (_, e) => e } + def iterator: Iterator[(B, A)] = log.iterator + def events: Iterator[A] = log.iterator.map { case (_, e) => e } def clear(): Unit = log.clear } diff --git a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala index 12c8140d8a..86d8facfc4 100644 --- a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala +++ b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala @@ -40,13 +40,17 @@ extends Map[A, B] override def isDefinedAt(key: A) = imap.isDefinedAt(key) - override def keys: Iterator[A] = imap.keys + override def keys: collection.Set[A] = imap.keys - override def keySet: collection.Set[A] = imap.keySet + override def keysIterator: Iterator[A] = imap.keysIterator - override def values: Iterator[B] = imap.values + override def values: collection.Set[A] = imap.values - def elements: Iterator[(A, B)] = imap.elements + override def valuesIterator: Iterator[B] = imap.valuesIterator + + def iterator: Iterator[(A, B)] = imap.iterator + + @deprecated def elements = iterator override def toList: List[(A, B)] = imap.toList diff --git a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala index af25841f84..bac4f95246 100644 --- a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala +++ b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala @@ -39,7 +39,9 @@ class ImmutableSetAdaptor[A](protected var set: immutable.Set[A]) extends Set[A] override def toString = set.toString - def elements: Iterator[A] = set.elements + def iterator: Iterator[A] = set.iterator + + @deprecated override def elements: Iterator[A] = iterator def +=(elem: A): this.type = { set = set + elem; this } diff --git a/src/library/scala/collection/mutable/LinkedHashMap.scala b/src/library/scala/collection/mutable/LinkedHashMap.scala index 29e77fb01c..c43a3ee2f4 100644 --- a/src/library/scala/collection/mutable/LinkedHashMap.scala +++ b/src/library/scala/collection/mutable/LinkedHashMap.scala @@ -75,7 +75,7 @@ class LinkedHashMap[A, B] extends Map[A, B] def += (kv: (A, B)): this.type = { put(kv._1, kv._2); this } def -=(key: A): this.type = { remove(key); this } - def elements: Iterator[(A, B)] = new Iterator[(A, B)] { + def iterator: Iterator[(A, B)] = new Iterator[(A, B)] { private var cur = firstEntry def hasNext = cur ne null def next = @@ -83,7 +83,7 @@ class LinkedHashMap[A, B] extends Map[A, B] else Iterator.empty.next } - override def keys: Iterator[A] = new Iterator[A] { + override def keysIterator: Iterator[A] = new Iterator[A] { private var cur = firstEntry def hasNext = cur ne null def next = @@ -91,7 +91,7 @@ class LinkedHashMap[A, B] extends Map[A, B] else Iterator.empty.next } - override def values: Iterator[B] = new Iterator[B] { + override def valuesIterator: Iterator[B] = new Iterator[B] { private var cur = firstEntry def hasNext = cur ne null def next = { val res = cur.value; cur = cur.later; res } diff --git a/src/library/scala/collection/mutable/LinkedHashSet.scala b/src/library/scala/collection/mutable/LinkedHashSet.scala index 14f6b18722..f2825db975 100644 --- a/src/library/scala/collection/mutable/LinkedHashSet.scala +++ b/src/library/scala/collection/mutable/LinkedHashSet.scala @@ -47,7 +47,7 @@ class LinkedHashSet[A] extends Set[A] super.clear() } - override def elements = ordered.elements + override def iterator = ordered.iterator override def foreach[U](f: A => U) = ordered foreach f } diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala index a83f620699..c75e18dcd1 100644 --- a/src/library/scala/collection/mutable/ListBuffer.scala +++ b/src/library/scala/collection/mutable/ListBuffer.scala @@ -277,7 +277,7 @@ final class ListBuffer[A] this } - override def elements = new Iterator[A] { + override def iterator = new Iterator[A] { var cursor: List[A] = null def hasNext: Boolean = !start.isEmpty && cursor != last0 def next(): A = @@ -309,7 +309,7 @@ final class ListBuffer[A] * * @return a <code>ListBuffer</code> with the same elements. */ - override def clone(): ListBuffer[A] = (new ListBuffer[A]) ++ this + override def clone(): ListBuffer[A] = (new ListBuffer[A]) ++= this /** Defines the prefix of the string representation. * diff --git a/src/library/scala/collection/mutable/ListMap.scala b/src/library/scala/collection/mutable/ListMap.scala index 8b8e5d87a6..a0d844cb5d 100644 --- a/src/library/scala/collection/mutable/ListMap.scala +++ b/src/library/scala/collection/mutable/ListMap.scala @@ -23,7 +23,7 @@ class ListMap[A, B] extends Map[A, B] with MutableMapTemplate[A, B, ListMap[A, B private var siz: Int = 0 def get(key: A): Option[B] = elems find (_._1 == key) map (_._2) - def elements: Iterator[(A, B)] = elems.elements + def iterator: Iterator[(A, B)] = elems.iterator def += (kv: (A, B)) = { elems = remove(kv._1, elems); elems = kv :: elems; siz += 1; this } def -= (key: A) = { elems = remove(key, elems); this } diff --git a/src/library/scala/collection/mutable/Map.scala b/src/library/scala/collection/mutable/Map.scala index 94e376cd67..eab5b426a8 100644 --- a/src/library/scala/collection/mutable/Map.scala +++ b/src/library/scala/collection/mutable/Map.scala @@ -26,7 +26,7 @@ trait Map[A, B] override def size = self.size override def update(key: A, value: B) = self.update(key, value) override def - (elem: A) = self - elem - override def elements = self.elements + override def iterator = self.iterator override def foreach[U](f: ((A, B)) => U) = self.foreach(f) override def empty[C] = self.empty[C] def get(key: A) = self.get(key) diff --git a/src/library/scala/collection/mutable/MutableList.scala b/src/library/scala/collection/mutable/MutableList.scala index 605d511f05..a2a283f2c4 100644 --- a/src/library/scala/collection/mutable/MutableList.scala +++ b/src/library/scala/collection/mutable/MutableList.scala @@ -92,8 +92,8 @@ class MutableList[A] extends LinearSequence[A] with LinearSequenceTemplate[A, Mu /** Returns an iterator over all elements of this list. */ - override def elements: Iterator[A] = - if (first0 eq null) Iterator.empty else first0.elements + override def iterator: Iterator[A] = + if (first0 eq null) Iterator.empty else first0.iterator override def last = last0.elem diff --git a/src/library/scala/collection/mutable/OpenHashMap.scala b/src/library/scala/collection/mutable/OpenHashMap.scala index 5a0810cfe4..8373b4fdde 100644 --- a/src/library/scala/collection/mutable/OpenHashMap.scala +++ b/src/library/scala/collection/mutable/OpenHashMap.scala @@ -165,7 +165,7 @@ class OpenHashMap[Key, Value](initialSize : Int) extends scala.collection.mutabl * An iterator over the elements of this map. Use of this iterator follows the same * contract for concurrent modification as the foreach method. */ - def elements = new Iterator[(Key, Value)]{ + def iterator = new Iterator[(Key, Value)]{ var index = 0; val initialModCount = modCount; @@ -184,6 +184,9 @@ class OpenHashMap[Key, Value](initialSize : Int) extends scala.collection.mutabl } } + /** @deprecated use `iterator` instead */ + @deprecated override def elements: Iterator[(Key, Value)] = iterator + override def clone : OpenHashMap[Key, Value] = { val it = new OpenHashMap[Key, Value] foreachUndeletedEntry(entry => it.put(entry.key, entry.hash, entry.value.get)); diff --git a/src/library/scala/collection/mutable/PriorityQueue.scala b/src/library/scala/collection/mutable/PriorityQueue.scala index d013497389..1665c38dac 100644 --- a/src/library/scala/collection/mutable/PriorityQueue.scala +++ b/src/library/scala/collection/mutable/PriorityQueue.scala @@ -88,7 +88,7 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] with CloneableCol * * @param iter an iterable object */ - def ++=(iter: Iterable[A]): Unit = this ++= iter.elements + def ++=(iter: Iterable[A]): Unit = this ++= iter.iterator /** Adds all elements provided by an iterator into the priority queue. * @@ -138,7 +138,7 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] with CloneableCol * * @return an iterator over all elements sorted in descending order. */ - override def elements: Iterator[A] = new Iterator[A] { + override def iterator: Iterator[A] = new Iterator[A] { val as: Array[AnyRef] = new Array[AnyRef](size0) Array.copy(array, 0, as, 0, size0) var i = size0 - 1 @@ -158,7 +158,7 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] with CloneableCol */ override def equals(obj: Any): Boolean = obj match { case that: PriorityQueue[_] => - (this.elements zip that.elements) forall { + (this.iterator zip that.iterator) forall { case (thiselem, thatelem) => thiselem == thatelem } case _ => diff --git a/src/library/scala/collection/mutable/PriorityQueueProxy.scala b/src/library/scala/collection/mutable/PriorityQueueProxy.scala index 7eab4df05e..de909fa470 100644 --- a/src/library/scala/collection/mutable/PriorityQueueProxy.scala +++ b/src/library/scala/collection/mutable/PriorityQueueProxy.scala @@ -31,7 +31,7 @@ abstract class PriorityQueueProxy[A <% Ordered[A]] extends PriorityQueue[A] * * @return the new iterator */ - override def elements: Iterator[A] = self.elements + override def iterator: Iterator[A] = self.iterator /** Returns the length of this priority queue. */ diff --git a/src/library/scala/collection/mutable/QueueProxy.scala b/src/library/scala/collection/mutable/QueueProxy.scala index cfe364108a..cd3ca80c5e 100644 --- a/src/library/scala/collection/mutable/QueueProxy.scala +++ b/src/library/scala/collection/mutable/QueueProxy.scala @@ -90,7 +90,7 @@ trait QueueProxy[A] extends Queue[A] with SeqProxy[A] { * * @return an iterator over all queue elements. */ - override def elements: Iterator[A] = self.elements + override def iteratoor: Iterator[A] = self.iterator /** This method clones the queue. * diff --git a/src/library/scala/collection/mutable/Set.scala b/src/library/scala/collection/mutable/Set.scala index 8118f8a58f..d17dee1753 100644 --- a/src/library/scala/collection/mutable/Set.scala +++ b/src/library/scala/collection/mutable/Set.scala @@ -17,7 +17,7 @@ import generic._ * have to provide functionality for the abstract methods in Set: * * def contains(elem: A): Boolean - * def elements: Iterator[A] + * def iterator: Iterator[A] * def += (elem: A): this.type * def -= (elem: A): this.type * diff --git a/src/library/scala/collection/mutable/Stack.scala b/src/library/scala/collection/mutable/Stack.scala index b63a07dbb1..b079a94f92 100644 --- a/src/library/scala/collection/mutable/Stack.scala +++ b/src/library/scala/collection/mutable/Stack.scala @@ -111,7 +111,7 @@ class Stack[A] private (var elems: List[A]) extends collection.Sequence[A] with * * @return an iterator over all stack elements. */ - override def elements: Iterator[A] = elems.elements + override def iterator: Iterator[A] = elems.iterator /** Creates a list of all stack elements in LIFO order. * diff --git a/src/library/scala/collection/mutable/StackProxy.scala b/src/library/scala/collection/mutable/StackProxy.scala index 1833af0f33..cb7f180849 100644 --- a/src/library/scala/collection/mutable/StackProxy.scala +++ b/src/library/scala/collection/mutable/StackProxy.scala @@ -94,7 +94,7 @@ trait StackProxy[A] extends Stack[A] with SeqProxy[A] { * * @return an iterator over all stack elements. */ - override def elements: Iterator[A] = self.elements + override def iterator: Iterator[A] = self.iterator /** Creates a list of all stack elements in FIFO order. * diff --git a/src/library/scala/collection/mutable/SynchronizedBuffer.scala b/src/library/scala/collection/mutable/SynchronizedBuffer.scala index 4209dff391..58c8d749bb 100644 --- a/src/library/scala/collection/mutable/SynchronizedBuffer.scala +++ b/src/library/scala/collection/mutable/SynchronizedBuffer.scala @@ -26,8 +26,8 @@ trait SynchronizedBuffer[A] extends Buffer[A] { super.length } - abstract override def elements: Iterator[A] = synchronized { - super.elements + abstract override def iterator: Iterator[A] = synchronized { + super.iterator } abstract override def apply(n: Int): A = synchronized { @@ -52,7 +52,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] { } /** Appends a number of elements provided by an iterable object - * via its <code>elements</code> method. The identity of the + * via its <code>iterator</code> method. The identity of the * buffer is returned. * * @param iter the iterable object. @@ -62,7 +62,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] { } /** Appends a number of elements provided by an iterable object - * via its <code>elements</code> method. + * via its <code>iterator</code> method. * * @param iter the iterable object. */ @@ -79,7 +79,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] { } /** Appends a number of elements provided by an iterable object - * via its <code>elements</code> method. + * via its <code>iterator</code> method. * * @param iter the iterable object. */ @@ -97,7 +97,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] { } /** Prepends a number of elements provided by an iterable object - * via its <code>elements</code> method. The identity of the + * via its <code>iterator</code> method. The identity of the * buffer is returned. * * @param iter the iterable object. @@ -115,7 +115,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] { } /** Prepends a number of elements provided by an iterable object - * via its <code>elements</code> method. The identity of the + * via its <code>iterator</code> method. The identity of the * buffer is returned. * * @param iter the iterable object. diff --git a/src/library/scala/collection/mutable/SynchronizedMap.scala b/src/library/scala/collection/mutable/SynchronizedMap.scala index 4b30ce5d4b..61c9b50568 100644 --- a/src/library/scala/collection/mutable/SynchronizedMap.scala +++ b/src/library/scala/collection/mutable/SynchronizedMap.scala @@ -21,7 +21,7 @@ package scala.collection.mutable trait SynchronizedMap[A, B] extends Map[A, B] { abstract override def get(key: A): Option[B] = synchronized { super.get(key) } - abstract override def elements: Iterator[(A, B)] = synchronized { super.elements } + abstract override def iterator: Iterator[(A, B)] = synchronized { super.iterator } abstract override def += (kv: (A, B)): this.type = synchronized[this.type] { super.+=(kv) } abstract override def -= (key: A): this.type = synchronized[this.type] { super.-=(key) } @@ -33,11 +33,13 @@ trait SynchronizedMap[A, B] extends Map[A, B] { override def getOrElseUpdate(key: A, default: => B): B = synchronized { super.getOrElseUpdate(key, default) } override def transform(f: (A, B) => B): this.type = synchronized[this.type] { super.transform(f) } override def retain(p: (A, B) => Boolean): this.type = synchronized[this.type] { super.retain(p) } - override def valueSet = synchronized { super.valueSet } + override def values: collection.immutable.Set[B] = synchronized { super.values } + override def valuesIterator: Iterator[B] = synchronized { super.valuesIterator } override def clone() = synchronized { super.clone() } override def foreach[U](f: ((A, B)) => U) = synchronized { super.foreach(f) } override def apply(key: A): B = synchronized { super.apply(key) } - override def keys: Iterator[A] = synchronized { super.keys } + override def keys: collection.Set[A] = synchronized { super.keys } + override def keysIterator: Iterator[A] = synchronized { super.keysIterator } override def isEmpty: Boolean = synchronized { super.isEmpty } override def contains(key: A): Boolean = synchronized {super.contains(key) } override def isDefinedAt(key: A) = synchronized { super.isDefinedAt(key) } diff --git a/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala b/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala index f500b46aa0..65cb592f0b 100644 --- a/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala +++ b/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala @@ -77,7 +77,7 @@ class SynchronizedPriorityQueue[A <% Ordered[A]] extends PriorityQueue[A] { * * @return an iterator over all elements sorted in descending order. */ - override def elements: Iterator[A] = synchronized { super.elements } + override def iterator: Iterator[A] = synchronized { super.iterator } /** Checks if two queues are structurally identical. * diff --git a/src/library/scala/collection/mutable/SynchronizedStack.scala b/src/library/scala/collection/mutable/SynchronizedStack.scala index 4c0f63cd76..740449ffe7 100644 --- a/src/library/scala/collection/mutable/SynchronizedStack.scala +++ b/src/library/scala/collection/mutable/SynchronizedStack.scala @@ -84,7 +84,7 @@ class SynchronizedStack[A] extends Stack[A] { * * @return an iterator over all stack elements. */ - override def elements: Iterator[A] = synchronized { super.elements } + override def iterator: Iterator[A] = synchronized { super.iterator } /** Creates a list of all stack elements in FIFO order. * diff --git a/src/library/scala/collection/script/Message.scala b/src/library/scala/collection/script/Message.scala index 670a8a426a..c4bf81eebc 100644 --- a/src/library/scala/collection/script/Message.scala +++ b/src/library/scala/collection/script/Message.scala @@ -72,7 +72,7 @@ class Script[A] extends ArrayBuffer[Message[A]] with Message[A] { override def toString(): String = { var res = "Script(" - var it = elements + var it = this.iterator var i = 1 while (it.hasNext) { if (i > 1) diff --git a/src/library/scala/io/BytePickle.scala b/src/library/scala/io/BytePickle.scala index ad2be7b9b2..135d608eb9 100644 --- a/src/library/scala/io/BytePickle.scala +++ b/src/library/scala/io/BytePickle.scala @@ -69,8 +69,8 @@ object BytePickle { case Def() => Array.concat(s, (List[Byte](1)).toArray) }; def appU(s: Array[Byte]): (RefDef, Array[Byte]) = - if (s(0) == 0) (Ref(), s.subArray(1, s.length)) - else (Def(), s.subArray(1, s.length)); + if (s(0) == 0) (Ref(), s.slice(1, s.length)) + else (Def(), s.slice(1, s.length)); } val REF = 0 @@ -91,7 +91,7 @@ object BytePickle { } while ((b & 0x80) != 0); x } - (readNat, s.subArray(num, s.length)) + (readNat, s.slice(num, s.length)) } } @@ -260,7 +260,7 @@ object BytePickle { } while ((b & 0x80) != 0); x } - (readNat, new UnPicklerState(s.stream.subArray(num, s.stream.length), s.dict)) + (readNat, new UnPicklerState(s.stream.slice(num, s.stream.length), s.dict)) } } @@ -268,7 +268,7 @@ object BytePickle { def appP(b: Byte, s: PicklerState): PicklerState = new PicklerState(Array.concat(s.stream, (List[Byte](b)).toArray), s.dict); def appU(s: UnPicklerState): (Byte, UnPicklerState) = - (s.stream(0), new UnPicklerState(s.stream.subArray(1, s.stream.length), s.dict)); + (s.stream(0), new UnPicklerState(s.stream.slice(1, s.stream.length), s.dict)); } def string: SPU[String] = diff --git a/src/library/scala/io/Source.scala b/src/library/scala/io/Source.scala index 3b79202b41..03c2e4dc00 100644 --- a/src/library/scala/io/Source.scala +++ b/src/library/scala/io/Source.scala @@ -68,7 +68,7 @@ object Source { * @return ... */ def fromChars(chars: Array[Char]): Source = { - val it = chars.elements + val it = chars.iterator new Source { def reset() = fromChars(chars) val iter = it @@ -81,7 +81,7 @@ object Source { * @return ... */ def fromString(s: String): Source = { - val it = s.elements + val it = s.iterator new Source { def reset() = fromString(s) val iter = it diff --git a/src/library/scala/io/UTF8Codec.scala b/src/library/scala/io/UTF8Codec.scala index 6d5e569971..d07354b117 100644 --- a/src/library/scala/io/UTF8Codec.scala +++ b/src/library/scala/io/UTF8Codec.scala @@ -85,7 +85,7 @@ object UTF8Codec { def encode(s: String): Array[Byte] = { val dst = new Array[Byte](s.length() * 3) val len = encode(s, dst, 0) - dst.subArray(0, len) + dst.slice(0, len) } def decode(src: Array[Byte], from: Int, diff --git a/src/library/scala/runtime/BoxedArray.scala b/src/library/scala/runtime/BoxedArray.scala index 04bb00113c..91651a9cec 100644 --- a/src/library/scala/runtime/BoxedArray.scala +++ b/src/library/scala/runtime/BoxedArray.scala @@ -86,10 +86,10 @@ abstract class BoxedArray[A] extends Vector[A] with VectorTemplate[A, BoxedArray } val buf = new StringBuilder() buf.append(start) - val elems = elements - if (elems.hasNext) buf.append(_deepToString(elems.next)) - while (elems.hasNext) { - buf.append(sep); buf.append(_deepToString(elems.next)) + val iter = this.iterator + if (iter.hasNext) buf.append(_deepToString(iter.next)) + while (iter.hasNext) { + buf.append(sep); buf.append(_deepToString(iter.next)) } buf.append(end) buf.toString @@ -108,8 +108,8 @@ abstract class BoxedArray[A] extends Vector[A] with VectorTemplate[A, BoxedArray x1.equals(x2) } def _sameElements(a1: BoxedArray[_], a2: BoxedArray[_]): Boolean = { - val it1 = a1.elements - val it2 = a2.elements + val it1 = a1.iterator + val it2 = a2.iterator var res = true while (res && it1.hasNext && it2.hasNext) res = _deepEquals(it1.next, it2.next) diff --git a/src/library/scala/runtime/RichString.scala b/src/library/scala/runtime/RichString.scala index 470cefabfe..6fc8f1e9a6 100644 --- a/src/library/scala/runtime/RichString.scala +++ b/src/library/scala/runtime/RichString.scala @@ -97,7 +97,7 @@ class RichString(val self: String) extends Proxy with Vector[Char] with VectorTe * <li>FF - form feed (0x0C hex)</li> * </ul> */ - def linesWithSeparators = new Iterator[String] { + def linesWithSeparators: Iterator[String] = new Iterator[String] { private val len = self.length private var index = 0 def hasNext: Boolean = index < len @@ -117,6 +117,13 @@ class RichString(val self: String) extends Proxy with Vector[Char] with VectorTe def lines: Iterator[String] = linesWithSeparators map (line => new RichString(line).stripLineEnd) + /** Return all lines in this string in an iterator, excluding trailing line + * end characters, i.e. apply <code>.stripLineEnd</code> to all lines + * returned by <code>linesWithSeparators</code>. + */ + def linesIterator: Iterator[String] = + linesWithSeparators map (line => new RichString(line).stripLineEnd) + /** Returns this string with first character converted to upper case */ def capitalize: String = if (self == null) null diff --git a/src/library/scala/runtime/ScalaRunTime.scala b/src/library/scala/runtime/ScalaRunTime.scala index 78298a16e6..86aa61aec2 100644 --- a/src/library/scala/runtime/ScalaRunTime.scala +++ b/src/library/scala/runtime/ScalaRunTime.scala @@ -21,7 +21,7 @@ object ScalaRunTime { def forceBoxedArray[A <: Any](xs: Seq[A]): Array[A] = { val array = new Array[A](xs.length) var i = 0 - for (x <- xs.elements) { array(i) = x; i += 1 } + for (x <- xs.iterator) { array(i) = x; i += 1 } array } diff --git a/src/library/scala/testing/SUnit.scala b/src/library/scala/testing/SUnit.scala index 22e5a8dfdd..1a333397a7 100644 --- a/src/library/scala/testing/SUnit.scala +++ b/src/library/scala/testing/SUnit.scala @@ -128,7 +128,7 @@ object SUnit { buf.length def failures() = - buf.elements map { x => new TestFailure(x) } + buf.iterator map { x => new TestFailure(x) } } /** The class <code>TestSuite</code> runs a composite of test cases. diff --git a/src/library/scala/util/automata/BaseBerrySethi.scala b/src/library/scala/util/automata/BaseBerrySethi.scala index d35e84fd83..6960407ebf 100644 --- a/src/library/scala/util/automata/BaseBerrySethi.scala +++ b/src/library/scala/util/automata/BaseBerrySethi.scala @@ -45,7 +45,7 @@ abstract class BaseBerrySethi { protected def compFirst(r: RegExp): immutable.Set[Int] = r match { case x:Alt => var tmp = emptySet - val it = x.rs.elements // union + val it = x.rs.iterator // union while (it.hasNext) { tmp = tmp ++ compFirst(it.next) } tmp case Eps => @@ -55,7 +55,7 @@ abstract class BaseBerrySethi { compFirst(x.r) case x:Sequ => var tmp = emptySet; - val it = x.rs.elements; // union + val it = x.rs.iterator; // union while (it.hasNext) { val z = it.next tmp = tmp ++ compFirst(z) @@ -73,7 +73,7 @@ abstract class BaseBerrySethi { protected def compLast(r: RegExp): immutable.Set[Int] = r match { case x:Alt => var tmp = emptySet - val it = x.rs.elements // union + val it = x.rs.iterator // union while (it.hasNext) { tmp = tmp ++ compFirst(it.next) } tmp case Eps => @@ -83,7 +83,7 @@ abstract class BaseBerrySethi { compLast(x.r) case x:Sequ => var tmp = emptySet - val it = x.rs.elements.toList.reverse.elements // union + val it = x.rs.iterator.toList.reverse.iterator // union while (it.hasNext) { val z = it.next tmp = tmp ++ compLast(z) @@ -109,7 +109,7 @@ abstract class BaseBerrySethi { var fol = emptySet if (r.length > 0) {//non-empty expr - val it = r.elements.toList.reverse.elements + val it = r.iterator.toList.reverse.iterator fol = fol + pos // don't modify pos ! while (it.hasNext) { @@ -137,7 +137,7 @@ abstract class BaseBerrySethi { case x:Alt => var first = emptySet - val it = x.rs.elements.toList.reverse.elements + val it = x.rs.iterator.toList.reverse.iterator while (it.hasNext) first = first ++ compFollow1(fol, it.next); first @@ -157,7 +157,7 @@ abstract class BaseBerrySethi { case x:Sequ => var first = emptySet - val it = x.rs.elements.toList.reverse.elements + val it = x.rs.iterator.toList.reverse.iterator while (it.hasNext) { val p = it.next first = compFollow1(fol, p) @@ -181,10 +181,10 @@ abstract class BaseBerrySethi { protected def traverse(r: RegExp): Unit = r match { // (is tree automaton stuff, more than Berry-Sethi) case x:Alt => - val it = x.rs.elements + val it = x.rs.iterator while (it.hasNext) traverse(it.next) case x:Sequ => - val it = x.rs.elements + val it = x.rs.iterator while (it.hasNext) traverse(it.next) case x:Meta => traverse(x.r) diff --git a/src/library/scala/util/automata/WordBerrySethi.scala b/src/library/scala/util/automata/WordBerrySethi.scala index 873f85cf4f..02632ac327 100644 --- a/src/library/scala/util/automata/WordBerrySethi.scala +++ b/src/library/scala/util/automata/WordBerrySethi.scala @@ -140,7 +140,7 @@ abstract class WordBerrySethi extends BaseBerrySethi { // determine "Sethi-length" of the regexp //activeBinders = new Vector() - var it = subexpr.elements + var it = subexpr.iterator while (it.hasNext) traverse(it.next) @@ -167,7 +167,7 @@ abstract class WordBerrySethi extends BaseBerrySethi { var j = 0; while (j < pos) { //Console.println("WBS.collectTrans, j = "+j) val fol = this.follow(j) - val it = fol.elements + val it = fol.iterator while (it.hasNext) { val k = it.next if (pos == k) @@ -218,7 +218,7 @@ abstract class WordBerrySethi extends BaseBerrySethi { } val initialsArr = new Array[Int](initials.size) - val it = initials.elements + val it = initials.iterator { var k = 0; while (k < initials.size) { diff --git a/src/library/scala/util/parsing/ast/Binders.scala b/src/library/scala/util/parsing/ast/Binders.scala index 75ce3b28d0..addcc1d9fd 100644 --- a/src/library/scala/util/parsing/ast/Binders.scala +++ b/src/library/scala/util/parsing/ast/Binders.scala @@ -102,17 +102,17 @@ trait Binders extends AbstractSyntax with Mappable { * For a typical let-binding, this is just the variable name. For an argument list to a method body, * there is one binder per formal argument. */ - def elements = substitution.keys + def iterator = substitution.keysIterator /** Return the `i'th binder in this scope.*/ - def apply(i: Int): binderType = elements.toList(i) + def apply(i: Int): binderType = this.iterator.toList(i) /** Returns true if this container has a binder equal (==) to `b' */ def binds(b: binderType): Boolean = substitution.contains(b) def indexFor(b: binderType): Option[Int] = { - val iter = elements.counted + val iter = this.iterator.counted for (that <- iter) { if (that.name == b.name) // TODO: why do name equals and structural equals differ? return Some(iter.count) @@ -164,10 +164,10 @@ trait Binders extends AbstractSyntax with Mappable { */ def getElementFor(b: binderType): Element = substitution(b) - override def toString: String = elements.toList.mkString("[",", ","]")+"!"+id // TODO show substitution? + override def toString: String = this.iterator.toList.mkString("[",", ","]")+"!"+id // TODO show substitution? /** Returns a list of strings that represent the binder elements, each tagged with this scope's id.*/ - def bindersToString: List[String] = (for(val b <- elements) yield b+"!"+id).toList + def bindersToString: List[String] = (for(b <- this.iterator) yield b+"!"+id).toList /** Return a new inheriting scope that won't check whether binding is respected until the scope is left (so as to support forward references) **/ def allowForwardRef: Scope[binderType] = this // TODO @@ -276,7 +276,7 @@ trait Binders extends AbstractSyntax with Mappable { implicit def ScopeIsMappable[bt <: NameElement <% Mappable[bt]](scope: Scope[bt]): Mappable[Scope[bt]] = new Mappable[Scope[bt]] { def gmap(f: Mapper): Scope[bt] = { val newScope = new Scope[bt]() - for(val b <- scope) newScope.addBinder(f(b)) + for(b <- scope) newScope.addBinder(f(b)) newScope } } diff --git a/src/library/scala/util/parsing/combinator/PackratParsers.scala b/src/library/scala/util/parsing/combinator/PackratParsers.scala index f99c5e6ae5..da09eff597 100644 --- a/src/library/scala/util/parsing/combinator/PackratParsers.scala +++ b/src/library/scala/util/parsing/combinator/PackratParsers.scala @@ -184,7 +184,7 @@ trait PackratParsers extends Parsers { if(evalSet contains p){ //something in cache, and p is in the evalSet //remove the rule from the evalSet of the Head - h.evalSet = h.evalSet.remove(_==p) + h.evalSet = h.evalSet.filterNot(_==p) val tempRes = p(in) //we know that cached has an entry here val tempEntry: MemoEntry[_] = cached.get // match {case Some(x: MemoEntry[_]) => x} diff --git a/src/library/scala/util/parsing/combinatorold/syntactical/BindingParsers.scala b/src/library/scala/util/parsing/combinatorold/syntactical/BindingParsers.scala index 6596312ece..b2328bba0e 100644 --- a/src/library/scala/util/parsing/combinatorold/syntactical/BindingParsers.scala +++ b/src/library/scala/util/parsing/combinatorold/syntactical/BindingParsers.scala @@ -132,7 +132,7 @@ trait BindingParsers extends Parsers with Binders { val oldEnv = binderEnv // save old environment // bring binders in the scope in scope - for(val b <- scope) binderEnv = binderEnv.extend(b, scope) + for(b <- scope) binderEnv = binderEnv.extend(b, scope) // return the result of running block (in which these binders are in scope) // before returning, the binderEnv is restored to its old value diff --git a/src/library/scala/xml/Elem.scala b/src/library/scala/xml/Elem.scala index f41bb4e749..85bddbef16 100644 --- a/src/library/scala/xml/Elem.scala +++ b/src/library/scala/xml/Elem.scala @@ -80,7 +80,7 @@ object Elem { */ override def text = { val sb = new StringBuilder() - val it = child.elements + val it = child.iterator while (it.hasNext) sb.append(it.next.text) sb.toString() diff --git a/src/library/scala/xml/MetaData.scala b/src/library/scala/xml/MetaData.scala index d947e40ee3..aafedf7702 100644 --- a/src/library/scala/xml/MetaData.scala +++ b/src/library/scala/xml/MetaData.scala @@ -164,7 +164,7 @@ abstract class MetaData extends Iterable[MetaData] { that match { case m: MetaData => var res = (this.length == m.length) && (this.hashCode() == m.hashCode()) - val it = this.elements + val it = this.iterator while (res && it.hasNext) { res = it.next.containedIn1(m) } res case _ => @@ -172,7 +172,7 @@ abstract class MetaData extends Iterable[MetaData] { } /** returns an iterator on attributes */ - def elements: Iterator[MetaData] = new Iterator[MetaData] { + def iterator: Iterator[MetaData] = new Iterator[MetaData] { var x: MetaData = MetaData.this def hasNext = Null != x def next = { diff --git a/src/library/scala/xml/NodeBuffer.scala b/src/library/scala/xml/NodeBuffer.scala index cde6870ead..d83876e255 100644 --- a/src/library/scala/xml/NodeBuffer.scala +++ b/src/library/scala/xml/NodeBuffer.scala @@ -47,13 +47,13 @@ class NodeBuffer extends scala.collection.mutable.ArrayBuffer[Node] { this &+ it.next case n:Node => - super.+(n) + super.+=(n) case ns:Iterable[_] => - this &+ ns.elements + this &+ ns.iterator case d => - super.+(new Atom(d)) + super.+=(new Atom(d)) } this } diff --git a/src/library/scala/xml/NodeSeq.scala b/src/library/scala/xml/NodeSeq.scala index c17b99b2e6..13e0566893 100644 --- a/src/library/scala/xml/NodeSeq.scala +++ b/src/library/scala/xml/NodeSeq.scala @@ -45,7 +45,7 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No def theSeq: Seq[Node] def length = theSeq.length - override def elements = theSeq.elements + override def iterator = theSeq.iterator def apply(i: Int): Node = theSeq.apply(i) def apply(f: Node => Boolean): NodeSeq = filter(f) @@ -76,10 +76,10 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No def \(that: String): NodeSeq = that match { case "_" => var zs: List[Node] = Nil - val it = this.elements + val it = this.iterator while (it.hasNext) { val x = it.next - val jt = x.child.elements + val jt = x.child.iterator while (jt.hasNext) { val y = jt.next if (y.typeTag$ != -1) @@ -114,10 +114,10 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No case _ => var zs: List[Node] = Nil - val it = this.elements + val it = this.iterator while (it.hasNext) { val x = it.next - val jt = x.child.elements + val jt = x.child.iterator while (jt.hasNext) { val y = jt.next if (y.label == that) @@ -145,10 +145,10 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No def \\ (that: String): NodeSeq = that match { case "_" => var zs: List[Node] = Nil - val it = this.elements + val it = this.iterator while (it.hasNext) { val x = it.next - val jt = x.descendant_or_self.elements + val jt = x.descendant_or_self.iterator while (jt.hasNext) { val y = jt.next if (y.typeTag$ != -1) @@ -159,14 +159,14 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No case _ if that.charAt(0) == '@' => var zs: List[Node] = Nil - val it = this.elements + val it = this.iterator while (it.hasNext) { val x = it.next - val jt = x.descendant_or_self.elements + val jt = x.descendant_or_self.iterator while (jt.hasNext) { val y = jt.next if (y.typeTag$ != -1) { - val kt = (y \ that).elements + val kt = (y \ that).iterator while (kt.hasNext) { zs = (kt.next)::zs } @@ -177,10 +177,10 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No case _ => var zs: List[Node] = Nil - val it = this.elements + val it = this.iterator while (it.hasNext) { val x = it.next - val jt = x.descendant_or_self.elements + val jt = x.descendant_or_self.iterator while (jt.hasNext) { val y = jt.next if (y.typeTag$ != -1 && y.label == that) @@ -190,7 +190,7 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No zs.reverse } - override def toString(): String = theSeq.elements.foldLeft ("") { + override def toString(): String = theSeq.iterator.foldLeft ("") { (s: String, x: Node) => s + x.toString() } /* @@ -209,7 +209,7 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No def text: String = { val sb = new StringBuilder() - val it = elements + val it = this.iterator while (it.hasNext) { sb.append(it.next.text) } diff --git a/src/library/scala/xml/Null.scala b/src/library/scala/xml/Null.scala index b269672b8c..5885201acd 100644 --- a/src/library/scala/xml/Null.scala +++ b/src/library/scala/xml/Null.scala @@ -21,7 +21,7 @@ case object Null extends MetaData { /** returns its argument */ def copy(next: MetaData) = next - override def elements = Iterator.empty + override def iterator = Iterator.empty override def filter(f: MetaData => Boolean): MetaData = this diff --git a/src/library/scala/xml/Parsing.scala b/src/library/scala/xml/Parsing.scala index 076a6e7074..7d5545233f 100644 --- a/src/library/scala/xml/Parsing.scala +++ b/src/library/scala/xml/Parsing.scala @@ -30,7 +30,7 @@ object Parsing { /** <pre>(#x20 | #x9 | #xD | #xA)+</pre> */ final def isSpace(cs: Seq[Char]): Boolean = { - val it = cs.elements + val it = cs.iterator it.hasNext && it.forall { isSpace } } @@ -75,7 +75,7 @@ object Parsing { def isName(s: String): Boolean = if (s.length() > 0) { val z: Seq[Char] = s - val y = z.elements + val y = z.iterator if (isNameStart(y.next)) { while (y.hasNext && isNameChar(y.next)) {} !y.hasNext @@ -97,7 +97,7 @@ object Parsing { def checkPubID(s: String): Boolean = if (s.length() > 0) { val z:Seq[Char] = s - val y = z.elements + val y = z.iterator while (y.hasNext && isPubIDChar(y.next)) {} !y.hasNext } else true diff --git a/src/library/scala/xml/PrettyPrinter.scala b/src/library/scala/xml/PrettyPrinter.scala index 11b219d99d..e97a2e0f59 100644 --- a/src/library/scala/xml/PrettyPrinter.scala +++ b/src/library/scala/xml/PrettyPrinter.scala @@ -91,7 +91,7 @@ class PrettyPrinter( width:Int, step:Int ) { items = Box(ind, s) :: items cur += s.length } else try { - for (b <- cut(s, ind).elements) // break it up + for (b <- cut(s, ind).iterator) // break it up items = b :: items } catch { case _:BrokenException => makePara(ind, s) // give up, para @@ -168,7 +168,7 @@ class PrettyPrinter( width:Int, step:Int ) { case _:Atom[_] | _:Comment | _:EntityRef | _:ProcInstr => makeBox( ind, node.toString().trim() ) case g @ Group(xs) => - traverse(xs.elements, pscope, ind) + traverse(xs.iterator, pscope, ind) case _ => val test = { val sb = new StringBuilder() @@ -184,7 +184,7 @@ class PrettyPrinter( width:Int, step:Int ) { if (stg.length < width - cur) { // start tag fits makeBox(ind, stg) makeBreak() - traverse(node.child.elements, node.scope, ind + step) + traverse(node.child.iterator, node.scope, ind + step) makeBox(ind, etg) } else if (len2 < width - cur) { // <start label + attrs + tag + content + end tag @@ -192,7 +192,7 @@ class PrettyPrinter( width:Int, step:Int ) { makeBreak() // todo: break the rest in pieces /*{ //@todo val sq:Seq[String] = stg.split(" "); - val it = sq.elements; + val it = sq.iterator; it.next; for (c <- it) { makeBox(ind+len2-2, c) @@ -201,7 +201,7 @@ class PrettyPrinter( width:Int, step:Int ) { }*/ makeBox(ind, stg.substring(len2, stg.length)) makeBreak() - traverse(node.child.elements, node.scope, ind + step) + traverse(node.child.iterator, node.scope, ind + step) makeBox(cur, etg) makeBreak() } else { // give up @@ -300,7 +300,7 @@ class PrettyPrinter( width:Int, step:Int ) { * @param sb the string buffer to which to append to */ def formatNodes(nodes: Seq[Node], pscope: NamespaceBinding, sb: StringBuilder): Unit = - for (n <- nodes.elements) { + for (n <- nodes.iterator) { sb.append(format(n, pscope)) } diff --git a/src/library/scala/xml/Utility.scala b/src/library/scala/xml/Utility.scala index f7f7171580..635585f79c 100644 --- a/src/library/scala/xml/Utility.scala +++ b/src/library/scala/xml/Utility.scala @@ -102,7 +102,7 @@ object Utility extends AnyRef with parsing.TokenTests * @return ... */ final def escape(text: String, s: StringBuilder): StringBuilder = { - for (c <- text.elements) c match { + for (c <- text.iterator) c match { case '<' => s.append("<") case '>' => s.append(">") case '&' => s.append("&") @@ -141,7 +141,7 @@ object Utility extends AnyRef with parsing.TokenTests */ def collectNamespaces(nodes: Seq[Node]): Set[String] = { var m = new HashSet[String]() - val it = nodes.elements + val it = nodes.iterator while (it.hasNext) collectNamespaces(it.next, m); m @@ -247,7 +247,7 @@ object Utility extends AnyRef with parsing.TokenTests if (children.isEmpty) return else if (children forall isAtomAndNotText) { // add space - val it = children.elements + val it = children.iterator val f = it.next toXML(f, pscope, sb) while (it.hasNext) { @@ -285,7 +285,7 @@ object Utility extends AnyRef with parsing.TokenTests + scpeHash * 31 + { var c = 0 - val i = children.elements + val i = children.iterator while(i.hasNext) c = c * 41 + i.next.hashCode c } @@ -379,7 +379,7 @@ object Utility extends AnyRef with parsing.TokenTests val sb = new StringBuilder var rfb: StringBuilder = null val nb = new NodeBuffer() - val it = zs.elements + val it = zs.iterator while (it.hasNext) { var c = it.next c match { diff --git a/src/library/scala/xml/dtd/ContentModel.scala b/src/library/scala/xml/dtd/ContentModel.scala index a1e2ea0aa5..24d7840ec3 100644 --- a/src/library/scala/xml/dtd/ContentModel.scala +++ b/src/library/scala/xml/dtd/ContentModel.scala @@ -35,7 +35,7 @@ object ContentModel extends WordExp { def getLabels(r: RegExp): scala.collection.Set[String] = { val s = new scala.collection.mutable.HashSet[String]() def traverse1(xs: Seq[RegExp]) { - val it = xs.elements + val it = xs.iterator while (it.hasNext) traverse(it.next) } def traverse(r: RegExp) { @@ -54,7 +54,7 @@ object ContentModel extends WordExp { /* precond: rs.length >= 1 */ private def buildString(rs: Seq[RegExp], sb: StringBuilder, sep: Char) { - val it = rs.elements + val it = rs.iterator val fst = it.next buildString(fst, sb) for (z <- it) { @@ -136,7 +136,7 @@ case class MIXED(r: ContentModel.RegExp) extends DFAContentModel { def cond(n:Node) = !n.isInstanceOf[Text] && !n.isInstanceOf[SpecialNode]; Console.println("ns = "+ns); - val jt = ns.elements; + val jt = ns.iterator; def hasNext = jt.hasNext; def next = { var r: Node = jt.next; @@ -162,7 +162,7 @@ Console.println("ns = "+ns); case class ELEMENTS(r:ContentModel.RegExp) extends DFAContentModel { /* def getIterator(ns:NodeSeq) = new Iterator[String] { - val jt = ns.elements.buffered; + val jt = ns.iterator.buffered; def hasNext = jt.hasNext; def next = { var r: Node = jt.next; diff --git a/src/library/scala/xml/dtd/ElementValidator.scala b/src/library/scala/xml/dtd/ElementValidator.scala index de969cab64..53fe483bc2 100644 --- a/src/library/scala/xml/dtd/ElementValidator.scala +++ b/src/library/scala/xml/dtd/ElementValidator.scala @@ -58,8 +58,8 @@ class ElementValidator() extends Function1[Node,Boolean] { case _ => x.namespace eq null }} - . map { x => ElemName(x.label) } - . elements; + .map { x => ElemName(x.label) } + .iterator; /** check attributes, return true if md corresponds to attribute declarations in adecls. */ @@ -71,7 +71,7 @@ class ElementValidator() extends Function1[Node,Boolean] { var ok = new scala.collection.mutable.BitSet(adecls.length); def find(Key:String): AttrDecl = { var attr: AttrDecl = null; - val jt = adecls.elements; while(j < adecls.length) { + val jt = adecls.iterator; while(j < adecls.length) { jt.next match { case a @ AttrDecl(Key, _, _) => attr = a; ok += j; j = adecls.length; case _ => j = j + 1; @@ -79,7 +79,7 @@ class ElementValidator() extends Function1[Node,Boolean] { } attr } - val it = md.elements; while(it.hasNext) { + val it = md.iterator; while(it.hasNext) { val attr = it.next j = 0 find(attr.key) match { @@ -99,7 +99,7 @@ class ElementValidator() extends Function1[Node,Boolean] { //val missing = ok.toSet(false); FIXME: it doesn't seem to be used anywhere j = 0 - var kt = adecls.elements + var kt = adecls.iterator while (kt.hasNext) { kt.next match { case AttrDecl(key, tpe, REQUIRED) if !ok(j) => @@ -129,7 +129,7 @@ class ElementValidator() extends Function1[Node,Boolean] { val j = exc.length def find(Key: String): Boolean = { var res = false - val jt = branches.elements + val jt = branches.iterator while (jt.hasNext && !res) jt.next match { // !!! check for match translation problem case ContentModel.Letter(ElemName(Key)) => res = true; diff --git a/src/library/scala/xml/dtd/Scanner.scala b/src/library/scala/xml/dtd/Scanner.scala index 0bb8d99b74..49f36aabf9 100644 --- a/src/library/scala/xml/dtd/Scanner.scala +++ b/src/library/scala/xml/dtd/Scanner.scala @@ -28,7 +28,7 @@ class Scanner extends Tokens with parsing.TokenTests { /** initializes the scanner on input s */ final def initScanner(s: String) { value = "" - it = (s).elements + it = (s).iterator token = 1+END next nextToken @@ -50,7 +50,7 @@ class Scanner extends Tokens with parsing.TokenTests { } final def accS(ds: Seq[Char]) { - val jt = ds.elements + val jt = ds.iterator while (jt.hasNext) { acc(jt.next) } } diff --git a/src/library/scala/xml/dtd/ValidationException.scala b/src/library/scala/xml/dtd/ValidationException.scala index 4425167a03..a05233a031 100644 --- a/src/library/scala/xml/dtd/ValidationException.scala +++ b/src/library/scala/xml/dtd/ValidationException.scala @@ -34,7 +34,7 @@ object MakeValidationException { def fromMissingAttribute(allKeys: scala.collection.Set[String]) = { val sb = new StringBuilder("missing value for REQUIRED attribute") if (allKeys.size > 1) sb.append('s'); - val it = allKeys.elements + val it = allKeys.iterator while (it.hasNext) { sb.append('\'').append(it.next).append('\'') } diff --git a/src/library/scala/xml/factory/NodeFactory.scala b/src/library/scala/xml/factory/NodeFactory.scala index 9a00548c2c..4d5743548d 100644 --- a/src/library/scala/xml/factory/NodeFactory.scala +++ b/src/library/scala/xml/factory/NodeFactory.scala @@ -31,8 +31,8 @@ trait NodeFactory[A <: Node] { /** faster equality, because */ def eqElements(ch1:Seq[Node], ch2:Seq[Node]): Boolean = { (ch1.length == ch2.length) && { - val it1 = ch1.elements; - val it2 = ch2.elements; + val it1 = ch1.iterator; + val it2 = ch2.iterator; var res = true; while(res && it1.hasNext) { res = it1.next.eq(it2.next); @@ -53,7 +53,7 @@ trait NodeFactory[A <: Node] { val hash = Utility.hashCode( pre, name, attrSeq.hashCode(), scpe.hashCode(), children ) ; cache.get( hash ) match { case Some(list) => // find structurally equal - val it = list.elements; + val it = list.iterator; val lookup = it.find { x => nodeEquals(x, pre, name, attrSeq, scpe, children) }; lookup match { case Some(x) => diff --git a/src/library/scala/xml/parsing/FactoryAdapter.scala b/src/library/scala/xml/parsing/FactoryAdapter.scala index d997a23676..4c09988151 100644 --- a/src/library/scala/xml/parsing/FactoryAdapter.scala +++ b/src/library/scala/xml/parsing/FactoryAdapter.scala @@ -93,7 +93,7 @@ abstract class FactoryAdapter extends DefaultHandler() { if (!capture) return if (!normalizeWhitespace) { // compliant: report every character - return buffer.append(ch, offset, length) + return buffer.appendAll(ch, offset, length) } // normalizing whitespace is not compliant, but useful diff --git a/src/library/scala/xml/parsing/MarkupParser.scala b/src/library/scala/xml/parsing/MarkupParser.scala index 1d41ee4a1a..369c0010e7 100644 --- a/src/library/scala/xml/parsing/MarkupParser.scala +++ b/src/library/scala/xml/parsing/MarkupParser.scala @@ -269,7 +269,7 @@ trait MarkupParser extends AnyRef with TokenTests { self: MarkupParser with Mar } def xToken(that: Seq[Char]): Unit = { - val it = that.elements; + val it = that.iterator; while (it.hasNext) xToken(it.next); } @@ -1173,7 +1173,7 @@ trait MarkupParser extends AnyRef with TokenTests { self: MarkupParser with Mar */ def normalizeAttributeValue(attval: String): String = { val s: Seq[Char] = attval - val it = s.elements + val it = s.iterator while (it.hasNext) { it.next match { case ' '|'\t'|'\n'|'\r' => diff --git a/src/library/scala/xml/parsing/TokenTests.scala b/src/library/scala/xml/parsing/TokenTests.scala index 1e7f920f0c..2fd6e39ec7 100644 --- a/src/library/scala/xml/parsing/TokenTests.scala +++ b/src/library/scala/xml/parsing/TokenTests.scala @@ -25,7 +25,7 @@ trait TokenTests { /** (#x20 | #x9 | #xD | #xA)+ */ final def isSpace(cs: Seq[Char]): Boolean = { - val it = cs.elements; + val it = cs.iterator; it.hasNext && it.forall { isSpace }; } @@ -72,7 +72,7 @@ trait TokenTests { */ def isName(s: String): Boolean = { if( s.length() > 0 ) { - val y = s.elements; + val y = s.iterator; if (isNameStart(y.next)) { while (y.hasNext && isNameChar(y.next)) {}; !y.hasNext @@ -105,7 +105,7 @@ trait TokenTests { * @param ianaEncoding The IANA encoding name. */ def isValidIANAEncoding(ianaEncoding: Seq[Char]): Boolean = { - val it = ianaEncoding.elements; + val it = ianaEncoding.iterator; if (!it.hasNext) return false; @@ -131,7 +131,7 @@ trait TokenTests { def checkPubID(s: String): Boolean = { //Console.println("checkPubID of \""+s+"\""); if (s.length() > 0) { - val y = s.elements; + val y = s.iterator; var c = ' '; while (y.hasNext && isPubIDChar(c)) { //Console.println(c); diff --git a/src/library/scala/xml/persistent/CachedFileStorage.scala b/src/library/scala/xml/persistent/CachedFileStorage.scala index 31f02597b8..19d232deee 100644 --- a/src/library/scala/xml/persistent/CachedFileStorage.scala +++ b/src/library/scala/xml/persistent/CachedFileStorage.scala @@ -78,7 +78,7 @@ extends java.lang.Thread with scala.util.logging.Logged { val res = ConstructingParser.fromSource(src,false).document.docElem(0) switch log("[load done]") - res.child.elements + res.child.iterator } /** saves the XML to file */ diff --git a/src/library/scala/xml/persistent/IndexedStorage.scala b/src/library/scala/xml/persistent/IndexedStorage.scala index d6720eac1d..979a048b63 100644 --- a/src/library/scala/xml/persistent/IndexedStorage.scala +++ b/src/library/scala/xml/persistent/IndexedStorage.scala @@ -40,7 +40,7 @@ extends CachedFileStorage(file) { } def nodes: Iterator[Node] = synchronized { - theMap.values + theMap.valuesIterator } def lookup(n: A): Option[Node] = theMap.get(n) diff --git a/src/library/scala/xml/persistent/SetStorage.scala b/src/library/scala/xml/persistent/SetStorage.scala index c5af1eff5e..90c59f80c3 100644 --- a/src/library/scala/xml/persistent/SetStorage.scala +++ b/src/library/scala/xml/persistent/SetStorage.scala @@ -27,7 +27,7 @@ class SetStorage(file: File) extends CachedFileStorage(file) { { val it = super.initialNodes dirty = it.hasNext - for(val x <- it) { + for(x <- it) { theSet += x; } } @@ -38,6 +38,6 @@ class SetStorage(file: File) extends CachedFileStorage(file) { def -= (e: Node): Unit = synchronized { this.dirty = true; theSet -= e } - def nodes = synchronized { theSet.elements } + def nodes = synchronized { theSet.iterator } } diff --git a/src/library/scala/xml/transform/BasicTransformer.scala b/src/library/scala/xml/transform/BasicTransformer.scala index 926cb624b7..d75b339e82 100644 --- a/src/library/scala/xml/transform/BasicTransformer.scala +++ b/src/library/scala/xml/transform/BasicTransformer.scala @@ -29,7 +29,7 @@ abstract class BasicTransformer extends Function1[Node,Node] { */ protected def buffer(pos: Int, ns: Seq[Node]): NodeBuffer = { val nb = new NodeBuffer() - var jt = ns.elements + var jt = ns.iterator var j = 0; while (j < pos-1) { nb.append(jt.next) j += 1 @@ -45,7 +45,7 @@ abstract class BasicTransformer extends Function1[Node,Node] { protected def freeze(nb: NodeBuffer): Seq[Node] = { val arr = new Array[Node](nb.length) var i = 0 - val it = nb.elements; while (it.hasNext) { + val it = nb.iterator; while (it.hasNext) { arr(i) = it.next i += 1 } @@ -62,7 +62,7 @@ abstract class BasicTransformer extends Function1[Node,Node] { * @return ... */ protected def unchanged(n: Node, ns: Seq[Node]) = - single(ns) && (ns.elements.next.eq(n)) + single(ns) && (ns.iterator.next.eq(n)) /** Call transform(Node) for each node in ns, append results * to NodeBuffer. @@ -78,7 +78,7 @@ abstract class BasicTransformer extends Function1[Node,Node] { */ def transform(ns: Seq[Node]): Seq[Node] = { var i = 0 - val it = ns.elements + val it = ns.iterator try { while (it.hasNext) { val n = it.next @@ -114,7 +114,7 @@ abstract class BasicTransformer extends Function1[Node,Node] { val seq = transform(n) if (!single(seq)) throw new UnsupportedOperationException("transform must return single node for root"); - else seq.elements.next + else seq.iterator.next } } diff --git a/src/library/scala/xml/transform/RuleTransformer.scala b/src/library/scala/xml/transform/RuleTransformer.scala index 32a21f7e74..682d7f2f2b 100644 --- a/src/library/scala/xml/transform/RuleTransformer.scala +++ b/src/library/scala/xml/transform/RuleTransformer.scala @@ -14,7 +14,7 @@ package scala.xml.transform class RuleTransformer(rules: RewriteRule*) extends BasicTransformer { override def transform(n: Node): Seq[Node] = { var m: Seq[Node] = super.transform(n) - val it = rules.elements; while (it.hasNext) { + val it = rules.iterator; while (it.hasNext) { val rule = it.next val m2 = rule.transform(m) //if(!m2.eq(m)) Console.println("applied rule \""+rule.name+"\""); |