#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];

}