#include <iostream>
#include <boost/graph/breadth_first_search.hpp>
#include <algorithm>
#include <boost/graph/adjacency_list.hpp>
#include <boost/bind.hpp>

using namespace std;
using namespace boost;

typedef adjacency_list 
<
   listS,
   listS,
   undirectedS,
   property<vertex_name_t, uint32_t>,
   property<edge_name_t, uint32_t>
> Graph;

typedef property_map<Graph, vertex_name_t>::type v_name_map_t;
typedef property_map<Graph, edge_name_t>::type e_name_map_t;
typedef property_map<Graph, vertex_name_t>::const_type const_v_name_map_t;
typedef property_map<Graph, edge_name_t>::const_type const_e_name_map_t;
typedef graph_traits<Graph>::vertex_descriptor Vertex;
typedef graph_traits<Graph>::edge_descriptor Edge;
typedef graph_traits<Graph>::vertex_iterator VertexIterator;
typedef graph_traits<Graph>::edge_iterator EdgeIterator;

class Visitor : 
   public default_bfs_visitor
{
   public:
   void tree_edge(Edge e, const Graph& g) const
   {
      Vertex u = source(e, g);
      Vertex v = target(e, g);
      const_v_name_map_t vmap = get(vertex_name, g);
      uint32_t u_name = vmap[u];
      uint32_t v_name = vmap[v];
      cout << u_name << " " << v_name << endl;
   }
};

class Op
{
   public:
      void operator()(Edge e, int a)
      {
         cout << "Op" << endl;
      }
};

class Op1
{
   public:
      void operator()(Vertex e, int a)
      {
         cout << "Op1" << endl;
      }
};

int
main(int argc, char* argv[])
{
   Graph g;
   Vertex u = add_vertex(g);
   Vertex v = add_vertex(g);
   Edge e;
   bool inserted;
   tie(e, inserted) = add_edge(u,v,g);
   v_name_map_t vmap = get(vertex_name, g);
   e_name_map_t emap = get(edge_name, g);
   vmap[v] = 1;
   vmap[u] = 2;
   emap[e] = 1;
   Op func_obj;
   Op1 func_obj1;
   EdgeIterator start, end;
   tie(start, end) = edges(g);
   for_each(start, end, bind<void>(func_obj, _1, 2));
   VertexIterator vstart, vend;
   tie(vstart, vend) = vertices(g);
   for_each(vstart, vend, bind<void>(func_obj1, _1, 2));
   return 0;
}