Document nodes encapsulate XML documents. The information associated with a document node includes the following.

The above information associated with a document node is set during construction and can be accessed later via the accessor functions.

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

A document node can be constructed using dm:document-node. The constructor takes a base URI value and a non-empty sequence of children nodes as arguments.

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

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.

The accessors dm:base-uri and dm:children return the values passed to the constructor as arguments.

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

The accessor dm:node-kind returns the string "document". The accessor dm:string-value returns the string-value of the document which is defined to be the concatenation of the string-values of all text-node descendants of the document node in document order.

function dm:node-kind(DocumentNode $n) returns xs:string function dm:string-value(DocumentNode $n) returns xs:string

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.

When a data model fragment is created from the PSVI a document information item is mapped to a Document Node. The precise transformation is described by specifying the PSVI property corresponding to each argument of the document node constructor.

The base-uri argument corresponds to the base URI property.

The children argument corresponds to the information items found in the children property, omitting any document type declaration information items.

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 empty-sequence() }

The mapping of the data model to the XML Information Set maps a Document Node to a document information item. Given a Document Node $n, the properties of the corresponding document information item are specified as follows:

The values of the properties character encoding scheme, standalone, version and all declarations processed are implementation-defined but must be consistent with the rest of the InfoItem properties.

Since Document Nodes are permissive, (for instance allow zero or more than one element node children or allow text node children) the mapping via dm:node-to-infoitem() may not produce a valid InfoSet.

Element nodes encapsulate XML elements. The information associated with an element node includes the following.

The above information associated with an element node is set during construction and can be accessed later via the accessor functions.

Element nodes must satisfy the following constraints.

Due to the definition of the element node constructor the first two constraints above are automatically satisfied .

An element node can be constructed using dm:element-node. The constructor takes an expanded-QName, a sequence of namespace nodes, a sequence of attribute nodes, a sequence of child nodes, and the node's type as arguments.

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

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

If consecutive text nodes are specified as the children of an element node they are collapsed into one text node whose string value is the concatenation of the string values of the consecutive text nodes.

To guarantee that the parent-child relationship is invertible, (i.e. that the parent of any child of a node is itself and that any node that has a parent is among its parent's children), 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 .

The data model permits element nodes without parents. In fact element nodes created by the element node constructor never have parents unless they are enclosed in other node constructors. Such nodes may represent partial results during expression processing.

The accessors return information associated with an element node. Some accessors simply return the values that were passed in as arguments to the constructor, while others return values that are derived from the information associated with the element node. The accessors dm:name, dm:namespaces, dm:attributes, dm:children and dm:type are examples of the former kind.

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 | ProcessingInstructionNode | CommentNode | TextNode)* function dm:type(ElementNode $n) returns xs:QName

The accessor dm:node-kind returns the string constant "element". The accessor dm:parent returns a sequence containing zero or one nodes representing the parent of the element node. The accessor dm:base-uri returns a sequence containing zero or one uri references representing the base URI of the element node. The accessor dm:unique-ID returns a sequence containing the unique ID of the element if it has one; otherwise, it returns the empty sequence.

function dm:node-kind(ElementNode $n) returns xs:string function dm:parent(ElementNode $n) returns (ElementNode | DocumentNode)? function dm:base-uri(ElementNode $n) returns xs:anyURI? function dm:unique-ID(ElementNode $n) returns xs:ID?

The accessor dm:string-value returns the string-value of the element which is defined to be the concatenation of the string-values of all text-node descendants of the element node in document order.

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

The accessor function dm:typed-value returns the typed-value of the node, which is a sequence of zero or more atomic values. The typed-value is closely related to the node's string-value and its type. For instance when the node's string-value is "3.14" and its type is xs:decimal the typed-value is a sequence containing the atomic value 3.14 of type decimal. In fact, when the type is an atomic type, typed-value is the atomic-value constructed from the string-value and the type. In the general case typed-value is defined via the function dm:atomic-value-sequence, which constructs a sequence of atomic values from a string and a type, in such a way to be consistent with validation.

define function dm:typed-value(ElementNode $n) returns AtomicValue* { return dm:atomic-value-sequence(dm:string-value($n), dm:type($n)) }

It is noted that when the element node's type is xs:anyType then dm:typed-value returns the node's string-value as xs:anySimpleType. If the type is a complex type with complex content then invoking dm:typed-value raises an error.

When a data model fragment is created from the PSVI an element information item is mapped to an Element Node. The precise transformation is described by specifying the PSVI property corresponding to each argument of the element node constructor.

The expanded-QName of the element is obtained as follows. Its local part corresponds to the local name property. Its namespace URI corresponds to the namespace name property.

The children of the element node correspond to the following:

Because the data model requires that all general entities be expanded, there will never be unexpanded entity reference information item children. See .

The attributes of the element node are nodes corresponding to attribute information items appearing in the attributes property. See .

The namespaces of the element node are nodes corresponding to namespace information items appearing in the in-scope namespaces property. See .

The type of an element is an expanded-QName whose namespace and local name is computed as described in . 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 . For an element in a well-formed document with no associated schema, type corresponds to xs:anyType. Consequently the typed-value of such an element is its string value as an instance of xs:anySimpleType.

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

The mapping of the data model to the XML Information Set maps an Element Node to an element information item. Given an Element Node $n, the properties of the corresponding element information item are specified as follows:

The value of the property namespace attributes is computed based on the difference of the namespaces of this element node and its parent's. This property contains a namespace attribute information item for each namespace that occurs in dm:namespaces($n), but not in dm:namespaces(dm:parent($n)). In addition, this property also contains a namespace attribute information item corresponding to xmlns="", if dm:namespaces(dm:parent($n)) contains a namespace node for the empty prefix, but dm:namespaces($n) does not.

Attribute nodes encapsulate XML attributes. The information associated with an attribute node includes the following.

The above information associated with an attribute node is set during construction and can be accessed later via the accessor functions.

For convenience, the element node that owns this attribute is called its "parent" even though an attribute node is not a "child" of its parent element.

An attribute node can be constructed using dm:attribute-node. The constructor takes the attribute's expanded-QName, string value and type.

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

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

The accessors dm:name, dm:string-value and dm:type return the values passed to the constructor as arguments.

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

The accessor dm:node-kind returns the string constant "attribute". The accessor dm:parent returns a sequence containing zero or one element nodes representing the parent of the attribute node.

function dm:node-kind(AttributeNode $n) returns xs:string function dm:parent(AttributeNode $n) returns ElementNode?

The accessor function dm:typed-value returns the typed-value of the node, which is a sequence of zero or more atomic values. The typed-value is closely related to the node's string-value and its type. It is defined via the function dm:atomic-value-sequence, which constructs a sequence of atomic values from a string and a type, in such a way to be consistent with validation. In particular when the type is an atomic type, typed-value is the atomic-value constructed from the string-value and the type. When the type of the attribute is xs:anySimpleType then dm:typed-value returns its string value as xs:anySimpleType.

define function dm:typed-value(AttributeNode $n) returns AtomicValue* { return dm:atomic-value-sequence(dm:string-value($n), dm:type($n)) }

The accessors dm:base-uri, dm:attributes, dm:children, dm:namespaces and dm:unique-ID applied to an attribute node always return the empty sequence.

When a data model fragment is created from the PSVI an attribute information item is mapped to an Attribute Node. The precise transformation is described by specifying the PSVI property corresponding to each argument of the attribute node constructor.

The expanded-QName of the attribute is obtained as follows. Its local part corresponds to the local name property. Its namespace URI corresponds to the namespace name property.

The string value of the attribute node corresponds to the following:

The type of an attribute is an expanded-QName whose namespace and local name is computed as described in . 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. For an attribute in a well-formed document with no associated schema, type corresponds to xs:anySimpleType. Consequently the typed-value of such an attribute is its string value as an instance of xs:anySimpleType.

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

The mapping of the data model to the XML Information Set maps an Attribute Node to an attribute information item. Given an Attribute Node $n, the properties of the corresponding attribute information item are specified as follows:

The values of the properties specified, attribute type and references are implementation-defined.

Namespace nodes encapsulate XML namespaces. The information associated with a namespace node includes the following.

The above information associated with a namespace node is set during construction and can be accessed later via the accessor functions.

Each element node has an associated set of namespace nodes corresponding to its in-scope namespaces.

A namespace node has no 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

The accessor dm:name returns the namespace prefix as the local-part of an xs:QName (whose namespace URI is the empty sequence). The accessor dm:string-value returns the namespace uri as an xs:string.

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

The accessor dm:node-kind returns the string constant "namespace".

function dm:node-kind(NamespaceNode $n) returns xs:string

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.

When a data model fragment is created from the PSVI a namespace information item is mapped to a Namespace Node. The precise transformation is described by specifying the PSVI property corresponding to each argument of the attribute node constructor.

The prefix argument corresponds to the prefix property.

The uri argument corresponds to the namespace name property.

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

The mapping of the data model to the XML Information Set maps a Namespace Node to a namespace information item. Given a Namespace Node $n, the properties of the corresponding namespace information item are specified as follows:

Processing instruction nodes encapsulate XML processing instructions. The information associated with a processing instruction node includes the following.

The above information associated with a processing instruction node is set during construction and can be accessed later via the accessor functions.

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

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

The accessor dm:name returns the target of the processing instruction as the local-part of an xs:QName (whose namespace URI is the empty sequence). The accessor dm:string-value returns the content of the processing instruction as an xs:string.

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

The accessor dm:node-kind returns the string constant "processing-instruction". The accessor dm:parent returns a sequence containing zero or one element or document node representing the parent of the processing instruction node.

function dm:node-kind(ProcessingInstructionNode $n) returns xs:string function dm:parent(ProcessingInstructionNode $n) returns (ElementNode | DocumentNode)?

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.

When a data model fragment is created from the PSVI a processing instruction information item is mapped to a Processing Instruction Node. The precise transformation is described by specifying the PSVI property corresponding to each argument of the processing instruction node constructor. There are no processing instruction nodes for processing instructions that are children of a document type declaration information item.

The target argument of the processing instruction constructor corresponds to the target property.

The content argument corresponds to the content property.

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

The mapping of the data model to the XML Information Set maps a Processing Instruction Node to a processing instruction information item. Given a Processing Instruction Node $n, the properties of the corresponding processing instruction information item are specified as follows:

Comment nodes encapsulate XML comments. The information associated with a comment node includes the following.

The above information associated with a comment node is set during construction and can be accessed later via the accessor functions.

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

The accessor dm:string-value return the value passed to the constructor as the argument.

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

The accessor dm:node-kind returns the string constant "comment". The accessor dm:parent returns a sequence containing zero or one element or document node representing the parent of the comment node.

function dm:node-kind(CommentNode $n) returns xs:string function dm:parent(CommentNode $n) returns (ElementNode | DocumentNode)?

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.

When a data model fragment is created from the PSVI a comment information item is mapped to a Comment Node. The precise transformation is described by specifying the PSVI property corresponding to the argument of the comment node constructor. There are no comment nodes for comments that are children of a document type declaration information item.

The content argument of the comment constructor corresponds to the content property.

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

The mapping of the data model to the XML Information Set maps a Comment Node to a comment information item. Given a Comment Node $n, the properties of the corresponding comment information item are specified as follows:

Text nodes encapsulate consecutive XML character data. The information associated with a text node includes the following.

The above information associated with a text node is set during construction and can be accessed later via the accessor functions.

Text nodes must satisfy the following constraints.

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 accessor dm:string-value return the value passed to the constructor as the argument.

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

The dm:typed-value accessor returns the string-value of the text node as xs:anySimpleType.

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

The accessor dm:node-kind returns the string constant "text". The accessor dm:parent returns a sequence containing zero or one element or document node representing the parent of the comment node.

function dm:node-kind(TextNode $n) returns xs:string function dm:parent(TextNode $n) returns (ElementNode | DocumentNode)?

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.

When a data model fragment is created from the PSVI a sequence of one or more consecutive character information items are mapped to a Text Node. 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. The precise transformation is described by specifying the PSVI property corresponding to the argument of the comment node constructor.

The content argument of the text node is the character data, which corresponds to the concatenated character code properties of each of the character information items.

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:subsequence($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:subsequence($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)) }

The mapping of the data model to the XML Information Set maps a Text Node to a sequence of character information items. Given a Text Node $n, the properties of the i^th character information items in the sequence are specified as follows (for $i = 1, 2, ..., xf:string-length(dm:string-value())):