GraphIntOld.hh

Go to the documentation of this file.

#ifndef __DIADES__GRAPH__GRAPHINT__HH
#define __DIADES__GRAPH__GRAPHINT__HH

#include <vector>
#include <unordered_set>
#include <unordered_map>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/list.hpp>
#include <diades/utils/Assertion.hh>
#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/Graph.hh.hh>



namespace Diades
{
  namespace Graph
  {
        class Graph {

        private:
          GraphData * _data;
          
        public:
          typedef vector<Node>::size_type SizeType;

          
          
        
        public :


          Graph():_data(nullptr){
              std::cout << "GDefault: data = " << _data << std::endl;
          }

          Graph(GraphData * data):_data(data)
          {
            std::cout << "GGraphData: data = " << _data << std::endl;
          }

          Graph(const Graph & g):_data(g._data)
          {
            std::cout << "Gcopy: data = " << _data << std::endl;
          }

          const GraphData * data() const 
          { 
              std::cout << "GconstData: data = " << _data << std::endl;
              return _data; 
          }

          GraphData * data()  
          { 
              std::cout << "GnonconstData: data = " << _data << std::endl;
              return _data; 
          }

          unsigned id() const
          {
                if(valid())
                  {
                        return _data->id();
                  }
                return 0;
          }
          
          void init()
          {
                if(valid())
                  {
                    std::cout << "Ginit(valid): b data = " << _data << std::endl;
                    _data->clear();
                    std::cout << "Ginit(valid): a data = " << _data << std::endl;
                  }
                else
                  {
                      std::cout << "Ginit(not valid): b data = " << _data << std::endl; 
                        _data = new GraphData();
                        std::cout << "Ginit(not valid): a data = " << _data << std::endl; 
                  }
          }

          void destroy()
          {
              std::cout << "Gdestroy: b data = " << _data << std::endl;
              if(valid())
              {
                   std::cout << "Gdestroy (valid): b data = " << _data << std::endl;
                delete _data;
                std::cout << "Gdestroy (valid): after delet data = " << _data << std::endl;
                _data = nullptr;
                std::cout << "Gdestroy (valid): finally data = " << _data << std::endl;
              }
          }

          
          virtual ~Graph(){
              std::cout << "Gdestructor data = " << _data << std::endl;
          }







          bool succeeds(const Node & n1, const Node & n2) const
          {
                return _data->succeeds(n1,n2);
          }


          bool preceeds(const Node & n1, const Node & n2) const
          {
                return succeeds(n2,n1);
          }






          

          //****************** Accessors *********************************

          bool operator==(const Graph & g) const
          {
                return _data == g._data;
          }

          
          bool operator!=(const Graph & g) const
          {
                return !( (*this) == g );
          }
          
          bool operator<(const Graph & g) const
          {
                if(!g.valid())
                  {
                        return false;
                  }
                else
                  {
                        if(!valid())
                          {
                                return true;
                          }
                        else
                          {
                                return id() < g.id();
                          }
                  }
          }

          SizeType numberOfNodes() const
          {
                require(GraphInvalid, valid(),"Graph::numberOfNodes, invalid graph");
                return _data->numberOfNodes();
          }
  
          SizeType numberOfEdges() const
          {
                require(GraphInvalid, valid(),"Graph::numberOfEdges, invalid graph");
                return _data->numberOfEdges();
          }
  
          bool empty() const
          {
                require(GraphInvalid, valid(),"Graph::empty(), invalid graph");
                return numberOfNodes()==0;
          }


          Node target(const Edge & edge) const;
          

          Node  source(const Edge & edge) const;
          

          
          const Node & targetRef(const Edge & edge) const;
          

          const Node & sourceRef(const Edge & edge) const;
          




          
          Node getNode(unsigned id) const;

          Edge getEdge(unsigned id) const;
          
          void transitiveClosure(Edge edge);


          bool cycleDetection(const Node & n) const
          {
                require(GraphInvalid, valid(),"Graph::cycleDetection(), invalid graph");
                return _data->cycleDetection(n);
          }




          Node  newNode();


          Edge  newEdge(Node  source, Node  target)
          {
                require(GraphInvalid, valid(),"Graph::newEdge(), invalid graph");
                return _data->newEdge(source,target);
          }
          

          virtual void deleteNode(Node & node)
          {
                require(GraphInvalid, valid(),"Graph::deleteNode(), invalid graph");
                return _data->deleteNode(node);
          }




          virtual void deleteNode(NodeIterator start,NodeIterator end)
          {
                require(GraphInvalid, valid(),"Graph::deleteNode(), invalid graph");
                return _data->deleteNode(start,end);
          }
          



          virtual void deleteEdge(Edge & edge)
          {
                require(GraphInvalid, valid(),"Graph::deleteEdge(), invalid graph");
                return _data->deleteEdge(edge);
          }



          virtual void deleteEdge(EdgeIterator start, EdgeIterator end)
          {
                require(GraphInvalid, valid(),"Graph::deleteEdge(), invalid graph");
                return _data->deleteEdge(start,end);
          }
          
          virtual void deleteEdge(LocalEdgeIterator start, LocalEdgeIterator end)
          {
                require(GraphInvalid, valid(),"Graph::deleteEdge(), invalid graph");
                return _data->deleteEdge(start,end);
          }


          virtual void deleteAllEdges()
          {
                require(GraphInvalid, valid(),"Graph::deleteAllEdges(), invalid graph");
                return _data->deleteAllEdges();
          }


          // /** Elimination of edge paths
          //  *  @param s a Node
          //  *  @pre s.valid() && s.owner()==this
          //  *  @post s.outDeg()==0
          //  *
          //  *  Elimination of transition paths from the state s in the current graph.
          //  */
          // virtual void eliminatePathsFrom(Node s);

          void clear()
          {
                require(GraphInvalid, valid(),"Graph::clear(), invalid graph");
                _data->clear();
          }



          NodeIterator nodeBegin() {
                require(GraphInvalid, valid(),"Graph::nodeBegin(), invalid graph");
                return NodeIterator(&_data->_vNodes,0);
          }

          NodeIterator nodeEnd()  {
                require(GraphInvalid, valid(),"Graph::nodeEnd(), invalid graph");
                return  NodeIterator(&_data->_vNodes,_data->_vNodes.size());
          }



          NodeIterator nodeBegin() const {
                require(GraphInvalid, valid(),"Graph::nodeBegin(), invalid graph");
                return NodeIterator(&_data->_vNodes,0);
          }

          NodeIterator nodeEnd()  const {
                require(GraphInvalid, valid(),"Graph::nodeEnd(), invalid graph");
                return  NodeIterator(&_data->_vNodes,_data->_vNodes.size());
          }


  
 

          EdgeIterator edgeBegin()
          {
                require(GraphInvalid, valid(),"Graph::edgeBegin(), invalid graph");
                return EdgeIterator(&_data->_vEdges,0);
          }

          EdgeIterator edgeEnd()
          {
                require(GraphInvalid, valid(),"Graph::edgeEnd(), invalid graph");
                return EdgeIterator(&_data->_vEdges,_data->_vEdges.size());
          }


          EdgeIterator edgeBegin() const
          {
                require(GraphInvalid, valid(),"Graph::edgeBegin(), invalid graph");
                return EdgeIterator(&_data->_vEdges,0);
          }

          EdgeIterator edgeEnd() const
          {
                require(GraphInvalid, valid(),"Graph::edgeEnd(), invalid graph");
                return EdgeIterator(&_data->_vEdges,_data->_vEdges.size());
          }

  
          OutEdgeIterator outEdgeBegin(const Node & node) const;

          OutEdgeIterator outEdgeEnd(const Node &  node) const;

          InEdgeIterator inEdgeBegin(const Node & node) const;

          InEdgeIterator inEdgeEnd(const Node & node) const; 

 

          //@name Others

          Graph & operator=(const Graph &g)
          {
                if(this != &g)
                  {
                        _data = g._data;
                  }
                return *this;
          }

          // /** Size of a graph
          //  *  @return the memory usage of a graph
          //  **/
          // SizeType memoryUsage() const;
        
          // /** Size of a sub-graph
          //  *  @param transitions to measure
          //  *  @return the memory usage of a sub-graph
          //  **/
          // SizeType memoryUsage(const unordered_set<Edge> & transitions) const;


          // /** Size of a graph (nodes)
          //  *  @return the memory usage of the graph nodes
          //  **/
          // SizeType nodeMemoryUsage() const;

          // /** Size of a graph (edges)
          //  *  @return the memory usage of the graph edges
          //  **/
          // SizeType edgeMemoryUsage() const;



          SizeType edgeCapacity() const {
                require(GraphInvalid,valid(),"Graph::edgeCapacity(), invalid graph");
                return _data->edgeCapacity();
          }

          
          SizeType nodeCapacity() const {
                require(GraphInvalid,valid(),"Graph::nodeCapacity(), invalid graph");
                return _data->nodeCapacity();
          }


          bool sanityCheck(string & log) const
          {
                if(!valid()) { log+="The graph is invalid"; return false; }
                return _data->sanityCheck(log);
          }


          bool valid() const
          {
                return _data != nullptr;
          }

        public:

          ostream & toDot(ostream & os);




          
        public:
          template<class Archive>
          void serialize(Archive & ar, const unsigned int version)
          {
                ar & _data;
          }


          friend ostream & operator << (ostream & os, const Graph & g)
          {
                return os << "[GRAPH: " << g._data << "]";
          }
        };

        inline Node Graph::getNode(unsigned id) const
        {
          if(valid())
                {
                  return _data->getNode(id);
                }
          return Node();
        }
        
        inline Edge Graph::getEdge(unsigned id) const
        {
          if(valid())
                {
                  return _data->getEdge(id);
                }
          return Edge();
        }
        
        inline Node  Graph::newNode()
        {
          require(GraphInvalid, valid(),"Graph::newNode(), invalid graph, please apply the init() method to the graph before!!");
          return _data->newNode();
        }
        
        
        inline Node  Graph::target(const Edge & edge) const
        {
          require(GraphInvalid, valid(),"Graph::target(), invalid graph");
          require(GraphInvalid, edge.valid() && (edge.owner() == *this),"Graph::target, invalid edge");
          return _data->target(edge);
        }
        
        
        inline Node Graph::source(const Edge & edge) const
        {
          require(GraphInvalid, valid(),"Graph::source(), invalid graph");
          require(GraphInvalid, edge.valid() && (edge.owner() == *this),"Graph::source, invalid edge");
          return _data->source(edge);
        }


        inline Node GraphData::target(const Edge & edge) const
        {
          require(GraphInvalid, edge.valid() && (edge.owner().data() == this),"GraphData::target, invalid edge");
          return _vNodes[edge._eData->_target->identifier()];
        }
        
        
        inline  Node GraphData::source(const Edge & edge) const
        {
          require(GraphInvalid, edge.valid() && (edge.owner().data() == this),"GraphData::source, invalid edge");
          return _vNodes[edge._eData->_source->identifier()];
        }
          


        inline const Node &  Graph::targetRef(const Edge & edge) const
        {
          require(GraphInvalid, valid(),"Graph::target(), invalid graph");
          require(GraphInvalid, edge.valid() && (edge.owner() == *this),"Graph::target, invalid edge");
          return _data->targetRef(edge);
        }
        
        
        inline const Node & Graph::sourceRef(const Edge & edge) const
        {
          require(GraphInvalid, valid(),"Graph::source(), invalid graph");
          require(GraphInvalid, edge.valid() && (edge.owner() == *this),"Graph::source, invalid edge");
          return _data->sourceRef(edge);
        }


        inline const Node & GraphData::targetRef(const Edge & edge) const
        {
          require(GraphInvalid, edge.valid() && (edge.owner().data() == this),"GraphData::target, invalid edge");
          return _vNodes[edge._eData->_target->identifier()];
        }
        
        
        inline  const Node & GraphData::sourceRef(const Edge & edge) const
        {
          require(GraphInvalid, edge.valid() && (edge.owner().data() == this),"GraphData::source, invalid edge");
          return _vNodes[edge._eData->_source->identifier()];
        }
          














        inline OutEdgeIterator Graph::outEdgeBegin(const Node & node) const {
          require(GraphInvalid, node.valid() && (node.owner() == *this),"Graph::outEdgeBegin, invalid node");
          return node.outEdgeBegin();
        }

        
        inline OutEdgeIterator Graph::outEdgeEnd(const Node &  node) const {
          require(GraphInvalid,node.valid() && (node.owner() == *this),"Graph::outEdgeEnd, invalid state");
          return node.outEdgeEnd();
        }
        
        
        inline InEdgeIterator Graph::inEdgeBegin(const Node & node) const {
          require(GraphInvalid, node.valid() && (node.owner() == *this),"Graph::inEdgeBegin, invalid node");
          return node.inEdgeBegin();
        }
        
        
        inline InEdgeIterator Graph::inEdgeEnd(const Node & node) const {
          require(GraphInvalid,node.valid() && (node.owner() == *this),"Graph::inEdgeEnd, invalid state");
          return node.inEdgeEnd();
        }



        
        template<typename InputIterator>
        inline void deleteEdge(Graph & g, InputIterator first, InputIterator last)
        {
          for(; first!= last; ++first)
                {
                  g.deleteEdge(*first);
                }
        }
        template<typename InputIterator>
        inline void deleteEdge(GraphData & g, InputIterator first, InputIterator last)
        {
          for(; first!= last; ++first)
                {
                  g.deleteEdge(*first);
                }
        }
  
        template<typename InputIterator>
        inline void deleteNode(Graph & g, InputIterator first, InputIterator last)
        {
          for(; first!= last; ++first)
                {
                  g.deleteNode(*first);
                }
        }

        
        template<typename InputIterator>
        inline void deleteNode(GraphData & g, InputIterator first, InputIterator last)
        {
          for(; first!= last; ++first)
                {
                  g.deleteNode(*first);
                }
        }
        template<typename InputIterator,typename Predicate>
        inline void deleteNode(Graph & g, InputIterator first, InputIterator last, Predicate pred)
        {
          for(; first!= last; ++first)
                {
                  if(pred()(*first))
                        {
                          g.deleteNode(*first);
                        }
                }
        }


        
        

  };
};


namespace boost {
  namespace serialization {


        template<class Archive>
        void save(Archive & ar, const ::Diades::Graph::GraphData & g,  const unsigned int version)
        {
          unsigned nbNodes = g.numberOfNodes();
          ar & nbNodes;
          unsigned nbEdges = g.numberOfEdges();
          ar & nbEdges;
          ar & g.listEdgeId();
          ar & g.listNodeId();
          unsigned size = g.vNodes().size();
          ar & size;
          for(::Diades::Graph::SizeType i = 0; i < size; ++i)
                {
                  if(g.vNodes().operator[](i).valid())
                        {
                          int id = g.vNodes().operator[](i).id();
                          ar & id; // == i?
                        }
                }
          size = g.vEdges().size();
          ar & size;
          for(::Diades::Graph::SizeType i = 0; i < size; ++i)
                {
                  if(g.vEdges().operator[](i).valid())
                        {
                          int id = g.vEdges().operator[](i).id();
                          ar & id;
                          id = g.vEdges().operator[](i).source().id();
                          ar & id;
                          id =  g.vEdges().operator[](i).target().id();
                          ar & id;
                        }
                }
          
        }


        
        template<class Archive>
        void load(Archive & ar, ::Diades::Graph::GraphData & g, const unsigned int version)
        {
          unsigned nbNodes;
          ar & nbNodes;
          unsigned nbEdges;
          ar & nbEdges;
          ar & g.listEdgeId();
          ar & g.listNodeId();
          ::Diades::Graph::SizeType size;
          ar & size;
          g.vNodes().resize(size);
          for(::Diades::Graph::SizeType i = 0; i < nbNodes; ++i)
                {
                  ::Diades::Graph::SizeType validNodeIndex;
                  ar & validNodeIndex;
                  g.newNode(validNodeIndex);
                }
          ar & size;
          g.vEdges().resize(size);
          for(::Diades::Graph::SizeType i = 0; i < nbEdges; ++i)
                {
                  ::Diades::Graph::SizeType validEdgeIndex;
                  ar & validEdgeIndex;
                  ::Diades::Graph::SizeType sourceNodeId;
                  ar & sourceNodeId;
                  ::Diades::Graph::SizeType targetNodeId;
                  ar & targetNodeId;
                  g.newEdge(validEdgeIndex, g.vNodes().operator[](sourceNodeId),g.vNodes().operator[](targetNodeId));
                }
        }
  };

};
                
BOOST_SERIALIZATION_SPLIT_FREE(::Diades::Graph::GraphData)



#endif