TreeNode.h

Go to the documentation of this file.

#ifndef __KOME_CORE_TREE_NODE_H__
#define __KOME_CORE_TREE_NODE_H__


#include <vector>
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <algorithm>


namespace kome {
    namespace core {

        template < typename T > class TreeNode {        
        public:
            TreeNode() : m_element() {
                m_parent = NULL;
            }

            TreeNode( T& elm ) : m_element( elm ){
                m_parent = NULL;
            }

            virtual ~TreeNode(){
                clearChildren();
            }

            T& getElement(){
                return m_element;
            }

            void setElement( T& elm ){
                m_element = elm;
            }

            TreeNode* getParentNode(){
                return m_parent;
            }

            unsigned int getNumberOfChildren(){
                return m_children.size();
            }

            TreeNode* getChild( int index ) {
                // check parameter
                if( index < 0 || index > m_children.size() ) {
                    return NULL;
                }

                return m_children[index];
            }

            void clearChildren() {
                for( unsigned int i = 0; i < m_children.size(); i++ ){
                    delete m_children[index];
                }
                m_children.clear();
            }

            TreeNode* addChild(){
                TreeNode<T>* child = new TreeNode<T>();
                m_children.push_back( child );
                return child;
            }

            TreeNode* addChild( T& elm ){
                TreeNode<T>* child = new TreeNode<T>( elm );
                m_children.push_back( child );
                return child;
            }

            void sortChildren( boost::function< bool ( TreeNode<T>&, TreeNode<T>& ) > lessFun ) {
                // check member
                if( m_children.size() == 0 ) {
                    return;
                }

                // sort ( This method is called recursively. )
                for( unsigned int i = 0; i < m_children.size(); i++ ) {
                    m_children[i]->sortChildre( lessFun );
                }

                std::sort( m_children.begin(), m_children.end(), lessFun );
            }

        protected:
            T m_element;

            std::vector< TreeNode<T>* > m_children;

            TreeNode<T>* m_parent;

            TreeNode( TreeNode<T>* parent ) : m_element() {
                m_parent = parent;
            }

            TreeNode( TreeNode<T>* parent, T& elm ) : m_element( elm ) {
                m_parent = parent;
            }
        };
    }
}

#endif  // __KOME_CORE_TREE_NODE_H__