MyTree.h

Aller à la documentation de ce fichier.

/* ***********************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      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:
        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() 
        { 
                if (elem) delete elem; 
        }

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

        T * Elems(int num)
        {
                return childs[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> *m_root;
        MyTreeNode<T> *m_current;

private:
        void Init()
        {
                m_root = NULL;
                m_current = NULL;
        }

public:
        MyTreeNode<T> * GetRoot() { return m_root; }
        MyTreeNode<T> * GetCurrent() { return m_current; }

        MyTree()
        {
                Init();
        }

        ~MyTree()
        {
                SuprAll();
        }

        BOOL SuprAll()
        {
                Init();
                return SuprNode(m_root,TRUE);
        }

        BOOL SuprNode(MyTreeNode<T> *node,BOOL recursif=FALSE)
        {
                if (!node) return FALSE;
                if (node->parent) // s'il y a un parent detruir son fils en question
                {
                        BOOL isFind = FALSE;
                        for (node->parent->childs=0;node->parent->childs.More();node->parent->childs++)
                        {
                                if (node->parent->childs.GetElem()==node) // j'ai trouvé le fils chez le pere
                                {
                                        node->parent->childs.SuprCurrent();
                                        isFind=TRUE;
                                        break;
                                }
                        }
                        if (!isFind) // y'a un pb, un pere mais pas de fils dans ce pere !
                                throw MyExceptionMemory("MyTree","SuprNode",sizeof(MyTreeNode<T>));
                }
                if (recursif) // en recursif: destruction de tout ces fils
                {
                        for (node->childs=0;node->childs.More();node->childs++)
                                if (!SuprNode(node->childs.GetElem(),TRUE)) return FALSE;
                }
                delete node;
                return TRUE;
        }

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

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

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

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

        MyTreeNode<T> *GetParent(MyTreeNode<T> *parent=NULL)
        {
                if (!parent) 
                {
                        parent = m_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 = m_current;    // Attacher ce noeuf a son parent
                if (parent)                      // si premier alors devient root
                {
                        node->parent = parent;
                        parent->childs+=node;
                }
                else { m_current = m_root = node; }
                return node;
        }
};

#endif

---