#include <iostream>

 #include <vector>

 #include <smart_graph.h>

 using namespace lemon;

 ///\todo This is only a static map!

 ///

 template<class GG>

 class BoolIterEdgeMap

 {

 public:

   typedef GG Graph;

   typedef typename GG::Edge Edge;

   typedef Edge Key;

   typedef bool Value;

   friend class RefType;

   friend class FalseIterator;

   friend class TrueIterator;

 private:

   Graph &G;

   typename Graph::EdgeMap<int> cref;

   std::vector<Edge> vals;

   int sep;           //map[e] is true <=> cref[e]>=sep

   bool isTrue(Edge e) {return cref[e]>=sep;}

   void swap(Edge e, int s) 

   {

     int ti=cref[e];

     Edge te=vals[s];

     cref[e]=s; vals[s]=e;

     cref[te]=ti; vals[ti]=te;

   }  

   void setTrue(Edge e) { if(cref[e]<sep) { sep--; swap(e,sep); } }

   void setFalse(Edge e) { if(cref[e]>=sep) { swap(e,sep); sep++; } }

 public:

   class FalseIterator 

   {

     BoolIterEdgeMap &M;

     int i;

   public:

     FalseIterator(BoolIterEdgeMap &_M) : M(_M), i(0) { }

     FalseIterator &operator++() { ++i; return *this;}

     operator Edge() { return i<M.sep ? M.vals[i] : INVALID; }

     operator bool() { return i<M.sep; }

   };

   class TrueIterator 

   {

     BoolIterEdgeMap &M;

     int i;

   public:

     TrueIterator(BoolIterEdgeMap &_M) : M(_M), i(M.vals.size()-1) { }

     TrueIterator &operator++() { --i; return *this;}

     operator Edge() { return i>=M.sep ? M.vals[i] : INVALID; }

     operator bool() { return i>=M.sep; }

   };

   class RefType 

   {

     BoolIterEdgeMap &M;

     Edge e;

   public:

     RefType(BoolIterEdgeMap &_M,Edge _e) : M(_M), e(_e) { }

     operator Value() const 

     {

       return M.isTrue(e);

     }

     Value operator = (Value v) const

     {

       if(v) M.setTrue(e); 

       else M.setFalse(e);

       return v;

     }

   };

 public:

   BoolIterEdgeMap(Graph &_G) : G(_G), cref(G)

   {

     sep=0;

     for(typename Graph::EdgeIt e(G);G.valid(e);G.next(e)) {

       cref[e]=sep;

       vals.push_back(e);

       sep++;

     }

   }

   RefType operator[] (Edge e) { return RefType(*this,e);}  

 };

 int main()

 {

   typedef SmartGraph Graph;

   typedef Graph::NodeIt NodeIt;

   typedef Graph::OutEdgeIt OutEdgeIt;

   typedef Graph::EdgeIt EdgeIt;

   Graph 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))

   BoolIterEdgeMap<Graph> map(G);

   bool b=true;

   for(EdgeIt e(G);G.valid(e);G.next(e)) {map[e]=b;b=!b;}

   std::cout << true << '\n';

   for(EdgeIt e(G);G.valid(e);G.next(e))

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

       << ": " << map[e] << '\n';

   std::cout << "True Edges:\n";

   for(BoolIterEdgeMap<Graph>::TrueIterator i(map);i;++i)

     std::cout << G.id(G.source(i)) << "->" << G.id(G.target(i)) << '\n';

   std::cout << "False Edges:\n";

   for(BoolIterEdgeMap<Graph>::FalseIterator i(map);i;++i)

     std::cout << G.id(G.source(i)) << "->" << G.id(G.target(i)) << '\n';

 }