/* -*- C++ -*-

  * src/lemon/merge_node_graph_wrapper.h - Part of LEMON, a generic C++ optimization library

  *

  * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  * (Egervary Combinatorial Optimization Research Group, EGRES).

  *

  * Permission to use, modify and distribute this software is granted

  * provided that this copyright notice appears in all copies. For

  * precise terms see the accompanying LICENSE file.

  *

  * This software is provided "AS IS" with no warranty of any kind,

  * express or implied, and with no claim as to its suitability for any

  * purpose.

  *

  */

 #ifndef LEMON_MERGE_NODE_GRAPH_WRAPPER_H

 #define LEMON_MERGE_NODE_GRAPH_WRAPPER_H

 #include <lemon/invalid.h>

 #include <lemon/maps.h>

 #include <lemon/map_defines.h>

 #include <lemon/graph_wrapper.h>

 #include <iostream>

 using std::cout;

 using std::endl;

 #include <boost/type_traits.hpp>

 #include <boost/utility/enable_if.hpp>

 namespace lemon {

   template <class _Graph1>

   class P1 : public GraphWrapperBase<_Graph1> {

   };

   template <class _Graph2>

   class P2 : public GraphWrapperBase<_Graph2> {

   };

   /*! A graph wrapper base class 

     for merging the node-set of two node-disjoint graphs 

     into the node-set of one graph. 

     Generic implementation for unrelated _Graph1::Node and _Graph2::Node.

    */

   template <typename _Graph1, typename _Graph2, typename Enable=void>

   class MergeNodeGraphWrapperBase : 

     public P1<_Graph1>, public P2<_Graph2> {

   public:

     static void printNode() { std::cout << "node: generic" << std::endl; }

     typedef _Graph1 Graph1;

     typedef _Graph2 Graph2;

     typedef P1<_Graph1> Parent1;

     typedef P2<_Graph2> Parent2;

     typedef typename Parent1::Node Graph1Node;

     typedef typename Parent2::Node Graph2Node;

   protected:

     MergeNodeGraphWrapperBase() { }

   public:

     template <typename _Value> class NodeMap;

     class Node : public Graph1Node, public Graph2Node {

       friend class MergeNodeGraphWrapperBase<_Graph1, _Graph2>;

       template <typename _Value> friend class NodeMap;

     protected:

       bool backward; //true, iff backward

     public:

       Node() { }

       /// \todo =false is needed, or causes problems?

       /// If \c _backward is false, then we get an edge corresponding to the 

       /// original one, otherwise its oppositely directed pair is obtained.

       Node(const Graph1Node& n1, 

 	   const Graph2Node& n2, bool _backward) : 

 	Graph1Node(n1), Graph2Node(n2), backward(_backward) { }

       Node(Invalid i) : Graph1Node(i), Graph2Node(i), backward(true) { }

       bool operator==(const Node& v) const { 

 	if (backward) 

 	  return (v.backward && 

 		  static_cast<Graph2Node>(*this)==static_cast<Graph2Node>(v)); 

 	else 

 	  return (!v.backward && 

 		  static_cast<Graph1Node>(*this)==static_cast<Graph1Node>(v)); 

       } 

       bool operator!=(const Node& v) const { 

 	return !(*this==v);

       }

     };

     //typedef void Edge;

     class Edge { };

     void first(Node& i) const {

       Parent1::graph->first(*static_cast<Graph1Node*>(&i));

       i.backward=false;

       if (*static_cast<Graph1Node*>(&i)==INVALID) {

 	Parent2::graph->first(*static_cast<Graph2Node*>(&i));

 	i.backward=true;

       }

     }

     void next(Node& i) const {

       if (!(i.backward)) {

 	Parent1::graph->next(*static_cast<Graph1Node*>(&i));

 	if (*static_cast<Graph1Node*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph2Node*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->next(*static_cast<Graph2Node*>(&i));

       }

     }

     int id(const Node& n) const { 

       if (!n.backward) 

 	return this->Parent1::graph->id(n);

       else

 	return this->Parent2::graph->id(n);

     }

     template <typename _Value> 

     class NodeMap { 

     protected:

       typedef typename _Graph1::template NodeMap<_Value> ParentMap1;

       typedef typename _Graph2::template NodeMap<_Value> ParentMap2;

       ParentMap1 forward_map;

       ParentMap2 backward_map;

     public:

       typedef _Value Value;

       typedef Node Key;

       NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw) : 

 	forward_map(*(gw.Parent1::graph)), 

 	backward_map(*(gw.Parent2::graph)) { }

       NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw, 

 	      const _Value& value) : 

 	forward_map(*(gw.Parent1::graph), value), 

 	backward_map(*(gw.Parent2::graph), value) { }

       _Value operator[](const Node& n) const {

 	if (!n.backward) 

 	  return forward_map[n];

 	else 

 	  return backward_map[n];

       }

       void set(const Node& n, const _Value& value) {

 	if (!n.backward) 

 	  forward_map.set(n, value);

 	else 

 	  backward_map.set(n, value);

       }

 //       using ParentMap1::operator[];

 //       using ParentMap2::operator[];

     };

   };

   /*! A graph wrapper base class 

     for merging the node-set of two node-disjoint graphs 

     into the node-set of one graph. 

     Specialization for the case when _Graph1::Node are the same _Graph2::Node.

    */

   template <typename _Graph1, typename _Graph2>

   class MergeNodeGraphWrapperBase<

     _Graph1, _Graph2, typename boost::enable_if<

     boost::is_same<typename _Graph1::Node, typename _Graph2::Node> >::type> : 

     public P1<_Graph1>, public P2<_Graph2> {

   public:

     static void printNode() { std::cout << "node: same" << std::endl; }

     typedef _Graph1 Graph1;

     typedef _Graph2 Graph2;

     typedef P1<_Graph1> Parent1;

     typedef P2<_Graph2> Parent2;

     typedef typename Parent1::Node Graph1Node;

     typedef typename Parent2::Node Graph2Node;

   protected:

     MergeNodeGraphWrapperBase() { }

   public:

     template <typename _Value> class NodeMap;

     class Node : public Graph1Node {

       friend class MergeNodeGraphWrapperBase<_Graph1, _Graph2>;

       template <typename _Value> friend class NodeMap;

     protected:

       bool backward; //true, iff backward

     public:

       Node() { }

       /// \todo =false is needed, or causes problems?

       /// If \c _backward is false, then we get an edge corresponding to the 

       /// original one, otherwise its oppositely directed pair is obtained.

       Node(const Graph1Node& n1, 

 	   const Graph2Node& n2, bool _backward) : 

 	Graph1Node(!backward ? n1 : n2), backward(_backward) { }

       Node(Invalid i) : Graph1Node(i), backward(true) { }

       bool operator==(const Node& v) const { 

 	return (backward==v.backward && 

 		static_cast<Graph1Node>(*this)==static_cast<Graph1Node>(v));

       } 

       bool operator!=(const Node& v) const { 

 	return !(*this==v);

       }

     };

     //typedef void Edge;

     class Edge { };

     void first(Node& i) const {

       Parent1::graph->first(*static_cast<Graph1Node*>(&i));

       i.backward=false;

       if (*static_cast<Graph1Node*>(&i)==INVALID) {

 	Parent2::graph->first(*static_cast<Graph1Node*>(&i));

 	i.backward=true;

       }

     }

     void next(Node& i) const {

       if (!(i.backward)) {

 	Parent1::graph->next(*static_cast<Graph1Node*>(&i));

 	if (*static_cast<Graph1Node*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph1Node*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->next(*static_cast<Graph1Node*>(&i));

       }

     }

     int id(const Node& n) const { 

       if (!n.backward) 

 	return this->Parent1::graph->id(n);

       else

 	return this->Parent2::graph->id(n);

     }

     template <typename _Value> 

     class NodeMap { 

     protected:

       typedef typename _Graph1::template NodeMap<_Value> ParentMap1;

       typedef typename _Graph2::template NodeMap<_Value> ParentMap2;

       ParentMap1 forward_map;

       ParentMap2 backward_map;

     public:

       typedef _Value Value;

       typedef Node Key;

       NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw) : 

 	forward_map(*(gw.Parent1::graph)), 

 	backward_map(*(gw.Parent2::graph)) { }

       NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw, 

 	      const _Value& value) : 

 	forward_map(*(gw.Parent1::graph), value), 

 	backward_map(*(gw.Parent2::graph), value) { }

       _Value operator[](const Node& n) const {

 	if (!n.backward) 

 	  return forward_map[n];

 	else 

 	  return backward_map[n];

       }

       void set(const Node& n, const _Value& value) {

 	if (!n.backward) 

 	  forward_map.set(n, value);

 	else 

 	  backward_map.set(n, value);

       }

 //       using ParentMap1::operator[];

 //       using ParentMap2::operator[];

     };

   };

   /*! A graph wrapper base class 

     for merging the node-set of two node-disjoint graphs 

     into the node-set of one graph. 

     Specialization for the case when 

     _Graph1::Node is a base class and _Graph2::Node is derived from it.

    */

   template <typename _Graph1, typename _Graph2>

   class MergeNodeGraphWrapperBase<

     _Graph1, _Graph2, typename boost::enable_if<

     boost::is_base_and_derived<typename _Graph1::Node, typename _Graph2::Node> >::type> : 

     public P1<_Graph1>, public P2<_Graph2> {

   public :

     static void printNode() { std::cout << "node: 2nd is derived" << std::endl; }

     typedef _Graph1 Graph1;

     typedef _Graph2 Graph2;

     typedef P1<_Graph1> Parent1;

     typedef P2<_Graph2> Parent2;

     typedef typename Parent1::Node Graph1Node;

     typedef typename Parent2::Node Graph2Node;

   protected:

     MergeNodeGraphWrapperBase() { }

   public:

     template <typename _Value> class NodeMap;

     class Node : public Graph2Node {

       friend class MergeNodeGraphWrapperBase<_Graph1, _Graph2>;

       template <typename _Value> friend class NodeMap;

     protected:

       bool backward; //true, iff backward

     public:

       Node() { }

       /// \todo =false is needed, or causes problems?

       /// If \c _backward is false, then we get an edge corresponding to the 

       /// original one, otherwise its oppositely directed pair is obtained.

       Node(const Graph1Node& n1, 

 	   const Graph2Node& n2, bool _backward) : 

 	Graph2Node(n2), backward(_backward) { 

 	if (!backward) *this=n1;

       }

       Node(Invalid i) : Graph2Node(i), backward(true) { }

       bool operator==(const Node& v) const { 

 	if (backward) 

 	  return (v.backward && 

 		  static_cast<Graph2Node>(*this)==static_cast<Graph2Node>(v)); 

 	else 

 	  return (!v.backward && 

 		  static_cast<Graph1Node>(*this)==static_cast<Graph1Node>(v)); 

       } 

       bool operator!=(const Node& v) const { 

 	return !(*this==v);

       }

     };

     //typedef void Edge;

     class Edge { };

     void first(Node& i) const {

       Parent1::graph->first(*static_cast<Graph1Node*>(&i));

       i.backward=false;

       if (*static_cast<Graph1Node*>(&i)==INVALID) {

 	Parent2::graph->first(*static_cast<Graph2Node*>(&i));

 	i.backward=true;

       }

     }

     void next(Node& i) const {

       if (!(i.backward)) {

 	Parent1::graph->next(*static_cast<Graph1Node*>(&i));

 	if (*static_cast<Graph1Node*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph2Node*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->next(*static_cast<Graph2Node*>(&i));

       }

     }

     int id(const Node& n) const { 

       if (!n.backward) 

 	return this->Parent1::graph->id(n);

       else

 	return this->Parent2::graph->id(n);

     }

     template <typename _Value> 

     class NodeMap { 

     protected:

       typedef typename _Graph1::template NodeMap<_Value> ParentMap1;

       typedef typename _Graph2::template NodeMap<_Value> ParentMap2;

       ParentMap1 forward_map;

       ParentMap2 backward_map;

     public:

       typedef _Value Value;

       typedef Node Key;

       NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw) : 

 	forward_map(*(gw.Parent1::graph)), 

 	backward_map(*(gw.Parent2::graph)) { }

       NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw, 

 	      const _Value& value) : 

 	forward_map(*(gw.Parent1::graph), value), 

 	backward_map(*(gw.Parent2::graph), value) { }

       _Value operator[](const Node& n) const {

 	if (!n.backward) 

 	  return forward_map[n];

 	else 

 	  return backward_map[n];

       }

       void set(const Node& n, const _Value& value) {

 	if (!n.backward) 

 	  forward_map.set(n, value);

 	else 

 	  backward_map.set(n, value);

       }

 //       using ParentMap1::operator[];

 //       using ParentMap2::operator[];

     };

   };

   /*! A graph wrapper base class 

     for merging the node-set of two node-disjoint graphs 

     into the node-set of one graph. 

     Specialized implementaton for the case when _Graph1::Node is derived 

     from _Graph2::Node.

    */

   template <typename _Graph1, typename _Graph2>

   class MergeNodeGraphWrapperBase<

     _Graph1, _Graph2, typename boost::enable_if<

     boost::is_base_and_derived<typename _Graph2::Node, typename _Graph1::Node> >::type> : 

     public P1<_Graph1>, public P2<_Graph2> {

   public :

     static void printNode() { std::cout << "node: 1st is derived" << std::endl; }

     typedef _Graph1 Graph1;

     typedef _Graph2 Graph2;

     typedef P1<_Graph1> Parent1;

     typedef P2<_Graph2> Parent2;

     typedef typename Parent1::Node Graph1Node;

     typedef typename Parent2::Node Graph2Node;

   protected:

     MergeNodeGraphWrapperBase() { }

   public:

     template <typename _Value> class NodeMap;

     class Node : public Graph1Node {

       friend class MergeNodeGraphWrapperBase<_Graph1, _Graph2>;

       template <typename _Value> friend class NodeMap;

     protected:

       bool backward; //true, iff backward

     public:

       Node() { }

       /// \todo =false is needed, or causes problems?

       /// If \c _backward is false, then we get an edge corresponding to the 

       /// original one, otherwise its oppositely directed pair is obtained.

       Node(const Graph1Node& n1, 

 	   const Graph2Node& n2, bool _backward) : 

 	Graph1Node(n1), backward(_backward) { 

 	if (backward) *this=n2;

       }

       Node(Invalid i) : Graph1Node(i), backward(true) { }

       bool operator==(const Node& v) const { 

 	if (backward) 

 	  return (v.backward && 

 		  static_cast<Graph2Node>(*this)==static_cast<Graph2Node>(v)); 

 	else 

 	  return (!v.backward && 

 		  static_cast<Graph1Node>(*this)==static_cast<Graph1Node>(v)); 

       } 

       bool operator!=(const Node& v) const { 

 	return !(*this==v);

       }

     };

     //typedef void Edge;

     class Edge { };

     void first(Node& i) const {

       Parent1::graph->first(*static_cast<Graph1Node*>(&i));

       i.backward=false;

       if (*static_cast<Graph1Node*>(&i)==INVALID) {

 	Parent2::graph->first(*static_cast<Graph2Node*>(&i));

 	i.backward=true;

       }

     }

     void next(Node& i) const {

       if (!(i.backward)) {

 	Parent1::graph->next(*static_cast<Graph1Node*>(&i));

 	if (*static_cast<Graph1Node*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph2Node*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->next(*static_cast<Graph2Node*>(&i));

       }

     }

     int id(const Node& n) const { 

       if (!n.backward) 

 	return this->Parent1::graph->id(n);

       else

 	return this->Parent2::graph->id(n);

     }

     template <typename _Value> 

     class NodeMap { 

     protected:

       typedef typename _Graph1::template NodeMap<_Value> ParentMap1;

       typedef typename _Graph2::template NodeMap<_Value> ParentMap2;

       ParentMap1 forward_map;

       ParentMap2 backward_map;

     public:

       typedef _Value Value;

       typedef Node Key;

       NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw) : 

 	forward_map(*(gw.Parent1::graph)), 

 	backward_map(*(gw.Parent2::graph)) { }

       NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw, 

 	      const _Value& value) : 

 	forward_map(*(gw.Parent1::graph), value), 

 	backward_map(*(gw.Parent2::graph), value) { }

       _Value operator[](const Node& n) const {

 	if (!n.backward) 

 	  return forward_map[n];

 	else 

 	  return backward_map[n];

       }

       void set(const Node& n, const _Value& value) {

 	if (!n.backward) 

 	  forward_map.set(n, value);

 	else 

 	  backward_map.set(n, value);

       }

 //       using ParentMap1::operator[];

 //       using ParentMap2::operator[];

     };

   };

   /*! A graph wrapper class 

     fors merging the node-set of two node-disjoint graphs 

     into one node-set. It does not satisfy 

     StaticGraph concept as it has no edge-set which 

     works together with the node-set.

    */

   template <typename _Graph1, typename _Graph2>

   class MergeNodeGraphWrapper : public 

   IterableGraphExtender<MergeNodeGraphWrapperBase<_Graph1, _Graph2> > {

   public:

     typedef _Graph1 Graph1;

     typedef _Graph2 Graph2;

     typedef IterableGraphExtender<

       MergeNodeGraphWrapperBase<_Graph1, _Graph2> > Parent;

   protected:

     MergeNodeGraphWrapper() { }

   public:

     MergeNodeGraphWrapper(_Graph1& _graph1, _Graph2& _graph2) { 

       Parent::Parent1::setGraph(_graph1);

       Parent::Parent2::setGraph(_graph2);

     }

   };

   /*! A grah wrapper base class 

     for merging the node-sets and edge-sets of 

     two node-disjoint graphs 

     into one graph.

     Generic implementation for unrelated _Graph1::Edge and _Graph2::Edge.

    */

   template <typename _Graph1, typename _Graph2, typename Enable=void>

   class MergeEdgeGraphWrapperBase : 

     public MergeNodeGraphWrapperBase<_Graph1, _Graph2> {

   public:

     static void printEdge() { std::cout << "edge: generic" << std::endl; }

     typedef _Graph1 Graph1;

     typedef _Graph2 Graph2;

     typedef MergeNodeGraphWrapperBase<_Graph1, _Graph2> Parent;

     typedef typename Parent::Parent1 Parent1;

     typedef typename Parent::Parent2 Parent2;

 //     typedef P1<_Graph1> Parent1;

 //     typedef P2<_Graph2> Parent2;

     typedef typename Parent1::Edge Graph1Edge;

     typedef typename Parent2::Edge Graph2Edge;

   protected:

     MergeEdgeGraphWrapperBase() { }

   public:

     template <typename _Value> class EdgeMap;

     typedef typename Parent::Node Node;

     class Edge : public Graph1Edge, public Graph2Edge {

       friend class MergeEdgeGraphWrapperBase<_Graph1, _Graph2>;

       template <typename _Value> friend class EdgeMap;

     protected:

       bool backward; //true, iff backward

     public:

       Edge() { }

       /// \todo =false is needed, or causes problems?

       /// If \c _backward is false, then we get an edge corresponding to the 

       /// original one, otherwise its oppositely directed pair is obtained.

       Edge(const Graph1Edge& n1, 

 	   const Graph2Edge& n2, bool _backward) : 

 	Graph1Edge(n1), Graph2Edge(n2), backward(_backward) { }

       Edge(Invalid i) : Graph1Edge(i), Graph2Edge(i), backward(true) { }

       bool operator==(const Edge& v) const { 

 	if (backward) 

 	  return (v.backward && 

 		  static_cast<Graph2Edge>(*this)==static_cast<Graph2Edge>(v)); 

 	else 

 	  return (!v.backward && 

 		  static_cast<Graph1Edge>(*this)==static_cast<Graph1Edge>(v)); 

       } 

       bool operator!=(const Edge& v) const { 

 	return !(*this==v);

       }

     };

     using Parent::first;

     void first(Edge& i) const {

       Parent1::graph->first(*static_cast<Graph1Edge*>(&i));

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	Parent2::graph->first(*static_cast<Graph2Edge*>(&i));

 	i.backward=true;

       }

     }

     void firstIn(Edge& i, const Node& n) const {

       Parent1::graph->firstIn(*static_cast<Graph1Edge*>(&i), n);

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	Parent2::graph->firstIn(*static_cast<Graph2Edge*>(&i), n);

 	i.backward=true;

       }

     }

     void firstOut(Edge& i, const Node& n) const {

       Parent1::graph->firstOut(*static_cast<Graph1Edge*>(&i), n);

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	Parent2::graph->firstOut(*static_cast<Graph2Edge*>(&i), n);

 	i.backward=true;

       }

     }

     using Parent::next;

     void next(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->next(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph2Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->next(*static_cast<Graph2Edge*>(&i));

       }

     }

     void nextIn(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->nextIn(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph2Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->nextIn(*static_cast<Graph2Edge*>(&i));

       }

     }

     void nextOut(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->nextOut(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph2Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->nextOut(*static_cast<Graph2Edge*>(&i));

       }

     }

     Node source(const Edge& i) const {

       if (!(i.backward)) {

 	return 

 	  Node(Parent1::graph->source(i), INVALID, false);

       } else {

 	return 

 	  Node(INVALID, Parent2::graph->source(i), true);

       }

     }

     Node target(const Edge& i) const {

       if (!(i.backward)) {

 	return 

 	  Node(Parent1::graph->target(i), INVALID, false);

       } else {

 	return 

 	  Node(INVALID, Parent2::graph->target(i), true);

       }

     }

     using Parent::id;

     int id(const Edge& n) const { 

       if (!n.backward) 

 	return this->Parent1::graph->id(n);

       else

 	return this->Parent2::graph->id(n);

     }

     template <typename _Value> 

     class EdgeMap { 

     protected:

       typedef typename Parent::Graph1::template EdgeMap<_Value> ParentMap1;

       typedef typename Parent::Graph2::template EdgeMap<_Value> ParentMap2;

       ParentMap1 forward_map;

       ParentMap2 backward_map;

     public:

       typedef _Value Value;

       typedef Edge Key;

       EdgeMap(const MergeEdgeGraphWrapperBase<_Graph1, _Graph2>& gw) : 

 	forward_map(*(gw.Parent1::graph)), 

 	backward_map(*(gw.Parent2::graph)) { }

       EdgeMap(const MergeEdgeGraphWrapperBase<_Graph1, _Graph2>& gw, 

 	      const _Value& value) : 

 	forward_map(*(gw.Parent1::graph), value), 

 	backward_map(*(gw.Parent2::graph), value) { }

       _Value operator[](const Edge& n) const {

 	if (!n.backward) 

 	  return forward_map[n];

 	else 

 	  return backward_map[n];

       }

       void set(const Edge& n, const _Value& value) {

 	if (!n.backward) 

 	  forward_map.set(n, value);

 	else 

 	  backward_map.set(n, value);

       }

 //       using ParentMap1::operator[];

 //       using ParentMap2::operator[];

     };

   };

   /*! A graph wrapper base class 

     for merging the node-sets and edge-sets of 

     two node-disjoint graphs 

     into one graph.

     Specialization for the case when _Graph1::Edge and _Graph2::Edge

     are the same.

    */

   template <typename _Graph1, typename _Graph2>

   class MergeEdgeGraphWrapperBase<

     _Graph1, _Graph2, typename boost::enable_if<

     boost::is_same<typename _Graph1::Edge, typename _Graph2::Edge> >::type> : 

     public MergeNodeGraphWrapperBase<_Graph1, _Graph2> {

   public:

     static void printEdge() { std::cout << "edge: same" << std::endl; }

     typedef _Graph1 Graph1;

     typedef _Graph2 Graph2;

     typedef MergeNodeGraphWrapperBase<_Graph1, _Graph2> Parent;

     typedef typename Parent::Parent1 Parent1;

     typedef typename Parent::Parent2 Parent2;

 //     typedef P1<_Graph1> Parent1;

 //     typedef P2<_Graph2> Parent2;

     typedef typename Parent1::Edge Graph1Edge;

     typedef typename Parent2::Edge Graph2Edge;

   protected:

     MergeEdgeGraphWrapperBase() { }

   public:

     template <typename _Value> class EdgeMap;

     typedef typename Parent::Node Node;

     class Edge : public Graph1Edge {

       friend class MergeEdgeGraphWrapperBase<_Graph1, _Graph2>;

       template <typename _Value> friend class EdgeMap;

     protected:

       bool backward; //true, iff backward

     public:

       Edge() { }

       /// \todo =false is needed, or causes problems?

       /// If \c _backward is false, then we get an edge corresponding to the 

       /// original one, otherwise its oppositely directed pair is obtained.

       Edge(const Graph1Edge& n1, 

 	   const Graph2Edge& n2, bool _backward) : 

 	Graph1Edge(!backward ? n1 : n2), backward(_backward) { }

       Edge(Invalid i) : Graph1Edge(i), backward(true) { }

       bool operator==(const Edge& v) const { 

 	return (backward==v.backward && 

 		static_cast<Graph1Edge>(*this)==static_cast<Graph1Edge>(v)); 

       }

       bool operator!=(const Edge& v) const { 

 	return !(*this==v);

       }

     };

     using Parent::first;

     void first(Edge& i) const {

       Parent1::graph->first(*static_cast<Graph1Edge*>(&i));

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	Parent2::graph->first(*static_cast<Graph1Edge*>(&i));

 	i.backward=true;

       }

     }

     void firstIn(Edge& i, const Node& n) const {

       Parent1::graph->firstIn(*static_cast<Graph1Edge*>(&i), n);

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	Parent2::graph->firstIn(*static_cast<Graph1Edge*>(&i), n);

 	i.backward=true;

       }

     }

     void firstOut(Edge& i, const Node& n) const {

       Parent1::graph->firstOut(*static_cast<Graph1Edge*>(&i), n);

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	Parent2::graph->firstOut(*static_cast<Graph1Edge*>(&i), n);

 	i.backward=true;

       }

     }

     using Parent::next;

     void next(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->next(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph1Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->next(*static_cast<Graph1Edge*>(&i));

       }

     }

     void nextIn(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->nextIn(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph1Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->nextIn(*static_cast<Graph1Edge*>(&i));

       }

     }

     void nextOut(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->nextOut(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph1Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->nextOut(*static_cast<Graph1Edge*>(&i));

       }

     }

     Node source(const Edge& i) const {

       if (!(i.backward)) {

 	return 

 	  Node(Parent1::graph->source(i), INVALID, false);

       } else {

 	return 

 	  Node(INVALID, Parent2::graph->source(i), true);

       }

     }

     Node target(const Edge& i) const {

       if (!(i.backward)) {

 	return 

 	  Node(Parent1::graph->target(i), INVALID, false);

       } else {

 	return 

 	  Node(INVALID, Parent2::graph->target(i), true);

       }

     }

     using Parent::id;

     int id(const Edge& n) const { 

       if (!n.backward) 

 	return this->Parent1::graph->id(n);

       else

 	return this->Parent2::graph->id(n);

     }

     template <typename _Value> 

     class EdgeMap { 

     protected:

       typedef typename Parent::Graph1::template EdgeMap<_Value> ParentMap1;

       typedef typename Parent::Graph2::template EdgeMap<_Value> ParentMap2;

       ParentMap1 forward_map;

       ParentMap2 backward_map;

     public:

       typedef _Value Value;

       typedef Edge Key;

       EdgeMap(const MergeEdgeGraphWrapperBase<_Graph1, _Graph2>& gw) : 

 	forward_map(*(gw.Parent1::graph)), 

 	backward_map(*(gw.Parent2::graph)) { }

       EdgeMap(const MergeEdgeGraphWrapperBase<_Graph1, _Graph2>& gw, 

 	      const _Value& value) : 

 	forward_map(*(gw.Parent1::graph), value), 

 	backward_map(*(gw.Parent2::graph), value) { }

       _Value operator[](const Edge& n) const {

 	if (!n.backward) 

 	  return forward_map[n];

 	else 

 	  return backward_map[n];

       }

       void set(const Edge& n, const _Value& value) {

 	if (!n.backward) 

 	  forward_map.set(n, value);

 	else 

 	  backward_map.set(n, value);

       }

 //       using ParentMap1::operator[];

 //       using ParentMap2::operator[];

     };

   };

   /*! A grah wrapper base class 

     for merging the node-sets and edge-sets of 

     two node-disjoint graphs 

     into one graph. 

     Specialized implementation for the case 

     when _Graph1::Edge is a base class and _Graph2::Edge

     is derived from it.

    */

   template <typename _Graph1, typename _Graph2>

   class MergeEdgeGraphWrapperBase<

     _Graph1, _Graph2, typename boost::enable_if<

     boost::is_base_and_derived<typename _Graph1::Edge, typename _Graph2::Edge> >::type> : 

     public MergeNodeGraphWrapperBase<_Graph1, _Graph2> {

   public:

     static void printEdge() { std::cout << "edge: 2nd is derived" << std::endl; }

     typedef _Graph1 Graph1;

     typedef _Graph2 Graph2;

     typedef MergeNodeGraphWrapperBase<_Graph1, _Graph2> Parent;

     typedef typename Parent::Parent1 Parent1;

     typedef typename Parent::Parent2 Parent2;

 //     typedef P1<_Graph1> Parent1;

 //     typedef P2<_Graph2> Parent2;

     typedef typename Parent1::Edge Graph1Edge;

     typedef typename Parent2::Edge Graph2Edge;

   protected:

     MergeEdgeGraphWrapperBase() { }

   public:

     template <typename _Value> class EdgeMap;

     typedef typename Parent::Node Node;

     class Edge : public Graph2Edge {

       friend class MergeEdgeGraphWrapperBase<_Graph1, _Graph2>;

       template <typename _Value> friend class EdgeMap;

     protected:

       bool backward; //true, iff backward

     public:

       Edge() { }

       /// \todo =false is needed, or causes problems?

       /// If \c _backward is false, then we get an edge corresponding to the 

       /// original one, otherwise its oppositely directed pair is obtained.

       Edge(const Graph1Edge& n1, 

 	   const Graph2Edge& n2, bool _backward) : 

 	Graph2Edge(n2), backward(_backward) { 

 	if (!backward) *this=n1;

       }

       Edge(Invalid i) : Graph2Edge(i), backward(true) { }

       bool operator==(const Edge& v) const { 

 	if (backward) 

 	  return (v.backward && 

 		  static_cast<Graph2Edge>(*this)==static_cast<Graph2Edge>(v)); 

 	else 

 	  return (!v.backward && 

 		  static_cast<Graph1Edge>(*this)==static_cast<Graph1Edge>(v)); 

       } 

       bool operator!=(const Edge& v) const { 

 	return !(*this==v);

       }

     };

     using Parent::first;

     void first(Edge& i) const {

       Parent1::graph->first(*static_cast<Graph1Edge*>(&i));

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	Parent2::graph->first(*static_cast<Graph2Edge*>(&i));

 	i.backward=true;

       }

     }

     void firstIn(Edge& i, const Node& n) const {

       Parent1::graph->firstIn(*static_cast<Graph1Edge*>(&i), n);

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	Parent2::graph->firstIn(*static_cast<Graph2Edge*>(&i), n);

 	i.backward=true;

       }

     }

     void firstOut(Edge& i, const Node& n) const {

       Parent1::graph->firstOut(*static_cast<Graph1Edge*>(&i), n);

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	Parent2::graph->firstOut(*static_cast<Graph2Edge*>(&i), n);

 	i.backward=true;

       }

     }

     using Parent::next;

     void next(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->next(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph2Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->next(*static_cast<Graph2Edge*>(&i));

       }

     }

     void nextIn(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->nextIn(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph2Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->nextIn(*static_cast<Graph2Edge*>(&i));

       }

     }

     void nextOut(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->nextOut(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph2Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->nextOut(*static_cast<Graph2Edge*>(&i));

       }

     }

     Node source(const Edge& i) const {

       if (!(i.backward)) {

 	return 

 	  Node(Parent1::graph->source(i), INVALID, false);

       } else {

 	return 

 	  Node(INVALID, Parent2::graph->source(i), true);

       }

     }

     Node target(const Edge& i) const {

       if (!(i.backward)) {

 	return 

 	  Node(Parent1::graph->target(i), INVALID, false);

       } else {

 	return 

 	  Node(INVALID, Parent2::graph->target(i), true);

       }

     }

     using Parent::id;

     int id(const Edge& n) const { 

       if (!n.backward) 

 	return this->Parent1::graph->id(n);

       else

 	return this->Parent2::graph->id(n);

     }

     template <typename _Value> 

     class EdgeMap { 

     protected:

       typedef typename Parent::Graph1::template EdgeMap<_Value> ParentMap1;

       typedef typename Parent::Graph2::template EdgeMap<_Value> ParentMap2;

       ParentMap1 forward_map;

       ParentMap2 backward_map;

     public:

       typedef _Value Value;

       typedef Edge Key;

       EdgeMap(const MergeEdgeGraphWrapperBase<_Graph1, _Graph2>& gw) : 

 	forward_map(*(gw.Parent1::graph)), 

 	backward_map(*(gw.Parent2::graph)) { }

       EdgeMap(const MergeEdgeGraphWrapperBase<_Graph1, _Graph2>& gw, 

 	      const _Value& value) : 

 	forward_map(*(gw.Parent1::graph), value), 

 	backward_map(*(gw.Parent2::graph), value) { }

       _Value operator[](const Edge& n) const {

 	if (!n.backward) 

 	  return forward_map[n];

 	else 

 	  return backward_map[n];

       }

       void set(const Edge& n, const _Value& value) {

 	if (!n.backward) 

 	  forward_map.set(n, value);

 	else 

 	  backward_map.set(n, value);

       }

 //       using ParentMap1::operator[];

 //       using ParentMap2::operator[];

     };

   };

   /*! A grah wrapper base class 

     for merging the node-sets and edge-sets of 

     two node-disjoint graphs 

     into one graph. 

     Specialized implementation for the case 

     when _Graph1::Edge is derived from _Graph2::Edge.

    */

   template <typename _Graph1, typename _Graph2>

   class MergeEdgeGraphWrapperBase<

     _Graph1, _Graph2, typename boost::enable_if<

     boost::is_base_and_derived<typename _Graph2::Edge, typename _Graph1::Edge> >::type> : 

     public MergeNodeGraphWrapperBase<_Graph1, _Graph2> {

   public:

     static void printEdge() { std::cout << "edge: 1st is derived" << std::endl; }

     typedef _Graph1 Graph1;

     typedef _Graph2 Graph2;

     typedef MergeNodeGraphWrapperBase<_Graph1, _Graph2> Parent;

     typedef typename Parent::Parent1 Parent1;

     typedef typename Parent::Parent2 Parent2;

 //     typedef P1<_Graph1> Parent1;

 //     typedef P2<_Graph2> Parent2;

     typedef typename Parent1::Edge Graph1Edge;

     typedef typename Parent2::Edge Graph2Edge;

   protected:

     MergeEdgeGraphWrapperBase() { }

   public:

     template <typename _Value> class EdgeMap;

     typedef typename Parent::Node Node;

     class Edge : public Graph1Edge {

       friend class MergeEdgeGraphWrapperBase<_Graph1, _Graph2>;

       template <typename _Value> friend class EdgeMap;

     protected:

       bool backward; //true, iff backward

     public:

       Edge() { }

       /// \todo =false is needed, or causes problems?

       /// If \c _backward is false, then we get an edge corresponding to the 

       /// original one, otherwise its oppositely directed pair is obtained.

       Edge(const Graph1Edge& n1, 

 	   const Graph2Edge& n2, bool _backward) : 

 	Graph1Edge(n1), backward(_backward) { 

 	if (backward) *this=n2;

       }

       Edge(Invalid i) : Graph1Edge(i), backward(true) { }

       bool operator==(const Edge& v) const { 

 	if (backward) 

 	  return (v.backward && 

 		  static_cast<Graph2Edge>(*this)==static_cast<Graph2Edge>(v)); 

 	else 

 	  return (!v.backward && 

 		  static_cast<Graph1Edge>(*this)==static_cast<Graph1Edge>(v)); 

       } 

       bool operator!=(const Edge& v) const { 

 	return !(*this==v);

       }

     };

     using Parent::first;

     void first(Edge& i) const {

       Parent1::graph->first(*static_cast<Graph1Edge*>(&i));

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	Parent2::graph->first(*static_cast<Graph2Edge*>(&i));

 	i.backward=true;

       }

     }

     void firstIn(Edge& i, const Node& n) const {

       Parent1::graph->firstIn(*static_cast<Graph1Edge*>(&i), n);

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	Parent2::graph->firstIn(*static_cast<Graph2Edge*>(&i), n);

 	i.backward=true;

       }

     }

     void firstOut(Edge& i, const Node& n) const {

       Parent1::graph->firstOut(*static_cast<Graph1Edge*>(&i), n);

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	Parent2::graph->firstOut(*static_cast<Graph2Edge*>(&i), n);

 	i.backward=true;

       }

     }

     using Parent::next;

     void next(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->next(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph2Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->next(*static_cast<Graph2Edge*>(&i));

       }

     }

     void nextIn(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->nextIn(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph2Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->nextIn(*static_cast<Graph2Edge*>(&i));

       }

     }

     void nextOut(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->nextOut(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  Parent2::graph->first(*static_cast<Graph2Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	Parent2::graph->nextOut(*static_cast<Graph2Edge*>(&i));

       }

     }

     Node source(const Edge& i) const {

       if (!(i.backward)) {

 	return 

 	  Node(Parent1::graph->source(i), INVALID, false);

       } else {

 	return 

 	  Node(INVALID, Parent2::graph->source(i), true);

       }

     }

     Node target(const Edge& i) const {

       if (!(i.backward)) {

 	return 

 	  Node(Parent1::graph->target(i), INVALID, false);

       } else {

 	return 

 	  Node(INVALID, Parent2::graph->target(i), true);

       }

     }

     using Parent::id;

     int id(const Edge& n) const { 

       if (!n.backward) 

 	return this->Parent1::graph->id(n);

       else

 	return this->Parent2::graph->id(n);

     }

     template <typename _Value> 

     class EdgeMap { 

     protected:

       typedef typename Parent::Graph1::template EdgeMap<_Value> ParentMap1;

       typedef typename Parent::Graph2::template EdgeMap<_Value> ParentMap2;

       ParentMap1 forward_map;

       ParentMap2 backward_map;

     public:

       typedef _Value Value;

       typedef Edge Key;

       EdgeMap(const MergeEdgeGraphWrapperBase<_Graph1, _Graph2>& gw) : 

 	forward_map(*(gw.Parent1::graph)), 

 	backward_map(*(gw.Parent2::graph)) { }

       EdgeMap(const MergeEdgeGraphWrapperBase<_Graph1, _Graph2>& gw, 

 	      const _Value& value) : 

 	forward_map(*(gw.Parent1::graph), value), 

 	backward_map(*(gw.Parent2::graph), value) { }

       _Value operator[](const Edge& n) const {

 	if (!n.backward) 

 	  return forward_map[n];

 	else 

 	  return backward_map[n];

       }

       void set(const Edge& n, const _Value& value) {

 	if (!n.backward) 

 	  forward_map.set(n, value);

 	else 

 	  backward_map.set(n, value);

       }

 //       using ParentMap1::operator[];

 //       using ParentMap2::operator[];

     };

   };

   /*! A graph wrapper class 

     for merging the node-sets and edge-sets of 

     two node-disjoint graphs 

     into one graph.

    */

   template <typename _Graph1, typename _Graph2>

   class MergeEdgeGraphWrapper : public 

   IterableGraphExtender<MergeEdgeGraphWrapperBase<_Graph1, _Graph2> > {

   public:

     typedef _Graph1 Graph1;

     typedef _Graph2 Graph2;

     typedef IterableGraphExtender<

       MergeEdgeGraphWrapperBase<_Graph1, _Graph2> > Parent;

   protected:

     MergeEdgeGraphWrapper() { }

   public:

     MergeEdgeGraphWrapper(_Graph1& _graph1, _Graph2& _graph2) { 

       Parent::Parent1::setGraph(_graph1);

       Parent::Parent2::setGraph(_graph2);

     }

   };

   /*! A graph wrapper base class for the following functionality.

     If a bijection is given between the node-sets of two graphs, 

     then the second one can be considered as a new edge-set 

     over th first node-set. 

    */

   template <typename _Graph, typename _EdgeSetGraph>

   class NewEdgeSetGraphWrapperBase : public GraphWrapperBase<_Graph> {

   public:

     typedef GraphWrapperBase<_Graph> Parent; 

     typedef _Graph Graph;

     typedef _EdgeSetGraph EdgeSetGraph;

     typedef typename _Graph::Node Node;

     typedef typename _EdgeSetGraph::Node ENode;

   protected:

     EdgeSetGraph* edge_set_graph;

     typename Graph::NodeMap<ENode>* e_node;

     typename EdgeSetGraph::NodeMap<Node>* n_node;

     void setEdgeSetGraph(EdgeSetGraph& _edge_set_graph) { 

       edge_set_graph=&_edge_set_graph; 

     }

     /// For each node of \c Graph, this gives a node of \c EdgeSetGraph .

     void setNodeMap(typename EdgeSetGraph::NodeMap<Node>& _n_node) { 

       n_node=&_n_node; 

     }

     /// For each node of \c EdgeSetGraph, this gives a node of \c Graph .

     void setENodeMap(typename Graph::NodeMap<ENode>& _e_node) { 

       e_node=&_e_node; 

     }

   public:

     class Edge : public EdgeSetGraph::Edge {

       typedef typename EdgeSetGraph::Edge Parent;

     public:

       Edge() { }

       Edge(const Parent& e) : Parent(e) { }

       Edge(Invalid i) : Parent(i) { }

     };

     using Parent::first;

     void first(Edge &e) const { 

       edge_set_graph->first(e);

     }

     void firstOut(Edge& e, const Node& n) const {

 //       cout << e_node << endl;

 //       cout << n_node << endl;

       edge_set_graph->firstOut(e, (*e_node)[n]);

     }

     void firstIn(Edge& e, const Node& n) const {

       edge_set_graph->firstIn(e, (*e_node)[n]);

     }

     using Parent::next;

     void next(Edge &e) const { 

       edge_set_graph->next(e);

     }

     void nextOut(Edge& e) const {

       edge_set_graph->nextOut(e);

     }

     void nextIn(Edge& e) const {

       edge_set_graph->nextIn(e);

     }

     Node source(const Edge& e) const { 

       return (*n_node)[edge_set_graph->source(e)];

     }

     Node target(const Edge& e) const { 

       return (*n_node)[edge_set_graph->target(e)];

     }

     int edgeNum() const { return edge_set_graph->edgeNum(); }

     Edge addEdge(const Node& u, const Node& v) {

       return edge_set_graph->addEdge((*e_node)[u], (*e_node)[v]);

     }

     using Parent::erase;

     void erase(const Edge& i) const { edge_set_graph->erase(i); }

     void clear() const { Parent::clear(); edge_set_graph->clear(); }

     bool forward(const Edge& e) const { return edge_set_graph->forward(e); }

     bool backward(const Edge& e) const { return edge_set_graph->backward(e); }

     int id(const Node& e) const { return Parent::id(e); }

     int id(const Edge& e) const { return edge_set_graph->id(e); }

     Edge opposite(const Edge& e) const { return edge_set_graph->opposite(e); }

     template <typename _Value>

     class EdgeMap : public EdgeSetGraph::EdgeMap<_Value> {

     public:

       typedef typename EdgeSetGraph::EdgeMap<_Value> Parent; 

       typedef _Value Value;

       typedef Edge Key;

       EdgeMap(const NewEdgeSetGraphWrapperBase& gw) : 

 	Parent(*(gw.edge_set_graph)) { }

       EdgeMap(const NewEdgeSetGraphWrapperBase& gw, const _Value& _value) : 

 	Parent(*(gw.edge_set_graph), _value) { }

     };

   };

   /*! A graph wrapper class for the following functionality.

     If a bijection is given between the node-sets of two graphs, 

     then the second one can be considered as a new edge-set 

     over th first node-set. 

    */

   template <typename _Graph, typename _EdgeSetGraph>

   class NewEdgeSetGraphWrapper : 

     public IterableGraphExtender<

     NewEdgeSetGraphWrapperBase<_Graph, _EdgeSetGraph> > {

   public:

     typedef _Graph Graph;

     typedef _EdgeSetGraph EdgeSetGraph;

     typedef IterableGraphExtender<

       NewEdgeSetGraphWrapper<_Graph, _EdgeSetGraph> > Parent;

   protected:

     NewEdgeSetGraphWrapper() { }

   public:

     NewEdgeSetGraphWrapper(_Graph& _graph, 

 			   _EdgeSetGraph& _edge_set_graph, 

 			   typename _Graph::

 			   NodeMap<typename _EdgeSetGraph::Node>& _e_node, 

 			   typename _EdgeSetGraph::

 			   NodeMap<typename _Graph::Node>& _n_node) { 

       setGraph(_graph);

       setEdgeSetGraph(_edge_set_graph);

       setNodeMap(_n_node);

       setENodeMap(_e_node);

     }

   };

   /*! A graph wrapper base class 

     for merging graphs of type _Graph1 and _Graph2 

     which are given on the same node-set 

     (specially on the node-set of Graph1) 

     into one graph.

     In an other point of view, _Graph1 is extended with 

     the edge-set of _Graph2.

    */

   template <typename _Graph1, typename _Graph2, typename Enable=void>

   class AugmentingGraphWrapperBase : 

     public P1<_Graph1> {

   public:

     void printAugment() const { std::cout << "generic" << std::endl; }

     typedef _Graph1 Graph1;

     typedef _Graph2 Graph2;

     typedef P1<_Graph1> Parent1;

     typedef P2<_Graph2> Parent2;

     typedef typename Parent1::Edge Graph1Edge;

     typedef typename Parent2::Edge Graph2Edge;

   protected:

     AugmentingGraphWrapperBase() { }

     _Graph2* graph2;

     void setGraph2(_Graph2& _graph2) { graph2=&_graph2; }

   public:

     template <typename _Value> class EdgeMap;

     typedef typename Parent1::Node Node;

     class Edge : public Graph1Edge, public Graph2Edge {

       friend class AugmentingGraphWrapperBase<_Graph1, _Graph2>;

       template <typename _Value> friend class EdgeMap;

     protected:

       bool backward; //true, iff backward

     public:

       Edge() { }

       /// \todo =false is needed, or causes problems?

       /// If \c _backward is false, then we get an edge corresponding to the 

       /// original one, otherwise its oppositely directed pair is obtained.

       Edge(const Graph1Edge& n1, 

 	   const Graph2Edge& n2, bool _backward) : 

 	Graph1Edge(n1), Graph2Edge(n2), backward(_backward) { }

       Edge(Invalid i) : Graph1Edge(i), Graph2Edge(i), backward(true) { }

       bool operator==(const Edge& v) const { 

 	if (backward) 

 	  return (v.backward && 

 		  static_cast<Graph2Edge>(*this)==static_cast<Graph2Edge>(v)); 

 	else 

 	  return (!v.backward && 

 		  static_cast<Graph1Edge>(*this)==static_cast<Graph1Edge>(v)); 

       } 

       bool operator!=(const Edge& v) const { 

 	return !(*this==v);

       }

     };

     using Parent1::first;

     void first(Edge& i) const {

       Parent1::graph->first(*static_cast<Graph1Edge*>(&i));

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	graph2->first(*static_cast<Graph2Edge*>(&i));

 	i.backward=true;

       }

     }

     void firstIn(Edge& i, const Node& n) const {

       Parent1::graph->firstIn(*static_cast<Graph1Edge*>(&i), n);

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	graph2->firstIn(*static_cast<Graph2Edge*>(&i), n);

 	i.backward=true;

       }

     }

     void firstOut(Edge& i, const Node& n) const {

       Parent1::graph->firstOut(*static_cast<Graph1Edge*>(&i), n);

       i.backward=false;

       if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	graph2->firstOut(*static_cast<Graph2Edge*>(&i), n);

 	i.backward=true;

       }

     }

     using Parent1::next;

     void next(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->next(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  graph2->first(*static_cast<Graph2Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	graph2->next(*static_cast<Graph2Edge*>(&i));

       }

     }

     void nextIn(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->nextIn(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  graph2->first(*static_cast<Graph2Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	graph2->nextIn(*static_cast<Graph2Edge*>(&i));

       }

     }

     void nextOut(Edge& i) const {

       if (!(i.backward)) {

 	Parent1::graph->nextOut(*static_cast<Graph1Edge*>(&i));

 	if (*static_cast<Graph1Edge*>(&i)==INVALID) {

 	  graph2->first(*static_cast<Graph2Edge*>(&i));

 	  i.backward=true;

 	}

       } else {

 	graph2->nextOut(*static_cast<Graph2Edge*>(&i));

       }

     }

     Node source(const Edge& i) const {

       if (!(i.backward)) {

 	return Parent1::graph->source(i);

       } else {

 	return graph2->source(i);

       }

     }

     Node target(const Edge& i) const {

       if (!(i.backward)) {

 	return Parent1::graph->target(i);

       } else {

 	return graph2->target(i);

       }

     }

     int id(const Node& n) const {

       return Parent1::id(n);

     };

     int id(const Edge& n) const { 

       if (!n.backward) 

 	return this->Parent1::graph->id(n);

       else

 	return this->graph2->id(n);

     }

     template <typename _Value> 

     class EdgeMap { 

     protected:

       typedef typename _Graph1::template EdgeMap<_Value> ParentMap1;

       typedef typename _Graph2::template EdgeMap<_Value> ParentMap2;

       ParentMap1 forward_map;

       ParentMap2 backward_map;

     public:

       typedef _Value Value;

       typedef Edge Key;

       EdgeMap(const AugmentingGraphWrapperBase<_Graph1, _Graph2>& gw) : 

 	forward_map(*(gw.Parent1::graph)), 

 	backward_map(*(gw.graph2)) { }

       EdgeMap(const AugmentingGraphWrapperBase<_Graph1, _Graph2>& gw, 

 	      const _Value& value) : 

 	forward_map(*(gw.Parent1::graph), value), 

 	backward_map(*(gw.graph2), value) { }

       _Value operator[](const Edge& n) const {

 	if (!n.backward) 

 	  return forward_map[n];

 	else 

 	  return backward_map[n];

       }

       void set(const Edge& n, const _Value& value) {

 	if (!n.backward) 

 	  forward_map.set(n, value);

 	else 

 	  backward_map.set(n, value);

       }

 //       using ParentMap1::operator[];

 //       using ParentMap2::operator[];

     };

   };

   /*! A graph wrapper class 

     for merging two graphs (of type _Graph1 and _Graph2)

     with the same node-set 

     (specially on the node-set of Graph1) 

     into one graph. 

     In an other point of view, _Graph1 is extended with 

     the edge-set of _Graph2.

    */  

   template <typename _Graph1, typename _Graph2>

   class AugmentingGraphWrapper : public 

   IterableGraphExtender<AugmentingGraphWrapperBase<_Graph1, _Graph2> > {

   public:

     typedef 

     IterableGraphExtender<AugmentingGraphWrapperBase<_Graph1, _Graph2> >

     Parent;

     typedef _Graph1 Graph1;

     typedef _Graph2 Graph2;

   protected:

     AugmentingGraphWrapper() { }

   public:

     AugmentingGraphWrapper(_Graph1& _graph1, _Graph2& _graph2) { 

       setGraph(_graph1); 

       setGraph2(_graph2);

     }

   };

 } //namespace lemon

 #endif //LEMON_MERGE_NODE_GRAPH_WRAPPER_H