Logo Search packages:      
Sourcecode: poco version File versions  Download package

TreeWalker.h

//
// TreeWalker.h
//
// $Id: //poco/1.2/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;


00055 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
//
00194 inline Node* TreeWalker::root() const
{
      return _pRoot;
}


00200 inline unsigned long TreeWalker::whatToShow() const
{
      return _whatToShow;
}


00206 inline NodeFilter* TreeWalker::filter() const
{
      return _pFilter;
}


00212 inline bool TreeWalker::expandEntityReferences() const
{
      return false;
}


00218 inline Node* TreeWalker::currentNode() const
{
      return _pCurrent;
}


00224 inline Node* TreeWalker::getCurrentNode() const
{
      return _pCurrent;
}


} } // namespace Poco::XML


#endif // DOM_TreeWalker_INCLUDED

Generated by  Doxygen 1.6.0   Back to index