Scala Standard Library 2.13.1 - 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): 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 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 formatted(fmtstr: String): String
60.  def fromSpecific(coll: IterableOnce[Int]): BitSet
61.  final def getClass(): Class[_ <: AnyRef]
62.  def groupBy[K](f: (Int) => K): immutable.Map[K, BitSet]
63.  def groupMap[K, B](key: (Int) => K)(f: (Int) => B): immutable.Map[K, Set[B]]
64.  def groupMapReduce[K, B](key: (Int) => K)(f: (Int) => B)(reduce: (B, B) => B): immutable.Map[K, B]
65.  def grouped(size: Int): Iterator[BitSet]
66.  def hashCode(): Int
67.  def head: Int
68.  def headOption: Option[Int]
69.  def init: BitSet
70.  def inits: Iterator[BitSet]
71.  def intersect(other: Set[Int]): BitSet
72.  def isEmpty: Boolean
73.  final def isInstanceOf[T0]: Boolean
74.  def isTraversableAgain: Boolean
75.  def iterableFactory: IterableFactory[Set]
76.  def iterator: Iterator[Int]
77.  def iteratorFrom(start: Int): Iterator[Int]
78.  def knownSize: Int
79.  def last: Int
80.  def lastKey: Int
81.  def lastOption: Option[Int]
82.  def lazyZip[B](that: Iterable[B]): LazyZip2[Int, B, BitSet.this.type]
83.  def map(f: (Int) => Int): BitSet
84.  def map[B](f: (Int) => B)(implicit ev: Ordering[B]): SortedSet[B]
85.  def map[B](f: (Int) => B): Set[B]
86.  def max[B >: Int](implicit ord: Ordering[B]): Int
87.  def maxBefore(key: Int): Option[Int]
88.  def maxBy[B](f: (Int) => B)(implicit cmp: math.Ordering[B]): Int
89.  def maxByOption[B](f: (Int) => B)(implicit cmp: math.Ordering[B]): Option[Int]
90.  def maxOption[B >: Int](implicit ord: math.Ordering[B]): Option[Int]
91.  def min[B >: Int](implicit ord: Ordering[B]): Int
92.  def minAfter(key: Int): Option[Int]
93.  def minBy[B](f: (Int) => B)(implicit cmp: math.Ordering[B]): Int
94.  def minByOption[B](f: (Int) => B)(implicit cmp: math.Ordering[B]): Option[Int]
95.  def minOption[B >: Int](implicit ord: math.Ordering[B]): Option[Int]
96.  final def mkString: String
97.  final def mkString(sep: String): String
98.  final def mkString(start: String, sep: String, end: String): String
99.  final def ne(arg0: AnyRef): Boolean
100.  def newSpecificBuilder: Builder[Int, BitSet]
101.  def nonEmpty: Boolean
102.  final def notify(): Unit
103.  final def notifyAll(): Unit
104.  final def ordering: Ordering[Int]
105.  def partition(p: (Int) => Boolean): (BitSet, BitSet)
106.  def partitionMap[A1, A2](f: (Int) => Either[A1, A2]): (Set[A1], Set[A2])
107.  def product[B >: Int](implicit num: math.Numeric[B]): B
108.  def range(from: Int, until: Int): BitSet
109.  def rangeFrom(from: Int): BitSet
110.  def rangeImpl(from: Option[Int], until: Option[Int]): BitSet
111.  def rangeTo(to: Int): BitSet
112.  def rangeUntil(until: Int): BitSet
113.  def reduce[B >: Int](op: (B, B) => B): B
114.  def reduceLeft[B >: Int](op: (B, Int) => B): B
115.  def reduceLeftOption[B >: Int](op: (B, Int) => B): Option[B]
116.  def reduceOption[B >: Int](op: (B, B) => B): Option[B]
117.  def reduceRight[B >: Int](op: (Int, B) => B): B
118.  def reduceRightOption[B >: Int](op: (Int, B) => B): Option[B]
119.  def reversed: Iterable[Int]
120.  def scan[B >: Int](z: B)(op: (B, B) => B): Set[B]
121.  def scanLeft[B](z: B)(op: (B, Int) => B): Set[B]
122.  def scanRight[B](z: B)(op: (Int, B) => B): Set[B]
123.  def size: Int
124.  def sizeCompare(that: Iterable[_]): Int
125.  def sizeCompare(otherSize: Int): Int
126.  final def sizeIs: SizeCompareOps
127.  def slice(from: Int, until: Int): BitSet
128.  def sliding(size: Int, step: Int): Iterator[BitSet]
129.  def sliding(size: Int): Iterator[BitSet]
130.  def sortedIterableFactory: SortedIterableFactory[SortedSet]
131.  def span(p: (Int) => Boolean): (BitSet, BitSet)
132.  def splitAt(n: Int): (BitSet, BitSet)
133.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[Int, S]): S with EfficientSplit
134.  def stringPrefix: String
135.  def subsetOf(that: Set[Int]): Boolean
136.  def subsets(): Iterator[BitSet]
137.  def subsets(len: Int): Iterator[BitSet]
138.  def sum[B >: Int](implicit num: math.Numeric[B]): B
139.  final def synchronized[T0](arg0: => T0): T0
140.  def tail: BitSet
141.  def tails: Iterator[BitSet]
142.  def take(n: Int): BitSet
143.  def takeRight(n: Int): BitSet
144.  def takeWhile(p: (Int) => Boolean): BitSet
145.  def tapEach[U](f: (Int) => U): BitSet
146.  def to[C1](factory: Factory[Int, C1]): C1
147.  def toArray[B >: Int](implicit arg0: ClassTag[B]): Array[B]
148.  def toBitMask: Array[Long]
149.  final def toBuffer[B >: Int]: Buffer[B]
150.  def toIndexedSeq: immutable.IndexedSeq[Int]
151.  final def toIterable: BitSet.this.type
152.  def toList: immutable.List[Int]
153.  def toMap[K, V](implicit ev: <:<[Int, (K, V)]): immutable.Map[K, V]
154.  def toSeq: immutable.Seq[Int]
155.  def toSet[B >: Int]: immutable.Set[B]
156.  def toString(): String
157.  def toVector: immutable.Vector[Int]
158.  def transpose[B](implicit asIterable: (Int) => Iterable[B]): Set[Set[B]]
159.  final def union(that: Set[Int]): BitSet
160.  def unsorted: Set[Int]
161.  def unzip[A1, A2](implicit asPair: (Int) => (A1, A2)): (Set[A1], Set[A2])
162.  def unzip3[A1, A2, A3](implicit asTriple: (Int) => (A1, A2, A3)): (Set[A1], Set[A2], Set[A3])
163.  def view: View[Int]
164.  final def wait(): Unit
165.  final def wait(arg0: Long, arg1: Int): Unit
166.  final def wait(arg0: Long): Unit
167.  def withFilter(p: (Int) => Boolean): SortedSetOps.WithFilter[Int, Set, SortedSet]
168.  def xor(other: BitSet): BitSet
169.  def zip[B](that: IterableOnce[B])(implicit ev: Ordering[(Int, B)]): SortedSet[(Int, B)]
170.  def zip[B](that: IterableOnce[B]): Set[(Int, B)]
171.  def zipAll[A1 >: Int, B](that: Iterable[B], thisElem: A1, thatElem: B): Set[(A1, B)]
172.  def zipWithIndex: Set[(Int, Int)]
173.  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.  final def from(from: Int): BitSet
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: BitSet
48.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
49.  def seq: BitSet.this.type
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): BitSet
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): BitSet
70.  def view(from: Int, until: Int): View[Int]
71.  def withFilter(f: (Int) => Boolean): Iterator[Int]
72.  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