Scala Standard Library 2.12.18 - scala.collection.parallel.immutable.ParHashSet.ParHashSetIterator (original) (raw)

class ParHashSetIterator extends IterableSplitter[T]

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. ParHashSetIterator
2. IterableSplitter
3. DelegatedSignalling
4. Signalling
5. Splitter
6. AugmentedIterableIterator
7. RemainsIterator
8. Iterator
9. TraversableOnce
10. GenTraversableOnce
11. AnyRef
12. Any

Implicitly

1. by MonadOps

2. by CollectionsHaveToParArray

3. by any2stringadd

4. by StringFormat

5. by Ensuring

6. by ArrowAssoc

7. by alternateImplicit

8. Hide All

9. Show All

Type Members

1.  class GroupedIterator[B >: A] extends AbstractIterator[Seq[B]] with Iterator[Seq[B]]
2.  class Appended[U >: T, PI <: IterableSplitter[U]] extends IterableSplitter[U]
3.  class Mapped[S] extends IterableSplitter[S]
4.  class Taken extends IterableSplitter[T]
5.  class Zipped[S] extends IterableSplitter[(T, S)]
6.  class ZippedAll[U >: T, S] extends IterableSplitter[(U, S)]

Value Members

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def +(other: String): String
4.  def ++(that: ⇒ Iterator[T]): Iterator[T]
5.  def ->[B](y: B): (ParHashSetIterator, B)
6.  final def ==(arg0: Any): Boolean
7.  def abort(): Unit
8.  def addString(b: StringBuilder): StringBuilder
9.  def addString(b: StringBuilder, sep: String): StringBuilder
10.  def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
11.  def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
12.  def appendParIterable[U >: T, PI <: IterableSplitter[U]](that: PI): Appended[U, PI]
13.  final def asInstanceOf[T0]: T0
14.  def buffered: BufferedIterator[T]
15.  def buildString(closure: ((String) ⇒ Unit) ⇒ Unit): String
16.  def clone(): AnyRef
17.  def collect[B](pf: PartialFunction[T, B]): Iterator[B]
18.  def collect2combiner[S, That](pf: PartialFunction[T, S], cb: Combiner[S, That]): Combiner[S, That]
19.  def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
20.  def contains(elem: Any): Boolean
21.  def copy2builder[U >: T, Coll, Bld <: Builder[U, Coll]](b: Bld): Bld
22.  def copyToArray(xs: Array[A], start: Int, len: Int): Unit
23.  def copyToArray(xs: Array[A]): Unit
24.  def copyToArray(xs: Array[A], start: Int): Unit
25.  def copyToBuffer[B >: T](dest: Buffer[B]): Unit
26.  def corresponds[B](that: GenTraversableOnce[B])(p: (T, B) ⇒ Boolean): Boolean
27.  def count(p: (T) ⇒ Boolean): Int
28.  def drop(n: Int): IterableSplitter[T]
29.  def drop2combiner[U >: T, This](n: Int, cb: Combiner[U, This]): Combiner[U, This]
30.  def dropWhile(p: (T) ⇒ Boolean): Iterator[T]
31.  def dup: IterableSplitter[T]
32.  def duplicate: (Iterator[T], Iterator[T])
33.  def ensuring(cond: (ParHashSetIterator) ⇒ Boolean, msg: ⇒ Any): ParHashSetIterator
34.  def ensuring(cond: (ParHashSetIterator) ⇒ Boolean): ParHashSetIterator
35.  def ensuring(cond: Boolean, msg: ⇒ Any): ParHashSetIterator
36.  def ensuring(cond: Boolean): ParHashSetIterator
37.  final def eq(arg0: AnyRef): Boolean
38.  def equals(arg0: Any): Boolean
39.  def exists(p: (T) ⇒ Boolean): Boolean
40.  def filter(p: (T) ⇒ Boolean): Iterator[T]
41.  def filter2combiner[U >: T, This](pred: (T) ⇒ Boolean, cb: Combiner[U, This]): Combiner[U, This]
42.  def filterNot(p: (T) ⇒ Boolean): Iterator[T]
43.  def filterNot2combiner[U >: T, This](pred: (T) ⇒ Boolean, cb: Combiner[U, This]): Combiner[U, This]
44.  def finalize(): Unit
45.  def find(p: (T) ⇒ Boolean): Option[T]
46.  def flatMap[B](f: (T) ⇒ GenTraversableOnce[B]): Iterator[B]
47.  def flatmap2combiner[S, That](f: (T) ⇒ GenTraversableOnce[S], cb: Combiner[S, That]): Combiner[S, That]
48.  def fold[U >: T](z: U)(op: (U, U) ⇒ U): U
49.  def foldLeft[B](z: B)(op: (B, T) ⇒ B): B
50.  def foldRight[B](z: B)(op: (T, B) ⇒ B): B
51.  def forall(p: (T) ⇒ Boolean): Boolean
52.  def foreach(f: (T) ⇒ Unit): Unit
53.  final def getClass(): Class[_]
54.  def grouped[B >: T](size: Int): GroupedIterator[B]
55.  def hasDefiniteSize: Boolean
56.  def hasNext: Boolean
57.  def hashCode(): Int
58.  var i: Int
59.  def indexFlag: Int
60.  def indexOf[B >: T](elem: B, from: Int): Int
61.  def indexOf[B >: T](elem: B): Int
62.  def indexWhere(p: (T) ⇒ Boolean, from: Int): Int
63.  def indexWhere(p: (T) ⇒ Boolean): Int
64.  def isAborted: Boolean
65.  def isEmpty: Boolean
66.  final def isInstanceOf[T0]: Boolean
67.  def isRemainingCheap: Boolean
68.  def isTraversableAgain: Boolean
69.  def length: Int
70.  def map[S](f: (T) ⇒ S): Mapped[S]
71.  def map2combiner[S, That](f: (T) ⇒ S, cb: Combiner[S, That]): Combiner[S, That]
72.  def max: A
73.  def maxBy[B](f: (A) ⇒ B): A
74.  def min: A
75.  def minBy[B](f: (A) ⇒ B): A
76.  def mkString: String
77.  def mkString(sep: String): String
78.  def mkString(start: String, sep: String, end: String): String
79.  final def ne(arg0: AnyRef): Boolean
80.  def next(): T
81.  def nonEmpty: Boolean
82.  final def notify(): Unit
83.  final def notifyAll(): Unit
84.  def padTo(len: Int, elem: T): Iterator[T]
85.  def partition(p: (T) ⇒ Boolean): (Iterator[T], Iterator[T])
86.  def partition2combiners[U >: T, This](pred: (T) ⇒ Boolean, btrue: Combiner[U, This], bfalse: Combiner[U, This]): (Combiner[U, This], Combiner[U, This])
87.  def patch[B >: T](from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B]
88.  def product: A
89.  def reduce[U >: T](op: (U, U) ⇒ U): U
90.  def reduceLeft[U >: T](howmany: Int, op: (U, U) ⇒ U): U
91.  def reduceLeft[B >: T](op: (B, T) ⇒ B): B
92.  def reduceLeftOption[B >: T](op: (B, T) ⇒ B): Option[B]
93.  def reduceOption[A1 >: T](op: (A1, A1) ⇒ A1): Option[A1]
94.  def reduceRight[B >: T](op: (T, B) ⇒ B): B
95.  def reduceRightOption[B >: T](op: (T, B) ⇒ B): Option[B]
96.  def remaining: Int
97.  def reversed: List[T]
98.  def sameElements(that: Iterator[_]): Boolean
99.  def scanLeft[B](z: B)(op: (B, T) ⇒ B): Iterator[B]
100.  def scanRight[B](z: B)(op: (T, B) ⇒ B): Iterator[B]
101.  def scanToArray[U >: T, A >: U](z: U, op: (U, U) ⇒ U, array: Array[A], from: Int): Unit
102.  def scanToCombiner[U >: T, That](howmany: Int, startValue: U, op: (U, U) ⇒ U, cb: Combiner[U, That]): Combiner[U, That]
103.  def scanToCombiner[U >: T, That](startValue: U, op: (U, U) ⇒ U, cb: Combiner[U, That]): Combiner[U, That]
104.  def seq: Iterator[T]
105.  def setIndexFlag(f: Int): Unit
106.  def setIndexFlagIfGreater(f: Int): Unit
107.  def setIndexFlagIfLesser(f: Int): Unit
108.  def shouldSplitFurther[S](coll: parallel.ParIterable[S], parallelismLevel: Int): Boolean
109.  val signalDelegate: Signalling
110.  def size: Int
111.  def sizeHintIfCheap: Int
112.  def slice(from1: Int, until1: Int): IterableSplitter[T]
113.  def slice2combiner[U >: T, This](from: Int, until: Int, cb: Combiner[U, This]): Combiner[U, This]
114.  def sliceIterator(from: Int, until: Int): Iterator[T]
115.  def sliding[B >: T](size: Int, step: Int = 1): GroupedIterator[B]
116.  def span(p: (T) ⇒ Boolean): (Iterator[T], Iterator[T])
117.  def span2combiners[U >: T, This](p: (T) ⇒ Boolean, before: Combiner[U, This], after: Combiner[U, This]): (Combiner[U, This], Combiner[U, This])
118.  def split: scala.Seq[IterableSplitter[T]]
119.  def splitAt2combiners[U >: T, This](at: Int, before: Combiner[U, This], after: Combiner[U, This]): (Combiner[U, This], Combiner[U, This])
120.  def splitWithSignalling: scala.Seq[IterableSplitter[T]]
121.  def sum: A
122.  final def synchronized[T0](arg0: ⇒ T0): T0
123.  val sz: Int
124.  def tag: Int
125.  def take(n: Int): IterableSplitter[T]
126.  def take2combiner[U >: T, This](n: Int, cb: Combiner[U, This]): Combiner[U, This]
127.  def takeWhile(p: (T) ⇒ Boolean): Iterator[T]
128.  def takeWhile2combiner[U >: T, This](p: (T) ⇒ Boolean, cb: Combiner[U, This]): (Combiner[U, This], Boolean)
129.  def to[Col[_]]: Col[A]
130.  def toArray: Array[A]
131.  def toBuffer[B >: T]: Buffer[B]
132.  def toIndexedSeq: immutable.IndexedSeq[T]
133.  def toIterable: Iterable[T]
134.  def toIterator: Iterator[T]
135.  def toList: List[T]
136.  def toMap[T, U]: collection.Map[T, U]
137.  def toParArray: ParArray[T]
138.  def toSeq: Seq[T]
139.  def toSet[B >: T]: immutable.Set[B]
140.  def toStream: immutable.Stream[T]
141.  def toString(): String
142.  def toTraversable: Traversable[T]
143.  def toVector: Vector[T]
144.  var triter: scala.Iterator[T]
145.  final def wait(): Unit
146.  final def wait(arg0: Long, arg1: Int): Unit
147.  final def wait(arg0: Long): Unit
148.  def withFilter(p: (T) ⇒ Boolean): Iterator[T]
149.  def zip[B](that: Iterator[B]): Iterator[(T, B)]
150.  def zip2combiner[U >: T, S, That](otherpit: RemainsIterator[S], cb: Combiner[(U, S), That]): Combiner[(U, S), That]
151.  def zipAll[B](that: Iterator[B], thisElem: T, thatElem: B): Iterator[(T, B)]
152.  def zipAll2combiner[U >: T, S, That](that: RemainsIterator[S], thiselem: U, thatelem: S, cb: Combiner[(U, S), That]): Combiner[(U, S), That]
153.  def zipAllParSeq[S, U >: T, R >: S](that: SeqSplitter[S], thisElem: U, thatElem: R): ZippedAll[U, R]
154.  def zipParSeq[S](that: SeqSplitter[S]): Zipped[S]
155.  def zipWithIndex: Iterator[(T, Int)]
156.  def →[B](y: B): (ParHashSetIterator, B)

Deprecated Value Members

1.  def /:[B](z: B)(op: (B, T) ⇒ B): B
2.  def :\[B](z: B)(op: (T, B) ⇒ B): B
3.  def formatted(fmtstr: String): String

Ungrouped