GraphNodeSet.hh

Go to the documentation of this file.

#ifndef __DIADES__GRAPH__GRAPHNODESET__HH
#define __DIADES__GRAPH__GRAPHNODESET__HH

#include <set>
#include <unordered_set>
//#include <boost/archive/text_oarchive.hpp>
//#include <boost/archive/text_iarchive.hpp>
#include <diades/utils/Assertion.hh>
#include <diades/utils/Exceptions.hh>
#include <diades/graph/Graph.hh>



using namespace std;



namespace Diades
{
        namespace Graph
        {

                class GraphNodeSet
                {
                public:
                        using Node = Diades::Graph::Node;
                        static string
                        typeName()
                        {
                                return "Graph::GraphNodeSet";
                        }
                        using Exception =  Diades::Utils::Exception<GraphNodeSet>;
                        using Iterator = set<Node>::const_iterator;
                protected:
                        
                        const Graph & _grph;

                        //        template<class Archive>
                        //        void serialize(Archive & ar, const unsigned int version)
                        //        {
                        //              ar & const_cast<Graph *>(_grph);
                        //              ar & _nodes;
                        //        }

                protected:
                        set<Node> _nodes;




                public:

                        GraphNodeSet(const Graph & graph) : _grph(graph), _nodes()
                        {
                        }

                        GraphNodeSet(const Graph & graph, Node n);

                        GraphNodeSet(const Graph & graph, const set<Node> & n);



                        GraphNodeSet(const Graph & graph, const unordered_set<Node> & s);




                        GraphNodeSet(const GraphNodeSet & ns);






                        void insertNode(Node n);

                        template<class InputNodeIterator>
                        void
                        insertNodes(InputNodeIterator first, InputNodeIterator last)
                        {
                                _nodes.insert(first, last);
                        }

                        void removeNode(Node n);

                        Iterator
                        findNode(Node n) const
                        {
                                require(Exception, n.valid(), "findNode: the node n is invalid.");
                                require(Exception, &n.owner() == &_grph, "findNode: the node n has an incorrect owner.");
                                return _nodes.find(n);
                        }

                        bool
                        isEmpty() const
                        {
                                return _nodes.empty();
                        }

                        int
                        size() const
                        {
                                return _nodes.size();
                        }


                        GraphNodeSet * nextGraphNodeSet(const set<Edge> & edges) const;


                        GraphNodeSet * previousGraphNodeSet(const set<Edge> & edges) const;

                        const Graph &
                        graph() const
                        {
                                return _grph;
                        }

                        Iterator
                        begin() const
                        {
                                return _nodes.begin();
                        }

                        Iterator
                        end() const
                        {
                                return _nodes.end();
                        }

                        set<Node> &
                        setOfNodes()
                        {
                                return _nodes;
                        }

                        bool operator==(const GraphNodeSet & ns) const
                        {
                                return(&_grph == &ns._grph) && (_nodes == ns._nodes);
                        }

                        friend ostream & operator<<(ostream & os, const GraphNodeSet & s);


                };


        };
};
#endif