Seq => collection.Seq

Author: lrytz

jvm/src/test/scala/scala/xml/ReuseNodesTest.scala

@@ -17,35 +17,35 @@ import org.junit.runner.RunWith
 object ReuseNodesTest {
 
   class OriginalTranformr(rules: RewriteRule*) extends RuleTransformer(rules:_*) {
-    override def transform(ns: Seq[Node]): Seq[Node] = {
+    override def transform(ns: collection.Seq[Node]): collection.Seq[Node] = {
       val xs = ns.toStream map transform
       val (xs1, xs2) = xs zip ns span { case (x, n) => unchanged(n, x) }
 
       if (xs2.isEmpty) ns
       else (xs1 map (_._2)) ++ xs2.head._1 ++ transform(ns drop (xs1.length + 1))
     }
-    override def transform(n:Node): Seq[Node] = super.transform(n)
+    override def transform(n:Node): collection.Seq[Node] = super.transform(n)
   }
 
   class ModifiedTranformr(rules: RewriteRule*) extends RuleTransformer(rules:_*) {
-    override def transform(ns: Seq[Node]): Seq[Node] = {
+    override def transform(ns: collection.Seq[Node]): collection.Seq[Node] = {
       val changed = ns flatMap transform
 
       if (changed.length != ns.length || (changed, ns).zipped.exists(_ != _)) changed
       else ns
     }
-    override def transform(n:Node): Seq[Node] = super.transform(n)
+    override def transform(n:Node): collection.Seq[Node] = super.transform(n)
   }
 
   class AlternateTranformr(rules: RewriteRule*) extends RuleTransformer(rules:_*) {
-    override def transform(ns: Seq[Node]): Seq[Node] = {
+    override def transform(ns: collection.Seq[Node]): collection.Seq[Node] = {
       val xs = ns.toStream map transform
       val (xs1, xs2) = xs zip ns span { case (x, n) => unchanged(n, x) }
 
       if (xs2.isEmpty) ns
       else (xs1 map (_._2)) ++ xs2.head._1 ++ transform(ns drop (xs1.length + 1))
     }
-    override def transform(n:Node): Seq[Node] = super.transform(n)
+    override def transform(n:Node): collection.Seq[Node] = super.transform(n)
   }
 
   def rewriteRule = new RewriteRule {
@@ -80,7 +80,7 @@ class ReuseNodesTest {
     recursiveAssert(original,transformed)
   }
 
-  def recursiveAssert(original:Seq[Node], transformed:Seq[Node]):Unit = {
+  def recursiveAssert(original: collection.Seq[Node], transformed: collection.Seq[Node]):Unit = {
     original zip transformed foreach { 
       case (x, y) => recursiveAssert(x, y) 
     }

jvm/src/test/scala/scala/xml/SerializationTest.scala

@@ -23,7 +23,7 @@ class SerializationTest {
   @Test
   def implicitConversion: Unit = {
     val parent = <parent><child></child><child/></parent>
-    val children: Seq[Node] = parent.child
+    val children: collection.Seq[Node] = parent.child
     val asNodeSeq: NodeSeq = children
     assertEquals(asNodeSeq, JavaByteSerialization.roundTrip(asNodeSeq))
   }

jvm/src/test/scala/scala/xml/XMLTest.scala

@@ -489,9 +489,9 @@ class XMLTestJVM {
   def attributes = {
     val noAttr = <t/>
     val attrNull = <t a={ null: String }/>
-    val attrNone = <t a={ None: Option[Seq[Node]] }/>
+    val attrNone = <t a={ None: Option[collection.Seq[Node]] }/>
     val preAttrNull = <t p:a={ null: String }/>
-    val preAttrNone = <t p:a={ None: Option[Seq[Node]] }/>
+    val preAttrNone = <t p:a={ None: Option[collection.Seq[Node]] }/>
     assertEquals(noAttr, attrNull)
     assertEquals(noAttr, attrNone)
     assertEquals(noAttr, preAttrNull)

shared/src/main/scala/scala/xml/Atom.scala

@@ -20,7 +20,7 @@ class Atom[+A](val data: A) extends SpecialNode with Serializable {
   if (data == null)
     throw new IllegalArgumentException("cannot construct " + getClass.getSimpleName + " with null")
 
-  override protected def basisForHashCode: Seq[Any] = Seq(data)
+  override protected def basisForHashCode: collection.Seq[Any] = Seq(data)
 
   override def strict_==(other: Equality) = other match {
     case x: Atom[_] => data == x.data

shared/src/main/scala/scala/xml/Attribute.scala

@@ -23,18 +23,18 @@ object Attribute {
   }
 
   /** Convenience functions which choose Un/Prefixedness appropriately */
-  def apply(key: String, value: Seq[Node], next: MetaData): Attribute =
+  def apply(key: String, value: collection.Seq[Node], next: MetaData): Attribute =
     new UnprefixedAttribute(key, value, next)
 
   def apply(pre: String, key: String, value: String, next: MetaData): Attribute =
     if (pre == null || pre == "") new UnprefixedAttribute(key, value, next)
     else new PrefixedAttribute(pre, key, value, next)
 
-  def apply(pre: String, key: String, value: Seq[Node], next: MetaData): Attribute =
+  def apply(pre: String, key: String, value: collection.Seq[Node], next: MetaData): Attribute =
     if (pre == null || pre == "") new UnprefixedAttribute(key, value, next)
     else new PrefixedAttribute(pre, key, value, next)
 
-  def apply(pre: Option[String], key: String, value: Seq[Node], next: MetaData): Attribute =
+  def apply(pre: Option[String], key: String, value: collection.Seq[Node], next: MetaData): Attribute =
     pre match {
       case None    => new UnprefixedAttribute(key, value, next)
       case Some(p) => new PrefixedAttribute(p, key, value, next)
@@ -50,11 +50,11 @@ object Attribute {
 abstract trait Attribute extends MetaData {
   def pre: String // will be null if unprefixed
   val key: String
-  val value: Seq[Node]
+  val value: collection.Seq[Node]
   val next: MetaData
 
-  def apply(key: String): Seq[Node]
-  def apply(namespace: String, scope: NamespaceBinding, key: String): Seq[Node]
+  def apply(key: String): collection.Seq[Node]
+  def apply(namespace: String, scope: NamespaceBinding, key: String): collection.Seq[Node]
   def copy(next: MetaData): Attribute
 
   def remove(key: String) =

shared/src/main/scala/scala/xml/Document.scala

@@ -30,7 +30,7 @@ class Document extends NodeSeq with pull.XMLEvent with Serializable {
    *  excluded. If there is a document type declaration, the list also
    *  contains a document type declaration information item.
    */
-  var children: Seq[Node] = _
+  var children: collection.Seq[Node] = _
 
   /** The element information item corresponding to the document element. */
   var docElem: Node = _
@@ -43,14 +43,14 @@ class Document extends NodeSeq with pull.XMLEvent with Serializable {
    *  declared in the DTD. If any notation is multiply declared, this property
    *  has no value.
    */
-  def notations: Seq[scala.xml.dtd.NotationDecl] =
+  def notations: collection.Seq[scala.xml.dtd.NotationDecl] =
     dtd.notations
 
   /**
    * An unordered set of unparsed entity information items, one for each
    *  unparsed entity declared in the DTD.
    */
-  def unparsedEntities: Seq[scala.xml.dtd.EntityDecl] =
+  def unparsedEntities: collection.Seq[scala.xml.dtd.EntityDecl] =
     dtd.unparsedEntities
 
   /** The base URI of the document entity. */
@@ -90,7 +90,7 @@ class Document extends NodeSeq with pull.XMLEvent with Serializable {
 
   // methods for NodeSeq
 
-  def theSeq: Seq[Node] = this.docElem
+  def theSeq: collection.Seq[Node] = this.docElem
 
   override def canEqual(other: Any) = other match {
     case _: Document => true

shared/src/main/scala/scala/xml/Elem.scala

@@ -111,7 +111,7 @@ class Elem(
   //  setting namespace scope if necessary
   //  cleaning adjacent text nodes if necessary
 
-  override protected def basisForHashCode: Seq[Any] =
+  override protected def basisForHashCode: collection.Seq[Any] =
     prefix :: label :: attributes :: child.toList
 
   /**
@@ -136,7 +136,7 @@ class Elem(
     attributes: MetaData = this.attributes,
     scope: NamespaceBinding = this.scope,
     minimizeEmpty: Boolean = this.minimizeEmpty,
-    child: Seq[Node] = this.child.toSeq): Elem = Elem(prefix, label, attributes, scope, minimizeEmpty, child: _*)
+    child: collection.Seq[Node] = this.child.toSeq): Elem = Elem(prefix, label, attributes, scope, minimizeEmpty, child: _*)
 
   /**
    * Returns concatenation of `text(n)` for each child `n`.

shared/src/main/scala/scala/xml/Equality.scala

@@ -30,7 +30,7 @@ package xml
  *
  *  Among the obstacles to sanity are/were:
  *
- *    Node extends NodeSeq extends Seq[Node]
+ *    Node extends NodeSeq extends collection.Seq[Node]
  *    MetaData extends Iterable[MetaData]
  *    The hacky "Group" xml node which throws exceptions
  *      with wild abandon, so don't get too close
@@ -69,7 +69,7 @@ object Equality {
 import Equality._
 
 trait Equality extends scala.Equals {
-  protected def basisForHashCode: Seq[Any]
+  protected def basisForHashCode: collection.Seq[Any]
 
   def strict_==(other: Equality): Boolean
   def strict_!=(other: Equality) = !strict_==(other)

shared/src/main/scala/scala/xml/Group.scala

@@ -14,7 +14,7 @@ package xml
  *
  *  @author  Burak Emir
  */
-final case class Group(nodes: Seq[Node]) extends Node {
+final case class Group(nodes: collection.Seq[Node]) extends Node {
   override def theSeq = nodes
 
   override def canEqual(other: Any) = other match {

shared/src/main/scala/scala/xml/MetaData.scala

@@ -99,9 +99,9 @@ abstract class MetaData
    * Gets value of unqualified (unprefixed) attribute with given key, null if not found
    *
    * @param  key
-   * @return value as Seq[Node] if key is found, null otherwise
+   * @return value as collection.Seq[Node] if key is found, null otherwise
    */
-  def apply(key: String): Seq[Node]
+  def apply(key: String): collection.Seq[Node]
 
   /**
    * convenience method, same as `apply(namespace, owner.scope, key)`.
@@ -110,7 +110,7 @@ abstract class MetaData
    *  @param owner the element owning this attribute list
    *  @param key   the attribute key
    */
-  final def apply(namespace_uri: String, owner: Node, key: String): Seq[Node] =
+  final def apply(namespace_uri: String, owner: Node, key: String): collection.Seq[Node] =
     apply(namespace_uri, owner.scope, key)
 
   /**
@@ -119,9 +119,9 @@ abstract class MetaData
    * @param  namespace_uri namespace uri of key
    * @param  scp a namespace scp (usually of the element owning this attribute list)
    * @param  k   to be looked for
-   * @return value as Seq[Node] if key is found, null otherwise
+   * @return value as collection.Seq[Node] if key is found, null otherwise
    */
-  def apply(namespace_uri: String, scp: NamespaceBinding, k: String): Seq[Node]
+  def apply(namespace_uri: String, scp: NamespaceBinding, k: String): collection.Seq[Node]
 
   /**
    * returns a copy of this MetaData item with next field set to argument.
@@ -147,7 +147,7 @@ abstract class MetaData
     case m: MetaData => this.asAttrMap == m.asAttrMap
     case _           => false
   }
-  protected def basisForHashCode: Seq[Any] = List(this.asAttrMap)
+  protected def basisForHashCode: collection.Seq[Any] = List(this.asAttrMap)
 
   /** filters this sequence of meta data */
   override def filter(f: MetaData => Boolean): MetaData =
@@ -158,7 +158,7 @@ abstract class MetaData
   def key: String
 
   /** returns value of this MetaData item */
-  def value: Seq[Node]
+  def value: collection.Seq[Node]
 
   /**
    * Returns a String containing "prefix:key" if the first key is
@@ -182,12 +182,12 @@ abstract class MetaData
    * Gets value of unqualified (unprefixed) attribute with given key, None if not found
    *
    * @param  key
-   * @return value in Some(Seq[Node]) if key is found, None otherwise
+   * @return value in Some(collection.Seq[Node]) if key is found, None otherwise
    */
-  final def get(key: String): Option[Seq[Node]] = Option(apply(key))
+  final def get(key: String): Option[collection.Seq[Node]] = Option(apply(key))
 
   /** same as get(uri, owner.scope, key) */
-  final def get(uri: String, owner: Node, key: String): Option[Seq[Node]] =
+  final def get(uri: String, owner: Node, key: String): Option[collection.Seq[Node]] =
     get(uri, owner.scope, key)
 
   /**
@@ -196,9 +196,9 @@ abstract class MetaData
    * @param  uri namespace of key
    * @param  scope a namespace scp (usually of the element owning this attribute list)
    * @param  key to be looked fore
-   * @return value as Some[Seq[Node]] if key is found, None otherwise
+   * @return value as Some[collection.Seq[Node]] if key is found, None otherwise
    */
-  final def get(uri: String, scope: NamespaceBinding, key: String): Option[Seq[Node]] =
+  final def get(uri: String, scope: NamespaceBinding, key: String): Option[collection.Seq[Node]] =
     Option(apply(uri, scope, key))
 
   protected def toString1(): String = sbToString(toString1)