std::node_ptr< T, I > Template-Klassenreferenz

#include <node_ptr.hpp>

Öffentliche Typen
using	name_type = I
using	value_type = T
using	self_type = node_ptr< T, I >

Öffentliche Methoden
	node (name_type strName, value_type *data, self_type *pParent)
	~node ()
self_type *	add_child (self_type *pChild)
self_type *	add_sibling (self_type *pSibling)
self_type *	find (name_type index)
self_type *	root ()
value_type &	get ()

Ausführliche Beschreibung

template<typename T, typename I = std::string>
class std::node_ptr< T, I >

Dokumentation der benutzerdefinierten Datentypen

name_type

template<typename T , typename I = std::string>

using std::node_ptr< T, I >::name_type = I

self_type

template<typename T , typename I = std::string>

using std::node_ptr< T, I >::self_type = node_ptr<T,I>

value_type

template<typename T , typename I = std::string>

using std::node_ptr< T, I >::value_type = T

Beschreibung der Konstruktoren und Destruktoren

~node()

template<typename T , typename I = std::string>

std::node_ptr< T, I >::~node

(

)

Dokumentation der Elementfunktionen

add_child()

template<typename T , typename I = std::string>

self_type* std::node_ptr< T, I >::add_child ( self_type *  pChild )

inline

                                            {
            if(! m_pChild) { //erstes Kind
        m_pChild = pChild;
                m_pChild->m_pParent = this;
            }
        else
        return m_pChild->add_child(pChild);
            return m_pChild;
    
        }

add_sibling()

template<typename T , typename I = std::string>

self_type* std::node_ptr< T, I >::add_sibling ( self_type *  pSibling )

inline

                                                {
            if(!m_pSibling) {//Erstes Geschwister {
        m_pSibling = pSibling;
                m_pSibling->m_pParent = this->m_pParent;
            }
        else            //Probieren wir's bei den Geschwistern
        return m_pSibling->add_sibling(pSibling);
            return m_pSibling;
        }

find()

template<typename T , typename I = std::string>

self_type* std::node_ptr< T, I >::find ( name_type  index )

inline

                                      {
            if(m_index == index)
                return this;
            if(m_pSibling) {
        self_type* praNode = m_pSibling->find(index);
        if(praNode) return praNode;
        }
            //Kinder
        if(m_pChild) {
        self_type* praNode = m_pChild->find(index);
        if(praNode) return praNode;
        }
            return 0;   
        }

get()

template<typename T , typename I = std::string>

value_type& std::node_ptr< T, I >::get ( )

inline

                          {
            return *m_data;
        }

node()

template<typename T , typename I = std::string>

std::node_ptr< T, I >::node ( name_type  strName, value_type *  data, self_type *  pParent  )

inlineexplicit

                                                                                {
            m_index = strName;
            m_pParent = pParent;
            m_pChild = NULL;
        m_pSibling = NULL;
        m_data = data;
        }

root()

template<typename T , typename I = std::string>

self_type* std::node_ptr< T, I >::root ( )

inline

                       {
            if(m_pParent) return m_pParent->root();
        return this;
        }

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/node_ptr.hpp