NodeImpl.hh

Go to the documentation of this file.

#ifndef __DIADES__GRAPH__NODEIMPL__HH
#define __DIADES__GRAPH__NODEIMPL__HH

#include <sstream>
#include <list>
#include <diades/graph/GraphGen.hh>
#include <diades/graph/EdgeData.hh>
#include <diades/graph/NodeData.hh>
#include <diades/graph/Edge.hh>
#include <diades/graph/Node.hh>
#include <diades/graph/GraphInt.hh>
#include <diades/graph/EdgeImpl.hh>



namespace Diades {
    namespace Graph {
        using std::cout;

        inline bool Node::valid() const {
            return (_nData != nullptr) && (_nData->isValid());
        }

        inline const Graph & NodeData::owner() const {
            require(Exception, isValid(), "owner: invalid node data (no owner)");
            return *_owner;
        }

        inline void NodeData::setOwner(Graph & newOwner) {
            _owner = &newOwner;
        }

        inline const Graph & Node::owner() const {
            require(Exception, valid(), "owner: invalid node  (no node data)");
            return _nData->owner();
        }

        inline void Node::printInformation() const {
            if (valid()) {
                cout << "Node Id: " << id() << "\n";
                cout << "Node Owner: " << &owner() << "\n";
                cout << "Number of input edges: " << inDeg() << "\n";
                cout << "Number of output edges: " << outDeg() << "\n";
            } else {
                cout << "Invalid node" << "\n";
            }
        }

        inline void Node::create(NodeId idt, Graph * own) {
            require(Exception, _nData == nullptr, "create: _nData is not null");
            require(Exception, own != nullptr, "create: own is null");

            _nData = new NodeData();
            _nData->setOwner(*own);
            _nData->setIdentifier(idt);
            ensure(Exception, valid(), "Node::create: invalid node");
        }

        inline bool Node::operator<(const Node & node) const {
            if (!valid()) {
                return node.valid();
            }
            if (!node.valid()) {
                return false;
            }
            if (&owner() != &(node.owner())) {
                return &owner() < &(node.owner());
            }
            return id() < node.id();
        }


        //      template<class Archive>
        //      void Node::save(Archive & ar, const unsigned int version) const
        //        {
        //              Graph g = owner();
        //              ar & g;
        //              NodeId idt = id();
        //              ar & idt;
        //        } 
        //
        //        
        //      template<class Archive>
        //      void Node::load(Archive & ar, const unsigned int version)
        //      {
        //        Graph g;
        //        ar & g;
        //        NodeId id;
        //        ar & id;
        //        if(g.valid())
        //              {
        //                operator=(g.getNode(id));
        //              }
        //        else
        //              {
        //                _nData = 0;
        //              }
        //      }
    };
};

#endif