class ParHashMap[K, V] extends ParMap[K, V] with GenericParMapTemplate[K, V, ParHashMap] with ParMapLike[K, V, ParHashMap[K, V], HashMap[K, V]] with ParHashTable[K, DefaultEntry[K, V]] with Serializable

A parallel hash map.

ParHashMap is a parallel map which internally keeps elements within a hash table. It uses chaining to resolve collisions.

K

type of the keys in the parallel hash map

V

type of the values in the parallel hash map

Self Type
ParHashMap[K, V]
Annotations
@SerialVersionUID()
Linear Supertypes
Serializable, java.io.Serializable, ParHashTable[K, DefaultEntry[K, V]], HashTable[K, DefaultEntry[K, V]], HashUtils[K], ParMap[K, V], ParMapLike[K, V, ParHashMap[K, V], HashMap[K, V]], mutable.Cloneable[ParHashMap[K, V]], Cloneable, java.lang.Cloneable, Shrinkable[K], Growable[(K, V)], Clearable, ParIterable[(K, V)], Mutable, parallel.ParMap[K, V], parallel.ParMapLike[K, V, ParHashMap[K, V], HashMap[K, V]], parallel.ParIterable[(K, V)], ParIterableLike[(K, V), ParHashMap[K, V], HashMap[K, V]], Parallel, CustomParallelizable[(K, V), ParHashMap[K, V]], Parallelizable[(K, V), ParHashMap[K, V]], GenericParMapTemplate[K, V, ParHashMap], GenericParTemplate[(K, V), ParIterable], HasNewCombiner[(K, V), ParHashMap[K, V]], GenMap[K, V], GenIterable[(K, V)], GenTraversable[(K, V)], GenericTraversableTemplate[(K, V), ParIterable], HasNewBuilder[(K, V), scala.collection.parallel.mutable.ParIterable[(K, V)] @scala.annotation.unchecked.uncheckedVariance], GenMapLike[K, V, ParHashMap[K, V]], Equals, GenIterableLike[(K, V), ParHashMap[K, V]], GenTraversableLike[(K, V), ParHashMap[K, V]], GenTraversableOnce[(K, V)], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ParHashMap
  2. Serializable
  3. Serializable
  4. ParHashTable
  5. HashTable
  6. HashUtils
  7. ParMap
  8. ParMapLike
  9. Cloneable
  10. Cloneable
  11. Cloneable
  12. Shrinkable
  13. Growable
  14. Clearable
  15. ParIterable
  16. Mutable
  17. ParMap
  18. ParMapLike
  19. ParIterable
  20. ParIterableLike
  21. Parallel
  22. CustomParallelizable
  23. Parallelizable
  24. GenericParMapTemplate
  25. GenericParTemplate
  26. HasNewCombiner
  27. GenMap
  28. GenIterable
  29. GenTraversable
  30. GenericTraversableTemplate
  31. HasNewBuilder
  32. GenMapLike
  33. Equals
  34. GenIterableLike
  35. GenTraversableLike
  36. GenTraversableOnce
  37. AnyRef
  38. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new ParHashMap()

Type Members

  1. trait Accessor [R, Tp] extends StrictSplitterCheckTask[R, Tp]

    Standard accessor task that iterates over the elements of the collection.

    Standard accessor task that iterates over the elements of the collection.

    R

    type of the result of this method (R for result).

    Tp

    the representation type of the task at hand.

    Attributes
    protected
    Definition Classes
    ParIterableLike
  2. class Aggregate [S] extends Accessor[S, Aggregate[S]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  3. trait BuilderOps [Elem, To] extends AnyRef
    Definition Classes
    ParIterableLike
  4. class Collect [S, That] extends Transformer[Combiner[S, That], Collect[S, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  5. abstract class Composite [FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends NonDivisibleTask[R, Composite[FR, SR, R, First, Second]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  6. class Copy [U >: T, That] extends Transformer[Combiner[U, That], Copy[U, That]]
    Attributes
    protected
    Definition Classes
    ParIterableLike
  7. class CopyToArray [U >: T, This >: Repr] extends Accessor[Unit, CopyToArray[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  8. class Count extends Accessor[Int, Count]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  9. class CreateScanTree [U >: T] extends Transformer[ScanTree[U], CreateScanTree[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  10. class Drop [U >: T, This >: Repr] extends Transformer[Combiner[U, This], Drop[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  11. class Exists extends Accessor[Boolean, Exists]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  12. class Filter [U >: T, This >: Repr] extends Transformer[Combiner[U, This], Filter[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  13. class FilterNot [U >: T, This >: Repr] extends Transformer[Combiner[U, This], FilterNot[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  14. class Find [U >: T] extends Accessor[Option[U], Find[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  15. class FlatMap [S, That] extends Transformer[Combiner[S, That], FlatMap[S, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  16. class Fold [U >: T] extends Accessor[U, Fold[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  17. class Forall extends Accessor[Boolean, Forall]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  18. class Foreach [S] extends Accessor[Unit, Foreach[S]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  19. class FromScanTree [U >: T, That] extends StrictSplitterCheckTask[Combiner[U, That], FromScanTree[U, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  20. class GroupBy [K, U >: T] extends Transformer[HashMapCombiner[K, U], GroupBy[K, U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  21. class Map [S, That] extends Transformer[Combiner[S, That], Map[S, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  22. class Max [U >: T] extends Accessor[Option[U], Max[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  23. class Min [U >: T] extends Accessor[Option[U], Min[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  24. trait NonDivisible [R] extends NonDivisibleTask[R, NonDivisible[R]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  25. trait NonDivisibleTask [R, Tp] extends StrictSplitterCheckTask[R, Tp]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  26. abstract class ParComposite [FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]

    Performs two tasks in parallel, and waits for both to finish.

    Performs two tasks in parallel, and waits for both to finish.

    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  27. class Partition [U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Partition[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  28. class Product [U >: T] extends Accessor[U, Product[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  29. class Reduce [U >: T] extends Accessor[Option[U], Reduce[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  30. abstract class ResultMapping [R, Tp, R1] extends NonDivisibleTask[R1, ResultMapping[R, Tp, R1]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  31. 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
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  32. case class ScanNode [U >: T](left: ScanTree[U], right: ScanTree[U]) extends ScanTree[U] with scala.Product with Serializable
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  33. trait ScanTree [U >: T] extends AnyRef
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  34. abstract class SeqComposite [FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]

    Sequentially performs one task after another.

    Sequentially performs one task after another.

    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  35. trait SignallingOps [PI <: DelegatedSignalling] extends AnyRef
    Definition Classes
    ParIterableLike
  36. class Slice [U >: T, This >: Repr] extends Transformer[Combiner[U, This], Slice[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  37. class Span [U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Span[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  38. class SplitAt [U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), SplitAt[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  39. trait StrictSplitterCheckTask [R, Tp] extends Task[R, Tp]
    Attributes
    protected
    Definition Classes
    ParIterableLike
  40. class Sum [U >: T] extends Accessor[U, Sum[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  41. class Take [U >: T, This >: Repr] extends Transformer[Combiner[U, This], Take[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  42. class TakeWhile [U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Boolean), TakeWhile[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  43. trait TaskOps [R, Tp] extends AnyRef
    Definition Classes
    ParIterableLike
  44. class ToParCollection [U >: T, That] extends Transformer[Combiner[U, That], ToParCollection[U, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  45. class ToParMap [K, V, That] extends Transformer[Combiner[(K, V), That], ToParMap[K, V, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  46. trait Transformer [R, Tp] extends Accessor[R, Tp]
    Attributes
    protected
    Definition Classes
    ParIterableLike
  47. class Zip [U >: T, S, That] extends Transformer[Combiner[(U, S), That], Zip[U, S, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  48. class ZipAll [U >: T, S, That] extends Transformer[Combiner[(U, S), That], ZipAll[U, S, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  49. class DefaultKeySet extends ParSet[K]
    Attributes
    protected
    Definition Classes
    ParMapLike
  50. class DefaultValuesIterable extends ParIterable[V]
    Attributes
    protected
    Definition Classes
    ParMapLike
  51. type Entry = DefaultEntry[K, V]
  52. class ParHashMapIterator extends EntryIterator[(K, V), ParHashMapIterator]
  53. type SSCTask[R, Tp] = StrictSplitterCheckTask[R, Tp]
    Definition Classes
    ParIterableLike
  54. abstract class EntryIterator [T, +IterRepr <: IterableSplitter[T]] extends IterableSplitter[T] with SizeMapUtils

    A parallel iterator returning all the entries.

    A parallel iterator returning all the entries.

    Definition Classes
    ParHashTable

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. def +[U >: V](kv: (K, U)): ParMap[K, U]
    Definition Classes
    ParMapLike → GenMapLike
  4. def ++[U >: (K, V), That](that: GenTraversableOnce[U])(implicit bf: CanBuildFrom[ParHashMap[K, V], U, That]): That
    Definition Classes
    ParIterableLike → GenTraversableLike
  5. def ++=(xs: TraversableOnce[(K, V)]): ParHashMap.this.type
    Definition Classes
    Growable
  6. def +=(kv: (K, V)): ParHashMap.this.type
    Definition Classes
    ParHashMap → ParMapLike → Growable
  7. def +=(elem1: (K, V), elem2: (K, V), elems: (K, V)*): ParHashMap.this.type
    Definition Classes
    Growable
  8. def -(key: K): ParHashMap[K, V]
    Definition Classes
    ParMapLike → GenMapLike
  9. def --=(xs: TraversableOnce[K]): ParHashMap.this.type
    Definition Classes
    Shrinkable
  10. def -=(key: K): ParHashMap.this.type
    Definition Classes
    ParHashMap → ParMapLike → Shrinkable
  11. def -=(elem1: K, elem2: K, elems: K*): ParHashMap.this.type
    Definition Classes
    Shrinkable
  12. def /:[S](z: S)(op: (S, (K, V)) ⇒ S): S
    Definition Classes
    ParIterableLike → GenTraversableOnce
  13. def :\[S](z: S)(op: ((K, V), S) ⇒ S): S
    Definition Classes
    ParIterableLike → GenTraversableOnce
  14. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  15. val _loadFactor: Int
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @transient()
  16. def addEntry(e: DefaultEntry[K, V]): Unit
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @deprecatedOverriding( ... , "2.11.0" )
  17. final def addEntry0(e: DefaultEntry[K, V], h: Int): Unit
    Attributes
    protected[this]
    Definition Classes
    HashTable
  18. def aggregate[S](z: ⇒ S)(seqop: (S, (K, V)) ⇒ S, combop: (S, S) ⇒ S): S

    Aggregates the results of applying an operator to subsequent elements.

    Aggregates the results of applying an operator to subsequent elements.

    This is a more general form of fold and reduce. It has similar semantics, but does not require the result to be a supertype of the element type. It traverses the elements in different partitions sequentially, using seqop to update the result, and then applies combop to results from different partitions. The implementation of this operation may operate on an arbitrary number of collection partitions, so combop may be invoked arbitrary number of times.

    For example, one might want to process some elements and then produce a Set. In this case, seqop would process an element and append it to the set, while combop would concatenate two sets from different partitions together. The initial value z would be an empty set.

    pc.aggregate(Set[Int]())(_ += process(_), _ ++ _)

    Another example is calculating geometric mean from a collection of doubles (one would typically require big doubles for this).

    S

    the type of accumulated results

    z

    the initial value for the accumulated result of the partition - this will typically be the neutral element for the seqop operator (e.g. Nil for list concatenation or 0 for summation) and may be evaluated more than once

    seqop

    an operator used to accumulate results within a partition

    combop

    an associative operator used to combine results from different partitions

    Definition Classes
    ParIterableLike → GenTraversableOnce
  19. def alwaysInitSizeMap: Boolean
    Definition Classes
    ParHashTable → HashTable
  20. def apply(key: K): V
    Definition Classes
    ParMapLike → GenMapLike
  21. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  22. def bf2seq[S, That](bf: CanBuildFrom[ParHashMap[K, V], S, That]): CanBuildFrom[HashMap[K, V], S, That]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  23. implicit def builder2ops[Elem, To](cb: Builder[Elem, To]): BuilderOps[Elem, To]
    Attributes
    protected
    Definition Classes
    ParIterableLike
  24. def calcSizeMapSize(tableLength: Int): Int
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @deprecatedOverriding( ... , "2.11.0" )
  25. def canEqual(other: Any): Boolean
    Definition Classes
    ParIterableLike
  26. def clear(): Unit
    Definition Classes
    ParHashMap → ParMapLike → Growable → Clearable
  27. def clearTable(): Unit
    Attributes
    protected
    Definition Classes
    HashTable
  28. def clone(): ParHashMap[K, V]
    Definition Classes
    Cloneable → AnyRef
  29. def collect[S, That](pf: PartialFunction[(K, V), S])(implicit bf: CanBuildFrom[ParHashMap[K, V], S, That]): That
    Definition Classes
    ParIterableLike → GenTraversableLike
  30. def combinerFactory[S, That](cbf: () ⇒ Combiner[S, That]): CombinerFactory[S, That]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  31. def combinerFactory: CombinerFactory[(K, V), ParHashMap[K, V]]

    Creates a combiner factory.

    Creates a combiner factory. Each combiner factory instance is used once per invocation of a parallel transformer method for a single collection.

    The default combiner factory creates a new combiner every time it is requested, unless the combiner is thread-safe as indicated by its canBeShared method. In this case, the method returns a factory which returns the same combiner each time. This is typically done for concurrent parallel collections, the combiners of which allow thread safe access.

    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  32. def companion: GenericCompanion[ParIterable] with GenericParCompanion[ParIterable]
    Definition Classes
    ParIterable → ParIterable → GenericParTemplate → GenIterable → GenTraversable → GenericTraversableTemplate
  33. def contains(key: K): Boolean
    Definition Classes
    ParMapLike → GenMapLike
  34. def copyToArray[U >: (K, V)](xs: Array[U], start: Int, len: Int): Unit
    Definition Classes
    ParIterableLike → GenTraversableOnce
  35. def copyToArray[U >: (K, V)](xs: Array[U], start: Int): Unit
    Definition Classes
    ParIterableLike → GenTraversableOnce
  36. def copyToArray[U >: (K, V)](xs: Array[U]): Unit
    Definition Classes
    ParIterableLike → GenTraversableOnce
  37. def count(p: ((K, V)) ⇒ Boolean): Int
    Definition Classes
    ParIterableLike → GenTraversableOnce
  38. def createNewEntry[V1](key: K, value: V1): Entry
    Attributes
    protected
    Definition Classes
    ParHashMap → HashTable
  39. def debugBuffer: ArrayBuffer[String]
    Definition Classes
    ParIterableLike
  40. def default(key: K): V
    Definition Classes
    ParMapLike → GenMapLike
  41. implicit def delegatedSignalling2ops[PI <: DelegatedSignalling](it: PI): SignallingOps[PI]
    Attributes
    protected
    Definition Classes
    ParIterableLike
  42. def drop(n: Int): ParHashMap[K, V]
    Definition Classes
    ParIterableLike → GenTraversableLike
  43. def dropWhile(pred: ((K, V)) ⇒ Boolean): ParHashMap[K, V]

    Drops all elements in the longest prefix of elements that satisfy the predicate, and returns a collection composed of the remaining elements.

    Drops all elements in the longest prefix of elements that satisfy the predicate, and returns a collection composed of the remaining elements.

    This method will use indexFlag signalling capabilities. This means that splitters may set and read the indexFlag state. The index flag is initially set to maximum integer value.

    pred

    the predicate used to test the elements

    returns

    a collection composed of all the elements after the longest prefix of elements in this parallel iterable that satisfy the predicate pred

    Definition Classes
    ParIterableLike → GenTraversableLike
  44. def elemEquals(key1: K, key2: K): Boolean
    Attributes
    protected
    Definition Classes
    HashTable
  45. def elemHashCode(key: K): Int
    Attributes
    protected
    Definition Classes
    HashUtils
  46. def empty: ParHashMap[K, V]
    Definition Classes
    ParHashMap → ParMap → ParMap → ParMapLike
  47. def entriesIterator: Iterator[DefaultEntry[K, V]]
    Attributes
    protected
    Definition Classes
    HashTable
  48. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  49. def equals(that: Any): Boolean
    Definition Classes
    GenMapLike → Equals → AnyRef → Any
  50. def exists(p: ((K, V)) ⇒ Boolean): Boolean

    Tests whether a predicate holds for some element of this parallel iterable.

    Tests whether a predicate holds for some element of this parallel iterable.

    This method will use abort signalling capabilities. This means that splitters may send and read abort signals.

    p

    a predicate used to test elements

    returns

    true if p holds for some element, false otherwise

    Definition Classes
    ParIterableLike → GenTraversableOnce
  51. def filter(pred: ((K, V)) ⇒ Boolean): ParHashMap[K, V]
    Definition Classes
    ParIterableLike → GenTraversableLike
  52. def filterKeys(p: (K) ⇒ Boolean): parallel.ParMap[K, V]
    Definition Classes
    ParMapLike → GenMapLike
  53. def filterNot(pred: ((K, V)) ⇒ Boolean): ParHashMap[K, V]
    Definition Classes
    ParIterableLike → GenTraversableLike
  54. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  55. def find(p: ((K, V)) ⇒ Boolean): Option[(K, V)]

    Finds some element in the collection for which the predicate holds, if such an element exists.

    Finds some element in the collection for which the predicate holds, if such an element exists. The element may not necessarily be the first such element in the iteration order.

    If there are multiple elements obeying the predicate, the choice is nondeterministic.

    This method will use abort signalling capabilities. This means that splitters may send and read abort signals.

    p

    predicate used to test the elements

    returns

    an option value with the element if such an element exists, or None otherwise

    Definition Classes
    ParIterableLike → GenTraversableOnce
  56. def findEntry(key: K): DefaultEntry[K, V]
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @deprecatedOverriding( ... , "2.11.0" )
  57. final def findEntry0(key: K, h: Int): DefaultEntry[K, V]
    Attributes
    protected[this]
    Definition Classes
    HashTable
  58. def findOrAddEntry[B](key: K, value: B): DefaultEntry[K, V]
    Attributes
    protected
    Definition Classes
    HashTable
  59. def flatMap[S, That](f: ((K, V)) ⇒ GenTraversableOnce[S])(implicit bf: CanBuildFrom[ParHashMap[K, V], S, That]): That
    Definition Classes
    ParIterableLike → GenTraversableLike
  60. def flatten[B](implicit asTraversable: ((K, V)) ⇒ GenTraversableOnce[B]): ParIterable[B]
    Definition Classes
    GenericTraversableTemplate
  61. def fold[U >: (K, V)](z: U)(op: (U, U) ⇒ U): U

    Folds the elements of this sequence using the specified associative binary operator.

    Folds the elements of this sequence using the specified associative binary operator. The order in which the elements are reduced is unspecified and may be nondeterministic.

    Note this method has a different signature than the foldLeft and foldRight methods of the trait Traversable. The result of folding may only be a supertype of this parallel collection's type parameter T.

    U

    a type parameter for the binary operator, a supertype of T.

    z

    a neutral element for the fold operation, it may be added to the result an arbitrary number of times, not changing the result (e.g. Nil for list concatenation, 0 for addition, or 1 for multiplication)

    op

    a binary operator that must be associative

    returns

    the result of applying fold operator op between all the elements and z

    Definition Classes
    ParIterableLike → GenTraversableOnce
  62. def foldLeft[S](z: S)(op: (S, (K, V)) ⇒ S): S
    Definition Classes
    ParIterableLike → GenTraversableOnce
  63. def foldRight[S](z: S)(op: ((K, V), S) ⇒ S): S
    Definition Classes
    ParIterableLike → GenTraversableOnce
  64. def forall(p: ((K, V)) ⇒ Boolean): Boolean

    Tests whether a predicate holds for all elements of this parallel iterable.

    Tests whether a predicate holds for all elements of this parallel iterable.

    This method will use abort signalling capabilities. This means that splitters may send and read abort signals.

    p

    a predicate used to test elements

    returns

    true if p holds for all elements, false otherwise

    Definition Classes
    ParIterableLike → GenTraversableOnce
  65. def foreach[U](f: ((K, V)) ⇒ U): Unit

    Applies a function f to all the elements of parallel iterable in an undefined order.

    Applies a function f to all the elements of parallel iterable in an undefined order.

    U

    the result type of the function applied to each element, which is always discarded

    f

    function applied to each element

    Definition Classes
    ParIterableLike → GenTraversableLike → GenTraversableOnce
  66. def foreachEntry[U](f: (DefaultEntry[K, V]) ⇒ U): Unit
    Attributes
    protected
    Definition Classes
    HashTable
  67. def genericBuilder[B]: Combiner[B, ParIterable[B]]
    Definition Classes
    GenericParTemplate → GenericTraversableTemplate
  68. def genericCombiner[B]: Combiner[B, ParIterable[B]]
    Definition Classes
    GenericParTemplate
  69. def genericMapCombiner[P, Q]: Combiner[(P, Q), ParHashMap[P, Q]]
    Definition Classes
    GenericParMapTemplate
  70. def get(key: K): Option[V]
    Definition Classes
    ParHashMap → GenMapLike
  71. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  72. def getOrElse[U >: V](key: K, default: ⇒ U): U
    Definition Classes
    ParMapLike → GenMapLike
  73. def groupBy[K](f: ((K, V)) ⇒ K): immutable.ParMap[K, ParHashMap[K, V]]
    Definition Classes
    ParIterableLike → GenTraversableLike
  74. def hasDefiniteSize: Boolean
    Definition Classes
    ParIterableLike → GenTraversableOnce
  75. def hashCode(): Int
    Definition Classes
    GenMapLike → AnyRef → Any
  76. def head: (K, V)
    Definition Classes
    ParIterableLike → GenTraversableLike
  77. def headOption: Option[(K, V)]
    Definition Classes
    ParIterableLike → GenTraversableLike
  78. final def improve(hcode: Int, seed: Int): Int
    Attributes
    protected
    Definition Classes
    HashUtils
  79. final def index(hcode: Int): Int
    Attributes
    protected
    Definition Classes
    HashTable
  80. def init: ParHashMap[K, V]
    Definition Classes
    ParIterableLike → GenTraversableLike
  81. def initTaskSupport(): Unit
    Attributes
    protected
    Definition Classes
    ParIterableLike
  82. def initWithContents(c: Contents[K, DefaultEntry[K, V]]): Unit
    Attributes
    protected
    Definition Classes
    HashTable
  83. def initialSize: Int
    Attributes
    protected
    Definition Classes
    HashTable
  84. def isDefinedAt(key: K): Boolean
    Definition Classes
    ParMapLike → GenMapLike
  85. def isEmpty: Boolean
    Definition Classes
    ParIterableLike → GenTraversableOnce
  86. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  87. def isSizeMapDefined: Boolean
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @deprecatedOverriding( ... , "2.11.0" )
  88. def isStrictSplitterCollection: Boolean

    Denotes whether this parallel collection has strict splitters.

    Denotes whether this parallel collection has strict splitters.

    This is true in general, and specific collection instances may choose to override this method. Such collections will fail to execute methods which rely on splitters being strict, i.e. returning a correct value in the remaining method.

    This method helps ensure that such failures occur on method invocations, rather than later on and in unpredictable ways.

    Definition Classes
    ParIterableLike
  89. final def isTraversableAgain: Boolean
    Definition Classes
    ParIterableLike → GenTraversableLike → GenTraversableOnce
  90. def iterator: Splitter[(K, V)]

    Creates a new split iterator used to traverse the elements of this collection.

    Creates a new split iterator used to traverse the elements of this collection.

    By default, this method is implemented in terms of the protected splitter method.

    returns

    a split iterator

    Definition Classes
    ParIterableLike → GenIterableLike
  91. def keySet: parallel.ParSet[K]
    Definition Classes
    ParMapLike → GenMapLike
  92. def keys: parallel.ParIterable[K]
    Definition Classes
    ParMapLike → GenMapLike
  93. def keysIterator: IterableSplitter[K]
    Definition Classes
    ParMapLike → GenMapLike
  94. def last: (K, V)
    Definition Classes
    ParIterableLike → GenTraversableLike
  95. def lastOption: Option[(K, V)]
    Definition Classes
    ParIterableLike → GenTraversableLike
  96. def map[S, That](f: ((K, V)) ⇒ S)(implicit bf: CanBuildFrom[ParHashMap[K, V], S, That]): That
    Definition Classes
    ParIterableLike → GenTraversableLike
  97. def mapCompanion: GenericParMapCompanion[ParHashMap]
    Definition Classes
    ParHashMap → ParMap → ParMap → GenericParMapTemplate
  98. def mapValues[S](f: (V) ⇒ S): parallel.ParMap[K, S]
    Definition Classes
    ParMapLike → GenMapLike
  99. def max[U >: (K, V)](implicit ord: Ordering[U]): (K, V)
    Definition Classes
    ParIterableLike → GenTraversableOnce
  100. def maxBy[S](f: ((K, V)) ⇒ S)(implicit cmp: Ordering[S]): (K, V)
    Definition Classes
    ParIterableLike → GenTraversableOnce
  101. def min[U >: (K, V)](implicit ord: Ordering[U]): (K, V)
    Definition Classes
    ParIterableLike → GenTraversableOnce
  102. def minBy[S](f: ((K, V)) ⇒ S)(implicit cmp: Ordering[S]): (K, V)
    Definition Classes
    ParIterableLike → GenTraversableOnce
  103. def mkString: String
    Definition Classes
    ParIterableLike → GenTraversableOnce
  104. def mkString(sep: String): String
    Definition Classes
    ParIterableLike → GenTraversableOnce
  105. def mkString(start: String, sep: String, end: String): String
    Definition Classes
    ParIterableLike → GenTraversableOnce
  106. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  107. def newBuilder: Builder[(K, V), ParIterable[(K, V)]]
    Attributes
    protected[this]
    Definition Classes
    GenericParTemplate → GenericTraversableTemplate → HasNewBuilder
  108. def newCombiner: ParHashMapCombiner[K, V]
    Attributes
    protected[this]
    Definition Classes
    ParHashMap → ParMap → GenericParMapTemplate → GenericParTemplate → HasNewCombiner
  109. def nnSizeMapAdd(h: Int): Unit
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @deprecatedOverriding( ... , "2.11.0" )
  110. def nnSizeMapRemove(h: Int): Unit
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @deprecatedOverriding( ... , "2.11.0" )
  111. def nnSizeMapReset(tableLength: Int): Unit
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @deprecatedOverriding( ... , "2.11.0" )
  112. def nonEmpty: Boolean
    Definition Classes
    ParIterableLike → GenTraversableOnce
  113. final def notify(): Unit
    Definition Classes
    AnyRef
  114. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  115. def par: ParHashMap[K, V]

    Returns a parallel implementation of this collection.

    Returns a parallel implementation of this collection.

    For most collection types, this method creates a new parallel collection by copying all the elements. For these collection, par takes linear time. Mutable collections in this category do not produce a mutable parallel collection that has the same underlying dataset, so changes in one collection will not be reflected in the other one.

    Specific collections (e.g. ParArray or mutable.ParHashMap) override this default behaviour by creating a parallel collection which shares the same underlying dataset. For these collections, par takes constant or sublinear time.

    All parallel collections return a reference to themselves.

    returns

    a parallel implementation of this collection

    Definition Classes
    ParIterableLike → CustomParallelizable → Parallelizable
  116. def parCombiner: Combiner[(K, V), ParHashMap[K, V]]

    The default par implementation uses the combiner provided by this method to create a new parallel collection.

    The default par implementation uses the combiner provided by this method to create a new parallel collection.

    returns

    a combiner for the parallel collection of type ParRepr

    Attributes
    protected[this]
    Definition Classes
    CustomParallelizable → Parallelizable
  117. def partition(pred: ((K, V)) ⇒ Boolean): (ParHashMap[K, V], ParHashMap[K, V])
    Definition Classes
    ParIterableLike → GenTraversableLike
  118. def product[U >: (K, V)](implicit num: Numeric[U]): U
    Definition Classes
    ParIterableLike → GenTraversableOnce
  119. def put(key: K, value: V): Option[V]
    Definition Classes
    ParHashMap → ParMapLike
  120. def reduce[U >: (K, V)](op: (U, U) ⇒ U): U

    Reduces the elements of this sequence using the specified associative binary operator.

    Reduces the elements of this sequence using the specified associative binary operator.

    The order in which operations are performed on elements is unspecified and may be nondeterministic.

    Note this method has a different signature than the reduceLeft and reduceRight methods of the trait Traversable. The result of reducing may only be a supertype of this parallel collection's type parameter T.

    U

    A type parameter for the binary operator, a supertype of T.

    op

    A binary operator that must be associative.

    returns

    The result of applying reduce operator op between all the elements if the collection is nonempty.

    Definition Classes
    ParIterableLike → GenTraversableOnce
    Exceptions thrown

    UnsupportedOperationException if this parallel iterable is empty.

  121. def reduceLeft[U >: (K, V)](op: (U, (K, V)) ⇒ U): U
    Definition Classes
    ParIterableLike
  122. def reduceLeftOption[U >: (K, V)](op: (U, (K, V)) ⇒ U): Option[U]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  123. def reduceOption[U >: (K, V)](op: (U, U) ⇒ U): Option[U]

    Optionally reduces the elements of this sequence using the specified associative binary operator.

    Optionally reduces the elements of this sequence using the specified associative binary operator.

    The order in which operations are performed on elements is unspecified and may be nondeterministic.

    Note this method has a different signature than the reduceLeftOption and reduceRightOption methods of the trait Traversable. The result of reducing may only be a supertype of this parallel collection's type parameter T.

    U

    A type parameter for the binary operator, a supertype of T.

    op

    A binary operator that must be associative.

    returns

    An option value containing result of applying reduce operator op between all the elements if the collection is nonempty, and None otherwise.

    Definition Classes
    ParIterableLike → GenTraversableOnce
  124. def reduceRight[U >: (K, V)](op: ((K, V), U) ⇒ U): U
    Definition Classes
    ParIterableLike → GenTraversableOnce
  125. def reduceRightOption[U >: (K, V)](op: ((K, V), U) ⇒ U): Option[U]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  126. def remove(key: K): Option[V]
  127. def removeEntry(key: K): DefaultEntry[K, V]
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @deprecatedOverriding( ... , "2.11.0" )
  128. def repr: ParHashMap[K, V]
    Definition Classes
    ParIterableLike → GenTraversableLike
  129. def reuse[S, That](oldc: Option[Combiner[S, That]], newc: Combiner[S, That]): Combiner[S, That]

    Optionally reuses an existing combiner for better performance.

    Optionally reuses an existing combiner for better performance. By default it doesn't - subclasses may override this behaviour. The provided combiner oldc that can potentially be reused will be either some combiner from the previous computational task, or None if there was no previous phase (in which case this method must return newc).

    oldc

    The combiner that is the result of the previous task, or None if there was no previous task.

    newc

    The new, empty combiner that can be used.

    returns

    Either newc or oldc.

    Attributes
    protected
    Definition Classes
    ParIterableLike
  130. def sameElements[U >: (K, V)](that: GenIterable[U]): Boolean
    Definition Classes
    ParIterableLike → GenIterableLike
  131. def scan(z: (K, V))(op: ((K, V), (K, V)) ⇒ (K, V)): ParHashMap[(K, V)]

    [use case] Computes a prefix scan of the elements of the collection.

    [use case]

    Computes a prefix scan of the elements of the collection.

    Note: The neutral element z may be applied more than once.

    z

    neutral element for the operator op

    op

    the associative operator for the scan

    returns

    a new parallel hash map containing the prefix scan of the elements in this parallel hash map

    Definition Classes
    ParIterableLike → GenTraversableLike
    Full Signature

    def scan[U >: (K, V), That](z: U)(op: (U, U) ⇒ U)(implicit bf: CanBuildFrom[ParHashMap[K, V], U, That]): That

  132. def scanBlockSize: Int
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  133. def scanLeft[S, That](z: S)(op: (S, (K, V)) ⇒ S)(implicit bf: CanBuildFrom[ParHashMap[K, V], S, That]): That
    Definition Classes
    ParIterableLike → GenTraversableLike
  134. def scanRight[S, That](z: S)(op: ((K, V), S) ⇒ S)(implicit bf: CanBuildFrom[ParHashMap[K, V], S, That]): That
    Definition Classes
    ParIterableLike → GenTraversableLike
  135. val seedvalue: Int
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @transient()
  136. def seq: HashMap[K, V]
    Definition Classes
    ParHashMap → ParMap → ParIterable → ParIterableLike → Parallelizable → GenMap → GenIterable → GenTraversable → GenMapLike → GenTraversableOnce
  137. def sequentially[S, That <: Parallel](b: (HashMap[K, V]) ⇒ HashMap[K, V]): ParHashMap[K, V]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  138. def size: Int
    Definition Classes
    ParHashMap → GenTraversableLike → GenTraversableOnce
  139. def sizeHintIfCheap: Int
    Attributes
    protected[scala.collection]
    Definition Classes
    GenTraversableOnce
  140. final def sizeMapBucketBitSize: Int
    Attributes
    protected
    Definition Classes
    HashUtils
  141. final def sizeMapBucketSize: Int
    Attributes
    protected
    Definition Classes
    HashUtils
  142. def sizeMapDisable(): Unit
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @deprecatedOverriding( ... , "2.11.0" )
  143. def sizeMapInit(tableLength: Int): Unit
    Attributes
    protected
    Definition Classes
    HashTable
  144. def sizeMapInitAndRebuild(): Unit
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @deprecatedOverriding( ... , "2.11.0" )
  145. val sizemap: Array[Int]
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @transient()
  146. def slice(unc_from: Int, unc_until: Int): ParHashMap[K, V]
    Definition Classes
    ParIterableLike → GenTraversableLike
  147. def span(pred: ((K, V)) ⇒ Boolean): (ParHashMap[K, V], ParHashMap[K, V])

    Splits this parallel iterable into a prefix/suffix pair according to a predicate.

    Splits this parallel iterable into a prefix/suffix pair according to a predicate.

    This method will use indexFlag signalling capabilities. This means that splitters may set and read the indexFlag state. The index flag is initially set to maximum integer value.

    pred

    the predicate used to test the elements

    returns

    a pair consisting of the longest prefix of the collection for which all the elements satisfy pred, and the rest of the collection

    Definition Classes
    ParIterableLike → GenTraversableLike
  148. def splitAt(n: Int): (ParHashMap[K, V], ParHashMap[K, V])
    Definition Classes
    ParIterableLike → GenTraversableLike
  149. def splitter: ParHashMapIterator

    Creates a new parallel iterator used to traverse the elements of this parallel collection.

    Creates a new parallel iterator used to traverse the elements of this parallel collection. This iterator is more specific than the iterator of the returned by iterator, and augmented with additional accessor and transformer methods.

    returns

    a parallel iterator

    Definition Classes
    ParHashMap → ParIterableLike
  150. def stringPrefix: String
    Definition Classes
    ParHashMap → ParMap → ParIterable → GenTraversableLike
  151. def sum[U >: (K, V)](implicit num: Numeric[U]): U
    Definition Classes
    ParIterableLike → GenTraversableOnce
  152. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  153. val table: Array[HashEntry[K, DefaultEntry[K, V]]]
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @transient()
  154. val tableSize: Int
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @transient()
  155. def tableSizeSeed: Int
    Attributes
    protected
    Definition Classes
    HashTable
  156. def tail: ParHashMap[K, V]
    Definition Classes
    ParIterableLike → GenTraversableLike
  157. def take(n: Int): ParHashMap[K, V]
    Definition Classes
    ParIterableLike → GenTraversableLike
  158. def takeWhile(pred: ((K, V)) ⇒ Boolean): ParHashMap[K, V]

    Takes the longest prefix of elements that satisfy the predicate.

    Takes the longest prefix of elements that satisfy the predicate.

    This method will use indexFlag signalling capabilities. This means that splitters may set and read the indexFlag state. The index flag is initially set to maximum integer value.

    pred

    the predicate used to test the elements

    returns

    the longest prefix of this parallel iterable of elements that satisfy the predicate pred

    Definition Classes
    ParIterableLike → GenTraversableLike
  159. implicit def task2ops[R, Tp](tsk: SSCTask[R, Tp]): TaskOps[R, Tp]
    Attributes
    protected
    Definition Classes
    ParIterableLike
  160. def tasksupport: TaskSupport

    The task support object which is responsible for scheduling and load-balancing tasks to processors.

    The task support object which is responsible for scheduling and load-balancing tasks to processors.

    Definition Classes
    ParIterableLike
    See also

    scala.collection.parallel.TaskSupport

  161. def tasksupport_=(ts: TaskSupport): Unit

    Changes the task support object which is responsible for scheduling and load-balancing tasks to processors.

    Changes the task support object which is responsible for scheduling and load-balancing tasks to processors.

    A task support object can be changed in a parallel collection after it has been created, but only during a quiescent period, i.e. while there are no concurrent invocations to parallel collection methods.

    Here is a way to change the task support of a parallel collection:

    import scala.collection.parallel._
val pc = mutable.ParArray(1, 2, 3)
pc.tasksupport = new ForkJoinTaskSupport(
  new java.util.concurrent.ForkJoinPool(2))
    Definition Classes
    ParIterableLike
    See also

    scala.collection.parallel.TaskSupport

  162. val threshold: Int
    Attributes
    protected
    Definition Classes
    HashTable
    Annotations
    @transient()
  163. def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, (K, V), Col[(K, V)]]): Col[(K, V)]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  164. def toArray[U >: (K, V)](implicit arg0: ClassTag[U]): Array[U]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  165. def toBuffer[U >: (K, V)]: Buffer[U]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  166. def toIndexedSeq: immutable.IndexedSeq[(K, V)]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  167. def toIterable: ParIterable[(K, V)]
    Definition Classes
    ParIterable → ParIterableLike → GenTraversableOnce
  168. def toIterator: scala.Iterator[(K, V)]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  169. def toList: List[(K, V)]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  170. def toMap[K, V](implicit ev: <:<[(K, V), (K, V)]): immutable.ParMap[K, V]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  171. def toParCollection[U >: (K, V), That](cbf: () ⇒ Combiner[U, That]): That
    Attributes
    protected
    Definition Classes
    ParIterableLike
  172. def toParMap[K, V, That](cbf: () ⇒ Combiner[(K, V), That])(implicit ev: <:<[(K, V), (K, V)]): That
    Attributes
    protected
    Definition Classes
    ParIterableLike
  173. def toSeq: ParSeq[(K, V)]
    Definition Classes
    ParIterable → ParIterableLike → GenTraversableOnce
  174. def toSet[U >: (K, V)]: immutable.ParSet[U]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  175. def toStream: Stream[(K, V)]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  176. def toString(): String
    Definition Classes
    ParIterableLike → AnyRef → Any
  177. def toTraversable: GenTraversable[(K, V)]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  178. def toVector: Vector[(K, V)]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  179. def transpose[B](implicit asTraversable: ((K, V)) ⇒ GenTraversableOnce[B]): ParIterable[ParIterable[B]]
    Definition Classes
    GenericTraversableTemplate
    Annotations
    @migration
    Migration

    (Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.

  180. def unzip[A1, A2](implicit asPair: ((K, V)) ⇒ (A1, A2)): (ParIterable[A1], ParIterable[A2])
    Definition Classes
    GenericTraversableTemplate
  181. def unzip3[A1, A2, A3](implicit asTriple: ((K, V)) ⇒ (A1, A2, A3)): (ParIterable[A1], ParIterable[A2], ParIterable[A3])
    Definition Classes
    GenericTraversableTemplate
  182. def update(key: K, value: V): Unit
  183. def updated[U >: V](key: K, value: U): ParMap[K, U]
    Definition Classes
    ParMap → ParMap → GenMap
  184. def values: parallel.ParIterable[V]
    Definition Classes
    ParMapLike → GenMapLike
  185. def valuesIterator: IterableSplitter[V]
    Definition Classes
    ParMapLike → GenMapLike
  186. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  187. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  188. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  189. def withDefault(d: (K) ⇒ V): ParMap[K, V]

    The same map with a given default function.

    The same map with a given default function. Note: get, contains, iterator, keys, etc are not affected by withDefault.

    Invoking transformer methods (e.g. map) will not preserve the default value.

    d

    the function mapping keys to values, used for non-present keys

    returns

    a wrapper of the map with a default value

    Definition Classes
    ParMap
  190. def withDefaultValue(d: V): ParMap[K, V]

    The same map with a given default value.

    The same map with a given default value.

    Invoking transformer methods (e.g. map) will not preserve the default value.

    d

    default value used for non-present keys

    returns

    a wrapper of the map with a default value

    Definition Classes
    ParMap
  191. def withFilter(pred: ((K, V)) ⇒ Boolean): ParHashMap[K, V]
    Definition Classes
    ParIterableLike
  192. def wrap[R](body: ⇒ R): NonDivisible[R]
    Attributes
    protected
    Definition Classes
    ParIterableLike
  193. def zip[U >: (K, V), S, That](that: GenIterable[S])(implicit bf: CanBuildFrom[ParHashMap[K, V], (U, S), That]): That
    Definition Classes
    ParIterableLike → GenIterableLike
  194. def zipAll[S, U >: (K, V), That](that: GenIterable[S], thisElem: U, thatElem: S)(implicit bf: CanBuildFrom[ParHashMap[K, V], (U, S), That]): That
    Definition Classes
    ParIterableLike → GenIterableLike
  195. def zipWithIndex[U >: (K, V), That](implicit bf: CanBuildFrom[ParHashMap[K, V], (U, Int), That]): That
    Definition Classes
    ParIterableLike → GenIterableLike

Inherited from Serializable

Inherited from java.io.Serializable

Inherited from ParHashTable[K, DefaultEntry[K, V]]

Inherited from HashTable[K, DefaultEntry[K, V]]

Inherited from HashUtils[K]

Inherited from ParMap[K, V]

Inherited from ParMapLike[K, V, ParHashMap[K, V], HashMap[K, V]]

Inherited from mutable.Cloneable[ParHashMap[K, V]]

Inherited from Cloneable

Inherited from java.lang.Cloneable

Inherited from Shrinkable[K]

Inherited from Growable[(K, V)]

Inherited from Clearable

Inherited from ParIterable[(K, V)]

Inherited from Mutable

Inherited from parallel.ParMap[K, V]

Inherited from parallel.ParMapLike[K, V, ParHashMap[K, V], HashMap[K, V]]

Inherited from parallel.ParIterable[(K, V)]

Inherited from ParIterableLike[(K, V), ParHashMap[K, V], HashMap[K, V]]

Inherited from Parallel

Inherited from CustomParallelizable[(K, V), ParHashMap[K, V]]

Inherited from Parallelizable[(K, V), ParHashMap[K, V]]

Inherited from GenericParMapTemplate[K, V, ParHashMap]

Inherited from GenericParTemplate[(K, V), ParIterable]

Inherited from HasNewCombiner[(K, V), ParHashMap[K, V]]

Inherited from GenMap[K, V]

Inherited from GenIterable[(K, V)]

Inherited from GenTraversable[(K, V)]

Inherited from GenericTraversableTemplate[(K, V), ParIterable]

Inherited from HasNewBuilder[(K, V), scala.collection.parallel.mutable.ParIterable[(K, V)] @scala.annotation.unchecked.uncheckedVariance]

Inherited from GenMapLike[K, V, ParHashMap[K, V]]

Inherited from Equals

Inherited from GenIterableLike[(K, V), ParHashMap[K, V]]

Inherited from GenTraversableLike[(K, V), ParHashMap[K, V]]

Inherited from GenTraversableOnce[(K, V)]

Inherited from AnyRef

Inherited from Any

Ungrouped