scala.collection.SortedMapLike

DefaultKeySortedSet

class DefaultKeySortedSet extends DefaultKeySet with SortedSet[A]

attributes: protected
source: SortedMapLike.scala
Inherited
  1. Hide All
  2. Show all
  1. SortedSet
  2. SortedSetLike
  3. Sorted
  4. DefaultKeySet
  5. Set
  6. SetLike
  7. Subtractable
  8. Addable
  9. GenericSetTemplate
  10. Iterable
  11. IterableLike
  12. Equals
  13. Traversable
  14. GenericTraversableTemplate
  15. TraversableLike
  16. TraversableOnce
  17. HasNewBuilder
  18. Function1
  19. AnyRef
  20. Any
Visibility
  1. Public
  2. All

Instance constructors

  1. new DefaultKeySortedSet()

Type Members

  1. type Self = SortedSet[A]

    The type implementing this traversable

  2. class WithFilter extends AnyRef

    A class supporting filtered operations .

Value Members

  1. def !=(arg0: AnyRef): Boolean

  2. def !=(arg0: Any): Boolean

    o != arg0 is the same as !(o == (arg0)).

  3. def ##(): Int

  4. def $asInstanceOf[T0](): T0

  5. def $isInstanceOf[T0](): Boolean

  6. def &(that: Set[A]): SortedSet[A]

    Computes the intersection between this set and another set .

  7. def &~(that: Set[A]): SortedSet[A]

    The difference of this set and another set .

  8. def **(that: Set[A]): SortedSet[A]

    This method is an alias for intersect.

  9. def +(elem: A): SortedSet[A]

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

  10. def +(elem1: A, elem2: A, elems: A*): SortedSet[A]

    Creates a new set with additional elements .

  11. def ++(xs: TraversableOnce[A]): SortedSet[A]

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

  12. def ++(that: TraversableOnce[A]): Set[A]

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

  13. def ++[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[SortedSet[A], B, That]): That

    Concatenates this set with the elements of a traversable collection .

  14. def -(elem: A): SortedSet[A]

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

  15. def -(elem1: A, elem2: A, elems: A*): SortedSet[A]

    Creates a new set from this set with some elements removed .

  16. def --(xs: TraversableOnce[A]): SortedSet[A]

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

  17. def /:[B](z: B)(op: (B, A) ⇒ B): B

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

  18. def :\[B](z: B)(op: (A, B) ⇒ B): B

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

  19. def ==(arg0: AnyRef): Boolean

    o == arg0 is the same as if (o eq null) arg0 eq null else o.equals(arg0).

  20. def ==(arg0: Any): Boolean

    o == arg0 is the same as o.equals(arg0).

  21. def addString(b: StringBuilder): StringBuilder

    Appends all elements of this set to a string builder .

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

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

  23. 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 .

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

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

  25. def apply(elem: A): Boolean

    Tests if some element is contained in this set .

  26. def asInstanceOf[T0]: T0

    This method is used to cast the receiver object to be of type T0.

  27. 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 .

  28. def clone(): AnyRef

    This method creates and returns a copy of the receiver object .

  29. def collect[B](pf: PartialFunction[A, B]): Set[B]

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

  30. def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[SortedSet[A], B, That]): That

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

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

    The factory companion object that builds instances of class Set .

  32. def compare(k0: A, k1: A): Int

    Comparison function that orders keys .

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

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

  34. def contains(key: A): Boolean

    Tests if some element is contained in this set .

  35. def copyToArray(xs: Array[A], start: Int, len: Int): Unit

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

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

    Copies elements of this set to an array .

  37. def copyToArray(xs: Array[A]): Unit

    [use case] Copies values of this set to an array .

  38. def copyToArray[B >: A](xs: Array[B]): Unit

    Copies values of this set to an array .

  39. def copyToArray(xs: Array[A], start: Int): Unit

    [use case] Copies values of this set to an array .

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

    Copies values of this set to an array .

  41. def copyToBuffer[B >: A](dest: Buffer[B]): Unit

    Copies all elements of this set to a buffer .

  42. def count(p: (A) ⇒ Boolean): Int

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

  43. def diff(that: Set[A]): SortedSet[A]

    Computes the difference of this set and another set .

  44. def drop(n: Int): SortedSet[A]

    Selects all elements except first n ones.

  45. def dropRight(n: Int): SortedSet[A]

    Selects all elements except last n ones.

  46. def dropWhile(p: (A) ⇒ Boolean): SortedSet[A]

    Drops longest prefix of elements that satisfy a predicate .

  47. def elements: Iterator[A]

  48. def empty: SortedSet[A]

    Needs to be overridden in subclasses .

  49. def eq(arg0: AnyRef): Boolean

    This method is used to test whether the argument (arg0) is a reference to the receiver object (this).

  50. def equals(that: Any): Boolean

    Compares this set with another object for equality .

  51. def exists(p: (A) ⇒ Boolean): Boolean

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

  52. def filter(p: (A) ⇒ Boolean): SortedSet[A]

    Selects all elements of this set which satisfy a predicate .

  53. def filterNot(p: (A) ⇒ Boolean): SortedSet[A]

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

  54. def finalize(): Unit

    This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object .

  55. def find(p: (A) ⇒ Boolean): Option[A]

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

  56. def first: A

  57. def firstKey: A

    Returns the first key of the collection .

  58. def firstOption: Option[A]

    None if iterable is empty.

  59. def flatMap[B](f: (A) ⇒ Traversable[B]): Set[B]

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

  60. def flatMap[B, That](f: (A) ⇒ Traversable[B])(implicit bf: CanBuildFrom[SortedSet[A], B, That]): That

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

  61. def flatten[B]: Set[B]

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

  62. def flatten[B](implicit asTraversable: (A) ⇒ Traversable[B]): Set[B]

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

  63. def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

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

  64. def foldRight[B](z: B)(op: (A, B) ⇒ B): B

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

  65. def forall(p: (A) ⇒ Boolean): Boolean

    Tests whether a predicate holds for all elements of this set .

  66. def foreach(f: (A) ⇒ Unit): Unit

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

  67. def foreach[C](f: (A) ⇒ C): Unit

    Applies a function f to all elements of this set.

  68. def from(from: A): SortedSet[A]

    Creates a ranged projection of this collection with no upper-bound .

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

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

  70. def getClass(): java.lang.Class[_ <: java.lang.Object]

    Returns a representation that corresponds to the dynamic class of the receiver object .

  71. def groupBy[K](f: (A) ⇒ K): Map[K, SortedSet[A]]

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

  72. def grouped(size: Int): Iterator[SortedSet[A]]

    Partitions elements in fixed size sets .

  73. def hasAll(j: Iterator[A]): Boolean

  74. def hasDefiniteSize: Boolean

    Tests whether this set is known to have a finite size .

  75. def hashCode(): Int

    Returns a hash code value for the object .

  76. def head: A

    Selects the first element of this set .

  77. def headOption: Option[A]

    Optionally selects the first element .

  78. def init: SortedSet[A]

    Selects all elements except the last .

  79. def intersect(that: Set[A]): SortedSet[A]

    Computes the intersection between this set and another set .

  80. def isEmpty: Boolean

    Tests if this set is empty .

  81. def isInstanceOf[T0]: Boolean

    This method is used to test whether the dynamic type of the receiver object is T0.

  82. def isTraversableAgain: Boolean

    Tests whether this set can be repeatedly traversed .

  83. def iterator: Iterator[A]

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

  84. def keySet: SortedSet[A]

    return as a projection the set of keys in this collection

  85. def last: A

    Selects the last element .

  86. def lastKey: A

    Returns the last key of the collection .

  87. def lastOption: Option[A]

    Optionally selects the last element .

  88. def map[B](f: (A) ⇒ B): Set[B]

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

  89. def map[B, That](f: (A) ⇒ B)(implicit bf: CanBuildFrom[SortedSet[A], B, That]): That

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

  90. def max: A

    [use case] Finds the largest element .

  91. def max[B >: A](implicit cmp: Ordering[B]): A

    Finds the largest element .

  92. def min: A

    [use case] Finds the smallest element .

  93. def min[B >: A](implicit cmp: Ordering[B]): A

    Finds the smallest element .

  94. def mkString: String

    Displays all elements of this set in a string .

  95. def mkString(sep: String): String

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

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

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

  97. def ne(arg0: AnyRef): Boolean

    o.ne(arg0) is the same as !(o.eq(arg0)).

  98. def newBuilder: Builder[A, SortedSet[A]]

    A common implementation of newBuilder for all sets in terms of empty.

  99. def nonEmpty: Boolean

    Tests whether the set is not empty .

  100. def notify(): Unit

    Wakes up a single thread that is waiting on the receiver object's monitor .

  101. def notifyAll(): Unit

    Wakes up all threads that are waiting on the receiver object's monitor .

  102. implicit def ordering: Ordering[A]

  103. def partition(p: (A) ⇒ Boolean): (SortedSet[A], SortedSet[A])

    Partitions this set in two sets according to a predicate .

  104. def product: Int

    [use case] Multiplies up the elements of this collection .

  105. def product[B >: A](implicit num: Numeric[B]): B

    Multiplies up the elements of this collection .

  106. def projection: IterableView[A, SortedSet[A]]

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

  107. def range(from: A, until: A): SortedSet[A]

    Creates a ranged projection of this collection with both a lower-bound and an upper-bound .

  108. def rangeImpl(from: Option[A], until: Option[A]): SortedSet[A]

    Creates a ranged projection of this collection .

  109. def reduceLeft[B >: A](op: (B, A) ⇒ B): B

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

  110. def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]

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

  111. def reduceRight[B >: A](op: (A, B) ⇒ B): B

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

  112. def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]

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

  113. def repr: SortedSet[A]

    The collection of type set underlying this TraversableLike object.

  114. def reversed: List[A]

  115. def sameElements(that: Iterable[A]): Boolean

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

  116. def sameElements[B >: A](that: Iterable[B]): Boolean

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

  117. def scanLeft[B, That](z: B)(op: (B, A) ⇒ B)(implicit bf: CanBuildFrom[SortedSet[A], B, That]): That

    Produces a collection containing cummulative results of applying the operator going left to right .

  118. def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[SortedSet[A], B, That]): That

    Produces a collection containing cummulative results of applying the operator going right to left .

  119. def size: Int

    The size of this set .

  120. def slice(from: Int, until: Int): SortedSet[A]

    Selects an interval of elements .

  121. def sliding[B >: A](size: Int, step: Int): Iterator[SortedSet[A]]

  122. def sliding[B >: A](size: Int): Iterator[SortedSet[A]]

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

  123. def span(p: (A) ⇒ Boolean): (SortedSet[A], SortedSet[A])

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

  124. def splitAt(n: Int): (SortedSet[A], SortedSet[A])

    Splits this set into two at a given position .

  125. def stringPrefix: String

    Defines the prefix of this object's toString representation.

  126. def subsetOf(that: Set[A]): Boolean

    Tests whether this set is a subset of another set .

  127. def sum: Int

    [use case] Sums up the elements of this collection .

  128. def sum[B >: A](implicit num: Numeric[B]): B

    Sums up the elements of this collection .

  129. def synchronized[T0](arg0: T0): T0

  130. def tail: SortedSet[A]

    Selects all elements except the first .

  131. def take(n: Int): SortedSet[A]

    Selects first n elements.

  132. def takeRight(n: Int): SortedSet[A]

    Selects last n elements.

  133. def takeWhile(p: (A) ⇒ Boolean): SortedSet[A]

    Takes longest prefix of elements that satisfy a predicate .

  134. def thisCollection: Iterable[A]

    The underlying collection seen as an instance of Set.

  135. def to(to: A): SortedSet[A]

    Create a range projection of this collection with no lower-bound .

  136. def toArray: Array[A]

    [use case] Converts this set to an array .

  137. def toArray[B >: A](implicit arg0: ClassManifest[B]): Array[B]

    Converts this set to an array .

  138. def toCollection(repr: SortedSet[A]): Iterable[A]

    A conversion from collections of type Repr to Set objects.

  139. def toIndexedSeq[B >: A]: IndexedSeq[B]

    Converts this set to an indexed sequence .

  140. def toIterable: Iterable[A]

    Converts this set to an iterable collection .

  141. def toIterator: Iterator[A]

    Returns an Iterator over the elements in this set .

  142. def toList: List[A]

    Converts this set to a list .

  143. def toMap[T, U](implicit ev: <:<[A, (T, U)]): Map[T, U]

    Converts this set to a map .

  144. def toSeq: Seq[A]

    Converts this set to a sequence .

  145. def toSet[B >: A]: Set[B]

    Converts this set to a set .

  146. def toStream: Stream[A]

    Converts this set to a stream .

  147. def toString(): String

    Converts this set to a string .

  148. def toTraversable: Traversable[A]

    Converts this set to an unspecified Traversable .

  149. def transpose[B](implicit asTraversable: (A) ⇒ Traversable[B]): Set[Set[B]]

    Transposes this set of traversable collections into a set of sets .

  150. def union(that: Set[A]): SortedSet[A]

    Computes the union between of set and another set .

  151. def until(until: A): SortedSet[A]

    Creates a ranged projection of this collection with no lower-bound .

  152. def unzip[A1, A2](implicit asPair: (A) ⇒ (A1, A2)): (Set[A1], Set[A2])

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

  153. def view(from: Int, until: Int): IterableView[A, SortedSet[A]]

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

  154. def view: IterableView[A, SortedSet[A]]

    Creates a non-strict view of this set .

  155. def wait(): Unit

  156. def wait(arg0: Long, arg1: Int): Unit

  157. def wait(arg0: Long): Unit

  158. def withFilter(p: (A) ⇒ Boolean): WithFilter

    Creates a non-strict filter of this set .

  159. def zip[B](that: Iterable[B]): Set[(A, B)]

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

  160. def zip[A1 >: A, B, That](that: Iterable[B])(implicit bf: CanBuildFrom[SortedSet[A], (A1, B), That]): That

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

  161. def zipAll[B](that: Iterable[B], thisElem: A, thatElem: B): Set[(A, B)]

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

  162. def zipAll[B, A1 >: A, That](that: Iterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[SortedSet[A], (A1, B), That]): That

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

  163. def zipWithIndex: Set[(A, Int)]

    [use case] Zips this set with its indices .

  164. def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[SortedSet[A], (A1, Int), That]): That

    Zips this set with its indices .

  165. def |(that: Set[A]): SortedSet[A]

    Computes the union between this set and another set .