ConstGraph.hpp

Go to the documentation of this file.

// vim:sw=2:ts=8
#ifndef CONST_GRAPH__HPP
#define CONST_GRAPH__HPP

#include <map>
#include <deque>
#include "boost/graph/adjacency_list.hpp"

#include "def_graph.hpp"
#include "PropertyFacility.hpp"


namespace gns {


  class ConstGraph
  {
    protected:
      Graph_t *graph;
      PropertyFacility *prop;

      typedef std::hash_map<NodeID, Node> id_node_map_t;
      typedef std::hash_map<EdgeID, Edge> id_edge_map_t;

      typedef std::hash_map<Node, NodeID> node_id_map_t;
      //typedef boost::property_map<Graph_t, boost::vertex_index_t>::type node_id_map_t;
      typedef std::hash_map<Edge, EdgeID> edge_id_map_t;
      //typedef boost::property_map<Graph_t, boost::edge_index_t>::type edge_id_map_t;

      node_id_map_t node_id_map;
      id_node_map_t id_node_map;

      edge_id_map_t edge_id_map;
      id_edge_map_t id_edge_map;


    public:
      ConstGraph();
      ConstGraph(PropertyFacility *p);
      ConstGraph(const ConstGraph &g);

      virtual ~ConstGraph();


      virtual bool node_exists(Node n) const;

      virtual bool node_exists(NodeID id) const;

      virtual Node node(const NodeID id) const;

      virtual NodeID node_id(const Node n) const;

      virtual void node_id(Node n, const NodeID id);

      virtual bool edge_exists(Edge e) const;

      virtual bool edge_exists(const EdgeID id) const;
      
      virtual Edge edge(const EdgeID id) const;

      virtual Edge edge(const Node u, const Node v) const;

      virtual EdgeID edge_id(const Edge e) const;

      virtual void edge_id(Edge e, const EdgeID id);

      /*void rebuild_node_ids();*/

      virtual void print() const;


      long num_nodes() const;

      long num_edges() const;

      long indeg(const Node n) const;

      long outdeg(const Node n) const;

      Node source(const Edge e) const;

      Node target(const Edge e) const;

      Node opposite(const Edge e, const Node n) const;

      NodeIter first_node() const;

      NodeIter last_node() const;

      EdgeIter first_edge() const;

      EdgeIter last_edge() const;

      OutEdgeIter first_out_edge(const Node n) const;

      OutEdgeIter last_out_edge(const Node n) const;

      InEdgeIter first_in_edge(const Node n) const;

      InEdgeIter last_in_edge(const Node n) const;

      PropertyFacility* properties() const;

      bool valid_node(Node n) const;

      bool valid_edge(Edge e) const;



    protected:

      virtual Node priv_new_node(NodeID id = "");

      virtual void priv_del_node(Node n);

      virtual Edge priv_new_edge(Node u, Node v, EdgeID id = "");

      virtual void priv_del_edge(Edge e);

      virtual void priv_del_edge(Node u, Node v);
 
      virtual void priv_add_nodes(int num, int start);

      virtual std::map<Node, Node>* init_copy(const ConstGraph *g, bool return_map);

      virtual void init(PropertyFacility *p);

  };


}

#endif

---