scala.xml

Unparsed

class Unparsed extends Atom[String]

An XML node for unparsed content. It will be output verbatim, all bets are off regarding wellformedness etc.

Go to: companion

Inherits

  1. Atom
  2. SpecialNode
  3. XMLEvent
  4. Node
  5. NodeSeq
  6. Seq
  7. Seq
  8. SeqLike
  9. PartialFunction
  10. Function1
  11. Iterable
  12. Iterable
  13. IterableLike
  14. Equals
  15. Traversable
  16. Immutable
  17. Traversable
  18. GenericTraversableTemplate
  19. TraversableLike
  20. HasNewBuilder
  21. AnyRef
  22. Any

Type Members

  1. class WithFilter extends AnyRef

    A class supporting filtered operations

Value Members

  1. def ++(that: Iterator[Node]): Traversable[Node]

    [use case] Concatenates this sequence with the elements of an iterator

  2. def ++[B >: Node, That](that: Iterator[B])(bf: CanBuildFrom[NodeSeq, B, That]): That

    Concatenates this sequence with the elements of an iterator

  3. def ++(that: Traversable[Node]): Traversable[Node]

    [use case] Concatenates this sequence with the elements of a traversable collection

  4. def ++[B >: Node, That](that: Traversable[B])(bf: CanBuildFrom[NodeSeq, B, That]): That

    Concatenates this sequence with the elements of a traversable collection

  5. def +:(elem: Node): Seq[Node]

    [use case] Prepends an element to this sequence

  6. def +:[B >: Node, That](elem: B)(bf: CanBuildFrom[NodeSeq, B, That]): That

    Prepends an element to this sequence

  7. def /:[B](z: B)(op: (B, Node) ⇒ B): B

    Applies a binary operator to a start value and all elements of this sequence, going left to right

  8. def :+(elem: Node): Seq[Node]

    [use case] Appends an element to this sequence

  9. def :+[B >: Node, That](elem: B)(bf: CanBuildFrom[NodeSeq, B, That]): That

    Appends an element to this sequence

  10. def :\[B](z: B)(op: (Node, B) ⇒ B): B

    Applies a binary operator to all elements of this sequence and a start value, going right to left

  11. def \(that: String): NodeSeq

    Projection function

  12. def \\(that: String): NodeSeq

    projection function

  13. def addString(b: StringBuilder): StringBuilder

    Appends all elements of this sequence to a string builder

  14. def addString(b: StringBuilder, sep: String): StringBuilder

    Appends all elements of this sequence to a string builder using a separator string

  15. def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

    Appends all elements of this sequence to a string builder using start, end, and separator strings

  16. def andThen[C](k: (Node) ⇒ C): PartialFunction[Int, C]

    Composes this partial function with a transformation function that gets applied to results of this partial function

  17. def apply(f: (Node) ⇒ Boolean): NodeSeq

  18. def apply(i: Int): Node

    Selects an element by its index in the sequence

  19. def buildString(sb: StringBuilder): StringBuilder

    returns text, with some characters escaped according to XML spec @param sb

  20. def buildString(stripComments: Boolean): String

    String representation of this node

  21. def canEqual(that: Any): Boolean

    Method called from equality methods, so that user-defined subclasses can refuse to be equal to other collections of the same kind

  22. def companion: GenericCompanion[Seq[A][A]]

    The factory companion object that builds instances of class Seq

  23. def compose[A](g: (A) ⇒ Int): (A) ⇒ Node

    (f compose g)(x) == f(g(x))

  24. def contains(elem: Any): Boolean

    Tests whether this sequence contains a given value as an element

  25. def containsSlice[B](that: Seq[B]): Boolean

    Tests whether this sequence contains a given sequence as a slice

  26. def copyToArray(xs: Array[Node], start: Int, len: Int): Unit

    [use case] Copies elements of this sequence to an array

  27. def copyToArray[B >: Node](xs: Array[B], start: Int, len: Int): Unit

    Copies elements of this sequence to an array

  28. def copyToArray(xs: Array[Node], start: Int): Unit

    [use case] Copies elements of this sequence to an array

  29. def copyToArray[B >: Node](xs: Array[B]): Unit

    Copies elements of this sequence to an array

  30. def copyToArray(xs: Array[Node], start: Int): Unit

    [use case] Copies elements of this sequence to an array

  31. def copyToArray[B >: Node](xs: Array[B], start: Int): Unit

    Copies elements of this sequence to an array

  32. def copyToBuffer[B >: Node](dest: Buffer[B]): Unit

    Copies all elements of this sequence to a buffer

  33. def corresponds[B](that: Seq[B])(p: (Node, B) ⇒ Boolean): Boolean

    Tests whether every element of this sequence relates to the corresponding element of another sequence by satisfying a test predicate

  34. def count(p: (Node) ⇒ Boolean): Int

    Counts the number of elements in the sequence which satisfy a predicate

  35. val data: String

  36. def descendant: List[Node]

    Descendant axis (all descendants of this node, not including node itself) includes all text nodes, element nodes, comments and processing instructions

  37. def descendant_or_self: List[Node]

    Descendant axis (all descendants of this node, including thisa node) includes all text nodes, element nodes, comments and processing instructions

  38. def diff[B >: Node, That](that: Seq[B]): NodeSeq

    Computes the multiset difference between this sequence and another sequence

  39. def drop(n: Int): NodeSeq

    Selects all elements except first n ones

  40. def dropRight(n: Int): NodeSeq

    Selects all elements except first n ones

  41. def dropWhile(p: (Node) ⇒ Boolean): NodeSeq

    Drops longest prefix of elements that satisfy a predicate

  42. def elements: Iterator[Node]

  43. def endsWith[B](that: Seq[B]): Boolean

    Tests whether this sequence ends with the given sequence

  44. def equalsWith[B](that: Seq[B])(f: (Node, B) ⇒ Boolean): Boolean

    Tests whether every element of this sequence relates to the corresponding element of another sequence by satisfying a test predicate

  45. def exists(p: (Node) ⇒ Boolean): Boolean

    Tests whether a predicate holds for some of the elements of this sequence

  46. def filter(p: (Node) ⇒ Boolean): NodeSeq

    Selects all elements of this sequence which satisfy a predicate

  47. def filterNot(p: (Node) ⇒ Boolean): NodeSeq

    Selects all elements of this sequence which do not satisfy a predicate

  48. def find(p: (Node) ⇒ Boolean): Option[Node]

    Finds the first element of the sequence satisfying a predicate, if any

  49. def findIndexOf(p: (Node) ⇒ Boolean): Int

    Returns index of the first element satisying a predicate, or -1

  50. def findLastIndexOf(p: (Node) ⇒ Boolean): Int

    Returns index of the last element satisying a predicate, or -1

  51. def first: Node

  52. def firstOption: Option[Node]

    None if iterable is empty

  53. def flatMap[B](f: (Node) ⇒ Traversable[B]): Traversable[B]

    [use case] Builds a new collection by applying a function to all elements of this sequence and concatenating the results

  54. def flatMap[B, That](f: (Node) ⇒ Traversable[B])(bf: CanBuildFrom[NodeSeq, B, That]): That

    Builds a new collection by applying a function to all elements of this sequence and concatenating the results

  55. def flatten[B]: CC[B]

    [use case] Converts this sequence of traversable collections into a sequence in which all element collections are concatenated

  56. def flatten[B](asTraversable: (Node) ⇒ Traversable[B]): Seq[B]

    Converts this sequence of traversable collections into a sequence in which all element collections are concatenated

  57. def foldLeft[B](z: B)(op: (B, Node) ⇒ B): B

    Applies a binary operator to a start value and all elements of this sequence, going left to right

  58. def foldRight[B](z: B)(op: (Node, B) ⇒ B): B

    Applies a binary operator to all elements of this sequence and a start value, going right to left

  59. def forall(p: (Node) ⇒ Boolean): Boolean

    Tests whether a predicate holds for all elements of this sequence

  60. def foreach(f: (Node) ⇒ Unit): Unit

    [use case] Applies a function f to all elements of this sequence

  61. def foreach[U](f: (Node) ⇒ U): Unit

    Applies a function f to all elements of this sequence

  62. def genericBuilder[B]: Builder[B, Seq[B]]

    The generic builder that builds instances of Seq at arbitrary element types

  63. def getNamespace(pre: String): String

    Convenience method, same as scope

  64. def groupBy[K](f: (Node) ⇒ K): Map[K, NodeSeq]

    Partitions this sequence into a map of sequences according to some discriminator function

  65. def grouped(size: Int): Iterator[NodeSeq]

    Partitions elements in fixed size sequences

  66. def hasDefiniteSize: Boolean

    Tests whether this sequence is known to have a finite size

  67. def hashCode(): Int

    Returns a hashcode

  68. def head: Node

    Selects the first element of this sequence

  69. def headOption: Option[Node]

    Optionally selects the first element

  70. def indexOf(elem: Node): Int

    [use case] Finds index of first occurrence of some value in this sequence after or at some start index

  71. def indexOf[B >: Node](elem: B, from: Int): Int

    Finds index of first occurrence of some value in this sequence after or at some start index

  72. def indexOf(elem: Node): Int

    [use case] Finds index of first occurrence of some value in this sequence

  73. def indexOf[B >: Node](elem: B): Int

    Finds index of first occurrence of some value in this sequence

  74. def indexOfSlice[B >: Node](that: Seq[B], from: Int): Int

    Finds first index after or at a start index where this sequence contains a given sequence as a slice

  75. def indexOfSlice[B >: Node](that: Seq[B]): Int

    Finds first index where this sequence contains a given sequence as a slice

  76. def indexWhere(p: (Node) ⇒ Boolean, from: Int): Int

    Finds index of the first element satisfying some predicate after or at some start index

  77. def indexWhere(p: (Node) ⇒ Boolean): Int

    Finds index of first element satisfying some predicate

  78. def indices: Range

    Produces the range of all indices of this sequence

  79. def init: NodeSeq

    Selects all elements except the last

  80. def intersect[B >: Node, That](that: Seq[B]): NodeSeq

    Computes the multiset intersection between this sequence and another sequence

  81. def isAtom: Boolean

    used internally

  82. def isDefinedAt(idx: Int): Boolean

    Tests whether this sequence contains given index

  83. def isEmpty: Boolean

    Tests whether this sequence is empty

  84. def iterator: Iterator[Node]

    Creates a new iterator over all elements contained in this iterable object

  85. def label: String

    label of this node

  86. def last: Node

    Selects the last element

  87. def lastIndexOf(elem: Node): Int

    [use case] Finds index of last occurrence of some value in this sequence before or at a given end index

  88. def lastIndexOf[B >: Node](elem: B, end: Int): Int

    Finds index of last occurrence of some value in this sequence before or at a given end index

  89. def lastIndexOf(elem: Node): Int

    [use case] Finds index of last occurrence of some value in this sequence

  90. def lastIndexOf[B >: Node](elem: B): Int

    Finds index of last occurrence of some value in this sequence

  91. def lastIndexOfSlice[B >: Node](that: Seq[B], end: Int): Int

    Finds last index before or at a given end index where this sequence contains a given sequence as a slice

  92. def lastIndexOfSlice[B >: Node](that: Seq[B]): Int

    Finds last index where this sequence contains a given sequence as a slice

  93. def lastIndexWhere(p: (Node) ⇒ Boolean, end: Int): Int

    Finds index of last element satisfying some predicate before or at given end index

  94. def lastIndexWhere(p: (Node) ⇒ Boolean): Int

    Finds index of last element satisfying some predicate

  95. def lastOption: Option[Node]

    Optionally selects the last element

  96. def length: Int

    The length of the sequence

  97. def lengthCompare(len: Int): Int

    Compares the length of this sequence to a test value

  98. def lift: (Int) ⇒ Option[Node]

    Turns this partial function into an plain function returning an Option result

  99. def map[B](f: (Node) ⇒ B): Traversable[B]

    [use case] Builds a new collection by applying a function to all elements of this sequence

  100. def map[B, That](f: (Node) ⇒ B)(bf: CanBuildFrom[NodeSeq, B, That]): That

    Builds a new collection by applying a function to all elements of this sequence

  101. def max[B >: Node](cmp: Ordering[B]): Node

    Finds the largest element

  102. def min: Node

    [use case] Finds the largest element

  103. def min: Node

    [use case] Finds the smallest element

  104. def min[B >: Node](cmp: Ordering[B]): Node

    Finds the smallest element

  105. def mkString: String

    Displays all elements of this sequence in a string

  106. def mkString(sep: String): String

    Displays all elements of this sequence in a string using a separator string

  107. def mkString(start: String, sep: String, end: String): String

    Displays all elements of this sequence in a string using start, end, and separator strings

  108. def nameToString(sb: StringBuilder): StringBuilder

    Appends qualified name of this node to StringBuilder

  109. def nonEmpty: Boolean

    Tests whether the sequence is not empty

  110. def orElse[A1 <: Int, B1 >: Node](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

    Composes this partial function with a fallback partial function which gets applied where this partial function is not defined

  111. def padTo(len: Int, elem: Node): Seq[Node]

    [use case] Appends an element value to this sequence until a given target length is reached

  112. def padTo[B >: Node, That](len: Int, elem: B)(bf: CanBuildFrom[NodeSeq, B, That]): That

    Appends an element value to this sequence until a given target length is reached

  113. def partialMap[B](pf: PartialFunction[Node, B]): Traversable[B]

    [use case] Builds a new collection by applying a partial function to all elements of this sequence on which the function is defined

  114. def partialMap[B, That](pf: PartialFunction[Node, B])(bf: CanBuildFrom[NodeSeq, B, That]): That

    Builds a new collection by applying a partial function to all elements of this sequence on which the function is defined

  115. def partition(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)

    Partitions this sequence in two sequences according to a predicate

  116. def patch(from: Int, that: Seq[Node], replaced: Int): Seq[Node]

    [use case] Produces a new sequence where a slice of elements in this sequence is replaced by another sequence

  117. def patch[B >: Node, That](from: Int, patch: Seq[B], replaced: Int)(bf: CanBuildFrom[NodeSeq, B, That]): That

    Produces a new sequence where a slice of elements in this sequence is replaced by another sequence

  118. def prefix: String

    prefix of this node

  119. def prefixLength(p: (Node) ⇒ Boolean): Int

    Returns the length of the longest prefix whose elements all satisfy some preficate

  120. def product: Int

    [use case] Multiplies up the elements of this collection

  121. def product[B >: Node](num: Numeric[B]): B

    Multiplies up the elements of this collection

  122. def projection: SeqView[Node, NodeSeq]

    returns a projection that can be used to call non-strict filter, map, and flatMap methods that build projections of the collection

  123. def reduceLeft[B >: Node](op: (B, Node) ⇒ B): B

    Applies a binary operator to all elements of this sequence, going left to right

  124. def reduceLeftOption[B >: Node](op: (B, Node) ⇒ B): Option[B]

    Optionally applies a binary operator to all elements of this sequence, going left to right

  125. def reduceRight[B >: Node](op: (Node, B) ⇒ B): B

    Applies a binary operator to all elements of this sequence, going right to left

  126. def reduceRightOption[B >: Node](op: (Node, B) ⇒ B): Option[B]

    Optionally applies a binary operator to all elements of this sequence, going right to left

  127. def removeDuplicates: NodeSeq

    Builds a new sequence from this sequence without any duplicate elements

  128. def repr: NodeSeq

    The collection of type sequence underlying this TraversableLike object

  129. def reverse: NodeSeq

    Returns new sequence wih elements in reversed order

  130. def reverseIterator: Iterator[Node]

    An iterator yielding elements in reversed order

  131. def reverseMap[B](f: (Node) ⇒ B): Seq[B]

    [use case] Builds a new collection by applying a function to all elements of this sequence and collecting the results in reversed order

  132. def reverseMap[B, That](f: (Node) ⇒ B)(bf: CanBuildFrom[NodeSeq, B, That]): That

    Builds a new collection by applying a function to all elements of this sequence and collecting the results in reversed order

  133. def reversedElements: Iterator[Node]

  134. def sameElements(that: Iterable[Node]): Boolean

    [use case] Checks if the other iterable collection contains the same elements in the same order as this sequence

  135. def sameElements[B >: Node](that: Iterable[B]): Boolean

    Checks if the other iterable collection contains the same elements in the same order as this sequence

  136. def scope: NamespaceBinding

    method returning the namespace bindings of this node

  137. def segmentLength(p: (Node) ⇒ Boolean, from: Int): Int

    Computes length of longest segment whose elements all satisfy some preficate

  138. def size: Int

    The size of this sequence, equivalent to length

  139. def slice(from: Int, until: Int): NodeSeq

    Selects an interval of elements

  140. def sliding[B >: Node](size: Int, step: Int): Iterator[NodeSeq]

  141. def sliding[B >: Node](size: Int): Iterator[NodeSeq]

    Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped

  142. def sortBy[B](f: (Node) ⇒ B)(ord: Ordering[B]): NodeSeq

    Sorts this Seq according to the Ordering which results from transforming an implicitly given Ordering with a transformation function

  143. def sortWith[B >: Node](ord: Ordering[B]): NodeSeq

    Sorts this sequence according to an Ordering

  144. def sortWith(lt: (Node, Node) ⇒ Boolean): NodeSeq

    Sorts this sequence according to a comparison function

  145. def span(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)

    Spits this sequence into a prefix/suffix pair according to a predicate

  146. def splitAt(n: Int): (NodeSeq, NodeSeq)

    Splits this sequence into two at a given position

  147. def startsWith[B](that: Seq[B]): Boolean

    Tests whether this sequence starts with the given sequence

  148. def startsWith[B](that: Seq[B], offset: Int): Boolean

    Tests whether this sequence contains the given sequence at a given index

  149. def stringPrefix: String

    Defines the prefix of this object's toString representation

  150. def sum: Int

    [use case] Sums up the elements of this collection

  151. def sum[B >: Node](num: Numeric[B]): B

    Sums up the elements of this collection

  152. def tail: NodeSeq

    Selects all elements except the first

  153. def take(n: Int): NodeSeq

    Selects first n elements

  154. def takeRight(n: Int): NodeSeq

    Selects last n elements

  155. def takeWhile(p: (Node) ⇒ Boolean): NodeSeq

    Takes longest prefix of elements that satisfy a predicate

  156. def text: String

    Returns a text representation of this node

  157. def theSeq: Seq[Node]

    returns a sequence consisting of only this node

  158. def toArray: Array[Node]

    [use case] Converts this sequence to an array

  159. def toArray[B >: Node](arg0: ClassManifest[B]): Array[B]

    Converts this sequence to an array

  160. def toIndexedSeq[B >: Node]: IndexedSeq[B]

    Converts this sequence to an indexed sequence

  161. def toIterable: Iterable[Node]

    Converts this sequence to an iterable collection

  162. def toList: List[Node]

    Converts this sequence to a list

  163. def toMap[T, U](ev: <:<[Node, (T, U)]): Map[T, U]

    Converts this sequence to a map

  164. def toSeq: Seq[Node]

    Converts this sequence to a sequence

  165. def toSet[B >: Node]: Set[B]

    Converts this sequence to a set

  166. def toStream: Stream[Node]

    Converts this sequence to a stream

  167. def toString(): String

    Same as toString(false)

  168. def transpose[B](asTraversable: (Node) ⇒ Traversable[B]): Seq[Seq[B]]

    Transposes this sequence of traversable collections into

  169. def union(that: Seq[Node]): Seq[Node]

    [use case] Computes the multiset intersection between this sequence and another sequence

  170. def union(that: Seq[Node]): Seq[Node]

    [use case] Computes the multiset difference between this sequence and another sequence

  171. def union(that: Seq[Node]): Seq[Node]

    [use case] Produces a new sequence which contains all elements of this sequence and also all elements of a given sequence

  172. def union[B >: Node, That](that: Seq[B])(bf: CanBuildFrom[NodeSeq, B, That]): That

    Produces a new sequence which contains all elements of this sequence and also all elements of a given sequence

  173. def unzip[A1, A2](asPair: (Node) ⇒ (A1, A2)): (Seq[A1], Seq[A2])

    Converts this sequence of pairs into two collections of the first and second halfs of each pair

  174. def updated(index: Int, elem: Node): Seq[Node]

    [use case] A copy of this sequence with one single replaced element

  175. def updated[B >: Node, That](index: Int, elem: B)(bf: CanBuildFrom[NodeSeq, B, That]): That

    A copy of this sequence with one single replaced element

  176. def view(from: Int, until: Int): SeqView[Node, NodeSeq]

    Creates a non-strict view of a slice of this sequence

  177. def view: SeqView[Node, NodeSeq]

    Creates a non-strict view of this sequence

  178. def withFilter(p: (Node) ⇒ Boolean): WithFilter

    Creates a non-strict filter of this sequence

  179. def xmlType(): TypeSymbol

    Returns a type symbol (e

  180. def zip[B](that: Iterable[B]): Iterable[(Node, B)]

    [use case] Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs

  181. def zip[A1 >: Node, B, That](that: Iterable[B])(bf: CanBuildFrom[NodeSeq, (A1, B), That]): That

    Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs

  182. def zipAll[B](that: Iterable[B], thisElem: Node, thatElem: B): Iterable[(Node, B)]

    [use case] Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs

  183. def zipAll[B, A1 >: Node, That](that: Iterable[B], thisElem: A1, thatElem: B)(bf: CanBuildFrom[NodeSeq, (A1, B), That]): That

    Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs

  184. def zipWithIndex: Iterable[(Node, Int)]

    [use case] Zips this sequence with its indices

  185. def zipWithIndex[A1 >: Node, That](bf: CanBuildFrom[NodeSeq, (A1, Int), That]): That

    Zips this sequence with its indices

Instance constructors

  1. new Unparsed(data: String)

  2. new Unparsed()