mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-11-18 05:32:52 +00:00
214 lines
7.1 KiB
C++
214 lines
7.1 KiB
C++
//
|
|
// TreeWalker.h
|
|
//
|
|
// $Id: //poco/1.4/XML/include/Poco/DOM/TreeWalker.h#1 $
|
|
//
|
|
// Library: XML
|
|
// Package: DOM
|
|
// Module: TreeWalker
|
|
//
|
|
// Definition of the DOM TreeWalker class.
|
|
//
|
|
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
|
|
// and Contributors.
|
|
//
|
|
// SPDX-License-Identifier: BSL-1.0
|
|
//
|
|
|
|
|
|
#ifndef DOM_TreeWalker_INCLUDED
|
|
#define DOM_TreeWalker_INCLUDED
|
|
|
|
|
|
#include "Poco/XML/XML.h"
|
|
#include "Poco/XML/XMLString.h"
|
|
|
|
|
|
namespace Poco {
|
|
namespace XML {
|
|
|
|
|
|
class Node;
|
|
class NodeFilter;
|
|
|
|
|
|
class XML_API TreeWalker
|
|
/// TreeWalker objects are used to navigate a document tree or subtree using
|
|
/// the view of the document defined by their whatToShow flags and filter (if
|
|
/// any). Any function which performs navigation using a TreeWalker will automatically
|
|
/// support any view defined by a TreeWalker.
|
|
///
|
|
/// Omitting nodes from the logical view of a subtree can result in a structure
|
|
/// that is substantially different from the same subtree in the complete, unfiltered
|
|
/// document. Nodes that are siblings in the TreeWalker view may be children
|
|
/// of different, widely separated nodes in the original view. For instance,
|
|
/// consider a NodeFilter that skips all nodes except for Text nodes and the
|
|
/// root node of a document. In the logical view that results, all text nodes
|
|
/// will be siblings and appear as direct children of the root node, no matter
|
|
/// how deeply nested the structure of the original document.
|
|
///
|
|
/// A TreeWalker can be directly instantiated using one of its constructors -
|
|
/// the DocumentTraversal interface is not needed and therefore not implemented.
|
|
/// Unlike most other DOM classes, TreeWalker supports value semantics.
|
|
///
|
|
/// If the TreeWalker's current node is removed from the document, the
|
|
/// result of calling any of the movement methods is undefined. This behavior
|
|
/// does not conform to the DOM Level 2 Traversal specification.
|
|
{
|
|
public:
|
|
TreeWalker(Node* root, unsigned long whatToShow, NodeFilter* pFilter = 0);
|
|
/// Creates a TreeWalker over the subtree rooted at the specified node.
|
|
|
|
TreeWalker(const TreeWalker& walker);
|
|
/// Creates a TreeWalker by copying another TreeWalker.
|
|
|
|
TreeWalker& operator = (const TreeWalker& walker);
|
|
/// Assignment operator.
|
|
|
|
~TreeWalker();
|
|
/// Destroys the TreeWalker.
|
|
|
|
Node* root() const;
|
|
/// The root node of the TreeWalker, as specified when it was created.
|
|
|
|
unsigned long whatToShow() const;
|
|
/// This attribute determines which node types are presented via the TreeWalker.
|
|
/// The available set of constants is defined in the NodeFilter interface. Nodes
|
|
/// not accepted by whatToShow will be skipped, but their children may still
|
|
/// be considered. Note that this skip takes precedence over the filter, if
|
|
/// any.
|
|
|
|
NodeFilter* filter() const;
|
|
/// The NodeFilter used to screen nodes.
|
|
|
|
bool expandEntityReferences() const;
|
|
/// The value of this flag determines whether the children of entity reference
|
|
/// nodes are visible to the iterator. If false, they and their descendants
|
|
/// will be rejected. Note that this rejection takes precedence over whatToShow
|
|
/// and the filter. Also note that this is currently the only situation where
|
|
/// NodeIterators may reject a complete subtree rather than skipping individual
|
|
/// nodes.
|
|
///
|
|
/// To produce a view of the document that has entity references expanded and
|
|
/// does not expose the entity reference node itself, use the whatToShow flags
|
|
/// to hide the entity reference node and set expandEntityReferences to true
|
|
/// when creating the iterator. To produce a view of the document that has entity
|
|
/// reference nodes but no entity expansion, use the whatToShow flags to show
|
|
/// the entity reference node and set expandEntityReferences to false.
|
|
///
|
|
/// This implementation does not support entity reference expansion and
|
|
/// thus always returns false.
|
|
|
|
Node* currentNode() const;
|
|
/// The node at which the TreeWalker is currently positioned.
|
|
/// Alterations to the DOM tree may cause the current node to no longer be accepted
|
|
/// by the TreeWalker's associated filter. currentNode may also be explicitly
|
|
/// set to any node, whether or not it is within the subtree specified by the
|
|
/// root node or would be accepted by the filter and whatToShow flags. Further
|
|
/// traversal occurs relative to currentNode even if it is not part of the current
|
|
/// view, by applying the filters in the requested direction; if no traversal
|
|
/// is possible, currentNode is not changed.
|
|
|
|
Node* getCurrentNode() const;
|
|
/// See currentNode().
|
|
|
|
void setCurrentNode(Node* pNode);
|
|
/// Sets the current node.
|
|
|
|
Node* parentNode();
|
|
/// Moves to and returns the closest visible ancestor node of the current node.
|
|
/// If the search for parentNode attempts to step upward from the TreeWalker's
|
|
/// root node, or if it fails to find a visible ancestor node, this method retains
|
|
/// the current position and returns null.
|
|
|
|
Node* firstChild();
|
|
/// Moves the TreeWalker to the first visible child of the current node, and
|
|
/// returns the new node. If the current node has no visible children, returns
|
|
/// null, and retains the current node.
|
|
|
|
Node* lastChild();
|
|
/// Moves the TreeWalker to the last visible child of the current node, and
|
|
/// returns the new node. If the current node has no visible children, returns
|
|
/// null, and retains the current node.
|
|
|
|
Node* previousSibling();
|
|
/// Moves the TreeWalker to the previous sibling of the current node, and returns
|
|
/// the new node. If the current node has no visible previous sibling, returns
|
|
/// null, and retains the current node.
|
|
|
|
Node* nextSibling();
|
|
/// Moves the TreeWalker to the next sibling of the current node, and returns
|
|
/// the new node. If the current node has no visible next sibling, returns null,
|
|
/// and retains the current node.
|
|
|
|
Node* previousNode();
|
|
/// Moves the TreeWalker to the previous visible node in document order relative
|
|
/// to the current node, and returns the new node. If the current node has no
|
|
/// previous node, or if the search for previousNode attempts to step upward
|
|
/// from the TreeWalker's root node, returns null, and retains the current node.
|
|
|
|
Node* nextNode();
|
|
/// Moves the TreeWalker to the next visible node in document order relative
|
|
/// to the current node, and returns the new node. If the current node has no
|
|
/// next node, or if the search for nextNode attempts to step upward from the
|
|
/// TreeWalker's root node, returns null, and retains the current node.
|
|
|
|
protected:
|
|
int accept(Node* pNode) const;
|
|
Node* next(Node* pNode) const;
|
|
Node* previous(Node* pNode) const;
|
|
|
|
private:
|
|
TreeWalker();
|
|
|
|
Node* _pRoot;
|
|
unsigned long _whatToShow;
|
|
NodeFilter* _pFilter;
|
|
Node* _pCurrent;
|
|
};
|
|
|
|
|
|
//
|
|
// inlines
|
|
//
|
|
inline Node* TreeWalker::root() const
|
|
{
|
|
return _pRoot;
|
|
}
|
|
|
|
|
|
inline unsigned long TreeWalker::whatToShow() const
|
|
{
|
|
return _whatToShow;
|
|
}
|
|
|
|
|
|
inline NodeFilter* TreeWalker::filter() const
|
|
{
|
|
return _pFilter;
|
|
}
|
|
|
|
|
|
inline bool TreeWalker::expandEntityReferences() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
inline Node* TreeWalker::currentNode() const
|
|
{
|
|
return _pCurrent;
|
|
}
|
|
|
|
|
|
inline Node* TreeWalker::getCurrentNode() const
|
|
{
|
|
return _pCurrent;
|
|
}
|
|
|
|
|
|
} } // namespace Poco::XML
|
|
|
|
|
|
#endif // DOM_TreeWalker_INCLUDED
|