Merge pull request scala#7705 from joshlemer/jsetwrapper-filterInPlace

scala.collection.convert.JSetWrapper#filterInPlace delegates to underlying#removeIf

Author: joshlemer

src/library/scala/collection/convert/Wrappers.scala

@@ -194,26 +194,34 @@ private[collection] trait Wrappers {
   @SerialVersionUID(3L)
   case class JSetWrapper[A](underlying: ju.Set[A]) extends mutable.AbstractSet[A] with mutable.SetOps[A, mutable.Set, mutable.Set[A]] with Serializable {
 
-    override def size = underlying.size
+    override def size: Int = underlying.size
     override def isEmpty: Boolean = underlying.isEmpty
     override def knownSize: Int = if (underlying.isEmpty) 0 else super.knownSize
-    def iterator = underlying.iterator.asScala
+    def iterator: Iterator[A] = underlying.iterator.asScala
 
     def contains(elem: A): Boolean = underlying.contains(elem)
 
     def addOne(elem: A): this.type = { underlying add elem; this }
     def subtractOne(elem: A): this.type = { underlying remove elem; this }
 
     override def remove(elem: A): Boolean = underlying remove elem
-    override def clear() = underlying.clear()
 
-    override def empty = JSetWrapper(new ju.HashSet[A])
+    override def clear(): Unit = {
+      underlying.clear()
+    }
+
+    override def empty: mutable.Set[A] = JSetWrapper(new ju.HashSet[A])
+
     // Note: Clone cannot just call underlying.clone because in Java, only specific collections
     // expose clone methods.  Generically, they're protected.
-    override def clone() =
-      new JSetWrapper[A](new ju.LinkedHashSet[A](underlying))
+    override def clone(): mutable.Set[A] = new JSetWrapper[A](new ju.LinkedHashSet[A](underlying))
+
+    override def iterableFactory: IterableFactory[mutable.Set] = mutable.HashSet
 
-    override def iterableFactory = mutable.HashSet
+    override def filterInPlace(p: A => Boolean): this.type = {
+      if (underlying.size() > 0) underlying.removeIf(!p(_))
+      this
+    }
   }
 
   @SerialVersionUID(3L)

test/junit/scala/collection/convert/JSetWrapperTest.scala

@@ -2,7 +2,7 @@ package scala.collection.convert
 
 import java.{util => ju}
 
-import org.junit.Assert.assertTrue
+import org.junit.Assert._
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
@@ -20,4 +20,15 @@ class JSetWrapperTest {
     assertTrue(sSet.isInstanceOf[Wrappers.JSetWrapper[_]])
     assertTrue(sSet.iterator.sameElements(Set(1, 2, 3)))
   }
+
+  @Test
+  def testFilterInPlace(): Unit = {
+    val jSet: ju.Set[Int] = new ju.HashSet(ju.Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
+    val sSet: collection.mutable.Set[Int] = jSet.asScala
+
+    sSet.filterInPlace(_ % 2 == 0)
+
+    assertEquals(sSet, Set(2, 4, 6, 8, 10))
+  }
+
 }

test/scalacheck/scala/collection/convert/WrapperProperties.scala

@@ -0,0 +1,24 @@
+
+package scala.collection.convert
+
+import org.scalacheck.{Properties, Test}
+import org.scalacheck.Prop._
+
+import scala.collection.immutable
+
+
+object WrapperProperties extends Properties("Wrappers") {
+
+  override def overrideParameters(p: Test.Parameters): Test.Parameters = p.withInitialSeed(42L)
+
+  property("JSetWrapper#filterInPlace(p)") = forAll { (hs: immutable.HashSet[Int], p: Int => Boolean) =>
+    val expected: collection.Set[Int] = hs.filter(p)
+    val actual: collection.Set[Int] = {
+      val jset = new java.util.HashSet[Int]()
+      hs.foreach(jset.add)
+      Wrappers.JSetWrapper(jset)
+    }.filterInPlace(p)
+    actual ?= expected
+  }
+
+}