mirror of
https://github.com/pocoproject/poco.git
synced 2024-12-13 18:45:10 +01:00
b0581433a7
fix: remove executable flag and change back to 100644 (was 100755) Signed-off-by: Roger Meier <r.meier@siemens.com>
288 lines
11 KiB
C++
288 lines
11 KiB
C++
//
|
|
// Node.h
|
|
//
|
|
// $Id: //poco/1.4/XML/include/Poco/DOM/Node.h#2 $
|
|
//
|
|
// Library: XML
|
|
// Package: DOM
|
|
// Module: DOM
|
|
//
|
|
// Definition of the DOM Node interface.
|
|
//
|
|
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
|
|
// and Contributors.
|
|
//
|
|
// SPDX-License-Identifier: BSL-1.0
|
|
//
|
|
|
|
|
|
#ifndef DOM_Node_INCLUDED
|
|
#define DOM_Node_INCLUDED
|
|
|
|
|
|
#include "Poco/XML/XML.h"
|
|
#include "Poco/DOM/EventTarget.h"
|
|
#include "Poco/XML/XMLString.h"
|
|
#include "Poco/SAX/NamespaceSupport.h"
|
|
|
|
|
|
namespace Poco {
|
|
namespace XML {
|
|
|
|
|
|
class NamedNodeMap;
|
|
class Document;
|
|
class NodeList;
|
|
|
|
|
|
class XML_API Node: public EventTarget
|
|
/// The Node interface is the primary datatype for the entire Document Object
|
|
/// Model. It represents a single node in the document tree. While all objects
|
|
/// implementing the Node interface expose methods for dealing with children,
|
|
/// not all objects implementing the Node interface may have children. For
|
|
/// example, Text nodes may not have children, and adding children to such
|
|
/// nodes results in a DOMException being raised.
|
|
///
|
|
/// The attributes nodeName, nodeValue and attributes are included as a mechanism
|
|
/// to get at node information without casting down to the specific derived
|
|
/// interface. In cases where there is no obvious mapping of these attributes
|
|
/// for a specific nodeType (e.g., nodeValue for an Element or attributes for
|
|
/// a Comment), this returns null. Note that the specialized interfaces may
|
|
/// contain additional and more convenient mechanisms to get and set the relevant
|
|
/// information.
|
|
///
|
|
/// This implementation differs in some ways from the W3C DOM recommendations.
|
|
/// For example, the DOM specifies that some methods can return null strings.
|
|
/// Instead of null strings, this implementation always returns empty strings.
|
|
{
|
|
public:
|
|
enum
|
|
{
|
|
ELEMENT_NODE = 1, /// The node is an Element.
|
|
ATTRIBUTE_NODE, /// The node is an Attr.
|
|
TEXT_NODE, /// The node is a Text node.
|
|
CDATA_SECTION_NODE, /// The node is a CDATASection.
|
|
ENTITY_REFERENCE_NODE, /// The node is an EntityReference.
|
|
ENTITY_NODE, /// The node is an Entity.
|
|
PROCESSING_INSTRUCTION_NODE, /// The node is a ProcessingInstruction.
|
|
COMMENT_NODE, /// The node is a Comment.
|
|
DOCUMENT_NODE, /// The node is a Document.
|
|
DOCUMENT_TYPE_NODE, /// The node is a DocumentType.
|
|
DOCUMENT_FRAGMENT_NODE, /// The node is a DocumentFragment.
|
|
NOTATION_NODE /// The node is a Notation.
|
|
};
|
|
|
|
virtual const XMLString& nodeName() const = 0;
|
|
/// Returns the name of this node, depending on its type.
|
|
|
|
const XMLString& nodeValue() const;
|
|
/// Returns the value of this node, depending on its type.
|
|
|
|
virtual const XMLString& getNodeValue() const = 0;
|
|
/// Returns the value of this node, depending on its type.
|
|
|
|
virtual void setNodeValue(const XMLString& value) = 0;
|
|
/// Sets the value of this node. Throws an exception
|
|
/// if the node is read-only.
|
|
|
|
virtual unsigned short nodeType() const = 0;
|
|
/// Returns a code representing the type of the underlying object.
|
|
|
|
virtual Node* parentNode() const = 0;
|
|
/// 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 null.
|
|
|
|
virtual NodeList* childNodes() const = 0;
|
|
/// Returns a NodeList containing all children of this node.
|
|
///
|
|
/// The returned NodeList must be released with a call
|
|
/// to release() when no longer needed.
|
|
|
|
virtual Node* firstChild() const = 0;
|
|
/// Returns the first child of this node. If there is no such
|
|
/// node, this returns null.
|
|
|
|
virtual Node* lastChild() const = 0;
|
|
/// Returns the last child of this node. If there is no such
|
|
/// node, this returns null.
|
|
|
|
virtual Node* previousSibling() const = 0;
|
|
/// Returns the node immediately preceding this node. If there
|
|
/// is no such node, this returns null.
|
|
|
|
virtual Node* nextSibling() const = 0;
|
|
/// Returns the node immediately following this node. If there
|
|
/// is no such node, this returns null.
|
|
|
|
virtual NamedNodeMap* attributes() const = 0;
|
|
/// Returns a NamedNodeMap containing the attributes of this
|
|
/// node (if it is an Element) or null otherwise.
|
|
///
|
|
/// The returned NamedNodeMap must be released with a call
|
|
/// to release() when no longer needed.
|
|
|
|
virtual Document* ownerDocument() const = 0;
|
|
/// Returns the Document object associated with this node.
|
|
/// This is also the Document object used to create new nodes.
|
|
/// When this node is a Document, this is null.
|
|
|
|
virtual Node* insertBefore(Node* newChild, Node* refChild) = 0;
|
|
/// Inserts the node newChild before the existing child node refChild.
|
|
///
|
|
/// If refChild is null, insert newChild at the end of the list of children.
|
|
/// If newChild is a DocumentFragment object, all of its children are
|
|
/// inserted in the same order, before refChild. If the newChild is already
|
|
/// in the tree, it is first removed.
|
|
|
|
virtual Node* replaceChild(Node* newChild, Node* oldChild) = 0;
|
|
/// Replaces the child node oldChild with newChild in the list of children,
|
|
/// and returns the oldChild node.
|
|
/// If newChild is a DocumentFragment object, oldChild is replaced by all of
|
|
/// the DocumentFragment children, which are inserted in the same order. If
|
|
/// the newChild is already in the tree, it is first removed.
|
|
|
|
virtual Node* removeChild(Node* oldChild) = 0;
|
|
/// Removes the child node indicated by oldChild from the list of children
|
|
/// and returns it.
|
|
|
|
virtual Node* appendChild(Node* newChild) = 0;
|
|
/// Appends the node newChild to the end of the list of children of this node.
|
|
/// If newChild is already in the tree, it is first removed.
|
|
|
|
virtual bool hasChildNodes() const = 0;
|
|
/// This is a convenience method to allow easy determination of whether a
|
|
/// node has any children.
|
|
/// Returns true if the node has any children, false otherwise.
|
|
|
|
virtual Node* cloneNode(bool deep) const = 0;
|
|
/// Returns a duplicate of this node, i.e., serves as a generic copy constructor
|
|
/// for nodes. The duplicate node has no parent; (parentNode is null.).
|
|
/// Cloning an Element copies all attributes and their values, including those
|
|
/// generated by the XML processor to represent defaulted attributes, but this
|
|
/// method does not copy any text it contains unless it is a deep clone, since
|
|
/// the text is contained in a child Text node. Cloning an Attribute directly,
|
|
/// as opposed to be cloned as part of an Element cloning operation, returns
|
|
/// a specified attribute (specified is true). Cloning any other type of node
|
|
/// simply returns a copy of this node.
|
|
/// Note that cloning an immutable subtree results in a mutable copy, but the
|
|
/// children of an EntityReference clone are readonly. In addition, clones of
|
|
/// unspecified Attr nodes are specified. And, cloning Document, DocumentType,
|
|
/// Entity, and Notation nodes is implementation dependent.
|
|
|
|
// DOM Level 2
|
|
virtual void normalize() = 0;
|
|
/// 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. This can be used to ensure that the DOM view
|
|
/// of a document is the same as if it were saved and re-loaded, and is useful
|
|
/// when operations (such as XPointer lookups) that depend on a particular
|
|
/// document tree structure are to be used.
|
|
///
|
|
/// Note: In cases where the document contains CDATASections, the normalize
|
|
/// operation alone may not be sufficient, since XPointers do not differentiate
|
|
/// between Text nodes and CDATASection nodes.
|
|
|
|
virtual bool isSupported(const XMLString& feature, const XMLString& version) const = 0;
|
|
/// Tests whether the DOM implementation implements a specific
|
|
/// feature and that feature is supported by this node.
|
|
|
|
virtual const XMLString& namespaceURI() const = 0;
|
|
/// Returns the namespace URI of the node.
|
|
/// This is not a computed value that is the result of a namespace lookup based on an
|
|
/// examination of the namespace declarations in scope. It is merely the namespace URI
|
|
/// given at creation time.
|
|
///
|
|
/// For nodes of any type other than ELEMENT_NODE and ATTRIBUTE_NODE and nodes created with a
|
|
/// DOM Level 1 method, such as createElement from the Document interface, this is always the
|
|
/// empty string.
|
|
|
|
virtual XMLString prefix() const = 0;
|
|
/// Returns the namespace prefix from the qualified name of the node.
|
|
|
|
virtual const XMLString& localName() const = 0;
|
|
/// Returns the local name of the node.
|
|
|
|
virtual bool hasAttributes() const = 0;
|
|
/// Returns whether this node (if it is an element) has any attributes.
|
|
|
|
// Extensions
|
|
typedef Poco::XML::NamespaceSupport NSMap;
|
|
|
|
virtual XMLString innerText() const = 0;
|
|
/// Returns a string containing the concatenated values of the node
|
|
/// and all its child nodes.
|
|
///
|
|
/// This method is not part of the W3C Document Object Model.
|
|
|
|
virtual Node* getNodeByPath(const XMLString& path) const = 0;
|
|
/// Searches a node (element or attribute) based on a simplified XPath
|
|
/// expression.
|
|
///
|
|
/// Only simple XPath expressions are supported. These are the slash
|
|
/// notation for specifying paths to elements, and the square bracket
|
|
/// expression for finding elements by their index, by attribute value,
|
|
/// or finding attributes by names.
|
|
///
|
|
/// The slash at the beginning is optional, the evaluation always starts
|
|
/// at this element. A double-slash at the beginning recursively searches
|
|
/// the entire subtree for the first element.
|
|
///
|
|
/// Examples:
|
|
/// elem1/elem2/elem3
|
|
/// /elem1/elem2/elem3
|
|
/// /elem1/elem2[1]
|
|
/// /elem1/elem2[@attr1]
|
|
/// /elem1/elem2[@attr1='value']
|
|
/// //elem2[@attr1='value']
|
|
/// //[@attr1='value']
|
|
///
|
|
/// This method is an extension to the W3C Document Object Model.
|
|
|
|
virtual Node* getNodeByPathNS(const XMLString& path, const NSMap& nsMap) const = 0;
|
|
/// Searches a node (element or attribute) based on a simplified XPath
|
|
/// expression. The given NSMap must contain mappings from namespace
|
|
/// prefixes to namespace URIs for all namespace prefixes used in
|
|
/// the path expression.
|
|
///
|
|
/// Only simple XPath expressions are supported. These are the slash
|
|
/// notation for specifying paths to elements, and the square bracket
|
|
/// expression for finding elements by their index, by attribute value,
|
|
/// or finding attributes by names.
|
|
///
|
|
/// The slash at the beginning is optional, the evaluation always starts
|
|
/// at this element. A double-slash at the beginning recursively searches
|
|
/// the entire subtree for the first element.
|
|
///
|
|
/// Examples:
|
|
/// /ns1:elem1/ns2:elem2/ns2:elem3
|
|
/// /ns1:elem1/ns2:elem2[1]
|
|
/// /ns1:elem1/ns2:elem2[@attr1]
|
|
/// /ns1:elem1/ns2:elem2[@attr1='value']
|
|
/// //ns2:elem2[@ns1:attr1='value']
|
|
/// //[@ns1:attr1='value']
|
|
///
|
|
/// This method is an extension to the W3C Document Object Model.
|
|
|
|
protected:
|
|
virtual ~Node();
|
|
};
|
|
|
|
|
|
//
|
|
// inlines
|
|
//
|
|
inline const XMLString& Node::nodeValue() const
|
|
{
|
|
return getNodeValue();
|
|
}
|
|
|
|
|
|
} } // namespace Poco::XML
|
|
|
|
|
|
#endif // DOM_Node_INCLUDED
|