MyTree.h

Go to the documentation of this file.

/* ***********************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2003-2004
        eMail:          sebastien.bloc@free.fr
        URL:            http://mignonsoft.free.fr

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
        http://www.gnu.org/copyleft/gpl.html
*********************************************************************************** */

#ifndef INCLUDE_MY_TREE_INCLUDE
#define INCLUDE_MY_TREE_INCLUDE

#include "MyList.h"


template <class T> 
class MyTreeNode
{
public:
        T *elem;                                                        // element de la liste 
        MyTreeNode *parent;
        MyList<MyTreeNode *> childs;      // enfants 

private:
        void Init()
        {
                elem = NULL;
                parent=NULL;
        }

public:
        typedef MyTreeNode<T> MyTreeNodeItem;

        MyTreeNode() { Init(); }

        MyTreeNode(T &_elem) 
        {
                Init();
                elem = new T;
                if (!elem) throw MyExceptionMemory("MyTreeNode","constructor",sizeof(T));
                *elem=_elem; //operator=(T &source) de la class appelé
        }

        MyTreeNode(T *_elem) 
        {
                Init();
                elem=_elem; 
        }

        ~MyTreeNode() 
        { 
                if (elem) delete elem; 
        }

        BOOL SuprChilds(BOOL recursif=FALSE)
        {
                MyTreeNodeItem *node;
                MyListItem<MyTreeNodeItem *> *item;
                item = childs.first;
                while (item)
                {
                        node = *item->elem;
                        item = item->after;
                        if (recursif) node->SuprChilds(TRUE);
                        node->SuprOnParent();
                        delete node;
                }
                return TRUE;
        }

        BOOL SuprOnParent()
        {
                if (!parent) return FALSE;
                if (!parent->childs.i.GoTo(this)) return FALSE;
                parent->childs.i.Supr();
                return TRUE;
        }

        MyTreeNode<T> * operator [] (int num)
        {
                return childs[num];
        }

        BOOL MoveTo(MyTreeNode<T> *dest)
        {
                if (!dest) return FALSE; // erreur si pas de destinataire

                // supression des lien dans la source: recherche du lien du fils dans le pere
                BOOL find=FALSE;
                for (parent->childs.i=0;parent->childs.i.More();parent->childs.i++)
                {
                        if (this==parent->childs.i.GetElem()) 
                        {
                                parent->childs.i.Supr();
                                find=TRUE;
                                break;
                        }
                }
                if (!find) return FALSE; // pas trouvé dans la liste des fils du pere (normalement impossible)

                // nouvelle emplacement dans la destination
                parent=dest;
                dest->childs.i+=this;
                return TRUE; 
        }

        BOOL FindOnParent(MyListIterator<MyTreeNodeItem *> &it)
        {
                if (!parent) return FALSE;
                it.Bind(&parent->childs);
                for (it=0;it.More();it++)
                {
                        if (this==it.GetElem()) return TRUE;
                }
                return FALSE;
        }

        void MoveToFirstChild()
        {
                MyListIterator<MyTreeNodeItem *> it;
                if (FindOnParent(it))
                {
                        it.MoveFirst();
                }
        }
        void MoveToLastChild()
        {
                MoveTo(parent);
        }

        T * Elems(int num)
        {
                return childs.i[num]->elem;
        }

        void operator=(MyTreeNode &source)
        {
                if (source.elem) 
                {
                        elem = new T;
                        if (!elem) throw CMyExceptionMemory("MyTreeNode","operator=",sizeof(T));
                        *elem=*source.elem;
                }
                else elem=NULL;
                parent=source.parent;
                childs=source.childs;
        }
};

template <class T> 
class MyTree
{
private:
        MyTreeNode<T> *root;
        MyTreeNode<T> *current;

private:
        void Init()
        {
                root = NULL;
                current = NULL;
        }

public:
        MyTreeNode<T> * GetRoot() { return root; }
        MyTreeNode<T> * GetCurrent() { return current; }

        MyTree()
        {
                Init();
        }

        ~MyTree()
        {
                SuprAll();
        }

        BOOL SuprNode(MyTreeNode<T> *node,BOOL recursif=TRUE)
        {
                if (!node) return FALSE;
                if (recursif) node->SuprChilds(TRUE);
                node->SuprOnParent();
                delete node;
                return TRUE;
        }

        void SuprAll()
        {
                SuprNode(root);
                Init();
        }

        void operator=(MyTreeNode<T> *node)
        {
                SuprAll();
                operator+=(node);
        }

        void operator+=(MyTreeNode<T> *node)
        {
                Clone (node,NULL);
        }

        void Clone(MyTreeNode<T> *nodeSource,MyTreeNode<T> *nodeParentClone)
        {
                if (!nodeSource) return;
                nodeParentClone = Add(*nodeSource->elem,nodeParentClone);
                for (nodeSource->childs.i=0;nodeSource->childs.i.More();nodeSource->childs.i++)
                {
                        Clone(nodeSource->childs.i.GetElem(),nodeParentClone);
                }
        }

        void operator=(MyTree<T> *otherTree)
        {
                SuprAll();
                operator+=(otherTree->GetRoot());
        }

        void operator+=(MyTree<T> *otherTree)
        {
                operator+=(otherTree->GetRoot());
        }

        MyTreeNode<T> *GoToChild(int numChild,MyTreeNode<T> *parent=NULL)
        {
                MyTreeNode<T> *xcurrent = GetChild(numChild,parent);
                if (xcurrent) current=xcurrent;
                return xcurrent;
        }

        MyTreeNode<T> * GoTo(MyTreeNode<T> *node)
        {
                MyTreeNode<T> * oldCurrent;
                oldCurrent = current;
                current=node;
                return oldCurrent;
        }

        MyTreeNode<T> *GetChild(int numChild,MyTreeNode<T> *parent=NULL)
        {
                if (!parent) 
                {
                        parent = current;
                        if (!parent) return NULL;
                }
                return parent->childs.i[numChild];
        }

        MyTreeNode<T> *GoToParent(MyTreeNode<T> *parent=NULL)
        {
                MyTreeNode<T> *xcurrent = GetParent(parent);
                if (current) current=xcurrent;
                return xcurrent;
        }

        MyTreeNode<T> *GetParent(MyTreeNode<T> *parent=NULL)
        {
                if (!parent) 
                {
                        parent = current;
                        if (!parent) return NULL;
                }
                return parent->parent;
        }

        MyTreeNode<T> * Add(T& elem,MyTreeNode<T> *parent=NULL)
        {
                MyTreeNode<T> *node = new MyTreeNode<T>(elem); // Creation d'un nouveau noeud
                if (!parent) parent = current;    // Attacher ce noeud a son parent
                if (parent)                      // si premier alors devient root
                {
                        node->parent = parent;
                        parent->childs.i+=node;
                }
                else { current = root = node; }
                return node;
        }

        MyTreeNode<T> * Add(T* elem,MyTreeNode<T> *parent=NULL)
        {
                MyTreeNode<T> *node = new MyTreeNode<T>(elem); // Creation d'un nouveau noeud
                if (!parent) parent = current;    // Attacher ce noeuf a son parent
                if (parent)                      // si premier alors devient root
                {
                        node->parent = parent;
                        parent->childs.i+=node;
                }
                else { current = root = node; }
                return node;
        }
};

#endif

---