source: XMLIO_V2/external/include/Poco/DOM/TreeWalker.h @ 80

//
// TreeWalker.h
//
// $Id: //poco/1.3/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.
//
// Permission is hereby granted, free of charge, to any person or organization
// obtaining a copy of the software and accompanying documentation covered by
// this license (the "Software") to use, reproduce, display, distribute,
// execute, and transmit the Software, and to prepare derivative works of the
// Software, and to permit third-parties to whom the Software is furnished to
// do so, all subject to the following:
// 
// The copyright notices in the Software and this entire statement, including
// the above license grant, this restriction and the following disclaimer,
// must be included in all copies of the Software, in whole or in part, and
// all derivative works of the Software, unless such copies or derivative
// works are solely in the form of machine-executable object code generated by
// a source language processor.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//


#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 NodeIterator.
                
        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