SI-5513: add inplace set-theoretic operations for mutable bitsets.

1 files changed, 50 insertions, 1 deletions

diff --git a/src/library/scala/collection/mutable/BitSet.scala b/src/library/scala/collection/mutable/BitSet.scala
index 2a535a799c..397f8099eb 100644
--- a/src/library/scala/collection/mutable/BitSet.scala
+++ b/src/library/scala/collection/mutable/BitSet.scala
@@ -58,6 +58,11 @@ class BitSet(protected var elems: Array[Long]) extends AbstractSet[Int]
     if (idx < nwords) elems(idx) else 0L
 
   private def updateWord(idx: Int, w: Long) {
+    ensureCapacity(idx)
+    elems(idx) = w
+  }
+
+  private def ensureCapacity(idx: Int) {
     if (idx >= nwords) {
       var newlen = nwords
       while (idx >= newlen) newlen = newlen * 2
@@ -65,7 +70,6 @@ class BitSet(protected var elems: Array[Long]) extends AbstractSet[Int]
       Array.copy(elems, 0, elems1, 0, nwords)
       elems = elems1
     }
-    elems(idx) = w
   }
 
   protected def fromBitMaskNoCopy(words: Array[Long]): BitSet = new BitSet(words)
@@ -92,6 +96,51 @@ class BitSet(protected var elems: Array[Long]) extends AbstractSet[Int]
   def += (elem: Int): this.type = { add(elem); this }
   def -= (elem: Int): this.type = { remove(elem); this }
 
+  /** Updates this bitset to the union with another bitset by performing a bitwise "or".
+   *
+   *  @param   other  the bitset to form the union with.
+   *  @return  the bitset itself.
+   */
+  def |= (other: BitSet): this.type = {
+    ensureCapacity(other.nwords)
+    for (i <- 0 until other.nwords)
+      elems(i) = elems(i) | other.word(i)
+    this
+  }
+  /** Updates this bitset to the intersection with another bitset by performing a bitwise "and".
+   *
+   *  @param   other  the bitset to form the intersection with.
+   *  @return  the bitset itself.
+   */
+  def &= (other: BitSet): this.type = {
+    ensureCapacity(other.nwords)
+    for (i <- 0 until other.nwords)
+      elems(i) = elems(i) & other.word(i)
+    this
+  }
+  /** Updates this bitset to the symmetric difference with another bitset by performing a bitwise "xor".
+   *
+   *  @param   other  the bitset to form the symmetric difference with.
+   *  @return  the bitset itself.
+   */
+  def ^= (other: BitSet): this.type = {
+    ensureCapacity(other.nwords)
+    for (i <- 0 until other.nwords)
+      elems(i) = elems(i) ^ other.word(i)
+    this
+  }
+  /** Updates this bitset to the difference with another bitset by performing a bitwise "and-not".
+   *
+   *  @param   other  the bitset to form the difference with.
+   *  @return  the bitset itself.
+   */
+  def &~= (other: BitSet): this.type = {
+    ensureCapacity(other.nwords)
+    for (i <- 0 until other.nwords)
+      elems(i) = elems(i) & ~other.word(i)
+    this
+  }
+
   override def clear() {
     elems = new Array[Long](elems.length)
   }