Edge.hh

Go to the documentation of this file.

#ifndef __DIADES__GRAPH__EDGE__HH
#define __DIADES__GRAPH__EDGE__HH

#include <sstream>
#include <list>
#include <boost/functional/hash.hpp>
#include <diades/utils/Exceptions.hh>
#include <diades/utils/Assertion.hh>
#include <diades/graph/GraphGen.hh>
#include <diades/graph/EdgeData.hh>
#include <diades/graph/NodeData.hh>


namespace Diades
{
    namespace Graph
    {
        using std::list;
        using std::ostream;
        using std::stringstream;

        class Node;

        class Edge
        {
        public:

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

            typedef EdgeData::EdgeId EdgeId;

        public:

            Edge() = default;

            Edge(const Edge & edge) =default;

            Edge(EdgeData * data) : _eData(data)
            {
                require(Exception, data != nullptr,
                        "Edge: there is no data (nullptr)");
                require(Exception, data != nullptr,
                        "Edge: there is no data (nullptr)");
            }

            ~Edge() = default;
            
            
            
            EdgeData * data()
            {
                return _eData;
            }

            Edge & operator=(const Edge & edge) = default;

            
            Edge& operator=(Edge && other) = default;
            
            


            Node source() const;

            Node target() const;


            const Node & sourceRef() const;

            const Node & targetRef() const;




            bool valid() const;

            bool operator==(const Edge & edge) const
            {
                return _eData == edge._eData;
            }

            bool operator!=(const Edge & edge) const
            {
                return !(*this == edge);
            }

            bool operator<(const Edge & edge) const;

            bool operator>(const Edge & edge) const
            {
                return ( (*this != edge) && !(*this < edge));
            }

            EdgeId id() const
            {
                require(Exception, valid(),
                        "id(): invalid edge");
                return _eData->_identifier;
            }


            const Graph & owner() const;

            int memoryUsage() const
            {
                return sizeof (Edge);
            }



        private:

            EdgeData * _eData; 

            list<Edge>::iterator sourcePos() const
            {
                require(Exception, _eData != nullptr, "Edge::sourcePos:  _eData is null");
                return _eData->_sourcePos;
            }

            list<Edge>::iterator targetPos() const
            {
                require(Exception, _eData != nullptr, "Edge::targetPos:  _eData is null");
                return _eData->_targetPos;
            }


            void create(EdgeId idt, NodeData * s, NodeData * t);

            void destroy()
            {
                require(Exception, valid(), "Edge::destroy: invalid edge");
                _eData->_target->delInEdge(_eData);
                _eData->_source->delOutEdge(_eData);
                delete _eData;
                _eData = 0;
                ensure(Exception, !valid(), "Edge::destroy: valid edge");
            }

            void changeSource(NodeData * s);


            void changeTarget(NodeData * t);

            friend class Graph;
            friend class Node;


            friend ostream & operator<<(ostream & os, const Edge & edge)
            {
                if (edge.valid())
                {
                    os << edge.id();
                } else
                {
                    os << "null";
                }
                return os;
            }
        };

        inline list<Edge>::iterator NodeData::newInEdge(EdgeData * eData)
        {
            _inEdges.push_back(Edge(eData));
            _inEdgesNb++;
            return --_inEdges.end();
        }

        inline list<Edge>::iterator NodeData::newOutEdge(EdgeData * eData)
        {
            _outEdges.push_back(Edge(eData));
            _outEdgesNb++;
            return --_outEdges.end();
        }

        typedef list<Edge>::iterator InEdgeIterator;
        typedef list<Edge>::iterator OutEdgeIterator;
        typedef list<Edge>::iterator LocalEdgeIterator;

        inline std::size_t hash_value(Diades::Graph::Edge const & e)
        {
            if (!e.valid())
            {
                return 0;
            }
            return boost::hash_value(e.id());
        }
    };
};



namespace std
{

    template <> struct hash<Diades::Graph::Edge>
    {

        size_t operator()(Diades::Graph::Edge const& edge) const
        {
            return Diades::Graph::hash_value(edge);
        }
    };

};


#endif