Merge pull request scala#6735 from xuwei-k/AbstractIterator

use AbstractIterator instead of Iterator

Author: julienrf

src/library/scala/collection/ArrayOps.scala

@@ -104,7 +104,7 @@ object ArrayOps {
     def withFilter(q: A => Boolean): WithFilter[A] = new WithFilter[A](a => p(a) && q(a), xs)
   }
 
-  private class ArrayIterator[A](private[this] val xs: Array[A]) extends Iterator[A] {
+  private class ArrayIterator[A](private[this] val xs: Array[A]) extends AbstractIterator[A] {
     private[this] var pos = 0
     def hasNext: Boolean = pos < xs.length
     def next(): A = try {
@@ -114,7 +114,7 @@ object ArrayOps {
     } catch { case _: ArrayIndexOutOfBoundsException => throw new NoSuchElementException }
   }
 
-  private class ReverseIterator[A](private[this] val xs: Array[A]) extends Iterator[A] {
+  private class ReverseIterator[A](private[this] val xs: Array[A]) extends AbstractIterator[A] {
     private[this] var pos = xs.length-1
     def hasNext: Boolean = pos >= 0
     def next(): A = try {
@@ -124,7 +124,7 @@ object ArrayOps {
     } catch { case _: ArrayIndexOutOfBoundsException => throw new NoSuchElementException }
   }
 
-  private class GroupedIterator[A](xs: Array[A], groupSize: Int) extends Iterator[Array[A]] {
+  private class GroupedIterator[A](xs: Array[A], groupSize: Int) extends AbstractIterator[Array[A]] {
     private[this] var pos = 0
     def hasNext: Boolean = pos < xs.length
     def next(): Array[A] = {

src/library/scala/collection/Seq.scala

@@ -454,7 +454,7 @@ trait SeqOps[+A, +CC[_], +C] extends Any
     if (n < 0 || n > size) Iterator.empty
     else new CombinationsItr(n)
 
-  private class PermutationsItr extends Iterator[C] {
+  private class PermutationsItr extends AbstractIterator[C] {
     private[this] val (elms, idxs) = init()
     private[this] var _hasNext = true
 
@@ -503,7 +503,7 @@ trait SeqOps[+A, +CC[_], +C] extends Any
     }
   }
 
-  private class CombinationsItr(n: Int) extends Iterator[C] {
+  private class CombinationsItr(n: Int) extends AbstractIterator[C] {
     // generating all nums such that:
     // (1) nums(0) + .. + nums(length-1) = n
     // (2) 0 <= nums(i) <= cnts(i), where 0 <= i <= cnts.length-1

src/library/scala/collection/Set.scala

@@ -100,7 +100,7 @@ trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]]
     *
     *  @author Eastsun
     */
-  private class SubsetsItr(elms: IndexedSeq[A], len: Int) extends Iterator[C] {
+  private class SubsetsItr(elms: IndexedSeq[A], len: Int) extends AbstractIterator[C] {
     private[this] val idxs = Array.range(0, len+1)
     private[this] var _hasNext = true
     idxs(len) = elms.size

src/library/scala/collection/StringOps.scala

@@ -16,7 +16,7 @@ object StringOps {
   private final val CR = 0x0D
   private final val SU = 0x1A
 
-  private class StringIterator(private[this] val s: String) extends Iterator[Char] {
+  private class StringIterator(private[this] val s: String) extends AbstractIterator[Char] {
     private[this] var pos = 0
     def hasNext: Boolean = pos < s.length
     def next(): Char = try {
@@ -26,7 +26,7 @@ object StringOps {
     } catch { case _: IndexOutOfBoundsException => Iterator.empty.next() }
   }
 
-  private class ReverseIterator(private[this] val s: String) extends Iterator[Char] {
+  private class ReverseIterator(private[this] val s: String) extends AbstractIterator[Char] {
     private[this] var pos = s.length-1
     def hasNext: Boolean = pos >= 0
     def next(): Char = try {
@@ -36,7 +36,7 @@ object StringOps {
     } catch { case _: IndexOutOfBoundsException => Iterator.empty.next() }
   }
 
-  private class GroupedIterator(s: String, groupSize: Int) extends Iterator[String] {
+  private class GroupedIterator(s: String, groupSize: Int) extends AbstractIterator[String] {
     private[this] var pos = 0
     def hasNext: Boolean = pos < s.length
     def next(): String = {

src/library/scala/collection/concurrent/TrieMap.scala

@@ -998,7 +998,7 @@ object TrieMap extends MapFactory[TrieMap] {
 }
 
 
-private[collection] class TrieMapIterator[K, V](var level: Int, private var ct: TrieMap[K, V], mustInit: Boolean = true) extends Iterator[(K, V)] {
+private[collection] class TrieMapIterator[K, V](var level: Int, private var ct: TrieMap[K, V], mustInit: Boolean = true) extends AbstractIterator[(K, V)] {
   private val stack = new Array[Array[BasicNode]](7)
   private val stackpos = new Array[Int](7)
   private var depth = -1

src/library/scala/collection/immutable/RedBlackTree.scala

@@ -491,7 +491,7 @@ private[collection] object RedBlackTree {
     def unapply[A, B](t: BlackTree[A, B]) = Some((t.key, t.value, t.left, t.right))
   }
 
-  private[this] abstract class TreeIterator[A, B, R](root: Tree[A, B], start: Option[A])(implicit ordering: Ordering[A]) extends Iterator[R] {
+  private[this] abstract class TreeIterator[A, B, R](root: Tree[A, B], start: Option[A])(implicit ordering: Ordering[A]) extends AbstractIterator[R] {
     protected[this] def nextResult(tree: Tree[A, B]): R
 
     override def hasNext: Boolean = lookahead ne null

src/library/scala/collection/mutable/RedBlackTree.scala

@@ -2,6 +2,7 @@ package scala
 package collection.mutable
 
 import scala.annotation.tailrec
+import collection.AbstractIterator
 import collection.Iterator
 
 import java.lang.String
@@ -471,7 +472,7 @@ private[collection] object RedBlackTree {
     new ValuesIterator(tree, start, end)
 
   private[this] abstract class TreeIterator[A, B, R](tree: Tree[A, B], start: Option[A], end: Option[A])
-                                                    (implicit ord: Ordering[A]) extends Iterator[R] {
+                                                    (implicit ord: Ordering[A]) extends AbstractIterator[R] {
 
     protected def nextResult(node: Node[A, B]): R