NodeData.hh

Go to the documentation of this file.

#ifndef __DIADES__GRAPH__NODEDATA__HH
#define __DIADES__GRAPH__NODEDATA__HH


#include <list>
#include <diades/utils/Assertion.hh>
#include <diades/utils/Exceptions.hh>
#include <diades/graph/GraphGen.hh>
#include <diades/graph/EdgeData.hh>


namespace Diades {
    namespace Graph {
        class Graph;

        class NodeData {
        public:

            static string typeName() {
                return "Graph::NodeData";
            }
            typedef Diades::Utils::Exception<NodeData> Exception;

        public:
            typedef vector<NodeData *>::size_type SizeType;
            typedef vector<Node>::size_type NodeId;
        public:

            NodeData() : _owner(nullptr), 
                    _identifier(0), 
                    _inEdges(), 
                    _outEdges(), 
                    _inEdgesNb(0), 
                    _outEdgesNb(0) {}
            
            ~NodeData(){}

            bool isValid() const {
                return (_owner != nullptr);
            }

            
            list<Edge>::iterator delInEdge(EdgeData * eData) {
                require(Exception, eData != nullptr, "NodeData::delInEdge: eData is null");
                list<Edge>::iterator result;
                if (eData != 0) {
                    result = _inEdges.erase(eData->_targetPos);
                    _inEdgesNb--;
                };
                return result;
            }

            list<Edge>::iterator delOutEdge(EdgeData * eData) {
                require(Exception, eData != nullptr, "NodeData::delOutEdge: eData is null");
                list<Edge>::iterator result;
                if (eData != nullptr) {
                    result = _outEdges.erase(eData->_sourcePos);
                    _outEdgesNb--;
                }
                return result;
            }
            
            list<Edge>::iterator newInEdge(EdgeData * eData);
            
            list<Edge>::iterator newOutEdge(EdgeData * eData);


            const Graph & owner() const;
            
            void setOwner(Graph & newOwner);

            SizeType outEdgesNb() const {
                return _outEdgesNb;
            }

            SizeType inEdgesNb() const {
                return _inEdgesNb;
            }

            list<Edge> & inEdges() const {
                return _inEdges;
            }

            list<Edge> & outEdges() const {
                return _outEdges;
            }
            
            NodeId identifier() const {
                return _identifier;
            }

            void setIdentifier(NodeId newId) {
                _identifier = newId;
            }
        private:
            Graph * _owner; 
            NodeId _identifier; 
            mutable list<Edge> _inEdges; 
            mutable list<Edge> _outEdges; 
            SizeType _inEdgesNb; 
            SizeType _outEdgesNb; 

            friend class Edge;
        };
    };
};

#endif