Split out steppers for Array, IndexedSeq, LinearSeq, Range, Vector

Author: Ichoran

src/main/scala/scala/compat/java8/StepConverters.scala

@@ -8,120 +8,6 @@ import scala.compat.java8.runtime._
 package converterImpls {
   import Stepper._
 
-  private[java8] class StepsObjectArray[A <: Object](underlying: Array[A], _i0: Int, _iN: Int)
-  extends StepsLikeIndexed[A, StepsObjectArray[A]](_i0, _iN) {
-    def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsObjectArray[A](underlying, i0, half)
-  }
-  
-  private[java8] class StepsAnyArray[A](underlying: Array[A], _i0: Int, _iN: Int)
-  extends StepsLikeIndexed[A, StepsAnyArray[A]](_i0, _iN) {
-    def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsAnyArray[A](underlying, i0, half)
-  }
-  
-  private[java8] class StepsUnitArray(underlying: Array[Unit], _i0: Int, _iN: Int)
-  extends StepsLikeIndexed[Unit, StepsUnitArray](_i0, _iN) {
-    def next() = if (hasNext()) { val j = i0; i0 += 1; () } else throwNSEE
-    def semiclone(half: Int) = new StepsUnitArray(underlying, i0, half)
-  }
-  
-  private[java8] class StepsBoxedBooleanArray(underlying: Array[Boolean], _i0: Int, _iN: Int)
-  extends StepsLikeIndexed[Boolean, StepsBoxedBooleanArray](_i0, _iN) {
-    def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsBoxedBooleanArray(underlying, i0, half)
-  }
-  
-  private[java8] class StepsBoxedByteArray(underlying: Array[Byte], _i0: Int, _iN: Int)
-  extends StepsLikeIndexed[Byte, StepsBoxedByteArray](_i0, _iN) {
-    def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsBoxedByteArray(underlying, i0, half)
-  }
-  
-  private[java8] class StepsBoxedCharArray(underlying: Array[Char], _i0: Int, _iN: Int)
-  extends StepsLikeIndexed[Char, StepsBoxedCharArray](_i0, _iN) {
-    def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsBoxedCharArray(underlying, i0, half)
-  }
-  
-  private[java8] class StepsBoxedShortArray(underlying: Array[Short], _i0: Int, _iN: Int)
-  extends StepsLikeIndexed[Short, StepsBoxedShortArray](_i0, _iN) {
-    def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsBoxedShortArray(underlying, i0, half)
-  }
-  
-  private[java8] class StepsBoxedFloatArray(underlying: Array[Float], _i0: Int, _iN: Int)
-  extends StepsLikeIndexed[Float, StepsBoxedFloatArray](_i0, _iN) {
-    def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsBoxedFloatArray(underlying, i0, half)
-  }
-  
-  private[java8] class StepsDoubleArray(underlying: Array[Double], _i0: Int, _iN: Int)
-  extends StepsDoubleLikeIndexed[StepsDoubleArray](_i0, _iN) {
-    def nextDouble() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsDoubleArray(underlying, i0, half)
-  }
-
-  private[java8] class StepsIntArray(underlying: Array[Int], _i0: Int, _iN: Int)
-  extends StepsIntLikeIndexed[StepsIntArray](_i0, _iN) {
-    def nextInt() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsIntArray(underlying, i0, half)
-  }
-
-  private[java8] class StepsLongArray(underlying: Array[Long], _i0: Int, _iN: Int)
-  extends StepsLongLikeIndexed[StepsLongArray](_i0, _iN) {
-    def nextLong() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsLongArray(underlying, i0, half)
-  }
-
-  private[java8] class StepsAnyIndexedSeq[A](underlying: collection.IndexedSeqLike[A, _], _i0: Int, _iN: Int)
-  extends StepsLikeIndexed[A, StepsAnyIndexedSeq[A]](_i0, _iN) {
-    def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsAnyIndexedSeq[A](underlying, i0, half)
-  }
-
-  private[java8] class StepsDoubleIndexedSeq[CC <: collection.IndexedSeqLike[Double, _]](underlying: CC, _i0: Int, _iN: Int)
-  extends StepsDoubleLikeIndexed[StepsDoubleIndexedSeq[CC]](_i0, _iN) {
-    def nextDouble() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsDoubleIndexedSeq[CC](underlying, i0, half)
-  }
-  
-  private[java8] class StepsIntIndexedSeq[CC <: collection.IndexedSeqLike[Int, _]](underlying: CC, _i0: Int, _iN: Int)
-  extends StepsIntLikeIndexed[StepsIntIndexedSeq[CC]](_i0, _iN) {
-    def nextInt() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsIntIndexedSeq[CC](underlying, i0, half)
-  }
-  
-  private[java8] class StepsLongIndexedSeq[CC <: collection.IndexedSeqLike[Long, _]](underlying: CC, _i0: Int, _iN: Int)
-  extends StepsLongLikeIndexed[StepsLongIndexedSeq[CC]](_i0, _iN) {
-    def nextLong() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsLongIndexedSeq[CC](underlying, i0, half)
-  }
-
-  private[java8] class StepsAnyLinearSeq[A, CC >: Null <: collection.LinearSeqLike[A, CC]](_underlying: CC, _maxN: Long)
-  extends StepsWithTail[A, CC, StepsAnyLinearSeq[A, CC]](_underlying, _maxN) {
-    protected def myIsEmpty(cc: CC): Boolean = cc.isEmpty
-    protected def myTailOf(cc: CC): CC = cc.tail
-    def next() = if (hasNext()) { maxN -= 1; val ans = underlying.head; underlying = underlying.tail; ans } else throwNSEE
-    def semiclone(half: Int) = new StepsAnyLinearSeq[A, CC](underlying, half)
-  }
-
-  private[java8] class StepsDoubleLinearSeq[CC >: Null <: collection.LinearSeqLike[Double, CC]](_underlying: CC, _maxN: Long)
-  extends StepsDoubleWithTail[CC, StepsDoubleLinearSeq[CC]](_underlying, _maxN) {
-    protected def myIsEmpty(cc: CC): Boolean = cc.isEmpty
-    protected def myTailOf(cc: CC): CC = cc.tail
-    def nextDouble() = if (hasNext()) { maxN -= 1; val ans = underlying.head; underlying = underlying.tail; ans } else throwNSEE
-    def semiclone(half: Int) = new StepsDoubleLinearSeq[CC](underlying, half)
-  }
-
-  private[java8] class StepsIntLinearSeq[CC >: Null <: collection.LinearSeqLike[Int, CC]](_underlying: CC, _maxN: Long)
-  extends StepsIntWithTail[CC, StepsIntLinearSeq[CC]](_underlying, _maxN) {
-    protected def myIsEmpty(cc: CC): Boolean = cc.isEmpty
-    protected def myTailOf(cc: CC): CC = cc.tail
-    def nextInt() = if (hasNext()) { maxN -= 1; val ans = underlying.head; underlying = underlying.tail; ans } else throwNSEE
-    def semiclone(half: Int) = new StepsIntLinearSeq[CC](underlying, half)
-  }
-
   private[java8] class StepsAnyIterator[A](_underlying: Iterator[A])
   extends StepsLikeIterator[A, StepsAnyIterator[A]](_underlying) {
     def semiclone() = new StepsAnyIterator(null)
@@ -146,157 +32,6 @@ package converterImpls {
     def nextLong() = if (proxied ne null) proxied.nextStep else underlying.next
   }
 
-  private[java8] class StepsLongLinearSeq[CC >: Null <: collection.LinearSeqLike[Long, CC]](_underlying: CC, _maxN: Long)
-  extends StepsLongWithTail[CC, StepsLongLinearSeq[CC]](_underlying, _maxN) {
-    protected def myIsEmpty(cc: CC): Boolean = cc.isEmpty
-    protected def myTailOf(cc: CC): CC = cc.tail
-    def nextLong() = if (hasNext()) { maxN -= 1; val ans = underlying.head; underlying = underlying.tail; ans } else throwNSEE
-    def semiclone(half: Int) = new StepsLongLinearSeq[CC](underlying, half)
-  }
-
-  private[java8] class StepsIntRange(underlying: Range, _i0: Int, _iN: Int)
-  extends StepsIntLikeIndexed[StepsIntRange](_i0, _iN) {
-    def nextInt() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsIntRange(underlying, i0, half)
-  }
-
-  private[java8] class StepsAnyNumericRange[T](underlying: collection.immutable.NumericRange[T], _i0: Int, _iN: Int)
-  extends StepsLikeIndexed[T, StepsAnyNumericRange[T]](_i0, _iN) {
-    def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsAnyNumericRange[T](underlying, i0, half)
-  }
-
-  private[java8] class StepsIntNumericRange(underlying: collection.immutable.NumericRange[Int], _i0: Int, _iN: Int)
-  extends StepsIntLikeIndexed[StepsIntNumericRange](_i0, _iN) {
-    def nextInt() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsIntNumericRange(underlying, i0, half)
-  }
-
-  private[java8] class StepsLongNumericRange(underlying: collection.immutable.NumericRange[Long], _i0: Int, _iN: Int)
-  extends StepsLongLikeIndexed[StepsLongNumericRange](_i0, _iN) {
-    def nextLong() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
-    def semiclone(half: Int) = new StepsLongNumericRange(underlying, i0, half)
-  }
-
-  private[java8] trait StepsVectorLike[A] {
-    protected def myVector: Vector[A]
-    protected var index: Int = 32
-    protected var data: Array[AnyRef] = null
-    protected var index1: Int = 32
-    protected var data1: Array[AnyRef] = null
-    protected final def advanceData(iX: Int) {
-      index1 += 1
-      if (index >= 32) initTo(iX)
-      else {
-        data = data1(index1).asInstanceOf[Array[AnyRef]]
-        index = 0
-      }
-    }
-    protected final def initTo(iX: Int) {
-      myVector.length match {
-        case x if x <=  0x20 => 
-          index = iX
-          data = CollectionInternals.getDisplay0(myVector)
-        case x if x <= 0x400 => 
-          index1 = iX >>> 5
-          data1 = CollectionInternals.getDisplay1(myVector)
-          index = iX & 0x1F
-          data = data1(index1).asInstanceOf[Array[AnyRef]]
-        case x =>
-          var N = 0
-          var dataN: Array[AnyRef] = 
-            if      (x <=    0x8000) { N = 2; CollectionInternals.getDisplay2(myVector) }
-            else if (x <=  0x100000) { N = 3; CollectionInternals.getDisplay3(myVector) }
-            else if (x <= 0x2000000) { N = 4; CollectionInternals.getDisplay4(myVector) }
-            else  /*x <= 0x40000000*/{ N = 5; CollectionInternals.getDisplay5(myVector) }
-          while (N > 2) {
-            dataN = dataN((iX >>> (5*N))&0x1F).asInstanceOf[Array[AnyRef]]
-            N -= 1
-          }
-          index1 = (iX >>> 5) & 0x1F
-          data1 = dataN((iX >>> 10) & 0x1F).asInstanceOf[Array[AnyRef]]
-          index = iX & 0x1F
-          data = data1(index1).asInstanceOf[Array[AnyRef]]
-      }
-    }
-  }
-
-  private[java8] class StepsAnyVector[A](underlying: Vector[A], _i0: Int, _iN: Int)
-  extends StepsLikeIndexed[A, StepsAnyVector[A]](_i0, _iN) 
-  with StepsVectorLike[A] {
-    protected def myVector = underlying
-    def next() = if (hasNext()) {
-      index += 1
-      if (index >= 32) advanceData(i0)
-      i0 += 1
-      data(index).asInstanceOf[A]
-    } else throwNSEE
-    def semiclone(half: Int) = {
-      val ans = new StepsAnyVector(underlying, i0, half)
-      index = 32
-      index1 = 32
-      i0 = half
-      ans
-    }
-  }
-
-  private[java8] class StepsDoubleVector(underlying: Vector[Double], _i0: Int, _iN: Int)
-  extends StepsDoubleLikeIndexed[StepsDoubleVector](_i0, _iN)
-  with StepsVectorLike[Double] {
-    protected def myVector = underlying
-    def nextDouble() = if (hasNext()) {
-      index += 1
-      if (index >= 32) advanceData(i0)
-      i0 += 1
-      data(index).asInstanceOf[Double]
-    } else throwNSEE
-    def semiclone(half: Int) = {
-      val ans = new StepsDoubleVector(underlying, i0, half)
-      index = 32
-      index1 = 32
-      i0 = half
-      ans
-    }    
-  }
-
-  private[java8] class StepsIntVector(underlying: Vector[Int], _i0: Int, _iN: Int)
-  extends StepsIntLikeIndexed[StepsIntVector](_i0, _iN)
-  with StepsVectorLike[Int] {
-    protected def myVector = underlying
-    def nextInt() = if (hasNext()) {
-      index += 1
-      if (index >= 32) advanceData(i0)
-      i0 += 1
-      data(index).asInstanceOf[Int]
-    } else throwNSEE
-    def semiclone(half: Int) = {
-      val ans = new StepsIntVector(underlying, i0, half)
-      index = 32
-      index1 = 32
-      i0 = half
-      ans
-    }    
-  }
-
-  private[java8] class StepsLongVector(underlying: Vector[Long], _i0: Int, _iN: Int)
-  extends StepsLongLikeIndexed[StepsLongVector](_i0, _iN)
-  with StepsVectorLike[Long] {
-    protected def myVector = underlying
-    def nextLong() = if (hasNext()) {
-      index += 1
-      if (index >= 32) advanceData(i0)
-      i0 += 1
-      data(index).asInstanceOf[Long]
-    } else throwNSEE
-    def semiclone(half: Int) = {
-      val ans = new StepsLongVector(underlying, i0, half)
-      index = 32
-      index1 = 32
-      i0 = half
-      ans
-    }    
-  }
-
   private[java8] class StepsAnyFlatHashTable[A](_underlying: Array[AnyRef], _i0: Int, _iN: Int)
   extends StepsLikeGapped[A, StepsAnyFlatHashTable[A]](_underlying, _i0, _iN) {
     def next() = if (currentEntry eq null) throwNSEE else { val ans = currentEntry.asInstanceOf[A]; currentEntry = null; ans }

src/main/scala/scala/compat/java8/collectionImpl/StepsArray.scala

@@ -0,0 +1,74 @@
+package scala.compat.java8.converterImpls
+
+import language.implicitConversions
+
+import scala.compat.java8.collectionImpl._
+import scala.compat.java8.runtime._
+
+import Stepper._
+
+private[java8] class StepsObjectArray[A <: Object](underlying: Array[A], _i0: Int, _iN: Int)
+extends StepsLikeIndexed[A, StepsObjectArray[A]](_i0, _iN) {
+  def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
+  def semiclone(half: Int) = new StepsObjectArray[A](underlying, i0, half)
+}
+
+private[java8] class StepsAnyArray[A](underlying: Array[A], _i0: Int, _iN: Int)
+extends StepsLikeIndexed[A, StepsAnyArray[A]](_i0, _iN) {
+  def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
+  def semiclone(half: Int) = new StepsAnyArray[A](underlying, i0, half)
+}
+
+private[java8] class StepsUnitArray(underlying: Array[Unit], _i0: Int, _iN: Int)
+extends StepsLikeIndexed[Unit, StepsUnitArray](_i0, _iN) {
+  def next() = if (hasNext()) { val j = i0; i0 += 1; () } else throwNSEE
+  def semiclone(half: Int) = new StepsUnitArray(underlying, i0, half)
+}
+
+private[java8] class StepsBoxedBooleanArray(underlying: Array[Boolean], _i0: Int, _iN: Int)
+extends StepsLikeIndexed[Boolean, StepsBoxedBooleanArray](_i0, _iN) {
+  def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
+  def semiclone(half: Int) = new StepsBoxedBooleanArray(underlying, i0, half)
+}
+
+private[java8] class StepsBoxedByteArray(underlying: Array[Byte], _i0: Int, _iN: Int)
+extends StepsLikeIndexed[Byte, StepsBoxedByteArray](_i0, _iN) {
+  def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
+  def semiclone(half: Int) = new StepsBoxedByteArray(underlying, i0, half)
+}
+
+private[java8] class StepsBoxedCharArray(underlying: Array[Char], _i0: Int, _iN: Int)
+extends StepsLikeIndexed[Char, StepsBoxedCharArray](_i0, _iN) {
+  def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
+  def semiclone(half: Int) = new StepsBoxedCharArray(underlying, i0, half)
+}
+
+private[java8] class StepsBoxedShortArray(underlying: Array[Short], _i0: Int, _iN: Int)
+extends StepsLikeIndexed[Short, StepsBoxedShortArray](_i0, _iN) {
+  def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
+  def semiclone(half: Int) = new StepsBoxedShortArray(underlying, i0, half)
+}
+
+private[java8] class StepsBoxedFloatArray(underlying: Array[Float], _i0: Int, _iN: Int)
+extends StepsLikeIndexed[Float, StepsBoxedFloatArray](_i0, _iN) {
+  def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
+  def semiclone(half: Int) = new StepsBoxedFloatArray(underlying, i0, half)
+}
+
+private[java8] class StepsDoubleArray(underlying: Array[Double], _i0: Int, _iN: Int)
+extends StepsDoubleLikeIndexed[StepsDoubleArray](_i0, _iN) {
+  def nextDouble() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
+  def semiclone(half: Int) = new StepsDoubleArray(underlying, i0, half)
+}
+
+private[java8] class StepsIntArray(underlying: Array[Int], _i0: Int, _iN: Int)
+extends StepsIntLikeIndexed[StepsIntArray](_i0, _iN) {
+  def nextInt() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
+  def semiclone(half: Int) = new StepsIntArray(underlying, i0, half)
+}
+
+private[java8] class StepsLongArray(underlying: Array[Long], _i0: Int, _iN: Int)
+extends StepsLongLikeIndexed[StepsLongArray](_i0, _iN) {
+  def nextLong() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
+  def semiclone(half: Int) = new StepsLongArray(underlying, i0, half)
+}

src/main/scala/scala/compat/java8/collectionImpl/StepsIndexedSeq.scala

@@ -0,0 +1,32 @@
+package scala.compat.java8.converterImpls
+
+import language.implicitConversions
+
+import scala.compat.java8.collectionImpl._
+import scala.compat.java8.runtime._
+
+import Stepper._
+
+private[java8] class StepsAnyIndexedSeq[A](underlying: collection.IndexedSeqLike[A, _], _i0: Int, _iN: Int)
+extends StepsLikeIndexed[A, StepsAnyIndexedSeq[A]](_i0, _iN) {
+  def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
+  def semiclone(half: Int) = new StepsAnyIndexedSeq[A](underlying, i0, half)
+}
+
+private[java8] class StepsDoubleIndexedSeq[CC <: collection.IndexedSeqLike[Double, _]](underlying: CC, _i0: Int, _iN: Int)
+extends StepsDoubleLikeIndexed[StepsDoubleIndexedSeq[CC]](_i0, _iN) {
+  def nextDouble() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
+  def semiclone(half: Int) = new StepsDoubleIndexedSeq[CC](underlying, i0, half)
+}
+
+private[java8] class StepsIntIndexedSeq[CC <: collection.IndexedSeqLike[Int, _]](underlying: CC, _i0: Int, _iN: Int)
+extends StepsIntLikeIndexed[StepsIntIndexedSeq[CC]](_i0, _iN) {
+  def nextInt() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
+  def semiclone(half: Int) = new StepsIntIndexedSeq[CC](underlying, i0, half)
+}
+
+private[java8] class StepsLongIndexedSeq[CC <: collection.IndexedSeqLike[Long, _]](underlying: CC, _i0: Int, _iN: Int)
+extends StepsLongLikeIndexed[StepsLongIndexedSeq[CC]](_i0, _iN) {
+  def nextLong() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE
+  def semiclone(half: Int) = new StepsLongIndexedSeq[CC](underlying, i0, half)
+}