Because XML documents are tree-structured, we define the data model using conventional terminology for trees. The data model is a node-labeled, tree-constructor representation, but also includes a concept of node identity. The identity of a node is established when a node-constructor is applied to create the node: each application of a node constructor creates a new node that is identical to itself, and not identical to any other node (see ).

The dm:node-equal function takes two nodes as arguments. It returns true if the arguments are identical and false otherwise.

function dm:node-equal(Node $n1, Node $n2) returns xs:boolean

This concept should not be confused with the concept of unique ID, which is a unique name assigned to an element by the author to represent references using ID/IDREF correlation.

A document order is defined on all the nodes in a document. The document node is the first node. Element nodes, comment nodes, and processing instruction nodes occur in the order of their representation in the XML (after expansion of entities). Element nodes occur before their children. The namespace nodes of an element immediately follow the element node (see ). The relative order of namespace nodes is implementation-dependent. The attribute nodes of an element immediately follow the namespace nodes of the element. The relative order of attribute nodes is implementation-dependent. Reverse document order is the reverse of document order.

The relative order of nodes in distinct documents is implementation-dependent but stable. In other words, given two distinct documents A and B, if a node in document A is before a node in document B, then every node in document A is before every node in document B.

The dm:node-before function takes two nodes as arguments. It returns true if the first argument is before (but not identical to) the second one in document order and false otherwise

function dm:node-before(Node $n1, Node $n2) returns xs:boolean

The data model is defined in terms of the after XML Schema validity assessment. XML Schema validity assessment is the process of assessing an XML element information item with respect to an XML Schema and augmenting it and some or all of its descendants with properties that provide information about validity and type assignment. The result of schema validity assessment is an augmented Infoset, known as the Post Schema-Validation Infoset, or PSVI.

The data model supports the following classes of XML documents:

The data model does not support XML documents that are not supported by the XML Information Set, for example, non-well-formed documents and documents that don't conform to XML Namespaces.

Schema-validated documents include documents in which some elements or attributes have been validated by "lax" or "skip" validation ().

An "incompletely validated document" is an XML document that has a corresponding schema but whose schema-validity assessment has resulted in one or more element or attribute information items being assigned values other than 'valid' for the validity property in the PSVI.

The data model supports incompletely validated documents. See .

The data model supports a representation of named types as expanded-QNames. Named types include both the built-in types defined by XML Schema Part 2 and types declared in a schema and imported by a query. Since named types in XML Schema are global, an expanded-QName uniquely identifies such a type, be it simple or complex: The namespace of the expanded-QName is the target namespace of the schema and its local name is the name of the type. The data model does not uniquely identify anonymous types and represents them by xs:anyType or xs:anySimpleType.

The data model associates type information with element nodes attribute nodes and atomic values. If this type information is something other than xs:anyType or xs:anySimpleType, the item is guaranteed to be a valid instance of that type as defined by XML Schema. The data model defines an accessor dm:type() that returns an expanded-QName corresponding to the type of the element node, attribute node or atomic value, provided that the type is globally declared. It returns xs:anyType or xs:anySimpleType if it is locally declared or if no type information exists. When no type information exists for an element or an attribute node we frequently use the terminology "element with unknown type" or "attribute with unknown simple type".

The data model does not represent element or attribute declaration schema components, but it supports various type-related operations. The semantics of such operations, e.g. checking if a particular instance of an element node has a given type is defined in .

This section specifies how the type of an element or attribute node is computed from the PSV Infoset additions that specify validity and type assessment for the node's corresponding information item.

A PSV element (attribute) information item has a validity and a type definition property. The validity property may be "valid", "invalid", or "notKnown" and reflects the outcome of the element's (attribute's) schema-validity assessment. The type definition property contains an element information item that is isomorphic to the XML Schema type definition of the element or attribute information item. Roughly speaking these two properties are used to compute the type of an element or attribute in the data model, which corresponds to the {target namespace} and the {name} of the type definition property if validity is "valid", or to xs:anyType (xs:anySimpleType) otherwise. Notice that the only information that can be inferred from an invalid or not known validity value is that the information item is well-formed, therefore, we must associate some general type information with the element or attribute node.

The precise definition of the type of an element or attribute information item is slightly more complex due to the following factors. First, XML Schema only guarantees the existence of either the type definition property, or the type definition namespace, type definition name and type definition anonymous properties. Second, if the type definition refers to a union type, there are further properties defined, that refer to the type definition which actually validated the element item's normalized value. These properties are either the member type definition, or the member type definition namespace, member type definition name and member type definition anonymous properties. If these are available the type of an element or attribute will refer to the member type that actually validated the schema normalized value. Having identified all the relevant properties we can now define how to compute a type.

The type of an element information item is represented by an xs:QName whose namespace and local name corresponds to the first applicable item in the following list:

The type of an attribute information item is represented by an xs:QName. Its definition is the same as for element information items except for using xs:anySimpleType instead of xs:anyType above.

We will find it convenient to define the following function that will be used later in various sections. The infoitem-to-type function takes an element or an attribute information item and returns an xs:QName that corresponds to the type of its argument.

function infoitem-to-type((ElementItem|AttributeItem) $ii) returns xs:QName define function infoitem-to-type(ElementItem $ii) { if (psvi-element-validity($ii) ne "valid") then return xf:QName-from-string("xs:anyType") else if (psvi-element-member-type-definition($ii) ne ()) then let $typedef:= psvi-element-member-type-definition($ii) let $name:= psvi-typedefinition-name($typedef) let $namespace:= psvi-typedefinition-namespace($typedef) return xf:QName-from-uri($namespace,$name) else if (psvi-element-type-definition($ii) ne ()) then let $typedef:= psvi-element-type-definition($ii) let $name:= psvi-typedefinition-name($typedef) let $namespace:= psvi-typedefinition-namespace($typedef) return xf:QName-from-uri($namespace,$name) else if (psvi-element-member-type-definition-anonymous($ii) eq false) then let $name:= psvi-element-member-type-definition-name($ii) let $namespace:= psvi-element-member-type-definition-namespace($ii) return xf:QName-from-uri($namespace,$name) else if (psvi-element-type-definition-anonymous($ii) eq false) then let $name:= psvi-element-type-definition-name($ii) let $namespace:= psvi-element-type-definition-namespace($ii) return xf:QName-from-uri($namespace,$name) else return xf:QName-from-string("xs:anyType") } function infoitem-to-type(AttributeItem $ii) { if (psvi-attribute-validity($ii) ne "valid") then return xf:QName-from-string("xs:anySimpleType") else if (psvi-attribute-member-type-definition($ii) ne ()) then let $typedef:= psvi-attribute-member-type-definition($ii) let $name:= psvi-typedefinition-name($typedef) let $namespace:= psvi-typedefinition-namespace($typedef) return xf:QName-from-uri($namespace,$name) else if (psvi-attribute-type-definition(a) ne ()) then let $typedef:= psvi-attribute-type-definition($ii) let $name:= psvi-typedefinition-name($typedef) let $namespace:= psvi-typedefinition-namespace($typedef) return xf:QName-from-uri($namespace,$name) else if (psvi-attribute-member-type-definition-anonymous($ii) eq false) then let $name:= psvi-attribute-member-type-definition-name($ii) let $namespace:= psvi-attribute-member-type-definition-namespace($ii) return xf:QName-from-uri($namespace,$name) else if (psvi-attribute-type-definition-anonymous($ii) eq false) then let $name:= psvi-attribute-type-definition-name($ii) let $namespace:= psvi-attribute-type-definition-namespace($ii) return xf:QName-from-uri($namespace,$name) else return xf:QName-from-string("xs:anySimpleType") }

Given information items that validate with respect to a DTD, ...

Given information items from a document a well-formed document, with no corresponding DTD or Schema...

The data model supports two representations of the character data that appears as element content: text nodes or a sequence of atomic values. Similarly, character data of attributes can also be represented in two ways: as a string or a sequence of atomic values. A text node represents a string of consecutive character information items and never has another text node as its immediately following sibling. An element node, for example, has child nodes that may include text nodes, comment nodes, processing instruction nodes, and other element nodes. In addition, the text content of an element may be interpreted as a sequence of atomic values, such as an integer, a date, or a sequence of prices. To illustrate, consider an element node whose type is a sequence of double-precision numbers. The element's children are three nodes: a text node with string contents " 12.00 ", followed by a comment node, followed by a text node with contents " 13.0", whereas its atomic value is a sequence containing the double-precision numbers 12.0 and 13.0.

It is noted that the two representations of character data are not equivalent. A sequence of atomic values contains more type information then a text-node or string representation when the atomic values are of different types (e.g. a sequence containing an integer, a date and a string). Since the text node child does not contain enough type information to reconstruct this typed value, an implementation must store the element's typed value separately from the text node. This precludes a "text node only" implementation.

Although the data model is able to represent comments, processing instructions, and insignificant whitespace, preservation of this information may be unnecessary and onerous for some applications.

Construction of a document from an XML information set is parameterized by three flags, ignore-comments, ignore-processing-instructions, and ignore-whitespace. If the ignore-comments flag is true, comment nodes are not preserved in the data model. If the ignore-processing-instructions flag is true, processing-instruction nodes are not preserved in the data model. If the ignore-whitespace flag is true, insignificant whitespace is not preserved.

ignore-comments : xs:boolean ignore-processing-instructions : xs:boolean ignore-whitespace : xs:boolean

Expressions which rely upon the presence or absence of comments, processing instructions, or insignificant whitespace may produce different results for two data models created from the same infoset (XML document), when each data model is constructed with different settings of these flags.

Insignificant whitespace is defined as a text node that:

A document is represented by a document node, which corresponds to a document information item.

A document node does not have an expanded-QName.

The dm:base-uri of the document corresponds to the base URI property.

The dm:string-value of the document node is the concatenation of the string-values of all text-node descendants of the document node in document order.

The dm:parent of the document node is always the empty sequence. A document node always represents the root of a tree.

The dm:children of the document node are nodes corresponding to the information items found in the children property, omitting any document type declaration information items.

In a well-formed document, the children of the document node consist exclusively of element nodes, processing-instruction nodes, and comment nodes, and exactly one of these children is an element node. A document node in the data model is more permissive: it permits more than one element node as a child and also permits text nodes as children.

A document node has the constructor dm:document-node, which takes a base URI value and a non-empty sequence of its children nodes. Like all other node constructors, the document-node constructor has the effect of creating a new node with a unique identity, distinct from all other nodes.

function dm:document-node( xs:anyURI $baseuri, (ElementNode | TextNode | ProcessingInstructionNode | CommentNode)+ $children) returns DocumentNode

The accessors dm:base-uri and dm:children return a document node's constituent parts:

function dm:base-uri(DocumentNode $n) returns xs:anyURI function dm:children(DocumentNode $n) returns (ElementNode | TextNode | ProcessingInstructionNode | CommentNode)+

The accessors dm:node-kind and dm:string-value also apply to document nodes and return results other than the empty sequence. The accessors dm:name, dm:typed-value, dm:parent, dm:attributes, dm:namespaces, dm:type and dm:unique-ID applied to a document node always return the empty sequence.

A document node is constructed from a Document Information Item by the infoitem-to-document-node function:

/* Accessors for document information items: */ function infoset-document-children(DocumentItem $ii) returns (ElementItem | ProcessingInstructionItem | CommentItem | DocTypeItem)* function infoset-document-base-uri(DocumentItem $ii) returns xs:anyURI

define function infoitem-to-document-node(DocumentItem $ii) returns DocumentNode { let $kids:= collapse-text-nodes(sequence-map(infoitem-to-node, infoset-document-children($ii))) return dm:document-node(infoset-document-base-uri($ii), $kids) }

The collapse-text-nodes function synthesizes a single text node from multiple text nodes. The sequence-map function applies its first function argument to each member of its second sequence argument and returns a new sequence containing the result of applying the function to each member of the sequence. In the pseudo-code above, infoitem-to-node is applied to each child of the document information item $ii and a new sequence of children nodes is constructed, each of which is a Node. The constructor dm:document-node constructs the document node in the data model.

function sequence-map(function $map, Item* $seq) returns Item*

The infoitem-to-node function maps an information item to a sequence of zero or one node.

define function infoitem-to-node(InfoItem $ii) returns Node? { return if (infoitem-kind($ii) = "element") then infoitem-to-element-node($ii) else if (infoitem-kind($ii) = "character") then infoitem-to-single-character-text-node($ii) else if (infoitem-kind($ii) = "processing-instruction") then if (not(ignore-processing-instructions)) then infoitem-to-processing-instruction-node($ii) else empty-sequence() else if (infoitem-kind($ii) = "comment") then if (not(ignore-comments)) then infoitem-to-comment-node($ii) else empty-sequence() else {-- infoitem-kind($ii) = "doctype" | "notation" | "unparsed-entity" --} empty-sequence() }

Each element node corresponds to an element information item.

An element node has an expanded-QName. The local part of the expanded-QName corresponds to the local name property. The namespace URI of the expanded-QName of the element node corresponds to the namespace name property.

The dm:parent of the element node corresponds to the node corresponding to the parent property.

An element node has an associated dm:typed-value, which is a sequence of zero or more atomic values. Examples of such values would be a sequence containing an integer, or an atomic value of some user-defined type or several dates, etc. For a document with a schema, the element's typed-value corresponds to the schema normalized value PSVI property if that exists, or the empty sequence otherwise. But if the element node has a complex type with complex content then dm:typed-value returns the error value. Furthermore, if the type of the element node is xs:anyType or xs:anySimpleType then dm:typed-value returns its string value with unknown simple type. In particular this implies the following: If an element was created with an xsi:nil attribute set to true, then its dm:typed-value is the empty sequence. For an element in a well-formed document with no associated schema, the element's dm:typed-value is its string value with unknown simple type. See .

The dm:children of the element node correspond to the element, comment, processing instruction, and character information items appearing in the children property. This correspondence is not one-to-one, as consecutive character information item children are coalesced into a single text node. Because the data model requires that all general entities be expanded, there will never be unexpanded entity reference information item children.

The dm:attributes of the element node are nodes corresponding to attribute information items appearing in the attributes property. The attributes of an element always have distinct names.

The dm:namespaces of the element node are nodes corresponding to namespace information items appearing in the in-scope namespaces property. The namespaces of an element always have distinct prefixes. See .

The dm:type of an element is an xs:QName and its namespace and local name correspond to the following:

It is noted that if the type referenced would be a union type then type refers to the member type that actually validated the schema normalized value. See .

The unique ID of the element node is an identifier optionally assigned by the user. It corresponds to the normalized value property of the attribute information item in the attributes property that has a type ID, if one exists.

An element node can be constructed in one of two ways: dm:element-node is useful for constructing an element from the PSVI, dm:element-node-atomic is useful when constructing an element via embedded expressions. The difference in the constructors is whether the children of the node are specified as a sequence of nodes or as a sequence of atomic values.

The constructor dm:element-node takes an expanded-QName, a sequence of namespace nodes, a sequence of attribute nodes, a sequence of child nodes, and the node's type.

function dm:element-node( xs:QName $qname, NamespaceNode* $nsnodes, AttributeNode* $attrnodes, (ElementNode | TextNode | ProcessingInstructionNode | CommentNode)* $children, xs:QName $type) returns ElementNode

The constructor dm:element-node-atomic takes an expanded-QName, a sequence of namespace nodes, a sequence of attribute nodes, a sequence of atomic values, and the node's type.

function dm:element-node-atomic( xs:QName $qname, NamespaceNode* $nsnodes, AttributeNode* $attrnodes, AtomicValue* $values, xs:QName $type) returns ElementNode

Like all other node constructors, the element node constructors has the effect of creating a new node with a unique identity, distinct from all other nodes.

To guarantee that the parent-child relationship is invertible, the element constructors logically create a copy of all of their namespace, attribute, and children arguments and set the parent property of these nodes to the newly created element node. As long as the parent-child constraint is satisfied, an implementation of the data model may choose to use specialized techniques to avoid creating physical copies of the arguments to an element constructor. See .

Neither constructor allows specifying the children of the node as a heterogeneous sequence, i.e. a sequence mixing nodes and atomic values. It is still possible to construct an element (with mixed content) from such a sequence in two steps: First the heterogeneous sequence will need to be turned into a homogeneous one by converting the atomic values to text nodes, then the now homogeneous sequence can be passed to the element-node constructor. Note that the precise type information of the atomic values is lost in the process, which is inline with XML Schema, that cannot represent the type of such mixed content.

The accessors dm:name, dm:namespaces, dm:attributes and dm:type return an element node's constituent parts. The dm:children accessor returns the sequence of children nodes for an element node if it was created with dm:element-node and it returns a singleton sequence containing a text node corresponding to the sequence of atomic values if it was created with dm:element-node-atomic. The string value of the text node in the latter case is the string value of the sequence of atomic values, which is obtained by inserting a #x20 (space) separator between the dm:string-values of the individual atomic values and concatenating the result (as defined in ). See .

function dm:name(ElementNode $n) returns xs:QName function dm:namespaces(ElementNode $n) returns NamespaceNode* function dm:attributes(ElementNode $n) returns AttributeNode* function dm:children(ElementNode $n) returns (ElementNode | TextNode | ProcessingInstructionNode | CommentNode)* function dm:type(ElementNode $n) returns xs:QName

The accessor function dm:typed-value returns a sequence of zero or more atomic values. If the element was created with dm:element-node, dm:typed-value corresponds to the schema normalized value PSVI property if that exists, or the empty sequence otherwise. But if the element node has a complex type with complex content then dm:typed-value returns the error value. Furthermore, if the type of the element node is xs:anyType or xs:anySimpleType then dm:typed-value returns its string value with unknown simple type. If the element was created with dm:element-node-atomic, dm:typed-value returns the sequence of atomic values that were used to construct the element.

function dm:typed-value(ElementNode $n) returns AtomicValue*

The dm:string-value of an element node returns the concatenation of the string-values of all text-node descendants of the element node in document order if it was created with dm:element-node and it returns the string representation of the sequence of atomic values if it was created with dm:element-node-atomic. See .

function dm:string-value(ElementNode $n) returns xs:string

If an element has a unique ID, the accessor function dm:unique-ID returns a sequence containing the unique ID of the node; otherwise, it returns the empty sequence.

function dm:unique-ID(ElementNode $n) returns xs:ID?

The node accessors dm:base-uri, dm:node-kind, dm:parent, and dm:string-value also apply to element nodes.

An element node is constructed from an Element Information Item by the infoitem-to-element-node function:

/* Accessors for element information items: */ function infoset-element-namespace-name(ElementItem $ii) returns xs:anyURI? function infoset-element-local-name(ElementItem $ii) returns xs:string function infoset-element-children(ElementItem $ii) returns InfoItem* function infoset-element-attributes(ElementItem $ii) returns AttributeItem* function infoset-element-in-scope-namespaces(ElementItem $ii) returns NamespaceItem* function infoset-element-base-uri(ElementItem $ii) returns xs:anyURI function psvi-element-validity(ElementItem $ii) returns xs:string function psvi-element-type-definition(ElementItem $ii) returns ElementItem function psvi-element-schema-normalized-value(ElementItem $ii) returns xs:string

define function infoitem-to-element-node(ElementItem $ii) returns ElementNode { let $qname:= xf:QName-from-uri(infoset-element-namespace-name($ii), infoset-element-local-name($ii)), $nsnodes:= sequence-map(infoitem-to-namespace-node, infoset-element-in-scope-namespaces($ii)), $attrnodes:= sequence-map(infoitem-to-attribute-node, infoset-element-attributes($ii)), $kids:= collapse-text-nodes(sequence-map( infoitem-to-node, infoset-element-children($ii))), $type:= infoitem-to-type($ii) return dm:element-node($qname, $nsnodes, $attrnodes, $kids, $type) }

Each element node has an associated set of attribute nodes, each corresponding to an attribute information item.

An attribute node has an expanded-QName. The local part of the expanded-QName corresponds to the local name property. The namespace name of the expanded-QName corresponds to the namespace name property.

An attribute node has an associated dm:string-value, which corresponds to the normalized value property.

An attribute node also has a dm:typed-value. For a document with a schema, the attribute's typed-value corresponds to the schema normalized value PSVI property. But if the type of the attribute node is xs:anySimpleType then dm:typed-value returns its string value with unknown simple type.

For convenience, the element node is called the "parent" of each of these attribute nodes even though an attribute node is not a "child" of its parent element. The dm:parent of the attribute node corresponds to the owner element property.

The dm:type of an attribute is an xs:QName and its namespace and local name correspond to the following:

It is noted that if the type referenced would be a union type then type refers to the member type that actually validated the schema normalized value.

An attribute node can be constructed in one of two ways: dm:attribute-node is useful for constructing an attribute from the PSVI, dm:attribute-node-atomic is useful when constructing an attribute with embedded expressions.

The constructor dm:attribute-node takes the attribute's name, a string value and the attribute's type.

function dm:attribute-node(xs:QName $qname, xs:string $value, xs:QName $type) returns AttributeNode

The constructor dm:attribute-node-atomic takes the attribute's name, a list of atomic values and the attribute's type.

function dm:attribute-node-atomic(xs:QName $qname, AtomicValue* $value, xs:QName $type) returns AttributeNode

Like all other node constructors, the attribute node constructors have the effect of creating a new node with a unique identity, distinct from all other nodes.

The accessors dm:name and dm:type return an attribute's constituent parts. The accessor dm:string-value returns an attribute's constituent part if it was created with dm:attribute-node and it returns the string representation of the sequence of atomic values if it was created with dm:attribute-node-atomic. The accessor function dm:typed-value returns a sequence of the atomic values of an attribute. In particular if the type of the attribute node is xs:anySimpleType then dm:typed-value returns its string value with unknown simple type.

function dm:name(AttributeNode $n) returns xs:QName function dm:string-value(AttributeNode $n) returns xs:string function dm:type(AttributeNode $n) returns xs:QName function dm:typed-value(AttributeNode $n) returns AtomicValue*

The node accessors dm:node-kind and dm:parent also apply to attribute nodes and may return results other than the empty sequence. The accessors dm:base-uri, dm:children, dm:attributes, dm:namespaces and dm:unique-ID applied to an attribute node always return the empty sequence.

An attribute node is constructed from an Attribute Information Item by the infoitem-to-attribute-node function:

/* Accessors for attribute information items: */ function infoset-attribute-namespace-name(AttributeItem $ii) returns xs:anyURI? function infoset-attribute-local-name(AttributeItem $ii) returns xs:string function infoset-attribute-normalized-value(AttributeItem $ii) returns xs:string function infoset-attribute-owner-element(AttributeItem $ii) returns ElementItem function psvi-attribute-validity(AttributeItem $ii) returns xs:string function psvi-attribute-type-definition(AttributeItem $ii) returns ElementItem function psvi-attribute-schema-normalized-value(AttributeItem $ii) returns xs:string

define function infoitem-to-attribute-node(AttributeItem $ii) returns AttributeNode { let $qname:= xf:QName-from-uri(infoset-attribute-namespace-name($ii), infoset-attribute-local-name($ii)), $type:= infoitem-to-type($ii) return dm:attribute-node($qname, infoset-attribute-normalized-value($ii), $type) }

Each element node has an associated set of namespace nodes, each corresponding to a namespace information item.

A namespace node has an expanded-QName. The local part of the QName corresponds to the prefix property. The namespace URI of the QName is the empty sequence.

The dm:string-value of the namespace node corresponds to the namespace name property.

A namespace node has no dm:parent.

A namespace node has the constructor dm:namespace-node, which takes a namespace prefix and the absolute URI of the namespace being declared. The namespace prefix may be the empty sequence. If the URI is the zero-length string, the prefix must be the empty sequence. Like all other node constructors, the namespace node constructor has the effect of creating a new node with a unique identity, distinct from all other nodes.

function dm:namespace-node(xs:string? $prefix, xs:string $uri) returns NamespaceNode

A namespace node's constituent parts may be obtained by applying the accessors dm:name (with the function xf:get-local-name) and dm:string-value.

function dm:name(NamespaceNode $n) returns xs:QName? function dm:string-value(NamespaceNode $n) returns xs:string

The node accessor dm:node-kind also applies to namespace nodes and returns a result other than the empty sequence. The accessors dm:base-uri, dm:typed-value, dm:parent, dm:children, dm:attributes, dm:namespaces, dm:type and dm:unique-ID applied to a namespace node always return the empty sequence.

A namespace node is constructed from a Namespace Information Item by the infoitem-to-namespace-node function:

function infoset-namespace-prefix(NamespaceItem $ii) returns xs:string? function infoset-namespace-namespace-name(NamespaceItem $ii) returns xs:string

define function infoitem-to-namespace-node(NamespaceItem $ii) returns NamespaceNode { return dm:namespace-node(infoset-namespace-prefix($ii), infoset-namespace-namespace-name($ii)) }

A processing instruction node corresponds to a processing instruction information item. There are no processing instruction nodes for processing instructions that are children of a document type declaration information item.

A processing instruction node has an expanded-QName. The local part of the expanded-QName corresponds to the target property. The namespace URI of the expanded-QName is the empty sequence. The local part is a string value that must be an NCName.

The string '?>' may not occur within a processing instruction's target value ().

The dm:string-value of the processing instruction node corresponds to the content property.

The dm:parent of the processing instruction node corresponds to the parent property.

A processing-instruction node has the constructor dm:processing-instruction-node, which takes an NCName representing the target and a string representing the content. Like all other node constructors, the processing node constructor has the effect of creating a new node with a unique identity, distinct from all other nodes.

function dm:processing-instruction-node(xs:NCName $target, xs:string $content) returns ProcessingInstructionNode

A processing instruction's constituent parts may be obtained by applying the accessors dm:name (with the function xf:get-local-name) and dm:string-value.

function dm:name(ProcessingInstructionNode $n) returns xs:QName function dm:string-value(ProcessingInstructionNode $n) returns xs:string

The node accessors dm:node-kind and dm:parent also apply to processing-instruction nodes and may return results other than the empty sequence. The accessors dm:base-uri, dm:typed-value, dm:children, dm:attributes, dm:namespaces, dm:type and dm:unique-ID applied to a processing-instruction node always return the empty sequence.

A processing-instruction node is constructed from an Processing Instruction Information Item by the infoitem-to-processing-instruction-node function:

/* Accessors for processing instruction information items */ function infoset-processing-instruction-target(ProcessingInstructionItem $ii) returns xs:string function infoset-processing-instruction-content(ProcessingInstructionItem $ii) returns xs:string

define function infoitem-to-processing-instruction-node(ProcessingInstructionItem $ii) returns ProcessingInstructionNode { return dm:processing-instruction-node( xf:NCName(infoset-processing-instruction-target($ii)), infoset-processing-instruction-content($ii)) }

A comment node corresponds to a comment information item. There are no comment nodes for comments that are children of a document type declaration information item.

A comment node does not have an expanded-QName.

The dm:string-value of the comment node corresponds to the content property.

The dm:parent of the comment node corresponds to the parent property.

The string "--" (double-hyphen) must not occur within a comment's string value ().

A comment node has the constructor dm:comment-node, which takes a string value. Like all other node constructors, the comment node constructor has the effect of creating a new node with a unique identity, distinct from all other nodes.

function dm:comment-node(xs:string $content) returns CommentNode

A comment node's constituent parts may be obtained by applying the accessor dm:string-value.

function dm:string-value(CommentNode $n) returns xs:string

The node accessors dm:node-kind and dm:parent also apply to comment nodes and may return results other than the empty sequence. The accessors dm:name, dm:base-uri, dm:typed-value, dm:children, dm:attributes, dm:namespaces, dm:type and dm:unique-ID applied to a comment node always return the empty sequence.

A comment node is constructed from a Comment Information Item by the infoitem-to-comment-node function:

/* Accessors for comment information items */ function infoset-comment-value(CommentItem $ii) returns xs:string

define function infoitem-to-comment-node(CommentItem $ii) returns CommentNode { return dm:comment-node(infoset-comment-value($ii)) }

A text node corresponds to a sequence of one or more consecutive character information items. As much character data as possible is grouped into each text node: a text node never has an immediately following or preceding sibling that is a text node.

A text node does not have an expanded-QName.

The dm:string-value of a text node is the character data, which corresponds to the concatenated character code properties of each of the character information items.

The dm:parent of the text node corresponds to the parent property of any one of the consecutive character information items (consecutive characters always have the same parent).

A text node has the constructor dm:text-node and takes a string value. Like all other node constructors, the text constructor has the effect of creating a new node with a unique identity, distinct from all other nodes.

function dm:text-node(xs:string $content) returns TextNode

The dm:string-value of a text node is simply its content.

function dm:string-value(TextNode $n) returns xs:string

The dm:typed-value accessor returns the string content of the text node with unknown simple type.

define function dm:typed-value(TextNode $n) returns AtomicValue { return dm:atomic-value(dm:string-value($n),xs:anySimpleType) }

The node accessors dm:node-kind and dm:parent also apply to text nodes and may return results other than the empty sequence. The accessors dm:name, dm:base-uri, dm:children, dm:attributes, dm:namespaces, dm:type and dm:unique-ID applied to a text node always return the empty sequence.

The mapping from character information items to text nodes occurs in the infoitem-to-element-node function. The infoset-character-code accessor maps a character information item to the ISO 10646 character code (in the range 0 to #x10FFFF, though not every value in this range is a legal XML character code) of the character.

function infoset-character-code(CharacterItem $ii) returns Code

The function infoitem-to-single-character-text-node takes one character information item and maps it to a text node with a string value of length one.

define function infoitem-to-single-character-text-node(CharacterItem $ii) returns TextNode { {-- convert character code to string of length 1 --} return dm:text-node(code2string(infoset-character-code($ii))) }

The collapse-text-nodes function synthesizes a single text node from multiple text nodes. It calls infoitem-to-text-nodes to collapse recursively one or more consecutive text nodes in its argument sequence. If insignificant whitespace is ignored, any text node containing only whitespace is eliminated. All other nodes are returned unchanged.

define function collapse-text-nodes(Node* $nodes) returns Node* { let $newnodes:= infoitem-to-text-nodes($nodes) return if (ignore-whitespace) then sequence-map(delete-whitespace-node, $newnodes) else $newnodes } define function infoitem-to-text-nodes(Node* $nodes) returns Node* { if (xf:empty($nodes)) then return empty-sequence() else let $head:= op:item-at($nodes, 1), $tail:= xf:sublist($nodes, 2) return if (dm:node-kind($head) = "text") then /* Collapse two consecutive text nodes and apply infoitem-to-text-nodes recursively */ if (xf:empty($tail)) then $head else if (dm:node-kind(op:item-at($tail,1)) = "text") then infoitem-to-text-nodes( op:concatenate( dm:text-node(xf:concat(dm:string-value($head), dm:string-value(op:item-at($tail,1)))), xf:sublist($tail, 2) ) ) else op:concatenate($head, op:concatenate(op:item-at($tail,1), infoitem-to-text-nodes($tail))) else op:concatenate($head, infoitem-to-text-nodes($tail)) }