def_graph.hpp

Go to the documentation of this file.

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


#define DEBUG 1 
#include <string>
#include <map>

// hash_map compiler specifics here
#ifdef __GNUC__
#if (__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ > 0)
  // GCC 3.1 and later
  #include <ext/hash_map>
  namespace std { using namespace __gnu_cxx; }
  namespace __gnu_cxx { using namespace std; }
  #define HASH_NAMESPACE __gnu_cxx
#endif
#endif

#include "boost/graph/adjacency_list.hpp"

#include "Property.hpp"


namespace gns {

  //typedef std::map<std::string, AbstractProperty*> NodeMap;
  //typedef std::map<std::string, AbstractProperty*> EdgeMap;

  typedef boost::adjacency_list <
    boost::listS,          // OutEdge List (per vertex)
    boost::listS,          // Vertex list (vecS would give us automatically indices but remove_vertex needs O(V+E))
    boost::bidirectionalS, // Directed graph, storing both in and out edges
    //boost::property<boost::vertex_index_t, std::string>, // Vertex properties
    //boost::property<boost::edge_index_t, std::string>,   // Edge properties
        boost::no_property,    // Vertex properties
        boost::no_property,    // Edge properties
    boost::no_property,    // Graph properties
    boost::listS           // Edge list
  > Graph_t;

  //typedef boost::property_traits<boost::property_map<Graph_t, boost::vertex_index_t>::type>::value_type NodeID;
  //typedef boost::property_traits<boost::property_map<Graph_t, boost::edge_index_t>::type>::value_type EdgeID;
  typedef std::string NodeID;  
  typedef std::string EdgeID;  
  typedef boost::graph_traits<Graph_t>::vertex_descriptor Node;         
  typedef boost::graph_traits<Graph_t>::edge_descriptor Edge;           
  typedef boost::graph_traits<Graph_t>::vertex_iterator NodeIter;       
  typedef boost::graph_traits<Graph_t>::edge_iterator EdgeIter;         
  typedef boost::graph_traits<Graph_t>::out_edge_iterator OutEdgeIter;  
  typedef boost::graph_traits<Graph_t>::in_edge_iterator InEdgeIter;    
//  typedef std::string PropertyName;


#define foreach_node(G, n) for(gns::NodeIter __next = (G)->first_node(), (n) = __next++; (n) != (G)->last_node(); (n) = __next, ++__next)

#define foreach_edge(G, e) for(gns::EdgeIter __next = (G)->first_edge(), (e) = __next++; (e) != (G)->last_edge(); (e) = __next, ++__next)

#define foreach_in_edge(G, n, e) for(gns::InEdgeIter __next = (G)->first_in_edge(n), (e) = __next++; (e) != (G)->last_in_edge(n); (e) = __next, ++__next)

#define foreach_out_edge(G, n, e) for(gns::OutEdgeIter __next = (G)->first_out_edge(n), (e) = __next++; (e) != (G)->last_out_edge(n); (e) = __next, ++__next)


}



//#include <iostream>
// For the hash_map in gnu c++
namespace HASH_NAMESPACE
{
  template<>
    struct hash< std::string >
    {
      std::size_t
        operator()(const std::string &s) const { return hash<const char *>()( s.c_str() ); }
    };
        

  template <>
    struct hash< void* > // Need this when vertex_descriptor=void*
    {
      std::size_t
        operator()(const void* v) const { return (std::size_t)v; }
    };


  template < typename D, typename V >
    struct hash< boost::detail::edge_desc_impl<D,V> >
    {
      std::size_t
        operator()(const boost::detail::edge_desc_impl<D,V> __x) const { return (std::size_t)__x.get_property(); }
    };

/*  template<> struct hash<void*> {
    size_t operator()(void* __x) const { return (long)__x; }
  };
  template<> struct hash<gns::Edge> {
    size_t operator()(gns::Edge __x) const { std::cout << "H" << &__x << std::endl; return (long)&__x; }
  };*/
}


#endif

---