treewalker.h

This software aims to create an applet and panel tools to manage a wireless interface card, such as

//
// TreeWalker.h
//
// $Id: //poco/Main/XML/include/DOM/TreeWalker.h#5 $
//
// Definition of the DOM TreeWalker class.
//
// Copyright (c) 2004, Guenter Obiltschnig/Applied Informatics.
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 
// 3. Redistributions in any form must be accompanied by information on
//    how to obtain complete source code for this software and any
//    accompanying software that uses this software.  The source code
//    must either be included in the distribution or be available for no
//    more than the cost of distribution plus a nominal fee, and must be
//    freely redistributable under reasonable conditions.  For an
//    executable file, complete source code means the source code for all
//    modules it contains.  It does not include source code for modules or
//    files that typically accompany the major components of the operating
//    system on which the executable file runs.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//


#ifndef DOM_TreeWalker_INCLUDED
#define DOM_TreeWalker_INCLUDED


#ifndef XML_XML_INCLUDED
#include "XML/XML.h"
#endif
#ifndef XML_XMLString_INCLUDED
#include "XML/XMLString.h"
#endif


XML_BEGIN


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;
}


XML_END


#endif // DOM_TreeWalker_INCLUDED