scala.xml

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

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

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

The class Comment implements an XML node for comments.

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.

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 @ _*) => ...

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.

The class EntityRef implements an XML node for entity references.

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.

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

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).

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

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.

This singleton object contains the unapplySeq method for convenient deconstruction.

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

• scala.xml.Comment — XML comment
• scala.xml.Elem — XML element
• scala.xml.EntityRef — XML entity
• scala.xml.PCData — Character data section (CDATA)
• scala.xml.ProcInstr — Processing instruction (PI)
• scala.xml.Text — Stand-alone parsed character data

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.

This object ...

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

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.

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.

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

prefixed attributes always have a non-null namespace.

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.

an XML node for processing instructions (PI)

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

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

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

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

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.

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

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

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

Unprefixed attributes have the null namespace, and no prefix field

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

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.