Trait Node

pub trait Node:
    Clone
    + PartialEq
    + Debug {
    type NodeIterator: Iterator<Item = Self>;

    // Required methods
    fn new_document() -> Self;
    fn node_type(&self) -> NodeType;
    fn name(&self) -> Rc<QualifiedName>;
    fn value(&self) -> Rc<Value>;
    fn get_id(&self) -> String;
    fn to_string(&self) -> String;
    fn to_xml(&self) -> String;
    fn to_xml_with_options(&self, od: &OutputDefinition) -> String;
    fn is_same(&self, other: &Self) -> bool;
    fn document_order(&self) -> Vec<usize>;
    fn cmp_document_order(&self, other: &Self) -> Ordering;
    fn is_id(&self) -> bool;
    fn is_idrefs(&self) -> bool;
    fn child_iter(&self) -> Self::NodeIterator;
    fn ancestor_iter(&self) -> Self::NodeIterator;
    fn owner_document(&self) -> Self;
    fn descend_iter(&self) -> Self::NodeIterator;
    fn next_iter(&self) -> Self::NodeIterator;
    fn prev_iter(&self) -> Self::NodeIterator;
    fn attribute_iter(&self) -> Self::NodeIterator;
    fn get_attribute(&self, a: &QualifiedName) -> Rc<Value>;
    fn get_attribute_node(&self, a: &QualifiedName) -> Option<Self>;
    fn new_element(&self, qn: Rc<QualifiedName>) -> Result<Self, Error>;
    fn new_text(&self, v: Rc<Value>) -> Result<Self, Error>;
    fn new_attribute(
        &self,
        qn: Rc<QualifiedName>,
        v: Rc<Value>,
    ) -> Result<Self, Error>;
    fn new_comment(&self, v: Rc<Value>) -> Result<Self, Error>;
    fn new_processing_instruction(
        &self,
        qn: Rc<QualifiedName>,
        v: Rc<Value>,
    ) -> Result<Self, Error>;
    fn new_namespace(
        &self,
        ns: Rc<Value>,
        prefix: Option<Rc<Value>>,
    ) -> Result<Self, Error>;
    fn push(&mut self, n: Self) -> Result<(), Error>;
    fn pop(&mut self) -> Result<(), Error>;
    fn insert_before(&mut self, n: Self) -> Result<(), Error>;
    fn add_attribute(&self, att: Self) -> Result<(), Error>;
    fn shallow_copy(&self) -> Result<Self, Error>;
    fn deep_copy(&self) -> Result<Self, Error>;
    fn get_canonical(&self) -> Result<Self, Error>;
    fn xmldecl(&self) -> XMLDecl;
    fn set_xmldecl(&mut self, d: XMLDecl) -> Result<(), Error>;
    fn add_namespace(&self, ns: Self) -> Result<(), Error>;
    fn namespace_iter(&self) -> Self::NodeIterator;
    fn get_dtd(&self) -> Option<DTD>;
    fn set_dtd(&self, dtd: DTD) -> Result<(), Error>;
    fn validate(&self, schema: Schema) -> Result<(), ValidationError>;

    // Provided methods
    fn to_json(&self) -> String { ... }
    fn is_element(&self) -> bool { ... }
    fn first_child(&self) -> Option<Self>
       where Self: Sized { ... }
    fn parent(&self) -> Option<Self>
       where Self: Sized { ... }
    fn eq(&self, other: &Self) -> bool { ... }
}

Nodes make up a document tree. Nodes must be fully navigable. The tree must be mutable but also stable (i.e. removing a node from the tree does not invalidate the remaining nodes).

Some nodes have names, such as elements. Some nodes have values, such as text or comments. Some have both a name and a value, such as attributes and processing instructions.

Element nodes have children and attributes.

Element nodes may have a Namespace node attached. This is the declaration of an XML Namespace. The namespace-iter() method iterates over all in-scope namespaces, which will include namespaces that are declared on ancestor elements.

Nodes must implement the PartialEq trait. This allows two (sub-)trees to be compared. The comparison is against the XML Infoset of each tree; i.e. do the trees contain the same information, but not necessarily the same string representation. For example, the order of attributes does not matter.

Required Associated Types

type NodeIterator: Iterator<Item = Self>

Required Methods

fn new_document() -> Self

Create a Document-type node. All other types of nodes are created using type-specific methods (new_element, new_text, etc).

fn node_type(&self) -> NodeType

Get the type of the node

fn name(&self) -> Rc<QualifiedName>

Get the name of the node. If the node doesn’t have a name, then returns a QualifiedName with an empty string for it’s localname. If the node is a namespace-type node, then the local part of the name is the namespace prefix. An unprefixed namespace has the empty string as its name.

fn value(&self) -> Rc<Value>

Get the value of the node. If the node doesn’t have a value, then returns a Value that is an empty string. If the node is a namespace-type node, then the value is the namespace URI.

fn get_id(&self) -> String

Get a unique identifier for this node.

fn to_string(&self) -> String

Get the string value of the node. See XPath ???

fn to_xml(&self) -> String

Serialise the node as XML

fn to_xml_with_options(&self, od: &OutputDefinition) -> String

Serialise the node as XML, with options such as indentation.

fn is_same(&self, other: &Self) -> bool

Check if two Nodes are the same Node

fn document_order(&self) -> Vec<usize>

Get the document order of the node. The value returned is relative to the document containing the node. Depending on the implementation, this value may be volatile; adding or removing nodes to/from the document may invalidate the ordering.

fn cmp_document_order(&self, other: &Self) -> Ordering

Compare the document order of this node with another node in the same document.

fn is_id(&self) -> bool

Check if a node is an XML ID

fn is_idrefs(&self) -> bool

Check if a node is an XML IDREF or IDREFS

fn child_iter(&self) -> Self::NodeIterator

An iterator over the children of the node

fn ancestor_iter(&self) -> Self::NodeIterator

An iterator over the ancestors of the node

fn owner_document(&self) -> Self

Get the document node

fn descend_iter(&self) -> Self::NodeIterator

An iterator over the descendants of the node

fn next_iter(&self) -> Self::NodeIterator

An iterator over the following siblings of the node

fn prev_iter(&self) -> Self::NodeIterator

An iterator over the preceding siblings of the node

fn attribute_iter(&self) -> Self::NodeIterator

An iterator over the attributes of an element

fn get_attribute(&self, a: &QualifiedName) -> Rc<Value>

Get an attribute of the node. Returns a copy of the attribute’s value. If the node does not have an attribute of the given name, a value containing an empty string is returned.

fn get_attribute_node(&self, a: &QualifiedName) -> Option<Self>

Get an attribute of the node. If the node is not an element returns None. Otherwise returns the attribute node. If the node does not have an attribute of the given name, returns None.

fn new_element(&self, qn: Rc<QualifiedName>) -> Result<Self, Error>

Create a new element-type node in the same document tree. The new node is not attached to the tree.

fn new_text(&self, v: Rc<Value>) -> Result<Self, Error>

Create a new text-type node in the same document tree. The new node is not attached to the tree.

fn new_attribute( &self, qn: Rc<QualifiedName>, v: Rc<Value>, ) -> Result<Self, Error>

Create a new attribute-type node in the same document tree. The new node is not attached to the tree.

fn new_comment(&self, v: Rc<Value>) -> Result<Self, Error>

Create a new comment-type node in the same document tree. The new node is not attached to the tree.

fn new_processing_instruction( &self, qn: Rc<QualifiedName>, v: Rc<Value>, ) -> Result<Self, Error>

Create a new processing-instruction-type node in the same document tree. The new node is not attached to the tree.

fn new_namespace( &self, ns: Rc<Value>, prefix: Option<Rc<Value>>, ) -> Result<Self, Error>

Create a namespace node for an XML Namespace declaration.

fn push(&mut self, n: Self) -> Result<(), Error>

Append a node to the child list

fn pop(&mut self) -> Result<(), Error>

Remove a node from the tree

fn insert_before(&mut self, n: Self) -> Result<(), Error>

Insert a node in the child list before the given node. The node will be detached from it’s current position prior to insertion.

fn add_attribute(&self, att: Self) -> Result<(), Error>

Set an attribute. self must be an element-type node. att must be an attribute-type node.

fn shallow_copy(&self) -> Result<Self, Error>

Shallow copy the node, i.e. copy only the node, but not it’s attributes or content.

fn deep_copy(&self) -> Result<Self, Error>

Deep copy the node, i.e. the node itself and it’s attributes and descendants. The resulting top-level node is unattached.

fn get_canonical(&self) -> Result<Self, Error>

Canonical XML representation of the node.

fn xmldecl(&self) -> XMLDecl

Get the XML Declaration for the document.

fn set_xmldecl(&mut self, d: XMLDecl) -> Result<(), Error>

Set the XML Declaration for the document.

fn add_namespace(&self, ns: Self) -> Result<(), Error>

Add a namespace declaration to this element-type node. NOTE: Does NOT assign a namespace to the element. The element’s name defines its namespace.

fn namespace_iter(&self) -> Self::NodeIterator

An iterator over the in-scope namespace nodes of an element. Note: These nodes are calculated at the time the iterator is created. It is not guaranteed that the namespace nodes returned will specify the current element node as their parent.

fn get_dtd(&self) -> Option<DTD>

Retrieve the internal representation of the DTD, for use in validation functions.

fn set_dtd(&self, dtd: DTD) -> Result<(), Error>

Store an internal representation of the DTD. Does not keep a copy of the original text

fn validate(&self, schema: Schema) -> Result<(), ValidationError>

Provided Methods

fn to_json(&self) -> String

Serialise the node as JSON

fn is_element(&self) -> bool

Check if a node is an element-type

fn first_child(&self) -> Option<Self>

where Self: Sized,

Get the first child of the node, if there is one

fn parent(&self) -> Option<Self>

where Self: Sized,

Get the parent of the node. Top-level nodes do not have parents, also nodes that have been detached from the tree.

fn eq(&self, other: &Self) -> bool

Compare two trees. If a non-document node is used, then the descendant subtrees are compared.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Node for RNode

type NodeIterator = Box<dyn Iterator<Item = Rc<Node>>>