From cdd4cf44dd7d1ae6097aaa384b785b260234de29 Mon Sep 17 00:00:00 2001 From: Aleksandar Pokopec Date: Fri, 24 Sep 2010 13:57:05 +0000 Subject: Fixed ParSeqView, added Patched and Reversed. --- .../scala/collection/parallel/ParSeqViewLike.scala | 71 ++++++++++++---------- .../collection/parallel/RemainsIterator.scala | 22 +++++++ 2 files changed, 62 insertions(+), 31 deletions(-) (limited to 'src') 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) + } -- cgit v1.2.3