Node.hh

Go to the documentation of this file.

#ifndef __DIADES__GRAPH__NODE__HH
#define __DIADES__GRAPH__NODE__HH

#include <list>
#include <boost/functional/hash.hpp>
#include <diades/graph/GraphGen.hh>
#include <diades/graph/EdgeData.hh>
#include <diades/graph/NodeData.hh>
#include <diades/graph/Edge.hh>



namespace Diades
{
    namespace Graph
    {

        class Node
        {
        public:

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

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

        public:


            Node() : _nData(nullptr)
            {
            }

            Node(const Node & node) : _nData(node._nData)
            {
            }

            Node(NodeData * data) : _nData(data)
            {
                require(Exception, data != nullptr,
                        "Node: null data pointer");
            }

            ~Node()
            {
            }

            NodeData * data()
            {
                return _nData;
            }

            Node & operator=(const Node & node)
            {
                if (this != &node)
                {
                    _nData = node._nData;
                }
                return *this;
            }





            SizeType memoryUsage() const
            {
                return sizeof (Node);
            }

            SizeType degree() const
            {
                require(Exception, valid(), "Node::degree: invalid node");
                return outDeg() + inDeg();
            }

            SizeType outDeg() const
            {
                require(Exception, valid(), "Node::outDeg: invalid node");
                return _nData->outEdgesNb();
            }

            SizeType inDeg() const
            {
                require(Exception, valid(), "Node::inDeg: invalid node");
                return _nData->inEdgesNb();
            }

            OutEdgeIterator outEdgeBegin() const
            {
                require(Exception, valid(), "Node::outEdgeBegin: invalid node");
                return _nData->outEdges().begin();
            }

            OutEdgeIterator outEdgeEnd() const
            {
                require(Exception, valid(), "Node::outEdgeEnd: invalid node");
                return _nData->outEdges().end();
            }

            InEdgeIterator inEdgeBegin() const
            {
                require(Exception, valid(), "Node::inEdgeBegin: invalid node");
                return _nData->inEdges().begin();
            }

            InEdgeIterator inEdgeEnd() const
            {
                require(Exception, valid(), "Node::inEdgeEnd: invalid node");
                return _nData->inEdges().end();
            }

            bool valid() const;

            bool operator==(const Node & node) const
            {
                return node._nData == _nData;
            }

            bool operator!=(const Node & node) const
            {
                return !(*this == node);
            }

            bool operator<(const Node & node) const;

            bool operator>(const Node & node) const
            {
                return !((*this == node) || ((*this) < node));
            }




            const Graph & owner() const;

            NodeId id() const
            {
                require(Exception, valid(), "id: node is not valid");
                return _nData->identifier();

            }


            void printInformation() const;


        private:

            void create(NodeId idt, Graph * own);

            void destroy()
            {
                require(Exception, _nData == nullptr || (_nData->inEdges().empty() && _nData->outEdges().empty()),
                        "Node::destroy: _nData is not null and output or input edges exist");
                if (_nData != nullptr)
                {
                    delete _nData;
                    _nData = nullptr;
                }
                ensure(Exception, !valid(), "Node::destroy: valid node");
            }

            void changeId(NodeId id)
            {
                require(Exception, valid(), "Node::changeId: invalid node");
                _nData->setIdentifier(id);
            }


            NodeData * _nData; 

            friend class Graph;

            //@name stream operation

            friend ostream & operator<<(ostream & os, const Node & node)
            {
                if (node.valid())
                {
                    os << node.id();
                } else
                {
                    os << "null_node";
                }
                return os;
            }

        public:

            //    template<class Archive>
            //    void save(Archive & ar, const unsigned int version) const;
            //
            //    
            //    template<class Archive>
            //    void load(Archive & ar, const unsigned int version);
            //
            //    BOOST_SERIALIZATION_SPLIT_MEMBER() 

        };

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



namespace std
{

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

        size_t operator()(Diades::Graph::Node const& node) const
        {
            return Diades::Graph::hash_value(node);
        }
    };

};







#endif