Type Definition xml_dom::level2::RefNode

type RefNode = RcRefCell<NodeImpl>;

Opaque DOM tree node reference. This is the type used by this implementation as the concrete type for the NodeRef associated type in the Node trait.

This is the common response type for DOM actions and can be cast to specific traits either by-hand or using the xml_dom::convert module. Also, note that this type supportsPartialEq and so two nodes can be tested to ensure they are the same.

Trait Implementations

impl Attribute for RefNode

fn value(&self) -> Option<String>

On retrieval, the value of the attribute is returned as a string.

fn set_value(&mut self, value: &str) -> Result<()>

Set the value for the node; see value.

fn unset_value(&mut self) -> Result<()>

Set the value for the node to None; see value.

fn owner_element(&self) -> Option<Self::NodeRef>

The Element node this attribute is attached to or null if this attribute is not in use.

fn specified(&self) -> bool

If this attribute was explicitly given a value in the original document, this is true; otherwise, it is false.

impl CDataSection for RefNode

impl CharacterData for RefNode

fn substring_data(&self, offset: usize, count: usize) -> Result<String>

Extracts a range of data from the node.

fn append_data(&mut self, new_data: &str) -> Result<()>

Append the string to the end of the character data of the node.

fn insert_data(&mut self, offset: usize, new_data: &str) -> Result<()>

Insert a string at the specified 16-bit unit offset.

fn delete_data(&mut self, offset: usize, count: usize) -> Result<()>

Remove a range of 16-bit units from the node. Upon success, data and length reflect the change.

fn replace_data(
    &mut self,
    offset: usize,
    count: usize,
    replace_data: &str
) -> Result<()>

Replace the characters starting at the specified 16-bit unit offset with the specified string.

fn length(&self) -> usize

The number of 16-bit units that are available through data and the substringData method below. This may have the value zero, i.e., CharacterData nodes may be empty.

fn data(&self) -> Option<String>

The character data of the node that implements this interface.

fn set_data(&mut self, data: &str) -> Result<()>

Set the data for the node; see data().

fn unset_data(&mut self) -> Result<()>

Set the data for the node to None; see data().

impl Comment for RefNode

impl Display for RefNode

fn fmt(&self, f: &mut Formatter) -> FmtResult

Formats the value using the given formatter.

impl Document for RefNode

fn doc_type(&self) -> Option<RefNode>

The Document Type Declaration (see DocumentType) associated with this document.

fn document_element(&self) -> Option<RefNode>

This is a convenience attribute that allows direct access to the child node that is the root element of the document.

fn implementation(&self) -> &dyn DOMImplementation<NodeRef = RefNode>

The DOMImplementation object that handles this document.

fn create_attribute(&self, name: &str) -> Result<RefNode>

Creates an Attribute of the given name. Note that the Attr instance can then be set on an Element using the setAttributeNode method.

fn create_attribute_with(&self, name: &str, value: &str) -> Result<RefNode>

Implementation defined extension: this is the same as create_attribute except that it also sets the attribute value.

fn create_attribute_ns(
    &self,
    namespace_uri: &str,
    qualified_name: &str
) -> Result<RefNode>

Creates an attribute of the given qualified name and namespace URI.

fn create_cdata_section(&self, data: &str) -> Result<RefNode>

Creates a CDataSection node whose value is the specified string.

fn create_document_fragment(&self) -> Result<RefNode>

Creates an empty DocumentFragment object.

fn create_entity_reference(&self, name: &str) -> Result<RefNode>

Creates an EntityReference object.

fn create_comment(&self, data: &str) -> RefNode

Creates a Comment node given the specified string.

fn create_element(&self, tag_name: &str) -> Result<RefNode>

Creates an element of the type specified.

fn create_element_ns(
    &self,
    namespace_uri: &str,
    qualified_name: &str
) -> Result<RefNode>

Creates an element of the given qualified name and namespace URI.

fn create_processing_instruction(
    &self,
    target: &str,
    data: Option<&str>
) -> Result<RefNode>

Creates a ProcessingInstruction node given the specified name and data strings.

fn create_text_node(&self, data: &str) -> RefNode

Creates a Text node given the specified string.

fn get_element_by_id(&self, id: &str) -> Option<RefNode>

Returns the Element whose ID is given by elementId.

fn get_elements_by_tag_name(&self, tag_name: &str) -> Vec<RefNode>

Returns a NodeList of all the Elements with a given tag name in the order in which they are encountered in a preorder traversal of the Document tree.

fn get_elements_by_tag_name_ns(
    &self,
    namespace_uri: &str,
    local_name: &str
) -> Vec<RefNode>

Returns a NodeList of all the Elements with a given local name and namespace URI in the order in which they are encountered in a preorder traversal of the Document tree.

impl DocumentDecl for RefNode

fn xml_declaration(&self) -> Option<XmlDecl>

Retrieve the current XML declaration, if set.

fn set_xml_declaration(&mut self, xml_decl: XmlDecl) -> Result<()>

Set the current XML declaration for this document.

impl DocumentFragment for RefNode

impl DocumentType for RefNode

fn entities(&self) -> HashMap<Name, Self::NodeRef, RandomState>

A NamedNodeMap containing the general entities, both external and internal, declared in the DTD. Parameter entities are not contained. Duplicates are discarded. For example in:

fn notations(&self) -> HashMap<Name, Self::NodeRef, RandomState>

A NamedNodeMap containing the notations declared in the DTD. Duplicates are discarded. Every node in this map also implements the Notation interface.

fn public_id(&self) -> Option<String>

The public identifier of the external subset.

fn system_id(&self) -> Option<String>

The system identifier of the external subset.

fn internal_subset(&self) -> Option<String>

The internal subset as a string.

impl Element for RefNode

fn get_attribute(&self, name: &str) -> Option<String>

Retrieves an attribute value by name.

fn set_attribute(&mut self, name: &str, value: &str) -> Result<()>

Adds a new attribute.

fn remove_attribute(&mut self, name: &str) -> Result<()>

Removes an attribute by name. If the removed attribute is known to have a default value, an attribute immediately appears containing the default value as well as the corresponding namespace URI, local name, and prefix when applicable.

fn get_attribute_node(&self, name: &str) -> Option<RefNode>

Retrieves an attribute node by name.

fn set_attribute_node(&mut self, new_attribute: RefNode) -> Result<RefNode>

Adds a new attribute node.

fn remove_attribute_node(&mut self, old_attribute: RefNode) -> Result<RefNode>

Removes the specified attribute node.

fn get_elements_by_tag_name(&self, tag_name: &str) -> Vec<RefNode>

Returns a NodeList of all descendant Elements with a given tag name, in the order in which they are encountered in a preorder traversal of this Element tree.

fn get_attribute_ns(
    &self,
    namespace_uri: &str,
    local_name: &str
) -> Option<String>

Retrieves an attribute value by local name and namespace URI.

fn set_attribute_ns(
    &mut self,
    namespace_uri: &str,
    qualified_name: &str,
    value: &str
) -> Result<()>

Adds a new attribute.

fn remove_attribute_ns(
    &mut self,
    namespace_uri: &str,
    local_name: &str
) -> Result<()>

Removes an attribute by local name and namespace URI.

fn get_attribute_node_ns(
    &self,
    namespace_uri: &str,
    local_name: &str
) -> Option<RefNode>

Retrieves an Attr node by local name and namespace URI.

fn set_attribute_node_ns(&mut self, new_attribute: RefNode) -> Result<RefNode>

Adds a new attribute.

fn get_elements_by_tag_name_ns(
    &self,
    namespace_uri: &str,
    local_name: &str
) -> Vec<RefNode>

Returns a NodeList of all the descendant Elements with a given local name and namespace URI in the order in which they are encountered in a preorder traversal of this Element tree.

fn has_attribute(&self, name: &str) -> bool

Returns true when an attribute with a given name is specified on this element or has a default value, false otherwise.

fn has_attribute_ns(&self, namespace_uri: &str, local_name: &str) -> bool

Returns true when an attribute with a given local name and namespace URI is specified on this element or has a default value, false otherwise.

fn tag_name(&self) -> String

The name of the element.

impl Entity for RefNode

fn public_id(&self) -> Option<String>

The public identifier associated with the entity, if specified.

fn system_id(&self) -> Option<String>

The system identifier associated with the entity, if specified.

fn notation_name(&self) -> Option<String>

For unparsed entities, the name of the notation for the entity.

impl EntityReference for RefNode

impl Namespaced for RefNode

fn contains_mapping(&self, prefix: Option<&str>) -> bool

Returns true if this, and only this, element has a URI mapping for the provided prefix, false otherwise.

fn get_namespace(&self, prefix: Option<&str>) -> Option<String>

Returns the namespace URI associated with the provided prefix, None if the prefix is not mapped to a URI for this, and only this, element.

fn resolve_namespace(&self, prefix: Option<&str>) -> Option<String>

Returns the namespace URI associated with the provided prefix for this element by looking up the DOM tree through parent_node links. Returns None if the prefix is not mapped to a URI on this, or any parent, element.

fn contains_mapped_namespace(&self, namespace_uri: &str) -> bool

Returns true if this, and only this, element has a URI mapping for the provided namespace_uri, false otherwise.

fn get_prefix(&self, namespace_uri: &str) -> NamespacePrefix

Returns the prefix associated with the provided namespace_uri, None if the namespace URI is not mapped with a prefix for this, and only this, element.

fn resolve_prefix(&self, namespace_uri: &str) -> NamespacePrefix

Returns the prefix associated with the provided namespace_uri for this element by looking up the DOM tree through parent_node links. Returns None if the namespace is not mapped with a prefix for this, or any parent, element.

impl Node for RefNode

type NodeRef = RefNode

The opaque reference type that wraps the implementation of a node within the DOM.

fn node_name(&self) -> Name

The name of this node, depending on its type; see the table above.

fn node_value(&self) -> Option<String>

The value of this node, depending on its type; see the table above. When it is defined to be None, setting it has no effect.

fn set_node_value(&mut self, value: &str) -> Result<()>

Set the value for the node; see node_value.

fn unset_node_value(&mut self) -> Result<()>

Set the value for the node to None; see node_value.

fn node_type(&self) -> NodeType

A code representing the type of the underlying object.

fn parent_node(&self) -> Option<RefNode>

The parent of this node. All nodes, except Attr, Document, DocumentFragment, Entity, and Notation may have a parent. However, if a node has just been created and not yet added to the tree, or if it has been removed from the tree, this is None.

fn child_nodes(&self) -> Vec<RefNode>

A Vec that contains all children of this node. If there are no children, this is a Vec containing no nodes.

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

The first child of this node. If there is no such node, this returns None.

fn last_child(&self) -> Option<RefNode>

The last child of this node. If there is no such node, this returns None.

fn previous_sibling(&self) -> Option<RefNode>

The node immediately preceding this node. If there is no such node, this returns None.

fn next_sibling(&self) -> Option<RefNode>

The node immediately following this node. If there is no such node, this returns None.

fn attributes(&self) -> HashMap<Name, RefNode, RandomState>

A HashMap containing the attributes of this node (if it is an Element) or None otherwise.

fn owner_document(&self) -> Option<RefNode>

The Document object associated with this node. This is also the Document object used to create new nodes. When this node is a Document or a DocumentType which is not used with any Document yet, this is None.

fn insert_before(
    &mut self,
    new_child: RefNode,
    ref_child: Option<RefNode>
) -> Result<RefNode>

Inserts the node newChild before the existing child node refChild.

fn replace_child(
    &mut self,
    new_child: RefNode,
    old_child: RefNode
) -> Result<RefNode>

Replaces the child node oldChild with newChild in the list of children, and returns the oldChild node.

fn remove_child(&mut self, old_child: Self::NodeRef) -> Result<Self::NodeRef>

Removes the child node indicated by oldChild from the list of children, and returns it.

fn append_child(&mut self, new_child: RefNode) -> Result<RefNode>

Adds the node newChild to the end of the list of children of this node.

fn has_child_nodes(&self) -> bool

Returns whether this node has any children.

fn clone_node(&self, deep: bool) -> Option<RefNode>

Returns a duplicate of this node, i.e., serves as a generic copy constructor for nodes.

fn normalize(&mut self)

Puts all Text nodes in the full depth of the sub-tree underneath this Node, including attribute nodes, into a "normal" form where only structure (e.g., elements, comments, processing instructions, CDATA sections, and entity references) separates Text nodes, i.e., there are neither adjacent Text nodes nor empty Text nodes.

fn is_supported(&self, feature: &str, version: &str) -> bool

Tests whether the DOM implementation implements a specific feature and that feature is supported by this node.

fn has_attributes(&self) -> bool

Returns whether this node (if it is an element) has any attributes.

fn namespace_uri(&self) -> Option<String>

The namespace URI of this node, or null if it is unspecified.

fn local_name(&self) -> String

Returns the local part of the qualified name of this node.

fn prefix(&self) -> Option<String>

The namespace prefix of this node, or null if it is unspecified.

impl Notation for RefNode

fn public_id(&self) -> Option<String>

The public identifier of this notation.

fn system_id(&self) -> Option<String>

The system identifier of this notation.

impl ProcessingInstruction for RefNode

fn length(&self) -> usize

The number of 16-bit units that are available through data.

fn data(&self) -> Option<String>

The content of this processing instruction.

fn set_data(&mut self, data: &str) -> Result<()>

Set the data for the node; see data.

fn unset_data(&mut self) -> Result<()>

Set the data for the node to None; see data.

fn target(&self) -> String

The target of this processing instruction.

impl Text for RefNode

fn split(&mut self, offset: usize) -> Result<RefNode>

Breaks this node into two nodes at the specified offset, keeping both in the tree as siblings.