scala.Enumeration

ValueSet

class ValueSet extends Set[Value] with SetLike[Value, ValueSet]

A class for sets of values Iterating through this set will yield values in increasing order of their ids.

Go to: companion

Inherits

  1. Set
  2. Set
  3. SetLike
  4. Subtractable
  5. Addable
  6. GenericSetTemplate
  7. Function1
  8. Iterable
  9. Iterable
  10. IterableLike
  11. Equals
  12. Traversable
  13. Immutable
  14. Traversable
  15. GenericTraversableTemplate
  16. TraversableLike
  17. HasNewBuilder
  18. AnyRef
  19. Any

Type Members

  1. class WithFilter extends AnyRef

    A class supporting filtered operations

Value Members

  1. def &(that: Set[Value]): ValueSet

    Computes the intersection between this set and another set

  2. def &~(that: Set[Value]): ValueSet

    The difference of this set and another set

  3. def **(that: Set[Value]): ValueSet

    This method is an alias for intersect

  4. def +(value: Value): ValueSet

    Creates a new set with an additional element, unless the element is already present

  5. def +(elem1: Value, elem2: Value, elems: Value*): ValueSet

    Creates a new set with additional elements

  6. def ++(iter: Iterator[Value]): ValueSet

    Creates a new set by adding all elements produced by an iterator to this set

  7. def ++(elems: Traversable[Value]): ValueSet

    Creates a new set by adding all elements contained in another collection to this set

  8. def ++(that: Iterator[Value]): Traversable[Value]

    [use case] Concatenates this set with the elements of an iterator

  9. def ++[B >: Value, That](that: Iterator[B])(bf: CanBuildFrom[ValueSet, B, That]): That

    Concatenates this set with the elements of an iterator

  10. def ++(that: Traversable[Value]): Traversable[Value]

    [use case] Concatenates this set with the elements of a traversable collection

  11. def ++[B >: Value, That](that: Traversable[B])(bf: CanBuildFrom[ValueSet, B, That]): That

    Concatenates this set with the elements of a traversable collection

  12. def -(value: Value): ValueSet

    Creates a new set with a given element removed from this set

  13. def -(elem1: Value, elem2: Value, elems: Value*): ValueSet

    Creates a new set from this set with some elements removed

  14. def --(iter: Iterator[Value]): ValueSet

    Creates a new set from this set by removing all elements produced by an iterator

  15. def --(elems: Traversable[Value]): ValueSet

    Creates a new set from this set by removing all elements of another collection

  16. def /:[B](z: B)(op: (B, Value) ⇒ B): B

    Applies a binary operator to a start value and all elements of this set, going left to right

  17. def :\[B](z: B)(op: (Value, B) ⇒ B): B

    Applies a binary operator to all elements of this set and a start value, going right to left

  18. def addString(b: StringBuilder): StringBuilder

    Appends all elements of this set to a string builder

  19. def addString(b: StringBuilder, sep: String): StringBuilder

    Appends all elements of this set to a string builder using a separator string

  20. def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

    Appends all elements of this set to a string builder using start, end, and separator strings

  21. def andThen[A](g: (Boolean) ⇒ A): (Value) ⇒ A

    (f andThen g)(x) == g(f(x))

  22. def apply(elem: Value): Boolean

    Tests if some element is contained in this set

  23. def canEqual(that: Any): Boolean

    Method called from equality methods, so that user-defined subclasses can refuse to be equal to other collections of the same kind

  24. def companion: GenericCompanion[Set[A][A]]

    The factory companion object that builds instances of class Set

  25. def compose[A](g: (A) ⇒ Value): (A) ⇒ Boolean

    (f compose g)(x) == f(g(x))

  26. def contains(v: Value): Boolean

    Tests if some element is contained in this set

  27. def copyToArray(xs: Array[Value], start: Int, len: Int): Unit

    [use case] Copies elements of this set to an array

  28. def copyToArray[B >: Value](xs: Array[B], start: Int, len: Int): Unit

    Copies elements of this set to an array

  29. def copyToArray(xs: Array[Value], start: Int): Unit

    [use case] Copies elements of this set to an array

  30. def copyToArray[B >: Value](xs: Array[B]): Unit

    Copies elements of this set to an array

  31. def copyToArray(xs: Array[Value], start: Int): Unit

    [use case] Copies elements of this set to an array

  32. def copyToArray[B >: Value](xs: Array[B], start: Int): Unit

    Copies elements of this set to an array

  33. def copyToBuffer[B >: Value](dest: Buffer[B]): Unit

    Copies all elements of this set to a buffer

  34. def count(p: (Value) ⇒ Boolean): Int

    Counts the number of elements in the set which satisfy a predicate

  35. def diff(that: Set[Value]): ValueSet

    Computes the difference of this set and another set

  36. def drop(n: Int): ValueSet

    Selects all elements except first n ones

  37. def dropRight(n: Int): ValueSet

    Selects all elements except first n ones

  38. def dropWhile(p: (Value) ⇒ Boolean): ValueSet

    Drops longest prefix of elements that satisfy a predicate

  39. def elements: Iterator[Value]

  40. def empty: ValueSet

  41. def equals(that: Any): Boolean

    Compares this set with another object for equality

  42. def exists(p: (Value) ⇒ Boolean): Boolean

    Tests whether a predicate holds for some of the elements of this set

  43. def filter(p: (Value) ⇒ Boolean): ValueSet

    Selects all elements of this set which satisfy a predicate

  44. def filterNot(p: (Value) ⇒ Boolean): ValueSet

    Selects all elements of this set which do not satisfy a predicate

  45. def find(p: (Value) ⇒ Boolean): Option[Value]

    Finds the first element of the set satisfying a predicate, if any

  46. def first: Value

  47. def firstOption: Option[Value]

    None if iterable is empty

  48. def flatMap[B](f: (Value) ⇒ Traversable[B]): Traversable[B]

    [use case] Builds a new collection by applying a function to all elements of this set and concatenating the results

  49. def flatMap[B, That](f: (Value) ⇒ Traversable[B])(bf: CanBuildFrom[ValueSet, B, That]): That

    Builds a new collection by applying a function to all elements of this set and concatenating the results

  50. def flatten[B]: CC[B]

    [use case] Converts this set of traversable collections into a set in which all element collections are concatenated

  51. def flatten[B](asTraversable: (Value) ⇒ Traversable[B]): Set[B]

    Converts this set of traversable collections into a set in which all element collections are concatenated

  52. def foldLeft[B](z: B)(op: (B, Value) ⇒ B): B

    Applies a binary operator to a start value and all elements of this set, going left to right

  53. def foldRight[B](z: B)(op: (Value, B) ⇒ B): B

    Applies a binary operator to all elements of this set and a start value, going right to left

  54. def forall(p: (Value) ⇒ Boolean): Boolean

    Tests whether a predicate holds for all elements of this set

  55. def foreach(f: (Value) ⇒ Unit): Unit

    [use case] Applies a function f to all elements of this set

  56. def foreach[U](f: (Value) ⇒ U): Unit

    Applies a function f to all elements of this set

  57. def genericBuilder[B]: Builder[B, Set[B]]

    The generic builder that builds instances of Set at arbitrary element types

  58. def groupBy[K](f: (Value) ⇒ K): Map[K, ValueSet]

    Partitions this set into a map of sets according to some discriminator function

  59. def grouped(size: Int): Iterator[ValueSet]

    Partitions elements in fixed size sets

  60. def hasDefiniteSize: Boolean

    Tests whether this set is known to have a finite size

  61. def hashCode(): Int

    Returns a hash code value for the object

  62. def head: Value

    Selects the first element of this set

  63. def headOption: Option[Value]

    Optionally selects the first element

  64. val ids: BitSet

  65. def init: ValueSet

    Selects all elements except the last

  66. def intersect(that: Set[Value]): ValueSet

    Computes the intersection between this set and another set

  67. def isEmpty: Boolean

    Tests if this set is empty

  68. def iterator: Iterator[Value]

    Creates a new iterator over all elements contained in this iterable object

  69. def last: Value

    Selects the last element

  70. def lastOption: Option[Value]

    Optionally selects the last element

  71. def map[B](f: (Value) ⇒ B): Traversable[B]

    [use case] Builds a new collection by applying a function to all elements of this set

  72. def map[B, That](f: (Value) ⇒ B)(bf: CanBuildFrom[ValueSet, B, That]): That

    Builds a new collection by applying a function to all elements of this set

  73. def max[B >: Value](cmp: Ordering[B]): Value

    Finds the largest element

  74. def min: Value

    [use case] Finds the largest element

  75. def min: Value

    [use case] Finds the smallest element

  76. def min[B >: Value](cmp: Ordering[B]): Value

    Finds the smallest element

  77. def mkString: String

    Displays all elements of this set in a string

  78. def mkString(sep: String): String

    Displays all elements of this set in a string using a separator string

  79. def mkString(start: String, sep: String, end: String): String

    Displays all elements of this set in a string using start, end, and separator strings

  80. def nonEmpty: Boolean

    Tests whether the set is not empty

  81. def partialMap[B](pf: PartialFunction[Value, B]): Traversable[B]

    [use case] Builds a new collection by applying a partial function to all elements of this set on which the function is defined

  82. def partialMap[B, That](pf: PartialFunction[Value, B])(bf: CanBuildFrom[ValueSet, B, That]): That

    Builds a new collection by applying a partial function to all elements of this set on which the function is defined

  83. def partition(p: (Value) ⇒ Boolean): (ValueSet, ValueSet)

    Partitions this set in two sets according to a predicate

  84. def product: Int

    [use case] Multiplies up the elements of this collection

  85. def product[B >: Value](num: Numeric[B]): B

    Multiplies up the elements of this collection

  86. def projection: IterableView[Value, ValueSet]

    returns a projection that can be used to call non-strict filter,map, and flatMap methods that build projections of the collection

  87. def reduceLeft[B >: Value](op: (B, Value) ⇒ B): B

    Applies a binary operator to all elements of this set, going left to right

  88. def reduceLeftOption[B >: Value](op: (B, Value) ⇒ B): Option[B]

    Optionally applies a binary operator to all elements of this set, going left to right

  89. def reduceRight[B >: Value](op: (Value, B) ⇒ B): B

    Applies a binary operator to all elements of this set, going right to left

  90. def reduceRightOption[B >: Value](op: (Value, B) ⇒ B): Option[B]

    Optionally applies a binary operator to all elements of this set, going right to left

  91. def repr: ValueSet

    The collection of type set underlying this TraversableLike object

  92. def sameElements(that: Iterable[Value]): Boolean

    [use case] Checks if the other iterable collection contains the same elements in the same order as this set

  93. def sameElements[B >: Value](that: Iterable[B]): Boolean

    Checks if the other iterable collection contains the same elements in the same order as this set

  94. def size: Int

    The size of this set

  95. def slice(from: Int, until: Int): ValueSet

    Selects an interval of elements

  96. def sliding[B >: Value](size: Int, step: Int): Iterator[ValueSet]

  97. def sliding[B >: Value](size: Int): Iterator[ValueSet]

    Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped

  98. def span(p: (Value) ⇒ Boolean): (ValueSet, ValueSet)

    Spits this set into a prefix/suffix pair according to a predicate

  99. def splitAt(n: Int): (ValueSet, ValueSet)

    Splits this set into two at a given position

  100. def stringPrefix: String

    Defines the prefix of this object's toString representation

  101. def subsetOf(that: Set[Value]): Boolean

    Tests whether this set is a subset of another set

  102. def sum: Int

    [use case] Sums up the elements of this collection

  103. def sum[B >: Value](num: Numeric[B]): B

    Sums up the elements of this collection

  104. def tail: ValueSet

    Selects all elements except the first

  105. def take(n: Int): ValueSet

    Selects first n elements

  106. def takeRight(n: Int): ValueSet

    Selects last n elements

  107. def takeWhile(p: (Value) ⇒ Boolean): ValueSet

    Takes longest prefix of elements that satisfy a predicate

  108. def toArray: Array[Value]

    [use case] Converts this set to an array

  109. def toArray[B >: Value](arg0: ClassManifest[B]): Array[B]

    Converts this set to an array

  110. def toIndexedSeq[B >: Value]: IndexedSeq[B]

    Converts this set to an indexed sequence

  111. def toIterable: Iterable[Value]

    Converts this set to an iterable collection

  112. def toList: List[Value]

    Converts this set to a list

  113. def toMap[T, U](ev: <:<[Value, (T, U)]): Map[T, U]

    Converts this set to a map

  114. def toSeq: Seq[Value]

    Converts this set to a sequence

  115. def toSet[B >: Value]: Set[B]

    Converts this set to a set

  116. def toStream: Stream[Value]

    Converts this set to a stream

  117. def toString(): String

    Converts this set to a string

  118. def transpose[B](asTraversable: (Value) ⇒ Traversable[B]): Set[Set[B]]

    Transposes this set of traversable collections into

  119. def union(that: Set[Value]): ValueSet

    Computes the union between of set and another set

  120. def unzip[A1, A2](asPair: (Value) ⇒ (A1, A2)): (Set[A1], Set[A2])

    Converts this set of pairs into two collections of the first and second halfs of each pair

  121. def view(from: Int, until: Int): IterableView[Value, ValueSet]

    Creates a non-strict view of a slice of this set

  122. def view: IterableView[Value, ValueSet]

    Creates a non-strict view of this set

  123. def withFilter(p: (Value) ⇒ Boolean): WithFilter

    Creates a non-strict filter of this set

  124. def zip[B](that: Iterable[B]): Iterable[(Value, B)]

    [use case] Returns a set formed from this set and another iterable collection by combining corresponding elements in pairs

  125. def zip[A1 >: Value, B, That](that: Iterable[B])(bf: CanBuildFrom[ValueSet, (A1, B), That]): That

    Returns a set formed from this set and another iterable collection by combining corresponding elements in pairs

  126. def zipAll[B](that: Iterable[B], thisElem: Value, thatElem: B): Iterable[(Value, B)]

    [use case] Returns a set formed from this set and another iterable collection by combining corresponding elements in pairs

  127. def zipAll[B, A1 >: Value, That](that: Iterable[B], thisElem: A1, thatElem: B)(bf: CanBuildFrom[ValueSet, (A1, B), That]): That

    Returns a set formed from this set and another iterable collection by combining corresponding elements in pairs

  128. def zipWithIndex: Iterable[(Value, Int)]

    [use case] Zips this set with its indices

  129. def zipWithIndex[A1 >: Value, That](bf: CanBuildFrom[ValueSet, (A1, Int), That]): That

    Zips this set with its indices

  130. def |(that: Set[Value]): ValueSet

    Computes the union between this set and another set

Instance constructors

  1. new ValueSet()