Scala Standard Library 2.13.15 - 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 unsorted: Set[Int]
10.  abstract def word(idx: Int): Long
11.  abstract def toIterable: Iterable[Int]

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): b.type
11.  final def addString(b: mutable.StringBuilder, sep: String): b.type
12.  def addString(b: mutable.StringBuilder, start: String, sep: String, end: String): b.type
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.  final def getClass(): Class[_ <: AnyRef]
57.  def groupBy[K](f: (Int) => K): immutable.Map[K, C]
58.  def groupMap[K, B](key: (Int) => K)(f: (Int) => B): immutable.Map[K, Set[B]]
59.  def groupMapReduce[K, B](key: (Int) => K)(f: (Int) => B)(reduce: (B, B) => B): immutable.Map[K, B]
60.  def grouped(size: Int): Iterator[C]
61.  def hashCode(): Int
62.  def head: Int
63.  def headOption: Option[Int]
64.  def init: C
65.  def inits: Iterator[C]
66.  def intersect(other: Set[Int]): C
67.  def isEmpty: Boolean
68.  final def isInstanceOf[T0]: Boolean
69.  def isTraversableAgain: Boolean
70.  def iterator: Iterator[Int]
71.  def iteratorFrom(start: Int): Iterator[Int]
72.  def knownSize: Int
73.  def last: Int
74.  def lastKey: Int
75.  def lastOption: Option[Int]
76.  def map(f: (Int) => Int): C
77.  def map[B](f: (Int) => B)(implicit ev: Ordering[B]): SortedSet[B]
78.  def map[B](f: (Int) => B): Set[B]
79.  def max[B >: Int](implicit ord: Ordering[B]): Int
80.  def maxBefore(key: Int): Option[Int]
81.  def maxBy[B](f: (Int) => B)(implicit ord: math.Ordering[B]): Int
82.  def maxByOption[B](f: (Int) => B)(implicit ord: math.Ordering[B]): Option[Int]
83.  def maxOption[B >: Int](implicit ord: math.Ordering[B]): Option[Int]
84.  def min[B >: Int](implicit ord: Ordering[B]): Int
85.  def minAfter(key: Int): Option[Int]
86.  def minBy[B](f: (Int) => B)(implicit ord: math.Ordering[B]): Int
87.  def minByOption[B](f: (Int) => B)(implicit ord: math.Ordering[B]): Option[Int]
88.  def minOption[B >: Int](implicit ord: math.Ordering[B]): Option[Int]
89.  final def mkString: String
90.  final def mkString(sep: String): String
91.  final def mkString(start: String, sep: String, end: String): String
92.  final def ne(arg0: AnyRef): Boolean
93.  def nonEmpty: Boolean
94.  final def notify(): Unit
95.  final def notifyAll(): Unit
96.  final def ordering: Ordering[Int]
97.  def partition(p: (Int) => Boolean): (C, C)
98.  def partitionMap[A1, A2](f: (Int) => Either[A1, A2]): (Set[A1], Set[A2])
99.  def product[B >: Int](implicit num: math.Numeric[B]): B
100.  def range(from: Int, until: Int): C
101.  def rangeFrom(from: Int): C
102.  def rangeImpl(from: Option[Int], until: Option[Int]): C
103.  def rangeTo(to: Int): C
104.  def rangeUntil(until: Int): C
105.  def reduce[B >: Int](op: (B, B) => B): B
106.  def reduceLeft[B >: Int](op: (B, Int) => B): B
107.  def reduceLeftOption[B >: Int](op: (B, Int) => B): Option[B]
108.  def reduceOption[B >: Int](op: (B, B) => B): Option[B]
109.  def reduceRight[B >: Int](op: (Int, B) => B): B
110.  def reduceRightOption[B >: Int](op: (Int, B) => B): Option[B]
111.  def reversed: Iterable[Int]
112.  def scan[B >: Int](z: B)(op: (B, B) => B): Set[B]
113.  def scanLeft[B](z: B)(op: (B, Int) => B): Set[B]
114.  def scanRight[B](z: B)(op: (Int, B) => B): Set[B]
115.  def size: Int
116.  def sizeCompare(that: Iterable[_]): Int
117.  def sizeCompare(otherSize: Int): Int
118.  final def sizeIs: SizeCompareOps
119.  def slice(from: Int, until: Int): C
120.  def sliding(size: Int, step: Int): Iterator[C]
121.  def sliding(size: Int): Iterator[C]
122.  def span(p: (Int) => Boolean): (C, C)
123.  def splitAt(n: Int): (C, C)
124.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[Int, S]): S with EfficientSplit
125.  def subsetOf(that: Set[Int]): Boolean
126.  def subsets(): Iterator[C]
127.  def subsets(len: Int): Iterator[C]
128.  def sum[B >: Int](implicit num: math.Numeric[B]): B
129.  final def synchronized[T0](arg0: => T0): T0
130.  def tail: C
131.  def tails: Iterator[C]
132.  def take(n: Int): C
133.  def takeRight(n: Int): C
134.  def takeWhile(p: (Int) => Boolean): C
135.  def tapEach[U](f: (Int) => U): C
136.  def to[C1](factory: Factory[Int, C1]): C1
137.  def toArray[B >: Int](implicit arg0: ClassTag[B]): Array[B]
138.  def toBitMask: Array[Long]
139.  final def toBuffer[B >: Int]: Buffer[B]
140.  def toIndexedSeq: immutable.IndexedSeq[Int]
141.  def toList: immutable.List[Int]
142.  def toMap[K, V](implicit ev: <:<[Int, (K, V)]): immutable.Map[K, V]
143.  def toSeq: immutable.Seq[Int]
144.  def toSet[B >: Int]: immutable.Set[B]
145.  def toString(): String
146.  def toVector: immutable.Vector[Int]
147.  def transpose[B](implicit asIterable: (Int) => Iterable[B]): Set[Set[B]]
148.  final def union(that: Set[Int]): C
149.  def unzip[A1, A2](implicit asPair: (Int) => (A1, A2)): (Set[A1], Set[A2])
150.  def unzip3[A1, A2, A3](implicit asTriple: (Int) => (A1, A2, A3)): (Set[A1], Set[A2], Set[A3])
151.  def view: View[Int]
152.  final def wait(): Unit
153.  final def wait(arg0: Long, arg1: Int): Unit
154.  final def wait(arg0: Long): Unit
155.  def withFilter(p: (Int) => Boolean): WithFilter[Int, Set]
156.  def xor(other: BitSet): C
157.  def zip[B](that: IterableOnce[B])(implicit ev: Ordering[(Int, B)]): SortedSet[(Int, B)]
158.  def zip[B](that: IterableOnce[B]): Set[(Int, B)]
159.  def zipAll[A1 >: Int, B](that: Iterable[B], thisElem: A1, thatElem: B): Set[(A1, B)]
160.  def zipWithIndex: Set[(Int, Int)]
161.  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.  def formatted(fmtstr: String): String
28.  final def from(from: Int): C
29.  def hasDefiniteSize: Boolean
30.  def isEmpty: Boolean
31.  def keysIteratorFrom(start: Int): Iterator[Int]
32.  def map[B](f: (Int) => B): IterableOnce[B]
33.  def max(implicit ord: math.Ordering[Int]): Int
34.  def maxBy[B](f: (Int) => B)(implicit cmp: math.Ordering[B]): Int
35.  def min(implicit ord: math.Ordering[Int]): Int
36.  def minBy[B](f: (Int) => B)(implicit cmp: math.Ordering[B]): Int
37.  def mkString: String
38.  def mkString(sep: String): String
39.  def mkString(start: String, sep: String, end: String): String
40.  def nonEmpty: Boolean
41.  def product(implicit num: math.Numeric[Int]): Int
42.  def reduce(f: (Int, Int) => Int): Int
43.  def reduceLeft(f: (Int, Int) => Int): Int
44.  def reduceLeftOption(f: (Int, Int) => Int): Option[Int]
45.  def reduceOption(f: (Int, Int) => Int): Option[Int]
46.  def reduceRight(f: (Int, Int) => Int): Int
47.  def reduceRightOption(f: (Int, Int) => Int): Option[Int]
48.  final def repr: C
49.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
50.  def size: Int
51.  def sum(implicit num: math.Numeric[Int]): Int
52.  def to[C1](factory: Factory[Int, C1]): C1
53.  final def to(to: Int): C
54.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
55.  def toBuffer[B >: A]: Buffer[B]
56.  def toIndexedSeq: IndexedSeq[Int]
57.  final def toIterable: Iterable[Int]
58.  def toIterator: Iterator[Int]
59.  final def toIterator: Iterator[Int]
60.  def toList: immutable.List[Int]
61.  def toMap[K, V](implicit ev: <:<[Int, (K, V)]): immutable.Map[K, V]
62.  def toSeq: immutable.Seq[Int]
63.  def toSet[B >: A]: immutable.Set[B]
64.  def toStream: immutable.Stream[Int]
65.  final def toStream: immutable.Stream[Int]
66.  final def toTraversable: Traversable[Int]
67.  final def toTraversable: Traversable[Int]
68.  def toVector: immutable.Vector[Int]
69.  final def until(until: Int): C
70.  def view(from: Int, until: Int): View[Int]
71.  def withFilter(f: (Int) => Boolean): Iterator[Int]
72.  def →[B](y: B): (BitSetOps[C], B)

Ungrouped