#include <iostream>

 #include <lemon/list_graph.h>

 #include <lemon/smart_graph.h>

 #include <merge_node_graph_wrapper.h>

 #include<lemon/concept_check.h>

 #include<lemon/concept/graph.h>

 using std::cout;

 using std::endl;

 using namespace lemon;

 using namespace lemon::concept;

 class Graph3 : ListGraph {

 public:

   class Node : public ListGraph::Node { };

   class Edge { };

 };

 int main() {

   typedef SmartGraph Graph1;

   typedef ListGraph Graph2;

 //   {

 //     checkConcept<StaticGraph, NewEdgeSetGraphWrapper<Graph1, Graph2> >(); 

 //   }

   {

   Graph1 g;

   Graph2 h;

   typedef MergeNodeGraphWrapper<Graph1, Graph2> GW;

   GW gw(g, h);

   Graph1::Node n1=g.addNode();

   Graph1::Node n2=g.addNode();

   Graph1::Node n3=g.addNode();

   Graph2::Node n4=h.addNode();

   Graph2::Node n5=h.addNode();

   //GW::NodeIt n(gw)

   for (GW::NodeIt n(gw); n!=INVALID; ++n) { 

     cout << gw.id(n) << endl;

   }

   GW::NodeMap<int> nm(gw);

   int i=0;

   for (GW::NodeIt n(gw); n!=INVALID; ++n) { 

     ++i;

     nm.set(n, i);

   }

   for (Graph1::NodeIt n(g); n!=INVALID; ++n) { 

     cout << nm[n] << endl;

   }

   for (Graph2::NodeIt n(h); n!=INVALID; ++n) { 

     cout << nm[n] << endl;

   }

   gw.print();

   {

 //    typedef SmartGraph Graph1;

     typedef ListGraph Graph1;

     typedef ListGraph Graph2;

     Graph1 g;

     Graph2 h;

     typedef MergeNodeGraphWrapper<Graph1, Graph2> GW;

     GW gw(g, h);    

     gw.print();

   }

   {

 //    typedef SmartGraph Graph1;

     typedef Graph3 Graph1;

     typedef ListGraph Graph2;

     Graph1 g;

     Graph2 h;

     typedef MergeNodeGraphWrapper<Graph1, Graph2> GW;

     GW gw(g, h);    

     gw.print();

   }

   {

 //    typedef SmartGraph Graph1;

     typedef ListGraph Graph1;

     typedef Graph3 Graph2;

     Graph1 g;

     Graph2 h;

     typedef MergeNodeGraphWrapper<Graph1, Graph2> GW;

     GW gw(g, h);    

     gw.print();

   }

   }

   {

     Graph1 g;

     Graph2 h;

     typedef Graph1::Node Node1;

     typedef Graph2::Node Node2;

     typedef NewEdgeSetGraphWrapper<Graph1, Graph2> GW;

     Graph1::NodeMap<Graph2::Node> e_node(g);

     Graph2::NodeMap<Graph1::Node> n_node(h);

     GW gw(g, h, e_node, n_node);

     for (int i=0; i<4; ++i) { 

       Node1 n=g.addNode();

       e_node.set(n, INVALID);

     }

     for (int i=0; i<4; ++i) {

       Graph1::Node n1=g.addNode();

       Graph2::Node n2=h.addNode();

       e_node.set(n1, n2);

       n_node.set(n2, n1);

     }

     for (Graph2::NodeIt n(h); n!=INVALID; ++n)

       for (Graph2::NodeIt m(h); m!=INVALID; ++m)

 	if ((h.id(n)+h.id(m))%3==0) h.addEdge(n, m);

 //     Graph1::NodeIt n(g);

 //     Node1 n1=n;

 //     Node1 n2=++n;

 //     Node1 n3=++n;

 //     Node1 n4=n;

 //     gw.addEdge(n1, n2);

 //     gw.addEdge(n1, n2);

 //     for (EdgeIt(e))

 //   Graph1::Node n1=g.addNode();

 //   Graph1::Node n2=g.addNode();

 //   Graph1::Node n3=g.addNode();

 //   Graph2::Node n4=h.addNode();

 //   Graph2::Node n5=h.addNode();

     for (GW::EdgeIt e(gw); e!=INVALID; ++e) 

       cout << gw.id(e) << endl;

     for (GW::NodeIt n(gw); n!=INVALID; ++n) {

       if (e_node[n]==INVALID) {

  	cout<<gw.id(n)<<" INVALID"<<endl;

       } else {

 	cout <<gw.id(n)<<" "<<h.id(e_node[n])<<" out_edges: ";

 	//	cout << &e_node << endl;

 	//cout << &n_node << endl;

 	for (GW::OutEdgeIt e(gw, n); e!=INVALID; ++e) {

 	  cout<<gw.id(e)<<" ";

 	}

 	cout<< endl;

       }

     }

   }

 }