Re: [Boost-users] Graph: writing graph properties to graphml file

Subject: Re: [Boost-users] Graph: writing graph properties to graphml file
From: Juerg Tschirren (juerg.tschirren_at_[hidden])
Date: 2012-03-15 11:22:13

I still have a problem getting graph properties written to a graphml file
(vertex and edge properties get written just fine). Following Jeremiah's
advise form two weeks ago I implemented the code below. The problem appears
to be that the instance of ref_property_map contained in the
dynamic_properties uses the key type Graph*, but the write_graphml function
implemented in boost/graph/graphml.hpp expects it to be of type Graph. This
of course results in a different typeid and the write_graphml function does
not recognize the entry in the dynamic properties as graph properties. I
tried to change the key type of ref_property_map to Graph, which resulted
in a compilation error. Any insight in how to solve that problem would be
greatly appreciated!

Here is my current code:
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/graphml.hpp>

struct VertexProperties {
  std::string strName;
};

struct EdgeProperties {
  std::string strName;
};

struct GraphProperties {
  std::string strName;
};

std::ostream& operator<< (std::ostream& strm, const VertexProperties& p) {
  strm << p.strName;
  return strm;
}

std::istream& operator>> (std::istream& strm, VertexProperties& p) {
  strm >> p.strName;
  return strm;
}

std::ostream& operator<< (std::ostream& strm, const EdgeProperties& p) {
  strm << p.strName;
  return strm;
}

std::istream& operator>> (std::istream& strm, EdgeProperties& p) {
  strm >> p.strName;
  return strm;
}

std::ostream& operator<< (std::ostream& strm, const GraphProperties& p) {
  strm << p.strName;
  return strm;
}

std::istream& operator>> (std::istream& strm, GraphProperties& p) {
  strm >> p.strName;
  return strm;
}

typedef boost::property<boost::vertex_name_t, VertexProperties> vertex_p;
typedef boost::property<boost::edge_weight_t, EdgeProperties> edge_p;
typedef boost::property<boost::graph_name_t, GraphProperties> graph_p;

typedef boost::adjacency_list<boost::listS, boost::vecS,
boost::directedS, vertex_p, edge_p, graph_p> Graph;

typedef boost::graph_traits<Graph>::vertex_descriptor vertex_t;
typedef boost::graph_traits<Graph>::edge_descriptor edge_t;

typedef boost::property_map<Graph, boost::vertex_name_t>::type
vertex_prop_t;
typedef boost::property_map<Graph, boost::edge_weight_t>::type edge_prop_t;
typedef boost::ref_property_map<Graph*, GraphProperties> graph_propt_t;

int main() {

  //-- create a graph:
  Graph g;
  vertex_t u = boost::add_vertex(g);
  vertex_t v = boost::add_vertex(g);
  edge_t e; bool b;
  boost::tie(e,b) = boost::add_edge(u,v,g);

  //-- get the property maps:
  vertex_prop_t vertexPropMap = boost::get(boost::vertex_name, g);
  edge_prop_t edgePropMap = get(boost::edge_weight, g);
  GraphProperties& graphProp = boost::get_property(g, boost::graph_name);

  //-- set some vertex, edge, and graph properties:
  vertexPropMap[u].strName = "first vertex";
  vertexPropMap[v].strName = "second vertex";
  edgePropMap[e].strName = "an edge";
  graphProp.strName = "the graph";

  //-- create dynamic property map:
  boost::dynamic_properties dp(boost::ignore_other_properties);
  dp.property("vertex_properties", vertexPropMap);
  dp.property("edge_properties", edgePropMap);
  graph_propt_t graphPropMap(graphProp);
  dp.property("graph_properties", graphPropMap);

  //-- write graphml to file:
  std::ofstream graphmlOutFile("graph.xml");
  boost::write_graphml(graphmlOutFile, g, dp, true);
  graphmlOutFile.close();

  return 0;
}

On Thu, 1 Mar 2012, Jeremiah Willcock  wrote:
> On Tue, 28 Feb 2012, Juerg Tschirren wrote:

> > I wrote the code below to construct a directed graph with internal
properties (for vertices, edges, and the graph itself) and write everything
to a graphml file. The code
> > compiles and works as it is, but my two questions are:
> >
> > 1. What dynamic property do I have to add to write the graph properties
out to the graphml file as well? So far I could only figure out how to
write vertex and edge
> > properties.

> You should be able to add a graph property like in the following code
> (from libs/graph/test/graphviz_test.cpp):

> boost::ref_property_map<graph_t*,std::string> gname(
>    get_property(graph,graph_name));
> dp.property("name",gname);

> > 2. Does everything else look good? Specifically, is it O.K. to define
the properties the way I did in the first typedef line (without using
boost::property<>), and is it
> > O.K. to access the properties the way I do it?

> It will work, but a better way would be to use boost::property or a class
> containing your string which you can then access using g[v].mem or
> g[e].mem.

>-- Jeremiah Willcock