Node_impl.h

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#ifndef __NODE_H_IMPL__
#define __NODE_H_IMPL__
 
#include <sstream>
 
#include "Node.h"


template<typename T>
std::string node_convertToString(const T & val){
        std::stringstream str;
        str << val;
        
        std::string varStr(str.str()), outputStr(""), strCheck(" \t\n/.:-");
        for(size_t i(0lu); i < varStr.size(); ++i){
                char ch = varStr[i];
                bool isNotFound(true);
                for(size_t j(0lu); j < strCheck.size() && isNotFound; ++j){
                        isNotFound &= ch != strCheck[j];
                }
                if(isNotFound){
                        outputStr += ch;
                }
        }
        return outputStr;
}


template<typename T, typename UIdx>
Node<T, UIdx>::Node(const std::string & name){
        initialisationNode();
        p_name = name;
}


template<typename T, typename UIdx>
Node<T, UIdx>::Node(const T & data, const std::string & name){
        initialisationNode();
        p_name = name;
        p_data = data;
}


template<typename T, typename UIdx>
Node<T, UIdx>::Node(const Node<T, UIdx> & other){
        copyNode(other);
}

template<typename T, typename UIdx>
Node<T, UIdx>::~Node(){
        
}


template<typename T, typename UIdx>
Node<T, UIdx> & Node<T, UIdx>::operator = (const Node<T, UIdx> & other){
        copyNode(other);
        return *this;
}


template<typename T, typename UIdx>
void Node<T, UIdx>::addChild(UIdx child){
        p_listChild.push_back(child);
}


template<typename T, typename UIdx>
void Node<T, UIdx>::addParent(UIdx parent){
        p_listParent.push_back(parent);
}


template<typename T, typename UIdx>
void Node<T, UIdx>::removeChild(UIdx child){
        listindex_remove(p_listChild, child);
}


template<typename T, typename UIdx>
void Node<T, UIdx>::removeParent(UIdx parent){
        listindex_remove(p_listParent, parent);
}


template<typename T, typename UIdx>
void Node<T, UIdx>::setListChild(const std::list<UIdx> & listChild){p_listChild = listChild;}


template<typename T, typename UIdx>
void Node<T, UIdx>::setListParent(const std::list<UIdx> & listParent){p_listParent = listParent;}


template<typename T, typename UIdx>
void Node<T, UIdx>::setIndex(UIdx index){p_index = index;}


template<typename T, typename UIdx>
void Node<T, UIdx>::setName(const std::string & name){p_name = name;}


template<typename T, typename UIdx>
void Node<T, UIdx>::setIsUpdated(bool isUpdated){p_isUpdated = isUpdated;}


template<typename T, typename UIdx>
void Node<T, UIdx>::setData(const T & data){p_data = data;}


template<typename T, typename UIdx>
const std::list<UIdx> & Node<T, UIdx>::getListChild() const{return p_listChild;}


template<typename T, typename UIdx>
std::list<UIdx> & Node<T, UIdx>::getListChild(){return p_listChild;}


template<typename T, typename UIdx>
const std::list<UIdx> & Node<T, UIdx>::getListParent() const{return p_listParent;}


template<typename T, typename UIdx>
std::list<UIdx> & Node<T, UIdx>::getListParent(){return p_listParent;}


template<typename T, typename UIdx>
UIdx Node<T, UIdx>::getIndex() const{return p_index;}


template<typename T, typename UIdx>
const std::string & Node<T, UIdx>::getName() const{return p_name;}


template<typename T, typename UIdx>
std::string & Node<T, UIdx>::getName(){return p_name;}


template<typename T, typename UIdx>
bool Node<T, UIdx>::getIsUpdated() const{return p_isUpdated;}


template<typename T, typename UIdx>
bool & Node<T, UIdx>::getIsUpdated(){return p_isUpdated;}


template<typename T, typename UIdx>
const T & Node<T, UIdx>::getData() const{return p_data;}


template<typename T, typename UIdx>
T & Node<T, UIdx>::getData(){return p_data;}


template<typename T, typename UIdx>
bool Node<T, UIdx>::isStart() const{return p_listParent.size() == 0lu;}


template<typename T, typename UIdx>
bool Node<T, UIdx>::isEnd() const{return p_listChild.size() == 0lu;}


template<typename T, typename UIdx>
std::string Node<T, UIdx>::getDotName() const{
        std::string body("");
        body += "node";
        body += node_convertToString(p_index);
        return body;
}


template<typename T, typename UIdx>
std::string Node<T, UIdx>::getDotDefinition() const{
        std::string body("");
        std::string strName(p_name);
        if(strName == ""){
                strName = node_convertToString(p_index);
        }
        body += "\t" + getDotName() + "[label=\"" + strName + "\"][color=\"blue\"]";
        if(isStart()){
                body += "[shape=octagon]";
        }else if(isEnd()){
                body += "[shape=cylinder]";
        }else{
                body += "[shape=record]";
        }
        body += ";\n";
        return body;
}


template<typename T, typename UIdx>
void Node<T, UIdx>::copyNode(const Node<T, UIdx> & other){
        p_listChild = other.p_listChild;
        p_listParent = other.p_listParent;
        p_index = other.p_index;
        p_name = other.p_name;
        p_isUpdated = other.p_isUpdated;
        p_data = other.p_data;
}

template<typename T, typename UIdx>
void Node<T, UIdx>::initialisationNode(){
        p_name = "";
        p_isUpdated = false;
}
 
 
 
 
 
#endif