Scala Standard Library 2.13.1 - scala.collection.BitSetOps (original) (raw)

trait BitSetOps[+C <: BitSet with BitSetOps[C]] extends SortedSetOps[Int, SortedSet, C]

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. BitSetOps
2. SortedSetOps
3. SortedOps
4. SetOps
5. Function1
6. IterableOps
7. IterableOnceOps
8. IterableOnce
9. AnyRef
10. Any

Implicitly

1. by iterableOnceExtensionMethods

2. by any2stringadd

3. by StringFormat

4. by Ensuring

5. by ArrowAssoc

6. Hide All

7. Show All

Visibility

1. Public
2. Protected

Abstract Value Members

1.  abstract def bitSetFactory: SpecificIterableFactory[Int, C]
2.  abstract def coll: C
3.  abstract def fromBitMaskNoCopy(elems: Array[Long]): C
4.  abstract def fromSpecific(coll: IterableOnce[Int]): C
5.  abstract def iterableFactory: IterableFactory[Set]
6.  abstract def newSpecificBuilder: Builder[Int, C]
7.  abstract def nwords: Int
8.  abstract def sortedIterableFactory: SortedIterableFactory[SortedSet]
9.  abstract def toIterable: Iterable[Int]
10.  abstract def unsorted: Set[Int]
11.  abstract def word(idx: Int): Long

Concrete Value Members

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  final def &(that: Set[Int]): C
4.  final def &~(that: Set[Int]): C
5.  final def ++(that: IterableOnce[Int]): C
6.  final def ++[B >: Int](suffix: IterableOnce[B]): Set[B]
7.  def ->[B](y: B): (BitSetOps[C], B)
8.  final def ==(arg0: Any): Boolean
9.  final def ^(other: BitSet): C
10.  final def addString(b: mutable.StringBuilder): mutable.StringBuilder
11.  final def addString(b: mutable.StringBuilder, sep: String): mutable.StringBuilder
12.  def addString(b: mutable.StringBuilder, start: String, sep: String, end: String): mutable.StringBuilder
13.  def andThen[A](g: (Boolean) => A): (Int) => A
14.  final def apply(elem: Int): Boolean
15.  final def asInstanceOf[T0]: T0
16.  def clone(): AnyRef
17.  def collect(pf: PartialFunction[Int, Int]): C
18.  def collect[B](pf: PartialFunction[Int, B])(implicit ev: Ordering[B]): SortedSet[B]
19.  def collect[B](pf: PartialFunction[Int, B]): Set[B]
20.  def collectFirst[B](pf: PartialFunction[Int, B]): Option[B]
21.  def compose[A](g: (A) => Int): (A) => Boolean
22.  def concat(other: IterableOnce[Int]): C
23.  def concat[B >: Int](suffix: IterableOnce[B]): Set[B]
24.  def contains(elem: Int): Boolean
25.  def copyToArray[B >: Int](xs: Array[B], start: Int, len: Int): Int
26.  def copyToArray[B >: Int](xs: Array[B], start: Int): Int
27.  def copyToArray[B >: Int](xs: Array[B]): Int
28.  def corresponds[B](that: IterableOnce[B])(p: (Int, B) => Boolean): Boolean
29.  def count(p: (Int) => Boolean): Int
30.  def diff(other: Set[Int]): C
31.  def drop(n: Int): C
32.  def dropRight(n: Int): C
33.  def dropWhile(p: (Int) => Boolean): C
34.  def empty: C
35.  def ensuring(cond: (BitSetOps[C]) => Boolean, msg: => Any): BitSetOps[C]
36.  def ensuring(cond: (BitSetOps[C]) => Boolean): BitSetOps[C]
37.  def ensuring(cond: Boolean, msg: => Any): BitSetOps[C]
38.  def ensuring(cond: Boolean): BitSetOps[C]
39.  final def eq(arg0: AnyRef): Boolean
40.  def equals(arg0: AnyRef): Boolean
41.  def exists(p: (Int) => Boolean): Boolean
42.  def filter(pred: (Int) => Boolean): C
43.  def filterNot(pred: (Int) => Boolean): C
44.  def finalize(): Unit
45.  def find(p: (Int) => Boolean): Option[Int]
46.  def firstKey: Int
47.  def flatMap(f: (Int) => IterableOnce[Int]): C
48.  def flatMap[B](f: (Int) => IterableOnce[B])(implicit ev: Ordering[B]): SortedSet[B]
49.  def flatMap[B](f: (Int) => IterableOnce[B]): Set[B]
50.  def flatten[B](implicit asIterable: (Int) => IterableOnce[B]): Set[B]
51.  def fold[A1 >: Int](z: A1)(op: (A1, A1) => A1): A1
52.  def foldLeft[B](z: B)(op: (B, Int) => B): B
53.  def foldRight[B](z: B)(op: (Int, B) => B): B
54.  def forall(p: (Int) => Boolean): Boolean
55.  def foreach[U](f: (Int) => U): Unit
56.  def formatted(fmtstr: String): String
57.  final def getClass(): Class[_ <: AnyRef]
58.  def groupBy[K](f: (Int) => K): immutable.Map[K, C]
59.  def groupMap[K, B](key: (Int) => K)(f: (Int) => B): immutable.Map[K, Set[B]]
60.  def groupMapReduce[K, B](key: (Int) => K)(f: (Int) => B)(reduce: (B, B) => B): immutable.Map[K, B]
61.  def grouped(size: Int): Iterator[C]
62.  def hashCode(): Int
63.  def head: Int
64.  def headOption: Option[Int]
65.  def init: C
66.  def inits: Iterator[C]
67.  def intersect(other: Set[Int]): C
68.  def isEmpty: Boolean
69.  final def isInstanceOf[T0]: Boolean
70.  def isTraversableAgain: Boolean
71.  def iterator: Iterator[Int]
72.  def iteratorFrom(start: Int): Iterator[Int]
73.  def knownSize: Int
74.  def last: Int
75.  def lastKey: Int
76.  def lastOption: Option[Int]
77.  def map(f: (Int) => Int): C
78.  def map[B](f: (Int) => B)(implicit ev: Ordering[B]): SortedSet[B]
79.  def map[B](f: (Int) => B): Set[B]
80.  def max[B >: Int](implicit ord: Ordering[B]): Int
81.  def maxBefore(key: Int): Option[Int]
82.  def maxBy[B](f: (Int) => B)(implicit cmp: math.Ordering[B]): Int
83.  def maxByOption[B](f: (Int) => B)(implicit cmp: math.Ordering[B]): Option[Int]
84.  def maxOption[B >: Int](implicit ord: math.Ordering[B]): Option[Int]
85.  def min[B >: Int](implicit ord: Ordering[B]): Int
86.  def minAfter(key: Int): Option[Int]
87.  def minBy[B](f: (Int) => B)(implicit cmp: math.Ordering[B]): Int
88.  def minByOption[B](f: (Int) => B)(implicit cmp: math.Ordering[B]): Option[Int]
89.  def minOption[B >: Int](implicit ord: math.Ordering[B]): Option[Int]
90.  final def mkString: String
91.  final def mkString(sep: String): String
92.  final def mkString(start: String, sep: String, end: String): String
93.  final def ne(arg0: AnyRef): Boolean
94.  def nonEmpty: Boolean
95.  final def notify(): Unit
96.  final def notifyAll(): Unit
97.  final def ordering: Ordering[Int]
98.  def partition(p: (Int) => Boolean): (C, C)
99.  def partitionMap[A1, A2](f: (Int) => Either[A1, A2]): (Set[A1], Set[A2])
100.  def product[B >: Int](implicit num: math.Numeric[B]): B
101.  def range(from: Int, until: Int): C
102.  def rangeFrom(from: Int): C
103.  def rangeImpl(from: Option[Int], until: Option[Int]): C
104.  def rangeTo(to: Int): C
105.  def rangeUntil(until: Int): C
106.  def reduce[B >: Int](op: (B, B) => B): B
107.  def reduceLeft[B >: Int](op: (B, Int) => B): B
108.  def reduceLeftOption[B >: Int](op: (B, Int) => B): Option[B]
109.  def reduceOption[B >: Int](op: (B, B) => B): Option[B]
110.  def reduceRight[B >: Int](op: (Int, B) => B): B
111.  def reduceRightOption[B >: Int](op: (Int, B) => B): Option[B]
112.  def reversed: Iterable[Int]
113.  def scan[B >: Int](z: B)(op: (B, B) => B): Set[B]
114.  def scanLeft[B](z: B)(op: (B, Int) => B): Set[B]
115.  def scanRight[B](z: B)(op: (Int, B) => B): Set[B]
116.  def size: Int
117.  def sizeCompare(that: Iterable[_]): Int
118.  def sizeCompare(otherSize: Int): Int
119.  final def sizeIs: SizeCompareOps
120.  def slice(from: Int, until: Int): C
121.  def sliding(size: Int, step: Int): Iterator[C]
122.  def sliding(size: Int): Iterator[C]
123.  def span(p: (Int) => Boolean): (C, C)
124.  def splitAt(n: Int): (C, C)
125.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[Int, S]): S with EfficientSplit
126.  def subsetOf(that: Set[Int]): Boolean
127.  def subsets(): Iterator[C]
128.  def subsets(len: Int): Iterator[C]
129.  def sum[B >: Int](implicit num: math.Numeric[B]): B
130.  final def synchronized[T0](arg0: => T0): T0
131.  def tail: C
132.  def tails: Iterator[C]
133.  def take(n: Int): C
134.  def takeRight(n: Int): C
135.  def takeWhile(p: (Int) => Boolean): C
136.  def tapEach[U](f: (Int) => U): C
137.  def to[C1](factory: Factory[Int, C1]): C1
138.  def toArray[B >: Int](implicit arg0: ClassTag[B]): Array[B]
139.  def toBitMask: Array[Long]
140.  final def toBuffer[B >: Int]: Buffer[B]
141.  def toIndexedSeq: immutable.IndexedSeq[Int]
142.  def toList: immutable.List[Int]
143.  def toMap[K, V](implicit ev: <:<[Int, (K, V)]): immutable.Map[K, V]
144.  def toSeq: immutable.Seq[Int]
145.  def toSet[B >: Int]: immutable.Set[B]
146.  def toString(): String
147.  def toVector: immutable.Vector[Int]
148.  def transpose[B](implicit asIterable: (Int) => Iterable[B]): Set[Set[B]]
149.  final def union(that: Set[Int]): C
150.  def unzip[A1, A2](implicit asPair: (Int) => (A1, A2)): (Set[A1], Set[A2])
151.  def unzip3[A1, A2, A3](implicit asTriple: (Int) => (A1, A2, A3)): (Set[A1], Set[A2], Set[A3])
152.  def view: View[Int]
153.  final def wait(): Unit
154.  final def wait(arg0: Long, arg1: Int): Unit
155.  final def wait(arg0: Long): Unit
156.  def withFilter(p: (Int) => Boolean): WithFilter[Int, Set]
157.  def xor(other: BitSet): C
158.  def zip[B](that: IterableOnce[B])(implicit ev: Ordering[(Int, B)]): SortedSet[(Int, B)]
159.  def zip[B](that: IterableOnce[B]): Set[(Int, B)]
160.  def zipAll[A1 >: Int, B](that: Iterable[B], thisElem: A1, thatElem: B): Set[(A1, B)]
161.  def zipWithIndex: Set[(Int, Int)]
162.  final def |(that: Set[Int]): C

Deprecated Value Members

1.  def +(elem1: Int, elem2: Int, elems: Int*): C
2.  def +(elem: Int): C
3.  def ++:[B >: Int](that: IterableOnce[B]): Set[B]
4.  def -(elem1: Int, elem2: Int, elems: Int*): C
5.  def -(elem: Int): C
6.  def --(that: IterableOnce[Int]): C
7.  def /:[B](z: B)(op: (B, Int) => B): B
8.  final def /:[B](z: B)(op: (B, Int) => B): B
9.  def :\[B](z: B)(op: (Int, B) => B): B
10.  final def :\[B](z: B)(op: (Int, B) => B): B
11.  def aggregate[B](z: => B)(seqop: (B, Int) => B, combop: (B, B) => B): B
12.  def collectFirst[B](f: PartialFunction[Int, B]): Option[B]
13.  def companion: IterableFactory[Set]
14.  def compare(k0: Int, k1: Int): Int
15.  def copyToBuffer(dest: Buffer[Int]): Unit
16.  final def copyToBuffer[B >: Int](dest: Buffer[B]): Unit
17.  def count(f: (Int) => Boolean): Int
18.  def exists(f: (Int) => Boolean): Boolean
19.  def filter(f: (Int) => Boolean): Iterator[Int]
20.  def find(p: (Int) => Boolean): Option[Int]
21.  def flatMap[B](f: (Int) => IterableOnce[B]): IterableOnce[B]
22.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
23.  def foldLeft[B](z: B)(op: (B, Int) => B): B
24.  def foldRight[B](z: B)(op: (Int, B) => B): B
25.  def forall(f: (Int) => Boolean): Boolean
26.  def foreach[U](f: (Int) => U): Unit
27.  final def from(from: Int): C
28.  def hasDefiniteSize: Boolean
29.  def isEmpty: Boolean
30.  def keysIteratorFrom(start: Int): Iterator[Int]
31.  def map[B](f: (Int) => B): IterableOnce[B]
32.  def max(implicit ord: math.Ordering[Int]): Int
33.  def maxBy[B](f: (Int) => B)(implicit cmp: math.Ordering[B]): Int
34.  def min(implicit ord: math.Ordering[Int]): Int
35.  def minBy[B](f: (Int) => B)(implicit cmp: math.Ordering[B]): Int
36.  def mkString: String
37.  def mkString(sep: String): String
38.  def mkString(start: String, sep: String, end: String): String
39.  def nonEmpty: Boolean
40.  def product(implicit num: math.Numeric[Int]): Int
41.  def reduce(f: (Int, Int) => Int): Int
42.  def reduceLeft(f: (Int, Int) => Int): Int
43.  def reduceLeftOption(f: (Int, Int) => Int): Option[Int]
44.  def reduceOption(f: (Int, Int) => Int): Option[Int]
45.  def reduceRight(f: (Int, Int) => Int): Int
46.  def reduceRightOption(f: (Int, Int) => Int): Option[Int]
47.  final def repr: C
48.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
49.  def size: Int
50.  def sum(implicit num: math.Numeric[Int]): Int
51.  def to[C1](factory: Factory[Int, C1]): C1
52.  final def to(to: Int): C
53.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
54.  def toBuffer[B >: A]: Buffer[B]
55.  def toIndexedSeq: IndexedSeq[Int]
56.  final def toIterable: Iterable[Int]
57.  def toIterator: Iterator[Int]
58.  final def toIterator: Iterator[Int]
59.  def toList: immutable.List[Int]
60.  def toMap[K, V](implicit ev: <:<[Int, (K, V)]): immutable.Map[K, V]
61.  def toSeq: immutable.Seq[Int]
62.  def toSet[B >: A]: immutable.Set[B]
63.  def toStream: immutable.Stream[Int]
64.  final def toStream: immutable.Stream[Int]
65.  final def toTraversable: Traversable[Int]
66.  final def toTraversable: Traversable[Int]
67.  def toVector: immutable.Vector[Int]
68.  final def until(until: Int): C
69.  def view(from: Int, until: Int): View[Int]
70.  def withFilter(f: (Int) => Boolean): Iterator[Int]
71.  def →[B](y: B): (BitSetOps[C], B)

Ungrouped