Packages

p

scala

xml

package xml

This library provides support for the XML literal syntax in Scala programs.

val planets: scala.xml.Elem = <planets>
  <planet id="earth">
    <title>Earth</title>
    <mass unit="kg">5.9742e24</mass>
    <radius unit="m">6378.14e3</radius>
  </planet>
  <planet id="mars">
    <title>Mars</title>
    <mass unit="kg">0.64191e24</mass>
    <radius unit="m">3397.0e3</radius>
  </planet>
</planets>

Additionally, you can mix Scala expressions in your XML elements by using the curly brace notation:

val sunMass = 1.99e30
val sunRadius = 6.96e8
val star = <star>
  <title>Sun</title>
  <mass unit="kg">{ sunMass }</mass>
  <radius unit="m">{ sunRadius }</radius>
  <surface unit="m²">{ 4 * Math.PI * Math.pow(sunRadius, 2) }</surface>
  <volume unit="m³">{ 4/3 * Math.PI * Math.pow(sunRadius, 3) }</volume>
</star>

An XML element, for example <star/> and <planet/>, is represented in this library as a case class, scala.xml.Elem.

The sub-elements of XML values share a common base class, scala.xml.Node.

However, the non-element declarations found in XML files share a different common base class, scala.xml.dtd.Decl. Additionally, document type declarations are represented by a different trait, scala.xml.dtd.DTD.

For reading and writing XML data to and from files, see scala.xml.XML. The default parser of XML data is the Xerces parser and is provided in Java by javax.xml.parsers.SAXParser.

For more control of the input, use the parser written in Scala that is provided, scala.xml.parsing.ConstructingParser.

For working with XHTML input, use scala.xml.parsing.XhtmlParser.

For more control of the output, use the scala.xml.PrettyPrinter.

Utility methods for working with XML data are provided in scala.xml.Utility.

XML values in Scala are immutable, but you can traverse and transform XML data with a scala.xml.transform.RuleTransformer.

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. xml
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. class Atom[+A] extends SpecialNode with Serializable

    The class Atom provides an XML node for text (PCDATA).

    The class Atom provides an XML node for text (PCDATA). It is used in both non-bound and bound XML representations.

  2. trait Attribute extends MetaData

    The Attribute trait defines the interface shared by both scala.xml.PrefixedAttribute and scala.xml.UnprefixedAttribute.

  3. case class Comment(commentText: String) extends SpecialNode with Product with Serializable

    The class Comment implements an XML node for comments.

    The class Comment implements an XML node for comments.

    commentText

    the text contained in this node, may not contain "--" and the final character may not be - to prevent a closing span of --> which is invalid. https://www.w3.org/TR/xml11//#IDA5CES

  4. class Document extends NodeSeq with Serializable

    A document information item (according to InfoSet spec).

    A document information item (according to InfoSet spec). The comments are copied from the Infoset spec, only augmented with some information on the Scala types for definitions that might have no value. Also plays the role of an XMLEvent for pull parsing.

    Annotations
    @SerialVersionUID()
  5. class Elem extends Node with Serializable

    An immutable data object representing an XML element.

    An immutable data object representing an XML element.

    Child elements can be other Elems or any one of the other Node types.

    XML attributes are implemented with the scala.xml.MetaData base class.

    Optional XML namespace scope is represented by scala.xml.NamespaceBinding.

  6. case class EntityRef(entityName: String) extends SpecialNode with Product with Serializable

    The class EntityRef implements an XML node for entity references.

    The class EntityRef implements an XML node for entity references.

    entityName

    the name of the entity reference, for example amp.

  7. type EntityResolver = org.xml.sax.EntityResolver
  8. trait Equality extends Equals
  9. final case class Group(nodes: collection.Seq[Node]) extends Node with Product with Serializable

    A hack to group XML nodes in one node for output.

  10. type InputSource = org.xml.sax.InputSource
  11. case class MalformedAttributeException(msg: String) extends RuntimeException with Product with Serializable
  12. abstract class MetaData extends AbstractIterable[MetaData] with Iterable[MetaData] with Equality with Serializable

    This class represents an attribute and at the same time a linked list of attributes.

    This class represents an attribute and at the same time a linked list of attributes. Every instance of this class is either

    • an instance of UnprefixedAttribute key,value or
    • an instance of PrefixedAttribute namespace_prefix,key,value or
    • Null, the empty attribute list.

    Namespace URIs are obtained by using the namespace scope of the element owning this attribute (see getNamespace).

  13. case class NamespaceBinding(prefix: String, uri: String, parent: NamespaceBinding) extends Equality with Product with Serializable

    The class NamespaceBinding represents namespace bindings and scopes.

    The class NamespaceBinding represents namespace bindings and scopes. The binding for the default namespace is treated as a null prefix. the absent namespace is represented with the null uri. Neither prefix nor uri may be empty, which is not checked.

    Annotations
    @SerialVersionUID()
  14. abstract class Node extends NodeSeq

    An abstract class representing XML with nodes of a labeled tree.

    An abstract class representing XML with nodes of a labeled tree. This class contains an implementation of a subset of XPath for navigation.

  15. class NodeBuffer extends ArrayBuffer[Node] with ScalaVersionSpecificNodeBuffer

    This class acts as a Buffer for nodes.

    This class acts as a Buffer for nodes. If it is used as a sequence of nodes Seq[Node], it must be ensured that no updates occur after that point, because scala.xml.Node is assumed to be immutable.

    Despite this being a sequence, don't use it as key in a hashtable. Calling the hashcode function will result in a runtime error.

  16. abstract class NodeSeq extends AbstractSeq[Node] with collection.immutable.Seq[Node] with ScalaVersionSpecificNodeSeq with Equality with Serializable

    This class implements a wrapper around Seq[Node] that adds XPath and comprehension methods.

  17. class PCData extends Atom[String]

    This class (which is not used by all XML parsers, but always used by the XHTML one) represents parseable character data, which appeared as CDATA sections in the input and is to be preserved as CDATA section in the output.

  18. class PrefixedAttribute extends MetaData with Attribute

    prefixed attributes always have a non-null namespace.

  19. class PrettyPrinter extends AnyRef

    Class for pretty printing.

    Class for pretty printing. After instantiating, you can use the format() and formatNode() methods to convert XML to a formatted string. The class can be reused to pretty print any number of XML nodes.

    Note

    This class is not threadsafe and should not be accessed by multiple threads at the same time.

  20. case class ProcInstr(target: String, proctext: String) extends SpecialNode with Product with Serializable

    an XML node for processing instructions (PI)

    an XML node for processing instructions (PI)

    target

    target name of this PI

    proctext

    text contained in this node, may not contain "?>"

  21. type SAXException = org.xml.sax.SAXException
  22. type SAXParseException = org.xml.sax.SAXParseException
  23. type SAXParser = javax.xml.parsers.SAXParser
  24. abstract class SpecialNode extends Node

    SpecialNode is a special XML node which represents either text (PCDATA), a comment, a PI, or an entity ref.

  25. class Text extends Atom[String]

    The class Text implements an XML node for text (PCDATA).

    The class Text implements an XML node for text (PCDATA). It is used in both non-bound and bound XML representations.

  26. class TextBuffer extends AnyRef

    The class TextBuffer is for creating text nodes without surplus whitespace.

    The class TextBuffer is for creating text nodes without surplus whitespace. All occurrences of one or more whitespace in strings appended with the append method will be replaced by a single space character, and leading and trailing space will be removed completely.

  27. abstract class TypeSymbol extends AnyRef
  28. class Unparsed extends Atom[String]

    An XML node for unparsed content.

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

  29. class UnprefixedAttribute extends MetaData with Attribute

    Unprefixed attributes have the null namespace, and no prefix field

Value Members

  1. val XercesClassName: String
  2. object Attribute extends Serializable

    This singleton object contains the apply and unapply methods for convenient construction and deconstruction.

  3. object Elem extends Serializable

    This singleton object contains the apply and unapplySeq methods for convenient construction and deconstruction.

    This singleton object contains the apply and unapplySeq methods for convenient construction and deconstruction. It is possible to deconstruct any Node instance (that is not a SpecialNode or a Group) using the syntax case Elem(prefix, label, attribs, scope, child @ _*) => ...

  4. object Equality

    In an attempt to contain the damage being inflicted on consistency by the ad hoc equals methods spread around xml, the logic is centralized and all the xml classes go through the xml.Equality trait.

    In an attempt to contain the damage being inflicted on consistency by the ad hoc equals methods spread around xml, the logic is centralized and all the xml classes go through the xml.Equality trait. There are two forms of xml comparison.

    1. def strict_==(other: scala.xml.Equality)

    This one tries to honor the little things like symmetry and hashCode contracts. The equals method routes all comparisons through this.

    1. xml_==(other: Any)

    This one picks up where strict_== leaves off. It might declare any two things equal.

    As things stood, the logic not only made a mockery of the collections equals contract, but also laid waste to that of case classes.

    Among the obstacles to sanity are/were:

    Node extends NodeSeq extends Seq[Node] MetaData extends Iterable[MetaData] The hacky "Group" xml node which throws exceptions with wild abandon, so don't get too close Rampant asymmetry and impossible hashCodes Most classes claiming to be equal to "String" if some specific stringification of it was the same. String was never going to return the favor.

  5. object MetaData extends Serializable
  6. object MinimizeMode extends Enumeration

    Governs how empty elements (i.e.

    Governs how empty elements (i.e. those without child elements) should be serialized.

  7. object Node extends Serializable

    This singleton object contains the unapplySeq method for convenient deconstruction.

  8. object NodeSeq extends Serializable

    This object ...

  9. object Null extends MetaData with Product with Serializable

    Essentially, every method in here is a dummy, returning Zero[T].

    Essentially, every method in here is a dummy, returning Zero[T]. It provides a backstop for the unusual collection defined by MetaData, sort of a linked list of tails.

  10. object PCData extends Serializable

    This singleton object contains the applyand unapply methods for convenient construction and deconstruction.

  11. object PrefixedAttribute extends Serializable
  12. object QNode

    This object provides an extractor method to match a qualified node with its namespace URI

  13. object Source
  14. object Text extends Serializable

    This singleton object contains the applyand unapply methods for convenient construction and deconstruction.

  15. object TextBuffer
  16. object TopScope extends NamespaceBinding

    top level namespace scope.

    top level namespace scope. only contains the predefined binding for the "xml" prefix which is bound to "http://www.w3.org/XML/1998/namespace"

  17. object Unparsed extends Serializable

    This singleton object contains the applyand unapply methods for convenient construction and deconstruction.

  18. object UnprefixedAttribute extends Serializable
  19. object Utility extends TokenTests

    The Utility object provides utility functions for processing instances of bound and not bound XML classes, as well as escaping text nodes.

  20. object XML extends XMLLoader[Elem]

    The object XML provides constants, and functions to load and save XML elements.

    The object XML provides constants, and functions to load and save XML elements. Use this when data binding is not desired, i.e. when XML is handled using Symbol nodes.

  21. object Xhtml

Inherited from AnyRef

Inherited from Any

Ungrouped