case class PCData(_data: String) extends Atom[String] with Product with Serializable
          
            Linear Supertypes
          
          
        
          
          
            
          
          
        
        
            Ordering
            
          - Alphabetic
- By Inheritance
                  Inherited
                  
                  
- PCData
- Product
- Atom
- Serializable
- Serializable
- SpecialNode
- XMLEvent
- Node
- NodeSeq
- Equality
- Seq
- Iterable
- Traversable
- Immutable
- AbstractSeq
- Seq
- SeqLike
- GenSeq
- GenSeqLike
- PartialFunction
- Function1
- AbstractIterable
- Iterable
- IterableLike
- Equals
- GenIterable
- GenIterableLike
- AbstractTraversable
- Traversable
- GenTraversable
- GenericTraversableTemplate
- TraversableLike
- GenTraversableLike
- Parallelizable
- TraversableOnce
- GenTraversableOnce
- FilterMonadic
- HasNewBuilder
- AnyRef
- Any
- Hide All
- Show All
              Visibility
              
        - Public
- All
Instance Constructors
-  new PCData(_data: String)
Type Members
- 
      
      
      
        
      
    
      
        
        type
      
      
        Self = NodeSeq
      
      
      - Attributes
- protected[this]
- Definition Classes
- TraversableLike
 
- 
      
      
      
        
      
    
      
        
        class
      
      
        WithFilter extends FilterMonadic[A, Repr]
      
      
      - Definition Classes
- TraversableLike
 
Value Members
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        !=(arg0: Any): Boolean
      
      
      - Definition Classes
- AnyRef → Any
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        ##(): Int
      
      
      - Definition Classes
- AnyRef → Any
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        ++[B >: Node, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        ++:[B >: Node, That](that: Traversable[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- TraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        ++:[B >: Node, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- TraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        +:[B >: Node, That](elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        /:[B](z: B)(op: (B, Node) ⇒ B): B
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        :+[B >: Node, That](elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        :\[B](z: B)(op: (Node, B) ⇒ B): B
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        ==(arg0: Any): Boolean
      
      
      - Definition Classes
- AnyRef → Any
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        \(that: String): NodeSeq
      
      
      - Definition Classes
- NodeSeq
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        \@(attributeName: String): String
      
      
      - Definition Classes
- NodeSeq
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        \\(that: String): NodeSeq
      
      
      - Definition Classes
- NodeSeq
 
-  val _data: String
- 
      
      
      
        
      
    
      
        
        def
      
      
        addString(b: StringBuilder): StringBuilder
      
      
      - Definition Classes
- TraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        addString(b: StringBuilder, sep: String): StringBuilder
      
      
      - Definition Classes
- TraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
      
      
      - Definition Classes
- TraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        aggregate[B](z: ⇒ B)(seqop: (B, Node) ⇒ B, combop: (B, B) ⇒ B): B
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        andThen[C](k: (Node) ⇒ C): PartialFunction[Int, C]
      
      
      - Definition Classes
- PartialFunction → Function1
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        apply(f: (Node) ⇒ Boolean): NodeSeq
      
      
      - Definition Classes
- NodeSeq
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        apply(i: Int): Node
      
      
      - Definition Classes
- NodeSeq → SeqLike → GenSeqLike → Function1
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        applyOrElse[A1 <: Int, B1 >: Node](x: A1, default: (A1) ⇒ B1): B1
      
      
      - Definition Classes
- PartialFunction
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        asInstanceOf[T0]: T0
      
      
      - Definition Classes
- Any
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        attribute(uri: String, key: String): Option[Seq[Node]]
      
      
      - Definition Classes
- Node
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        attribute(key: String): Option[Seq[Node]]
      
      
      - Definition Classes
- Node
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        attributes: Null.type
      
      
      - Definition Classes
- SpecialNode → Node
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        basisForHashCode: Seq[Any]
      
      
      - Attributes
- protected
- Definition Classes
- Atom → Node → NodeSeq → Equality
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        buildString(sb: StringBuilder): StringBuilder
      
      
      Returns text, with some characters escaped according to the XML specification. Returns text, with some characters escaped according to the XML specification. - sb
- ... 
- returns
- ... 
 - Definition Classes
- PCData → Atom → SpecialNode
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        buildString(stripComments: Boolean): String
      
      
      - Definition Classes
- Node
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        canEqual(other: Any): Boolean
      
      
      - Definition Classes
- Atom → Node → NodeSeq → Equality → IterableLike → Equals
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        child: Nil.type
      
      
      - Definition Classes
- SpecialNode → Node
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        clone(): AnyRef
      
      
      - Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        collect[B, That](pf: PartialFunction[Node, B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        collectFirst[B](pf: PartialFunction[Node, B]): Option[B]
      
      
      - Definition Classes
- TraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        combinations(n: Int): Iterator[NodeSeq]
      
      
      - Definition Classes
- SeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        companion: GenericCompanion[Seq]
      
      
      - Definition Classes
- Seq → Seq → GenSeq → Iterable → Iterable → GenIterable → Traversable → Traversable → GenTraversable → GenericTraversableTemplate
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        compose[A](g: (A) ⇒ Int): (A) ⇒ Node
      
      
      - Definition Classes
- Function1
- Annotations
- @unspecialized()
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        contains[A1 >: Node](elem: A1): Boolean
      
      
      - Definition Classes
- SeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        containsSlice[B](that: GenSeq[B]): Boolean
      
      
      - Definition Classes
- SeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        copyToArray[B >: Node](xs: Array[B], start: Int, len: Int): Unit
      
      
      - Definition Classes
- IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        copyToArray[B >: Node](xs: Array[B]): Unit
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        copyToArray[B >: Node](xs: Array[B], start: Int): Unit
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        copyToBuffer[B >: Node](dest: Buffer[B]): Unit
      
      
      - Definition Classes
- TraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        corresponds[B](that: GenSeq[B])(p: (Node, B) ⇒ Boolean): Boolean
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        count(p: (Node) ⇒ Boolean): Int
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        val
      
      
        data: String
      
      
      - Definition Classes
- Atom
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        descendant: List[Node]
      
      
      - Definition Classes
- Node
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        descendant_or_self: List[Node]
      
      
      - Definition Classes
- Node
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        diff[B >: Node](that: GenSeq[B]): NodeSeq
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        distinct: NodeSeq
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        doCollectNamespaces: Boolean
      
      
      - Definition Classes
- Atom → Node
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        doTransform: Boolean
      
      
      - Definition Classes
- Atom → Node
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        drop(n: Int): NodeSeq
      
      
      - Definition Classes
- IterableLike → TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        dropRight(n: Int): NodeSeq
      
      
      - Definition Classes
- IterableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        dropWhile(p: (Node) ⇒ Boolean): NodeSeq
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        endsWith[B](that: GenSeq[B]): Boolean
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        eq(arg0: AnyRef): Boolean
      
      
      - Definition Classes
- AnyRef
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        equals(x: Any): Boolean
      
      
      - Definition Classes
- PCData → Equality → GenSeqLike → Equals → AnyRef → Any
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        exists(p: (Node) ⇒ Boolean): Boolean
      
      
      - Definition Classes
- IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        filter(p: (Node) ⇒ Boolean): NodeSeq
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        filterNot(p: (Node) ⇒ Boolean): NodeSeq
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        finalize(): Unit
      
      
      - Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        find(p: (Node) ⇒ Boolean): Option[Node]
      
      
      - Definition Classes
- IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        flatMap[B, That](f: (Node) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike → FilterMonadic
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        flatten[B](implicit asTraversable: (Node) ⇒ GenTraversableOnce[B]): Seq[B]
      
      
      - Definition Classes
- GenericTraversableTemplate
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        fold[A1 >: Node](z: A1)(op: (A1, A1) ⇒ A1): A1
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        foldLeft[B](z: B)(op: (B, Node) ⇒ B): B
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        foldRight[B](z: B)(op: (Node, B) ⇒ B): B
      
      
      - Definition Classes
- IterableLike → TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        forall(p: (Node) ⇒ Boolean): Boolean
      
      
      - Definition Classes
- IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        foreach[U](f: (Node) ⇒ U): Unit
      
      
      - Definition Classes
- IterableLike → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        genericBuilder[B]: Builder[B, Seq[B]]
      
      
      - Definition Classes
- GenericTraversableTemplate
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        getClass(): Class[_]
      
      
      - Definition Classes
- AnyRef → Any
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        getNamespace(pre: String): String
      
      
      - Definition Classes
- Node
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        groupBy[K](f: (Node) ⇒ K): Map[K, NodeSeq]
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        grouped(size: Int): Iterator[NodeSeq]
      
      
      - Definition Classes
- IterableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        hasDefiniteSize: Boolean
      
      
      - Definition Classes
- TraversableLike → TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        hashCode(): Int
      
      
      - Definition Classes
- Equality → AnyRef → Any
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        head: Node
      
      
      - Definition Classes
- IterableLike → TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        headOption: Option[Node]
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        indexOf[B >: Node](elem: B, from: Int): Int
      
      
      - Definition Classes
- GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        indexOf[B >: Node](elem: B): Int
      
      
      - Definition Classes
- GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        indexOfSlice[B >: Node](that: GenSeq[B], from: Int): Int
      
      
      - Definition Classes
- SeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        indexOfSlice[B >: Node](that: GenSeq[B]): Int
      
      
      - Definition Classes
- SeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        indexWhere(p: (Node) ⇒ Boolean, from: Int): Int
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        indexWhere(p: (Node) ⇒ Boolean): Int
      
      
      - Definition Classes
- GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        indices: Range
      
      
      - Definition Classes
- SeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        init: NodeSeq
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        inits: Iterator[NodeSeq]
      
      
      - Definition Classes
- TraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        intersect[B >: Node](that: GenSeq[B]): NodeSeq
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        isAtom: Boolean
      
      
      - Definition Classes
- Node
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        isDefinedAt(idx: Int): Boolean
      
      
      - Definition Classes
- GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        isEmpty: Boolean
      
      
      - Definition Classes
- SeqLike → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        isInstanceOf[T0]: Boolean
      
      
      - Definition Classes
- Any
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        isTraversableAgain: Boolean
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        iterator: Iterator[Node]
      
      
      - Definition Classes
- NodeSeq → IterableLike → GenIterableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        label: String
      
      
      - Definition Classes
- Atom → Node
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        last: Node
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        lastIndexOf[B >: Node](elem: B, end: Int): Int
      
      
      - Definition Classes
- GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        lastIndexOf[B >: Node](elem: B): Int
      
      
      - Definition Classes
- GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        lastIndexOfSlice[B >: Node](that: GenSeq[B], end: Int): Int
      
      
      - Definition Classes
- SeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        lastIndexOfSlice[B >: Node](that: GenSeq[B]): Int
      
      
      - Definition Classes
- SeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        lastIndexWhere(p: (Node) ⇒ Boolean, end: Int): Int
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        lastIndexWhere(p: (Node) ⇒ Boolean): Int
      
      
      - Definition Classes
- GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        lastOption: Option[Node]
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        length: Int
      
      
      - Definition Classes
- NodeSeq → SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        lengthCompare(len: Int): Int
      
      
      - Definition Classes
- SeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        lift: (Int) ⇒ Option[Node]
      
      
      - Definition Classes
- PartialFunction
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        map[B, That](f: (Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike → FilterMonadic
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        max[B >: Node](implicit cmp: Ordering[B]): Node
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        maxBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        min[B >: Node](implicit cmp: Ordering[B]): Node
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        minBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        mkString: String
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        mkString(sep: String): String
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        mkString(start: String, sep: String, end: String): String
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        nameToString(sb: StringBuilder): StringBuilder
      
      
      - Definition Classes
- Node
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        namespace: Null
      
      
      - Definition Classes
- SpecialNode → Node
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        ne(arg0: AnyRef): Boolean
      
      
      - Definition Classes
- AnyRef
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        newBuilder: Builder[Node, NodeSeq]
      
      
      - Attributes
- protected[this]
- Definition Classes
- NodeSeq → GenericTraversableTemplate → TraversableLike → HasNewBuilder
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        nonEmpty: Boolean
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        nonEmptyChildren: Seq[Node]
      
      
      - Definition Classes
- Node
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        notify(): Unit
      
      
      - Definition Classes
- AnyRef
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        notifyAll(): Unit
      
      
      - Definition Classes
- AnyRef
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        orElse[A1 <: Int, B1 >: Node](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
      
      
      - Definition Classes
- PartialFunction
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        padTo[B >: Node, That](len: Int, elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        par: ParSeq[Node]
      
      
      - Definition Classes
- Parallelizable
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        parCombiner: Combiner[Node, ParSeq[Node]]
      
      
      - Attributes
- protected[this]
- Definition Classes
- Seq → SeqLike → Iterable → TraversableLike → Parallelizable
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        partition(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        patch[B >: Node, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        permutations: Iterator[NodeSeq]
      
      
      - Definition Classes
- SeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        prefix: String
      
      
      - Definition Classes
- Node
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        prefixLength(p: (Node) ⇒ Boolean): Int
      
      
      - Definition Classes
- GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        product[B >: Node](implicit num: Numeric[B]): B
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        reduce[A1 >: Node](op: (A1, A1) ⇒ A1): A1
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        reduceLeft[B >: Node](op: (B, Node) ⇒ B): B
      
      
      - Definition Classes
- TraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        reduceLeftOption[B >: Node](op: (B, Node) ⇒ B): Option[B]
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        reduceOption[A1 >: Node](op: (A1, A1) ⇒ A1): Option[A1]
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        reduceRight[B >: Node](op: (Node, B) ⇒ B): B
      
      
      - Definition Classes
- IterableLike → TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        reduceRightOption[B >: Node](op: (Node, B) ⇒ B): Option[B]
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        repr: NodeSeq
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        reverse: NodeSeq
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        reverseIterator: Iterator[Node]
      
      
      - Definition Classes
- SeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        reverseMap[B, That](f: (Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        reversed: List[Node]
      
      
      - Attributes
- protected[this]
- Definition Classes
- TraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        runWith[U](action: (Node) ⇒ U): (Int) ⇒ Boolean
      
      
      - Definition Classes
- PartialFunction
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        sameElements[B >: Node](that: GenIterable[B]): Boolean
      
      
      - Definition Classes
- IterableLike → GenIterableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        scan[B >: Node, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        scanLeft[B, That](z: B)(op: (B, Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        scanRight[B, That](z: B)(op: (Node, B) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
- Annotations
- @migration
- Migration
- (Changed in version 2.9.0) The behavior of - scanRighthas changed. The previous behavior can be reproduced with scanRight.reverse.
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        scope: NamespaceBinding
      
      
      - Definition Classes
- Node
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        segmentLength(p: (Node) ⇒ Boolean, from: Int): Int
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        seq: Seq[Node]
      
      
      - Definition Classes
- Seq → Seq → GenSeq → GenSeqLike → Iterable → Iterable → GenIterable → Traversable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        size: Int
      
      
      - Definition Classes
- SeqLike → GenTraversableLike → TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        sizeHintIfCheap: Int
      
      
      - Attributes
- protected[scala.collection]
- Definition Classes
- GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        slice(from: Int, until: Int): NodeSeq
      
      
      - Definition Classes
- IterableLike → TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        sliding(size: Int, step: Int): Iterator[NodeSeq]
      
      
      - Definition Classes
- IterableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        sliding(size: Int): Iterator[NodeSeq]
      
      
      - Definition Classes
- IterableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        sortBy[B](f: (Node) ⇒ B)(implicit ord: Ordering[B]): NodeSeq
      
      
      - Definition Classes
- SeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        sortWith(lt: (Node, Node) ⇒ Boolean): NodeSeq
      
      
      - Definition Classes
- SeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        sorted[B >: Node](implicit ord: Ordering[B]): NodeSeq
      
      
      - Definition Classes
- SeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        span(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        splitAt(n: Int): (NodeSeq, NodeSeq)
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        startsWith[B](that: GenSeq[B], offset: Int): Boolean
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        startsWith[B](that: GenSeq[B]): Boolean
      
      
      - Definition Classes
- GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        strict_!=(other: Equality): Boolean
      
      
      - Definition Classes
- Equality
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        strict_==(other: Equality): Boolean
      
      
      - Definition Classes
- Atom → Node → NodeSeq → Equality
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        stringPrefix: String
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        sum[B >: Node](implicit num: Numeric[B]): B
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        synchronized[T0](arg0: ⇒ T0): T0
      
      
      - Definition Classes
- AnyRef
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        tail: NodeSeq
      
      
      - Definition Classes
- TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        tails: Iterator[NodeSeq]
      
      
      - Definition Classes
- TraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        take(n: Int): NodeSeq
      
      
      - Definition Classes
- IterableLike → TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        takeRight(n: Int): NodeSeq
      
      
      - Definition Classes
- IterableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        takeWhile(p: (Node) ⇒ Boolean): NodeSeq
      
      
      - Definition Classes
- IterableLike → TraversableLike → GenTraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        text: String
      
      
      - Definition Classes
- Atom → Node → NodeSeq
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        theSeq: Seq[Node]
      
      
      - Definition Classes
- Node → NodeSeq
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        thisCollection: Seq[Node]
      
      
      - Attributes
- protected[this]
- Definition Classes
- SeqLike → IterableLike → TraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Node, Col[Node]]): Col[Node]
      
      
      - Definition Classes
- TraversableLike → TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        toArray[B >: Node](implicit arg0: ClassTag[B]): Array[B]
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        toBuffer[B >: Node]: Buffer[B]
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        toCollection(repr: NodeSeq): Seq[Node]
      
      
      - Attributes
- protected[this]
- Definition Classes
- SeqLike → IterableLike → TraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        toIndexedSeq: IndexedSeq[Node]
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        toIterable: Iterable[Node]
      
      
      - Definition Classes
- IterableLike → TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        toIterator: Iterator[Node]
      
      
      - Definition Classes
- IterableLike → TraversableLike → GenTraversableOnce
- Annotations
- @deprecatedOverriding( ... , "2.11.0" )
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        toList: List[Node]
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        toMap[T, U](implicit ev: <:<[Node, (T, U)]): Map[T, U]
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        toSeq: Seq[Node]
      
      
      - Definition Classes
- Seq → SeqLike → GenSeqLike → TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        toSet[B >: Node]: Set[B]
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        toStream: Stream[Node]
      
      
      - Definition Classes
- IterableLike → TraversableLike → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        toString(): String
      
      
      - Definition Classes
- Node → NodeSeq → SeqLike → Function1 → TraversableLike → AnyRef → Any
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        toTraversable: Traversable[Node]
      
      
      - Definition Classes
- TraversableLike → TraversableOnce → GenTraversableOnce
- Annotations
- @deprecatedOverriding( ... , "2.11.0" )
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        toVector: Vector[Node]
      
      
      - Definition Classes
- TraversableOnce → GenTraversableOnce
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        transpose[B](implicit asTraversable: (Node) ⇒ GenTraversableOnce[B]): Seq[Seq[B]]
      
      
      - Definition Classes
- GenericTraversableTemplate
- Annotations
- @migration
- Migration
- (Changed in version 2.9.0) - transposethrows an- IllegalArgumentExceptionif collections are not uniformly sized.
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        union[B >: Node, That](that: GenSeq[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        unzip[A1, A2](implicit asPair: (Node) ⇒ (A1, A2)): (Seq[A1], Seq[A2])
      
      
      - Definition Classes
- GenericTraversableTemplate
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        unzip3[A1, A2, A3](implicit asTriple: (Node) ⇒ (A1, A2, A3)): (Seq[A1], Seq[A2], Seq[A3])
      
      
      - Definition Classes
- GenericTraversableTemplate
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        updated[B >: Node, That](index: Int, elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
      
      
      - Definition Classes
- SeqLike → GenSeqLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        view(from: Int, until: Int): SeqView[Node, NodeSeq]
      
      
      - Definition Classes
- SeqLike → IterableLike → TraversableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        view: SeqView[Node, NodeSeq]
      
      
      - Definition Classes
- SeqLike → IterableLike → TraversableLike
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        wait(): Unit
      
      
      - Definition Classes
- AnyRef
- Annotations
- @throws( ... )
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        wait(arg0: Long, arg1: Int): Unit
      
      
      - Definition Classes
- AnyRef
- Annotations
- @throws( ... )
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        wait(arg0: Long): Unit
      
      
      - Definition Classes
- AnyRef
- Annotations
- @throws( ... )
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        withFilter(p: (Node) ⇒ Boolean): FilterMonadic[Node, NodeSeq]
      
      
      - Definition Classes
- TraversableLike → FilterMonadic
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        xmlType(): TypeSymbol
      
      
      - Definition Classes
- Node
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        xml_!=(other: Any): Boolean
      
      
      - Definition Classes
- Equality
 
- 
      
      
      
        
      
    
      
        final 
        def
      
      
        xml_==(other: Any): Boolean
      
      
      - Definition Classes
- Equality
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        xml_sameElements[A](that: Iterable[A]): Boolean
      
      
      - Definition Classes
- NodeSeq
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        zip[A1 >: Node, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[NodeSeq, (A1, B), That]): That
      
      
      - Definition Classes
- IterableLike → GenIterableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        zipAll[B, A1 >: Node, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[NodeSeq, (A1, B), That]): That
      
      
      - Definition Classes
- IterableLike → GenIterableLike
 
- 
      
      
      
        
      
    
      
        
        def
      
      
        zipWithIndex[A1 >: Node, That](implicit bf: CanBuildFrom[NodeSeq, (A1, Int), That]): That
      
      
      - Definition Classes
- IterableLike → GenIterableLike