Scala Standard Library 2.13.15 - scala.collection.BitSet (original) (raw)

trait BitSet extends SortedSet[Int] with BitSetOps[BitSet]

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. BitSet
2. BitSetOps
3. SortedSet
4. SortedSetFactoryDefaults
5. SortedSetOps
6. SortedOps
7. Set
8. Equals
9. SetOps
10. Function1
11. Iterable
12. IterableFactoryDefaults
13. IterableOps
14. IterableOnceOps
15. IterableOnce
16. AnyRef
17. 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

Concrete Value Members

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

Deprecated Value Members

1.  def +(elem1: Int, elem2: Int, elems: Int*): BitSet
2.  def +(elem: Int): BitSet
3.  def ++:[B >: Int](that: IterableOnce[B]): Set[B]
4.  def -(elem1: Int, elem2: Int, elems: Int*): BitSet
5.  def -(elem: Int): BitSet
6.  def --(that: IterableOnce[Int]): BitSet
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): BitSet
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: BitSet
49.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
50.  def seq: BitSet.this.type
51.  def size: Int
52.  def sum(implicit num: math.Numeric[Int]): Int
53.  def to[C1](factory: Factory[Int, C1]): C1
54.  final def to(to: Int): BitSet
55.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
56.  def toBuffer[B >: A]: Buffer[B]
57.  def toIndexedSeq: IndexedSeq[Int]
58.  final def toIterable: Iterable[Int]
59.  final def toIterable: BitSet.this.type
60.  def toIterator: Iterator[Int]
61.  final def toIterator: Iterator[Int]
62.  def toList: immutable.List[Int]
63.  def toMap[K, V](implicit ev: <:<[Int, (K, V)]): immutable.Map[K, V]
64.  def toSeq: immutable.Seq[Int]
65.  def toSet[B >: A]: immutable.Set[B]
66.  def toStream: immutable.Stream[Int]
67.  final def toStream: immutable.Stream[Int]
68.  final def toTraversable: Traversable[Int]
69.  final def toTraversable: Traversable[Int]
70.  def toVector: immutable.Vector[Int]
71.  final def until(until: Int): BitSet
72.  def view(from: Int, until: Int): View[Int]
73.  def withFilter(f: (Int) => Boolean): Iterator[Int]
74.  def →[B](y: B): (BitSet, B)

Inherited from BitSetOps[BitSet]

Inherited from SortedSet[Int]

Inherited from SortedSetFactoryDefaults[Int, SortedSet, Set]

Inherited from SortedSetOps[Int, SortedSet, BitSet]

Inherited from SortedOps[Int, BitSet]

Inherited from Set[Int]

Inherited from Equals

Inherited from SetOps[Int, Set, BitSet]

Inherited from (Int) => Boolean

Inherited from Iterable[Int]

Inherited from IterableFactoryDefaults[Int, [x]Set[x]]

Inherited from IterableOps[Int, [_]Set[_], BitSet]

Inherited from IterableOnceOps[Int, [_]Set[_], BitSet]

Inherited from IterableOnce[Int]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion iterableOnceExtensionMethods fromBitSet to IterableOnceExtensionMethods[Int]

Inherited by implicit conversion any2stringadd fromBitSet to any2stringadd[BitSet]

Inherited by implicit conversion StringFormat fromBitSet to StringFormat[BitSet]

Inherited by implicit conversion Ensuring fromBitSet to Ensuring[BitSet]

Inherited by implicit conversion ArrowAssoc fromBitSet to ArrowAssoc[BitSet]

Ungrouped