Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

XFuNTreePreOrderIterator.h

Go to the documentation of this file.
00001 /*! \file 
00002  * X-Forge Util <br>
00003  * Copyright 2000-2003 Fathammer Ltd
00004  * 
00005  * \brief N-Tree pre-order iterator template
00006  *
00007  * $Id: XFuNTreePreOrderIterator.h,v 1.6 2003/03/20 13:19:59 jetro Exp $
00008  * $Date: 2003/03/20 13:19:59 $
00009  * $Revision: 1.6 $
00010  */
00011 
00012 #ifndef XFUNTREEPREORDERITERATOR_H_INCLUDED
00013 #define XFUNTREEPREORDERITERATOR_H_INCLUDED
00014 
00015 #include <xfutil/XFuNTreeAbstractIterator.h>
00016 #include <xfutil/XFuDynamicArray.h>
00017 
00018 template<class T> class XFuNTree;
00019 template<class T> class XFuNTreeNode;
00020 
00021 
00022 template<class T> class XFuNTreePreOrderIterator : public XFuNTreeAbstractIterator<T>
00023 {
00024 
00025 public:
00026     //! Assignment operator overload.
00027     void operator=(const XFuNTreePreOrderIterator &aClone);
00028 
00029     //! Advances to the next node, pre-operation.
00030     /*!
00031      * \return Reference to next node.
00032      */
00033     XFuNTreePreOrderIterator<T> & operator++();
00034     //! Advances to the next node, post-operation.
00035     /*!
00036      * \return Next node.
00037      */
00038     XFuNTreePreOrderIterator<T> operator++(int);
00039 
00040     //! Creates an empty iterator.
00041     XFuNTreePreOrderIterator();
00042     //! Creates an iterator pointing to a node.
00043     XFuNTreePreOrderIterator(XFuNTreeNode<T> *aNode, const UINT32 aNodes, 
00044                              const UINT32 aChildNodes);
00045     //! Clones an iterator.
00046     XFuNTreePreOrderIterator(const XFuNTreePreOrderIterator<T> &aClone);
00047 
00048     //! Destructor.
00049     ~XFuNTreePreOrderIterator();
00050 
00051 protected:
00052     
00053     //! Number of nodes in tree.
00054     UINT32 mNodes;
00055 
00056     //! Stack used for saving pointers to unvisited nodes.
00057     XFuDynamicArray<XFuNTreeNode<T> *> *mStack;
00058 };
00059 
00060 
00061 template<class T>
00062 void XFuNTreePreOrderIterator<T>::operator=(const XFuNTreePreOrderIterator &aClone)
00063 {
00064     mNode = aClone.mNode;
00065     mNodes = aClone.mNodes;
00066     mChildNodes = aClone.mChildNodes;
00067 
00068     if (aClone.mStack != NULL)
00069     {
00070         if (mStack == NULL)
00071             mStack = XFuDynamicArray<XFuNTreeNode<T> *>::create(
00072                 aClone.mStack->maxSize());
00073 
00074         if (mStack == NULL)
00075         {
00076             mNode = NULL;
00077             mNodes = 0;
00078             mChildNodes = 0;
00079             return;
00080         }      
00081 
00082         UINT32 i, lastElement;
00083         XFuNTreeNode<T> *temp = NULL;
00084 
00085         lastElement = aClone.mStack->size();
00086         for (i = 0; i < lastElement; ++i)
00087         {
00088             temp = aClone.mStack->get(i);
00089             mStack->put(i, temp);
00090         }
00091     }
00092     else
00093     {
00094         if (mStack != NULL)
00095         {
00096             delete mStack;
00097             mStack = NULL;
00098         }
00099     }
00100 }
00101 
00102 
00103 template<class T>
00104 XFuNTreePreOrderIterator<T> & XFuNTreePreOrderIterator<T>::operator++()
00105 {
00106     if (!mStack->isEmpty())
00107     {
00108         mNode = mStack->remove();
00109 
00110         INT32 i;
00111         for (i = (mChildNodes - 1); i >= 0; --i)
00112         {
00113             if (mNode->isValid(i))
00114                 mStack->put(mNode->getChild(i));
00115         }
00116     }
00117 
00118     return *this;
00119 }
00120 
00121 
00122 template<class T>
00123 XFuNTreePreOrderIterator<T> XFuNTreePreOrderIterator<T>::operator++(int)
00124 {
00125     XFuNTreePreOrderIterator<T> newIt = XFuNTreePreOrderIterator<T>(*this);
00126 
00127 /*
00128     if (mNode != NULL) mNode = mNode->mNext;
00129 
00130     return newIt;
00131 */
00132 }
00133 
00134 
00135 template<class T> XFuNTreePreOrderIterator<T>::XFuNTreePreOrderIterator()
00136 {
00137     mNode = NULL;
00138     mNodes = 0;
00139     mStack = NULL;
00140 }
00141 
00142 
00143 template<class T> 
00144 XFuNTreePreOrderIterator<T>::XFuNTreePreOrderIterator(XFuNTreeNode<T> *aNode,
00145                                                       const UINT32 aNodes,
00146                                                       const UINT32 aChildNodes)
00147 {
00148     if (aNode != NULL)
00149     {
00150         mNode = aNode;
00151         mNodes = aNodes;
00152         mChildNodes = aChildNodes;
00153 
00154         mStack = XFuDynamicArray<XFuNTreeNode<T> *>::create(aNodes);
00155         if (mStack == NULL)
00156         {
00157             mNode = NULL;
00158             mNodes = 0;
00159             mChildNodes = 0;
00160         }
00161         else
00162         {
00163             INT32 i;
00164             for (i = (mChildNodes - 1); i >= 0; --i)
00165             {
00166                 if (mNode->isValid(i))
00167                     mStack->put(mNode->getChild(i));
00168             }
00169         }
00170     }
00171 }
00172 
00173 
00174 template<class T> 
00175 XFuNTreePreOrderIterator<T>::XFuNTreePreOrderIterator(
00176     const XFuNTreePreOrderIterator<T> &aClone)
00177 {
00178     mNode = aClone.mNode;
00179 
00180     if (aClone.mStack != NULL)
00181     {
00182         if (mStack == NULL)
00183         {
00184             mStack = XFuDynamicArray<XFuNTreeNode<T> *>::create(
00185                 aClone.mStack->maxSize());
00186 
00187             if (mStack == NULL)
00188             {
00189                 mNode = NULL;
00190                 mNodes = 0;
00191                 mChildNodes = 0;
00192                 return;
00193             }
00194         }
00195 
00196         UINT32 i, lastElement;
00197         XFuNTreeNode<T> *temp = NULL;
00198 
00199         lastElement = aClone.mStack->size();
00200         for (i = 0; i < lastElement; ++i)
00201         {
00202             temp = aClone.mStack->get(i);
00203             mStack->put(i, temp);
00204         }
00205     }
00206     else
00207     {
00208         delete mStack;
00209         mStack = NULL;
00210     }
00211 }
00212 
00213 
00214 template<class T>
00215 XFuNTreePreOrderIterator<T>::~XFuNTreePreOrderIterator()
00216 {
00217     delete mStack;
00218 }
00219 
00220 
00221 #endif // !XFUNTREEPREORDERITERATOR_H_INCLUDED

   
X-Forge Documentation
Confidential
Copyright © 2002-2003 Fathammer
   
Documentation generated
with doxygen
by Dimitri van Heesch