add cross-scala way for set and map adaptors' addAll/subtractAll

- this mirrors the provisions of buffer-wrapper and is needed
  by third party swing extensions to avoid forking sources
  between Scala 2.12 and 2.13
- also provide a default `clear` implementation

Author: Sciss

build.sbt

@@ -16,7 +16,7 @@ scalaVersionsByJvm in ThisBuild := Map(
   11 -> List("2.11.12", "2.12.8", "2.13.0-M5").map(_ -> false)
 )
 
-scalaVersion in ThisBuild := "2.11.12"  // for testing
+scalaVersion in ThisBuild := "2.13.0-M5"  // for testing
 
 OsgiKeys.exportPackage := Seq(s"scala.swing.*;version=${version.value}")
 

src/main/scala-2.12/scala/swing/MapWrapper.scala

@@ -1,9 +1,18 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2007-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
 package scala.swing
 
+import scala.annotation.tailrec
 import scala.collection.mutable
 
 /**
-  * Default partial implementation for set adapters.
+  * Default partial implementation for mutable map adapters.
   */
 abstract class MapWrapper[K, V] extends mutable.Map[K, V] {
   // abstract
@@ -15,4 +24,41 @@ abstract class MapWrapper[K, V] extends mutable.Map[K, V] {
 
   final def +=(elem: (K, V)): this.type = addOne     (elem)
   final def -=(key: K)      : this.type = subtractOne(key)
+
+  /** The collection passed to `addAll` and `subtractAll` */
+  type MoreElem[+B] = TraversableOnce[B]
+
+  /** Cross-version way for creating an iterator from `MoreElem`. */
+  final protected def mkIterator[B](xs: MoreElem[B]): Iterator[B] = xs.toIterator
+
+  final override def ++=(xs: MoreElem[(K, V)]): this.type = addAll     (xs)
+  final override def --=(xs: MoreElem[ K    ]): this.type = subtractAll(xs)
+
+  def addAll(xs: MoreElem[(K, V)]): this.type = {
+    @tailrec def loop(xsl: scala.collection.LinearSeq[(K, V)]): Unit =
+      if (xsl.nonEmpty) {
+        addOne(xsl.head)
+        loop(xsl.tail)
+      }
+
+    xs match {
+      case xsl: scala.collection.LinearSeq[(K, V)] => loop(xsl)
+      case _ => xs.foreach(addOne)
+    }
+    this
+  }
+
+  def subtractAll(xs: MoreElem[K]): this.type = {
+    @tailrec def loop(xsl: collection.LinearSeq[K]): Unit =
+      if (xsl.nonEmpty) {
+        subtractOne(xsl.head)
+        loop(xsl.tail)
+      }
+
+    xs match {
+      case xsl: scala.collection.LinearSeq[K] => loop(xsl)
+      case _ => xs.foreach(subtractOne)
+    }
+    this
+  }
 }

src/main/scala-2.12/scala/swing/SetWrapper.scala

@@ -1,9 +1,18 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2007-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
 package scala.swing
 
+import scala.annotation.tailrec
 import scala.collection.mutable
 
 /**
-  * Default partial implementation for set adapters.
+  * Default partial implementation for mutable set adapters.
   */
 abstract class SetWrapper[A] extends mutable.Set[A] {
   // abstract
@@ -15,4 +24,41 @@ abstract class SetWrapper[A] extends mutable.Set[A] {
 
   final def +=(elem: A): this.type = addOne     (elem)
   final def -=(elem: A): this.type = subtractOne(elem)
+
+  /** The collection passed to `addAll` and `subtractAll` */
+  type MoreElem[+B] = TraversableOnce[B]
+
+  /** Cross-version way for creating an iterator from `MoreElem`. */
+  final protected def mkIterator[B](xs: MoreElem[B]): Iterator[B] = xs.toIterator
+
+  final override def ++=(xs: MoreElem[A]): this.type = addAll     (xs)
+  final override def --=(xs: MoreElem[A]): this.type = subtractAll(xs)
+
+  def addAll(xs: MoreElem[A]): this.type = {
+    @tailrec def loop(xsl: scala.collection.LinearSeq[A]): Unit =
+      if (xsl.nonEmpty) {
+        addOne(xsl.head)
+        loop(xsl.tail)
+      }
+
+    xs match {
+      case xsl: scala.collection.LinearSeq[A] => loop(xsl)
+      case _ => xs.foreach(addOne)
+    }
+    this
+  }
+
+  def subtractAll(xs: MoreElem[A]): this.type = {
+    @tailrec def loop(xsl: collection.LinearSeq[A]): Unit =
+      if (xsl.nonEmpty) {
+        subtractOne(xsl.head)
+        loop(xsl.tail)
+      }
+
+    xs match {
+      case xsl: scala.collection.LinearSeq[A] => loop(xsl)
+      case _ => xs.foreach(subtractOne)
+    }
+    this
+  }
 }

src/main/scala-2.13.0-M5/scala/swing/MapWrapper.scala

@@ -1,5 +1,22 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2007-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
 package scala.swing
 
 import scala.collection.mutable
 
-abstract class MapWrapper[K, V] extends mutable.Map[K, V]
+/**
+  * Default partial implementation for mutable map adapters.
+  */
+abstract class MapWrapper[K, V] extends mutable.Map[K, V] {
+  /** The collection passed to `addAll` and `subtractAll` */
+  type MoreElem[+B] = IterableOnce[B]
+
+  /** Cross-version way for creating an iterator from `MoreElem`. */
+  final protected def mkIterator[B](xs: MoreElem[B]): Iterator[B] = xs.iterator
+}

src/main/scala-2.13.0-M5/scala/swing/SetWrapper.scala

@@ -1,5 +1,24 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2007-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
 package scala.swing
 
 import scala.collection.mutable
 
-abstract class SetWrapper[A] extends mutable.Set[A]
+/**
+  * Default partial implementation for mutable set adapters.
+  */
+abstract class SetWrapper[A] extends mutable.Set[A] {
+  /** The collection passed to `addAll` and `subtractAll` */
+  type MoreElem[+B] = IterableOnce[B]
+
+  /** Cross-version way for creating an iterator from `MoreElem`. */
+  final protected def mkIterator[B](xs: MoreElem[B]): Iterator[B] = xs.iterator
+
+  override def clear(): Unit = iterator.toList.foreach(remove)
+}

src/main/scala/scala/swing/ButtonGroup.scala

@@ -23,8 +23,6 @@ class ButtonGroup(initialButtons: AbstractButton*) {
     override def subtractOne(b: AbstractButton): this.type = { peer.remove(b.peer); this }
     override def addOne     (b: AbstractButton): this.type = { peer.add   (b.peer); this }
 
-    override def clear(): Unit = iterator.toList.foreach(remove)
-
     def contains(b: AbstractButton): Boolean = this.iterator.contains(b)
 
     override def size: Int = peer.getButtonCount