Fixed ParSeqView, added Patched and Reversed.

2 files changed, 62 insertions, 31 deletions

diff --git a/src/library/scala/collection/parallel/ParSeqViewLike.scala b/src/library/scala/collection/parallel/ParSeqViewLike.scala
index 2116d4f4b4..02f1124410 100644
--- a/src/library/scala/collection/parallel/ParSeqViewLike.scala
+++ b/src/library/scala/collection/parallel/ParSeqViewLike.scala
@@ -80,19 +80,22 @@ self =>
     override def seq = (self.seq.zipAll(other, thisElem, thatElem)).asInstanceOf[SeqView[(U, S), CollSeq]]
   }
 
-  // TODO from
   trait Reversed extends super.Reversed with Transformed[T] {
-    def seq = self.seq.reverse
+    override def parallelIterator: ParSeqIterator[T] = self.parallelIterator.reverse
+    override def seq = self.seq.reverse.asInstanceOf[SeqView[T, CollSeq]]
   }
 
+  // use only with ParSeq patches, otherwise force
   trait Patched[U >: T] extends super.Patched[U] with Transformed[U] {
-    def seq = self.seq.patch(from, patch, replaced).asInstanceOf[SeqView[U, CollSeq]]
+    def patchPar: ParSeq[U] = patch.asInstanceOf[ParSeq[U]]
+    override def parallelIterator: ParSeqIterator[U] = self.parallelIterator.patchParSeq[U](from, patchPar.parallelIterator, replaced)
+    override def seq = self.seq.patch(from, patch, replaced).asInstanceOf[SeqView[U, CollSeq]]
   }
 
+  // use Patched instead
   trait Prepended[U >: T] extends super.Prepended[U] with Transformed[U] {
-    def seq = (fst +: self.seq).asInstanceOf[SeqView[U, CollSeq]]
+    unsupported
   }
-  // TODO until
 
   /* wrapper virtual ctors */
 
@@ -113,25 +116,52 @@ self =>
     val thisElem = _thisElem
     val thatElem = _thatElem
   }
-
-  // TODO from here
   protected override def newReversed: Transformed[T] = new Reversed { }
-  protected override def newPatched[U >: T](_from: Int, _patch: Seq[U], _replaced: Int): Transformed[U] = new Patched[U] { val from = _from; val patch = _patch; val replaced = _replaced }
-  protected override def newPrepended[U >: T](elem: U): Transformed[U] = new Prepended[U] { protected[this] val fst = elem }
-  // TODO until here
+  protected override def newPatched[U >: T](_from: Int, _patch: Seq[U], _replaced: Int): Transformed[U] = new Patched[U] {
+    val from = _from;
+    val patch = _patch;
+    val replaced = _replaced
+  }
+  protected override def newPrepended[U >: T](elem: U): Transformed[U] = unsupported
 
   /* operation overrides */
 
+  /* sliced */
   override def slice(from: Int, until: Int): This = newSliced(from, until).asInstanceOf[This]
   override def take(n: Int): This = newSliced(0, n).asInstanceOf[This]
   override def drop(n: Int): This = newSliced(n, length).asInstanceOf[This]
   override def splitAt(n: Int): (This, This) = (take(n), drop(n))
+
+  /* appended */
   override def ++[U >: T, That](xs: TraversableOnce[U])(implicit bf: CanBuildFrom[This, U, That]): That = newAppended(xs.toTraversable).asInstanceOf[That]
+  override def :+[U >: T, That](elem: U)(implicit bf: CanBuildFrom[This, U, That]): That = ++(Iterator.single(elem))(bf)
+  override def union[U >: T, That](that: Seq[U])(implicit bf: CanBuildFrom[This, U, That]): That = this ++ that
+
+  /* misc */
   override def map[S, That](f: T => S)(implicit bf: CanBuildFrom[This, S, That]): That = newMapped(f).asInstanceOf[That]
   override def zip[U >: T, S, That](that: Iterable[S])(implicit bf: CanBuildFrom[This, (U, S), That]): That = newZippedTryParSeq(that).asInstanceOf[That]
   override def zipWithIndex[U >: T, That](implicit bf: CanBuildFrom[This, (U, Int), That]): That =
     newZipped(new ParRange(0, parallelIterator.remaining, 1, false)).asInstanceOf[That]
+  override def reverse: This = newReversed.asInstanceOf[This]
+  override def reverseMap[S, That](f: T => S)(implicit bf: CanBuildFrom[This, S, That]): That = reverse.map(f)
+
+  /* patched */
+  override def updated[U >: T, That](index: Int, elem: U)(implicit bf: CanBuildFrom[This, U, That]): That = {
+    require(0 <= index && index < length)
+    patch(index, List(elem), 1)(bf)
+  }
+  override def padTo[U >: T, That](len: Int, elem: U)(implicit bf: CanBuildFrom[This, U, That]): That = patch(length, Seq.fill(len - length)(elem), 0)
+  override def +:[U >: T, That](elem: U)(implicit bf: CanBuildFrom[This, U, That]): That = patch(0, mutable.ParArray.fromTraversables(Iterator.single(elem)), 0)
+  override def patch[U >: T, That](from: Int, patch: Seq[U], replace: Int)(implicit bf: CanBuildFrom[This, U, That]): That = newPatched(from, patch, replace).asInstanceOf[That]
 
+  /* forced */
+  override def diff[U >: T](that: Seq[U]): This = newForced(thisParSeq diff that).asInstanceOf[This]
+  override def intersect[U >: T](that: Seq[U]): This = newForced(thisParSeq intersect that).asInstanceOf[This]
+  override def sorted[U >: T](implicit ord: Ordering[U]): This = newForced(thisParSeq sorted ord).asInstanceOf[This]
+  override def collect[S, That](pf: PartialFunction[T, S])(implicit bf: CanBuildFrom[This, S, That]): That = filter(pf.isDefinedAt).map(pf)(bf)
+  override def scanLeft[S, That](z: S)(op: (S, T) => S)(implicit bf: CanBuildFrom[This, S, That]): That = newForced(thisParSeq.scanLeft(z)(op)).asInstanceOf[That]
+  override def scanRight[S, That](z: S)(op: (T, S) => S)(implicit bf: CanBuildFrom[This, S, That]): That = newForced(thisParSeq.scanRight(z)(op)).asInstanceOf[That]
+  override def groupBy[K](f: T => K): collection.immutable.Map[K, This] = thisParSeq.groupBy(f).mapValues(xs => newForced(xs).asInstanceOf[This])
   override def force[U >: T, That](implicit bf: CanBuildFrom[Coll, U, That]) = bf ifParallel { pbf =>
     executeAndWaitResult(new Force(pbf, parallelIterator) mapResult { _.result })
   } otherwise {
@@ -140,26 +170,6 @@ self =>
     b.result
   }
 
-  // TODO from here
-  override def collect[S, That](pf: PartialFunction[T, S])(implicit bf: CanBuildFrom[This, S, That]): That = filter(pf.isDefinedAt).map(pf)(bf)
-  override def scanLeft[S, That](z: S)(op: (S, T) => S)(implicit bf: CanBuildFrom[This, S, That]): That = newForced(thisSeq.scanLeft(z)(op)).asInstanceOf[That]
-  override def scanRight[S, That](z: S)(op: (T, S) => S)(implicit bf: CanBuildFrom[This, S, That]): That = newForced(thisSeq.scanRight(z)(op)).asInstanceOf[That]
-  override def groupBy[K](f: T => K): collection.immutable.Map[K, This] = thisSeq.groupBy(f).mapValues(xs => newForced(xs).asInstanceOf[This])
-  override def +:[U >: T, That](elem: U)(implicit bf: CanBuildFrom[This, U, That]): That = newPrepended(elem).asInstanceOf[That]
-  override def reverse: This = newReversed.asInstanceOf[This]
-  override def patch[U >: T, That](from: Int, patch: Seq[U], replaced: Int)(implicit bf: CanBuildFrom[This, U, That]): That = newPatched(from, patch, replaced).asInstanceOf[That]
-  override def padTo[U >: T, That](len: Int, elem: U)(implicit bf: CanBuildFrom[This, U, That]): That = patch(length, Seq.fill(len - length)(elem), 0)
-  override def reverseMap[S, That](f: T => S)(implicit bf: CanBuildFrom[This, S, That]): That = reverse.map(f)
-  override def updated[U >: T, That](index: Int, elem: U)(implicit bf: CanBuildFrom[This, U, That]): That = {
-    require(0 <= index && index < length)
-    patch(index, List(elem), 1)(bf)
-  }
-  override def :+[U >: T, That](elem: U)(implicit bf: CanBuildFrom[This, U, That]): That = ++(Iterator.single(elem))(bf)
-  override def union[U >: T, That](that: Seq[U])(implicit bf: CanBuildFrom[This, U, That]): That = this ++ that
-  override def diff[U >: T](that: Seq[U]): This = newForced(thisSeq diff that).asInstanceOf[This]
-  override def intersect[U >: T](that: Seq[U]): This = newForced(thisSeq intersect that).asInstanceOf[This]
-  override def sorted[U >: T](implicit ord: Ordering[U]): This = newForced(thisSeq sorted ord).asInstanceOf[This]
-
   /* tasks */
 
   protected[this] class Force[U >: T, That](cbf: CanCombineFrom[Coll, U, That], protected[this] val pit: ParSeqIterator[T])
@@ -169,7 +179,6 @@ self =>
     protected[this] def newSubtask(p: SuperParIterator) = new Force(cbf, down(p))
     override def merge(that: Force[U, That]) = result = result combine that.result
   }
-  // TODO until here
 
 }
 
diff --git a/src/library/scala/collection/parallel/RemainsIterator.scala b/src/library/scala/collection/parallel/RemainsIterator.scala
index 56eaf5a451..ae19ed8744 100644
--- a/src/library/scala/collection/parallel/RemainsIterator.scala
+++ b/src/library/scala/collection/parallel/RemainsIterator.scala
@@ -548,6 +548,28 @@ self =>
 
   override def zipAllParSeq[S, U >: T, R >: S](that: ParSeqIterator[S], thisElem: U, thatElem: R) = new ZippedAll[U, R](that, thisElem, thatElem)
 
+  def reverse: ParSeqIterator[T] = {
+    val pa = mutable.ParArray.fromTraversables(self)
+    new pa.ParArrayIterator with pa.SCPI {
+      override def reverse = self
+    }
+  }
+
+  class Patched[U >: T](from: Int, patch: ParSeqIterator[U], replaced: Int) extends ParSeqIterator[U] {
+    var signalDelegate = self.signalDelegate
+    private[this] val trio = {
+      val pits = self.psplit(from, replaced, self.remaining - from - replaced)
+      (pits(0).appendParSeq[U, ParSeqIterator[U]](patch)) appendParSeq pits(2)
+    }
+    def hasNext = trio.hasNext
+    def next = trio.next
+    def remaining = trio.remaining
+    def split = trio.split
+    def psplit(sizes: Int*) = trio.psplit(sizes: _*)
+  }
+
+  def patchParSeq[U >: T](from: Int, patchElems: ParSeqIterator[U], replaced: Int) = new Patched(from, patchElems, replaced)
+
 }