Scala Standard Library 2.12.18 - scala.collection.parallel.mutable.ParArray (original) (raw)

class ParArray[T] extends ParSeq[T] with GenericParTemplate[T, ParArray] with ParSeqLike[T, ParArray[T], ArraySeq[T]] with Serializable

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. ParArray
2. Serializable
3. Serializable
4. ParSeq
5. ParSeq
6. ParSeqLike
7. ParIterable
8. Mutable
9. ParIterable
10. ParIterableLike
11. Parallel
12. CustomParallelizable
13. GenericParTemplate
14. HasNewCombiner
15. GenSeq
16. GenIterable
17. GenTraversable
18. GenericTraversableTemplate
19. HasNewBuilder
20. GenSeqLike
21. Equals
22. GenIterableLike
23. GenTraversableLike
24. Parallelizable
25. GenTraversableOnce
26. AnyRef
27. Any

Implicitly

1. by CollectionsHaveToParArray

2. by any2stringadd

3. by StringFormat

4. by Ensuring

5. by ArrowAssoc

6. Hide All

7. Show All

Instance Constructors

1.  new ParArray(sz: Int)

Type Members

1.  class Aggregate[S] extends Accessor[S, Aggregate[S]]
2.  trait BuilderOps[Elem, To] extends AnyRef
3.  class Collect[S, That] extends Transformer[Combiner[S, That], Collect[S, That]]
4.  abstract class Composite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends NonDivisibleTask[R, Composite[FR, SR, R, First, Second]]
5.  class Copy[U >: T, That] extends Transformer[Combiner[U, That], Copy[U, That]]
6.  class CopyToArray[U >: T, This >: Repr] extends Accessor[Unit, CopyToArray[U, This]]
7.  class Count extends Accessor[Int, Count]
8.  class CreateScanTree[U >: T] extends Transformer[ScanTree[U], CreateScanTree[U]]
9.  class Drop[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Drop[U, This]]
10.  class Exists extends Accessor[Boolean, Exists]
11.  class Filter[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Filter[U, This]]
12.  class FilterNot[U >: T, This >: Repr] extends Transformer[Combiner[U, This], FilterNot[U, This]]
13.  class Find[U >: T] extends Accessor[Option[U], Find[U]]
14.  class FlatMap[S, That] extends Transformer[Combiner[S, That], FlatMap[S, That]]
15.  class Fold[U >: T] extends Accessor[U, Fold[U]]
16.  class Forall extends Accessor[Boolean, Forall]
17.  class Foreach[S] extends Accessor[Unit, Foreach[S]]
18.  class FromScanTree[U >: T, That] extends StrictSplitterCheckTask[Combiner[U, That], FromScanTree[U, That]]
19.  class GroupBy[K, U >: T] extends Transformer[HashMapCombiner[K, U], GroupBy[K, U]]
20.  class Max[U >: T] extends Accessor[Option[U], Max[U]]
21.  class Min[U >: T] extends Accessor[Option[U], Min[U]]
22.  trait NonDivisible[R] extends NonDivisibleTask[R, NonDivisible[R]]
23.  trait NonDivisibleTask[R, Tp] extends StrictSplitterCheckTask[R, Tp]
24.  abstract class ParComposite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]
25.  class Partition[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Partition[U, This]]
26.  class Product[U >: T] extends Accessor[U, Product[U]]
27.  class Reduce[U >: T] extends Accessor[Option[U], Reduce[U]]
28.  abstract class ResultMapping[R, Tp, R1] extends NonDivisibleTask[R1, ResultMapping[R, Tp, R1]]
29.  case class ScanLeaf[U >: T](pit: IterableSplitter[U], op: (U, U) ⇒ U, from: Int, len: Int, prev: Option[ScanLeaf[U]], acc: U) extends ScanTree[U] with scala.Product with Serializable
30.  case class ScanNode[U >: T](left: ScanTree[U], right: ScanTree[U]) extends ScanTree[U] with scala.Product with Serializable
31.  trait ScanTree[U >: T] extends AnyRef
32.  abstract class SeqComposite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]
33.  trait SignallingOps[PI <: DelegatedSignalling] extends AnyRef
34.  class Slice[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Slice[U, This]]
35.  class Span[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Span[U, This]]
36.  class SplitAt[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), SplitAt[U, This]]
37.  trait StrictSplitterCheckTask[R, Tp] extends Task[R, Tp]
38.  class Sum[U >: T] extends Accessor[U, Sum[U]]
39.  class Take[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Take[U, This]]
40.  class TakeWhile[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Boolean), TakeWhile[U, This]]
41.  trait TaskOps[R, Tp] extends AnyRef
42.  class ToParCollection[U >: T, That] extends Transformer[Combiner[U, That], ToParCollection[U, That]]
43.  class ToParMap[K, V, That] extends Transformer[Combiner[(K, V), That], ToParMap[K, V, That]]
44.  class ZipAll[U >: T, S, That] extends Transformer[Combiner[(U, S), That], ZipAll[U, S, That]]
45.  trait Accessor[R, Tp] extends ParSeqLike.Accessor[R, Tp]
46.  class Corresponds[S] extends Accessor[Boolean, Corresponds[S]]
47.  abstract class Elements extends SeqSplitter[T] with scala.BufferedIterator[T]
48.  class IndexWhere extends Accessor[Int, IndexWhere]
49.  class LastIndexWhere extends Accessor[Int, LastIndexWhere]
50.  class Reverse[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Reverse[U, This]]
51.  class ReverseMap[S, That] extends Transformer[Combiner[S, That], ReverseMap[S, That]]
52.  class SameElements[U >: T] extends Accessor[Boolean, SameElements[U]]
53.  class SegmentLength extends Accessor[(Int, Boolean), SegmentLength]
54.  trait Transformer[R, Tp] extends Accessor[R, Tp] with ParSeqLike.Transformer[R, Tp]
55.  class Updated[U >: T, That] extends Transformer[Combiner[U, That], Updated[U, That]]
56.  class Zip[U >: T, S, That] extends Transformer[Combiner[(U, S), That], Zip[U, S, That]]
57.  class Map[S] extends Task[Unit, Map[S]]
58.  class ParArrayIterator extends SeqSplitter[T]
59.  type SSCTask[R, Tp] = StrictSplitterCheckTask[R, Tp]
60.  class ScanToArray[U >: T] extends Task[Unit, ScanToArray[U]]
61.  type SuperParIterator = IterableSplitter[T]

Value Members

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def +(other: String): String
4.  def ++[U >: T, That](that: GenTraversableOnce[U])(implicit bf: CanBuildFrom[ParArray[T], U, That]): That
5.  def +:(elem: A): ParArray[A]
6.  def ->[B](y: B): (ParArray[T], B)
7.  def :+(elem: A): ParArray[A]
8.  final def ==(arg0: Any): Boolean
9.  def aggregate[S](z: ⇒ S)(seqop: (S, T) ⇒ S, combop: (S, S) ⇒ S): S
10.  def apply(i: Int): T
11.  val arrayseq: ArraySeq[T]
12.  final def asInstanceOf[T0]: T0
13.  def bf2seq[S, That](bf: CanBuildFrom[ParArray[T], S, That]): CanBuildFrom[ArraySeq[T], S, That]
14.  implicit def builder2ops[Elem, To](cb: Builder[Elem, To]): BuilderOps[Elem, To]
15.  def canEqual(other: Any): Boolean
16.  def clone(): AnyRef
17.  def collect[B](pf: PartialFunction[A, B]): ParArray[B]
18.  def combinerFactory[S, That](cbf: () ⇒ Combiner[S, That]): CombinerFactory[S, That]
19.  def combinerFactory: CombinerFactory[T, ParArray[T]]
20.  def companion: GenericCompanion[ParArray] with GenericParCompanion[ParArray]
21.  def copyToArray(xs: Array[A], start: Int, len: Int): Unit
22.  def copyToArray(xs: Array[A], start: Int): Unit
23.  def copyToArray(xs: Array[A]): Unit
24.  def corresponds[S](that: GenSeq[S])(p: (T, S) ⇒ Boolean): Boolean
25.  def count(p: (T) ⇒ Boolean): Int
26.  def debugBuffer: ArrayBuffer[String]
27.  implicit def delegatedSignalling2ops[PI <: DelegatedSignalling](it: PI): SignallingOps[PI]
28.  def diff(that: GenSeq[A]): ParArray[A]
29.  def distinct: ParArray[T]
30.  def down(p: IterableSplitter[_]): SeqSplitter[T]
31.  def drop(n: Int): ParArray[T]
32.  def dropWhile(pred: (T) ⇒ Boolean): ParArray[T]
33.  def endsWith[S](that: GenSeq[S]): Boolean
34.  def ensuring(cond: (ParArray[T]) ⇒ Boolean, msg: ⇒ Any): ParArray[T]
35.  def ensuring(cond: (ParArray[T]) ⇒ Boolean): ParArray[T]
36.  def ensuring(cond: Boolean, msg: ⇒ Any): ParArray[T]
37.  def ensuring(cond: Boolean): ParArray[T]
38.  final def eq(arg0: AnyRef): Boolean
39.  def equals(that: Any): Boolean
40.  def exists(p: (T) ⇒ Boolean): Boolean
41.  def filter(pred: (T) ⇒ Boolean): ParArray[T]
42.  def filterNot(pred: (T) ⇒ Boolean): ParArray[T]
43.  def finalize(): Unit
44.  def find(p: (T) ⇒ Boolean): Option[T]
45.  def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): ParArray[B]
46.  def flatten[B]: ParArray[B]
47.  def fold[U >: T](z: U)(op: (U, U) ⇒ U): U
48.  def foldLeft[S](z: S)(op: (S, T) ⇒ S): S
49.  def foldRight[S](z: S)(op: (T, S) ⇒ S): S
50.  def forall(p: (T) ⇒ Boolean): Boolean
51.  def foreach[U](f: (T) ⇒ U): Unit
52.  def genericBuilder[B]: Combiner[B, ParArray[B]]
53.  def genericCombiner[B]: Combiner[B, ParArray[B]]
54.  final def getClass(): Class[_]
55.  def groupBy[K](f: (T) ⇒ K): immutable.ParMap[K, ParArray[T]]
56.  def hasDefiniteSize: Boolean
57.  def hashCode(): Int
58.  def head: T
59.  def headOption: Option[T]
60.  def indexOf(elem: T, from: Int): Int
61.  def indexOf(elem: T): Int
62.  def indexWhere(p: (T) ⇒ Boolean, from: Int): Int
63.  def indexWhere(p: (T) ⇒ Boolean): Int
64.  def init: ParArray[T]
65.  def initTaskSupport(): Unit
66.  def intersect(that: scala.Seq[T]): ParArray[T]
67.  def isDefinedAt(idx: Int): Boolean
68.  def isEmpty: Boolean
69.  final def isInstanceOf[T0]: Boolean
70.  def isStrictSplitterCollection: Boolean
71.  final def isTraversableAgain: Boolean
72.  def iterator: PreciseSplitter[T]
73.  def last: T
74.  def lastIndexOf(elem: T, end: Int): Int
75.  def lastIndexOf(elem: T): Int
76.  def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
77.  def lastIndexWhere(p: (T) ⇒ Boolean): Int
78.  def lastOption: Option[T]
79.  def length: Int
80.  def map[B](f: (A) ⇒ B): ParArray[B]
81.  def max: A
82.  def maxBy[B](f: (A) ⇒ B): A
83.  def min: A
84.  def minBy[B](f: (A) ⇒ B): A
85.  def mkString: String
86.  def mkString(sep: String): String
87.  def mkString(start: String, sep: String, end: String): String
88.  final def ne(arg0: AnyRef): Boolean
89.  def newBuilder: Builder[T, ParArray[T]]
90.  def newCombiner: Combiner[T, ParArray[T]]
91.  def nonEmpty: Boolean
92.  final def notify(): Unit
93.  final def notifyAll(): Unit
94.  def padTo(len: Int, elem: A): ParArray[A]
95.  def par: ParArray[T]
96.  def parCombiner: Combiner[T, ParArray[T]]
97.  def partition(pred: (T) ⇒ Boolean): (ParArray[T], ParArray[T])
98.  def patch(from: Int, that: GenSeq[A], replaced: Int): ParArray[A]
99.  def prefixLength(p: (T) ⇒ Boolean): Int
100.  def product: A
101.  def reduce[U >: T](op: (U, U) ⇒ U): U
102.  def reduceLeft[U >: T](op: (U, T) ⇒ U): U
103.  def reduceLeftOption[U >: T](op: (U, T) ⇒ U): Option[U]
104.  def reduceOption[U >: T](op: (U, U) ⇒ U): Option[U]
105.  def reduceRight[U >: T](op: (T, U) ⇒ U): U
106.  def reduceRightOption[U >: T](op: (T, U) ⇒ U): Option[U]
107.  def repr: ParArray[T]
108.  def reuse[S, That](oldc: Option[Combiner[S, That]], newc: Combiner[S, That]): Combiner[S, That]
109.  def reverse: ParArray[T]
110.  def reverseMap[B](f: (A) ⇒ B): ParArray[B]
111.  def sameElements(that: GenIterable[A]): Boolean
112.  def scan(z: T)(op: (T, T) ⇒ T): ParArray[T]
113.  def scanBlockSize: Int
114.  def scanLeft[S, That](z: S)(op: (S, T) ⇒ S)(implicit bf: CanBuildFrom[ParArray[T], S, That]): That
115.  def scanRight[S, That](z: S)(op: (T, S) ⇒ S)(implicit bf: CanBuildFrom[ParArray[T], S, That]): That
116.  def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
117.  def seq: ArraySeq[T]
118.  def sequentially[S, That <: Parallel](b: (ArraySeq[T]) ⇒ Parallelizable[S, That]): ParArray[T]
119.  def size: Int
120.  def sizeHintIfCheap: Int
121.  def slice(unc_from: Int, unc_until: Int): ParArray[T]
122.  def span(pred: (T) ⇒ Boolean): (ParArray[T], ParArray[T])
123.  def splitAt(n: Int): (ParArray[T], ParArray[T])
124.  def splitter: ParArrayIterator
125.  def startsWith[S](that: GenSeq[S], offset: Int): Boolean
126.  def startsWith[B](that: GenSeq[B]): Boolean
127.  def stringPrefix: String
128.  def sum: A
129.  final def synchronized[T0](arg0: ⇒ T0): T0
130.  def tail: ParArray[T]
131.  def take(n: Int): ParArray[T]
132.  def takeWhile(pred: (T) ⇒ Boolean): ParArray[T]
133.  implicit def task2ops[R, Tp](tsk: SSCTask[R, Tp]): TaskOps[R, Tp]
134.  def tasksupport: TaskSupport
135.  def tasksupport_=(ts: TaskSupport): Unit
136.  def to[Col[_]]: Col[A]
137.  def toArray: Array[A]
138.  def toBuffer[U >: T]: Buffer[U]
139.  def toIndexedSeq: immutable.IndexedSeq[T]
140.  def toIterable: ParIterable[T]
141.  def toIterator: scala.Iterator[T]
142.  def toList: List[T]
143.  def toMap[T, U]: collection.Map[T, U]
144.  def toParArray: ParArray[T]
145.  def toParCollection[U >: T, That](cbf: () ⇒ Combiner[U, That]): That
146.  def toParMap[K, V, That](cbf: () ⇒ Combiner[(K, V), That])(implicit ev: <:<[T, (K, V)]): That
147.  def toSeq: ParSeq[T]
148.  def toSet[U >: T]: immutable.ParSet[U]
149.  def toStream: Stream[T]
150.  def toString(): String
151.  def toTraversable: GenTraversable[T]
152.  def toVector: Vector[T]
153.  def transpose[B](implicit asTraversable: (T) ⇒ GenTraversableOnce[B]): ParArray[ParArray[B]]
154.  def union(that: GenSeq[T]): ParArray[T]
155.  def unzip[A1, A2](implicit asPair: (T) ⇒ (A1, A2)): (ParArray[A1], ParArray[A2])
156.  def unzip3[A1, A2, A3](implicit asTriple: (T) ⇒ (A1, A2, A3)): (ParArray[A1], ParArray[A2], ParArray[A3])
157.  def update(i: Int, elem: T): Unit
158.  def updated(index: Int, elem: A): ParArray[A]
159.  final def wait(): Unit
160.  final def wait(arg0: Long, arg1: Int): Unit
161.  final def wait(arg0: Long): Unit
162.  def withFilter(pred: (T) ⇒ Boolean): ParArray[T]
163.  def wrap[R](body: ⇒ R): NonDivisible[R]
164.  def zip[B](that: GenIterable[B]): ParArray[(A, B)]
165.  def zipAll[B](that: Iterable[B], thisElem: A, thatElem: B): ParArray[(A, B)]
166.  def zipWithIndex: ParArray[(A, Int)]
167.  def →[B](y: B): (ParArray[T], B)

Deprecated Value Members

1.  def /:[S](z: S)(op: (S, T) ⇒ S): S
2.  def :\[S](z: S)(op: (T, S) ⇒ S): S
3.  def formatted(fmtstr: String): String
4.  def view: SeqView[T, ArraySeq[T]]

Inherited from Serializable

Inherited from java.io.Serializable

Inherited from ParSeq[T]

Inherited from parallel.ParSeq[T]

Inherited from ParSeqLike[T, ParArray[T], ArraySeq[T]]

Inherited from ParIterable[T]

Inherited from Mutable

Inherited from parallel.ParIterable[T]

Inherited from ParIterableLike[T, ParArray[T], ArraySeq[T]]

Inherited from Parallel

Inherited from CustomParallelizable[T, ParArray[T]]

Inherited from GenericParTemplate[T, ParArray]

Inherited from HasNewCombiner[T, scala.collection.parallel.mutable.ParArray[T] @scala.annotation.unchecked.uncheckedVariance]

Inherited from GenSeq[T]

Inherited from GenIterable[T]

Inherited from GenTraversable[T]

Inherited from GenericTraversableTemplate[T, ParArray]

Inherited from HasNewBuilder[T, scala.collection.parallel.mutable.ParArray[T] @scala.annotation.unchecked.uncheckedVariance]

Inherited from GenSeqLike[T, ParArray[T]]

Inherited from Equals

Inherited from GenIterableLike[T, ParArray[T]]

Inherited from GenTraversableLike[T, ParArray[T]]

Inherited from Parallelizable[T, ParArray[T]]

Inherited from GenTraversableOnce[T]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion CollectionsHaveToParArray fromParArray[T] to CollectionsHaveToParArray[ParArray[T], T]

Inherited by implicit conversion any2stringadd fromParArray[T] to any2stringadd[ParArray[T]]

Inherited by implicit conversion StringFormat fromParArray[T] to StringFormat[ParArray[T]]

Inherited by implicit conversion Ensuring fromParArray[T] to Ensuring[ParArray[T]]

Inherited by implicit conversion ArrowAssoc fromParArray[T] to ArrowAssoc[ParArray[T]]

Ungrouped