#include <iostream>

 #include <smart_graph.h>

 using namespace lemon;

 template<class GG,class TT>

 class CinCoutMap

 {

 public:

   typedef GG Graph;

   typedef typename GG::Edge Edge;

   typedef Edge Key;

   typedef TT Value;

   class RefType 

   {

     Graph &G;

     Edge e;

   public:

     RefType(Graph &_G,Edge _e) : G(_G), e(_e) { }

     operator Value() const 

     {

       Value tmp;

       std::cout << G.id(G.source(e)) << "->"

 		<< G.id(G.target(e)) << ": ";

       std::cin  >> tmp;

       return tmp;

     }

     Value operator = (Value v) const

     {

       std::cout << G.id(G.source(e)) << "->"

 		<< G.id(G.target(e)) << ": " << v << '\n';

       return v;

     }

   };

 private:

   Graph &G;

 public:

   CinCoutMap(Graph &_G) : G(_G) { }

   RefType operator[] (Edge e) const { return RefType(G,e);}  

 };

 template<class K,class T>

 class NullMap

 {

 public:

   typedef K Key;

   typedef T Value;

   class RefType 

   {

     Value val;

   public:

     RefType(Value v) : val(v) { }   

     operator Value() const { return val; }

     Value operator = (Value v) const { return val; }

   };

 private:

   Value val;

 public:

   NullMap(Value v) : val(v) { }

   RefType operator[] (Key e) const { return RefType(v);}  

 };

 int main()

 {

   typedef SmartGraph Graph;

   typedef Graph::NodeIt NodeIt;

   typedef Graph::OutEdgeIt OutEdgeIt;

   typedef Graph::EdgeIt EdgeIt;

   Graph G;

   CinCoutMap<Graph,int> map(G);

   Graph::EdgeMap<int> emap(G);

   for(int i=0;i<3;i++) G.addNode();

   for(NodeIt n(G);G.valid(n);G.next(n))

     for(NodeIt m(G);G.valid(m);G.next(m)) if(n!=m)

       G.addEdge(n,m);

   //for(OutEdgeIt e(G,NodeIt(G));G.valid(e);G.next(e))

   for(EdgeIt e(G);G.valid(e);G.next(e)) emap[e] = map[e];

   std::cout << '\n';

   for(EdgeIt e(G);G.valid(e);G.next(e))  map[e] = emap[e];

 }