/* -*- C++ -*-

  *

  * This file is a part of LEMON, a generic C++ optimization library

  *

  * Copyright (C) 2003-2006

  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  * (Egervary Research Group on Combinatorial Optimization, 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_BPUGRAPH_ADAPTOR_H

 #define LEMON_BPUGRAPH_ADAPTOR_H

 #include <lemon/bits/invalid.h>

 #include <lemon/maps.h>

 #include <lemon/bits/graph_adaptor_extender.h>

 #include <lemon/bits/traits.h>

 #include <iostream>

 ///\ingroup graph_adaptors

 ///\file

 ///\brief Several graph adaptors.

 ///

 ///This file contains several useful bpugraph adaptor functions.

 ///

 ///\author Balazs Dezso

 namespace lemon {

   /// \ingroup graph_adaptors

   ///

   /// \brief Base type for the Bipartite Undirected Graph Adaptors

   ///

   /// This is the base type for most of LEMON bpugraph adaptors. 

   /// This class implements a trivial graph adaptor i.e. it only wraps the 

   /// functions and types of the graph. The purpose of this class is to 

   /// make easier implementing graph adaptors. E.g. if an adaptor is 

   /// considered which differs from the wrapped graph only in some of its 

   /// functions or types, then it can be derived from BpUGraphAdaptor, and 

   /// only the differences should be implemented.

   ///

   /// \author Balazs Dezso 

   template<typename _BpUGraph>

   class BpUGraphAdaptorBase {

   public:

     typedef _BpUGraph Graph;

     typedef Graph ParentGraph;

   protected:

     Graph* graph;

     BpUGraphAdaptorBase() : graph(0) {}

     void setGraph(Graph& _graph) { graph = &_graph; }

     Graph& getGraph() { return *graph; }

     const Graph& getGraph() const { return *graph; }

   public:

     BpUGraphAdaptorBase(Graph& _graph) : graph(&_graph) {}

     typedef typename Graph::Node Node;

     typedef typename Graph::ANode ANode;

     typedef typename Graph::BNode BNode;

     typedef typename Graph::Edge Edge;

     typedef typename Graph::UEdge UEdge;

     void first(Node& i) const { graph->first(i); }

     void firstANode(Node& i) const { graph->firstANode(i); }

     void firstBNode(Node& i) const { graph->firstBNode(i); }

     void first(Edge& i) const { graph->first(i); }

     void first(UEdge& i) const { graph->first(i); }

     void firstIn(Edge& i, const Node& n) const { graph->firstIn(i, n); }

     void firstOut(Edge& i, const Node& n ) const { graph->firstOut(i, n); }

     void firstInc(UEdge &i, bool &d, const Node &n) const {

       graph->firstInc(i, d, n);

     }

     void firstFromANode(UEdge& i, const Node& n) const {

       graph->firstFromANode(i, n);

     }

     void firstFromBNode(UEdge& i, const Node& n) const {

       graph->firstFromBNode(i, n);

     }

     void next(Node& i) const { graph->next(i); }

     void nextANode(Node& i) const { graph->nextANode(i); }

     void nextBNode(Node& i) const { graph->nextBNode(i); }

     void next(Edge& i) const { graph->next(i); }

     void next(UEdge& i) const { graph->next(i); }

     void nextIn(Edge& i) const { graph->nextIn(i); }

     void nextOut(Edge& i) const { graph->nextOut(i); }

     void nextInc(UEdge &i, bool &d) const { graph->nextInc(i, d); }

     void nextFromANode(UEdge& i) const { graph->nextFromANode(i); }

     void nextFromBNode(UEdge& i) const { graph->nextFromBNode(i); }

     Node source(const UEdge& e) const { return graph->source(e); }

     Node target(const UEdge& e) const { return graph->target(e); }

     Node source(const Edge& e) const { return graph->source(e); }

     Node target(const Edge& e) const { return graph->target(e); }

     Node aNode(const UEdge& e) const { return graph->aNode(e); }

     Node bNode(const UEdge& e) const { return graph->bNode(e); }

     bool aNode(const Node& n) const { return graph->aNode(n); }

     bool bNode(const Node& n) const { return graph->bNode(n); }

     typedef NodeNumTagIndicator<Graph> NodeNumTag;

     int nodeNum() const { return graph->nodeNum(); }

     int aNodeNum() const { return graph->aNodeNum(); }

     int bNodeNum() const { return graph->bNodeNum(); }

     typedef EdgeNumTagIndicator<Graph> EdgeNumTag;

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

     int uEdgeNum() const { return graph->uEdgeNum(); }

     typedef FindEdgeTagIndicator<Graph> FindEdgeTag;

     Edge findEdge(const Node& source, const Node& target, 

 		  const Edge& prev = INVALID) {

       return graph->findEdge(source, target, prev);

     }

     UEdge findUEdge(const Node& source, const Node& target, 

                     const UEdge& prev = INVALID) {

       return graph->findUEdge(source, target, prev);

     }

     Node addANode() const { return graph->addANode(); }

     Node addBNode() const { return graph->addBNode(); }

     UEdge addEdge(const Node& source, const Node& target) const { 

       return graph->addEdge(source, target); 

     }

     void erase(const Node& i) const { graph->erase(i); }

     void erase(const UEdge& i) const { graph->erase(i); }

     void clear() const { graph->clear(); }

     bool direction(const Edge& e) const { return graph->direction(e); }

     Edge direct(const UEdge& e, bool d) const { return graph->direct(e, d); }

     int id(const Node& v) const { return graph->id(v); }

     int id(const ANode& v) const { return graph->id(v); }

     int id(const BNode& v) const { return graph->id(v); }

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

     int id(const UEdge& e) const { return graph->id(e); }

     Node fromNodeId(int id) const { return graph->fromNodeId(id); }

     ANode nodeFromANodeId(int id) const { return graph->nodeFromANodeId(id); }

     BNode nodeFromBNodeId(int id) const { return graph->nodeFromBNodeId(id); }

     Edge fromEdgeId(int id) const { return graph->fromEdgeId(id); }

     UEdge fromUEdgeId(int id) const { return graph->fromUEdgeId(id); }

     int maxNodeId() const { return graph->maxNodeId(); }

     int maxANodeId() const { return graph->maxANodeId(); }

     int maxBNodeId() const { return graph->maxBNodeId(); }

     int maxEdgeId() const { return graph->maxEdgeId(); }

     int maxUEdgeId() const { return graph->maxEdgeId(); }

     typedef typename ItemSetTraits<Graph, Node>::ItemNotifier NodeNotifier;

     NodeNotifier& getNotifier(Node) const {

       return graph->getNotifier(Node()); 

     } 

     typedef typename ItemSetTraits<Graph, ANode>::ItemNotifier ANodeNotifier;

     ANodeNotifier& getNotifier(ANode) const {

       return graph->getNotifier(ANode());

     } 

     typedef typename ItemSetTraits<Graph, BNode>::ItemNotifier BNodeNotifier;

     BNodeNotifier& getNotifier(BNode) const {

       return graph->getNotifier(BNode());

     } 

     typedef typename ItemSetTraits<Graph, Edge>::ItemNotifier EdgeNotifier;

     EdgeNotifier& getNotifier(Edge) const {

       return graph->getNotifier(Edge());

     } 

     typedef typename ItemSetTraits<Graph, UEdge>::ItemNotifier UEdgeNotifier;

     UEdgeNotifier& getNotifier(UEdge) const {

       return graph->getNotifier(UEdge());

     } 

     template <typename _Value>

     class NodeMap : public Graph::template NodeMap<_Value> {

     public:

       typedef typename Graph::template NodeMap<_Value> Parent;

       explicit NodeMap(const BpUGraphAdaptorBase<Graph>& ga) 

 	: Parent(*ga.graph) {}

       NodeMap(const BpUGraphAdaptorBase<Graph>& ga, const _Value& value)

 	: Parent(*ga.graph, value) {}

       NodeMap& operator=(const NodeMap& cmap) {

 	return operator=<NodeMap>(cmap);

       }

       template <typename CMap>

       NodeMap& operator=(const CMap& cmap) {

         Parent::operator=(cmap);

 	return *this;

       }

     };

     template <typename _Value>

     class ANodeMap : public Graph::template ANodeMap<_Value> {

     public:

       typedef typename Graph::template ANodeMap<_Value> Parent;

       explicit ANodeMap(const BpUGraphAdaptorBase& ga) 

 	: Parent(*ga.graph) {}

       ANodeMap(const BpUGraphAdaptorBase& ga, const _Value& value)

 	: Parent(*ga.graph, value) {}

       ANodeMap& operator=(const ANodeMap& cmap) {

 	return operator=<ANodeMap>(cmap);

       }

       template <typename CMap>

       ANodeMap& operator=(const CMap& cmap) {

         Parent::operator=(cmap);

 	return *this;

       }

     };

     template <typename _Value>

     class BNodeMap : public Graph::template BNodeMap<_Value> {

     public:

       typedef typename Graph::template BNodeMap<_Value> Parent;

       explicit BNodeMap(const BpUGraphAdaptorBase<Graph>& ga) 

 	: Parent(*ga.graph) {}

       BNodeMap(const BpUGraphAdaptorBase<Graph>& ga, const _Value& value)

 	: Parent(*ga.graph, value) {}

       BNodeMap& operator=(const BNodeMap& cmap) {

 	return operator=<BNodeMap>(cmap);

       }

       template <typename CMap>

       BNodeMap& operator=(const CMap& cmap) {

         Parent::operator=(cmap);

 	return *this;

       }

     };

     template <typename _Value>

     class EdgeMap : public Graph::template EdgeMap<_Value> {

     public:

       typedef typename Graph::template EdgeMap<_Value> Parent;

       explicit EdgeMap(const BpUGraphAdaptorBase<Graph>& ga) 

 	: Parent(*ga.graph) {}

       EdgeMap(const BpUGraphAdaptorBase<Graph>& ga, const _Value& value)

 	: Parent(*ga.graph, value) {}

       EdgeMap& operator=(const EdgeMap& cmap) {

 	return operator=<EdgeMap>(cmap);

       }

       template <typename CMap>

       EdgeMap& operator=(const CMap& cmap) {

         Parent::operator=(cmap);

 	return *this;

       }

     };

     template <typename _Value>

     class UEdgeMap : public Graph::template UEdgeMap<_Value> {

     public:

       typedef typename Graph::template UEdgeMap<_Value> Parent;

       explicit UEdgeMap(const BpUGraphAdaptorBase<Graph>& ga) 

 	: Parent(*ga.graph) {}

       UEdgeMap(const BpUGraphAdaptorBase<Graph>& ga, const _Value& value)

 	: Parent(*ga.graph, value) {}

       UEdgeMap& operator=(const UEdgeMap& cmap) {

 	return operator=<UEdgeMap>(cmap);

       }

       template <typename CMap>

       UEdgeMap& operator=(const CMap& cmap) {

         Parent::operator=(cmap);

 	return *this;

       }

     };

   };

   /// \ingroup graph_adaptors

   ///

   /// \brief Trivial Bipartite Undirected Graph Adaptor

   ///

   /// Trivial Bipartite Undirected Graph Adaptor. It does not change

   /// the functionality of the adapted graph.

   template <typename _BpUGraph>

   class BpUGraphAdaptor 

     : public BpUGraphAdaptorExtender< BpUGraphAdaptorBase<_BpUGraph> > { 

   public:

     typedef _BpUGraph Graph;

     typedef BpUGraphAdaptorExtender<BpUGraphAdaptorBase<_BpUGraph> > Parent;

   protected:

     BpUGraphAdaptor() : Parent() {}

   public:

     explicit BpUGraphAdaptor(Graph& _graph) { setGraph(_graph); }

   };

   template <typename _BpUGraph>

   class SwapBpUGraphAdaptorBase : public BpUGraphAdaptorBase<_BpUGraph> {

   public:

     typedef _BpUGraph Graph;

     typedef BpUGraphAdaptorBase<_BpUGraph> Parent;

   protected:

     SwapBpUGraphAdaptorBase() {}

   public:

     typedef typename Parent::Node Node;

     typedef typename Parent::BNode ANode;

     typedef typename Parent::ANode BNode;

     typedef typename Parent::Edge Edge;

     typedef typename Parent::UEdge UEdge;

     bool direction(const Edge& e) const { return !Parent::direction(e); }

     Edge direct(const UEdge& e, bool b) const { return Parent::direct(e, !b); }

     Node aNode(const UEdge& e) const { return Parent::bNode(e); }

     Node bNode(const UEdge& e) const { return Parent::aNode(e); }

     bool aNode(const Node& n) const { return Parent::bNode(n); }

     bool bNode(const Node& n) const { return Parent::aNode(n); }

     void firstANode(Node& i) const { Parent::firstBNode(i); }

     void firstBNode(Node& i) const { Parent::firstANode(i); }

     void nextANode(Node& i) const { Parent::nextBNode(i); }

     void nextBNode(Node& i) const { Parent::nextANode(i); }

     void firstFromANode(UEdge& i, const Node& n) const {

       Parent::firstFromBNode(i, n);

     }

     void firstFromBNode(UEdge& i, const Node& n) const {

       Parent::firstFromANode(i, n);

     }

     void nextFromANode(UEdge& i) const { Parent::nextFromBNode(i); }

     void nextFromBNode(UEdge& i) const { Parent::nextFromANode(i); }

     int id(const ANode& v) const { return Parent::id(v); }

     int id(const BNode& v) const { return Parent::id(v); }

     ANode nodeFromANodeId(int id) const { return Parent::nodeFromBNodeId(id); }

     BNode nodeFromBNodeId(int id) const { return Parent::nodeFromANodeId(id); }

     int maxANodeId() const { return Parent::maxBNodeId(); }

     int maxBNodeId() const { return Parent::maxANodeId(); }

     int aNodeNum() const { return Parent::bNodeNum(); }

     int bNodeNum() const { return Parent::aNodeNum(); }

     typedef typename Parent::BNodeNotifier ANodeNotifier;

     ANodeNotifier& getNotifier(ANode) const {

       return Parent::getNotifier(typename Parent::BNode());

     } 

     typedef typename Parent::ANodeNotifier BNodeNotifier;

     BNodeNotifier& getNotifier(BNode) const {

       return Parent::getNotifier(typename Parent::ANode());

     } 

     template <typename _Value>

     class ANodeMap : public Graph::template BNodeMap<_Value> {

     public:

       typedef typename Graph::template BNodeMap<_Value> Parent;

       explicit ANodeMap(const SwapBpUGraphAdaptorBase& ga) 

 	: Parent(*ga.graph) {}

       ANodeMap(const SwapBpUGraphAdaptorBase& ga, const _Value& value)

 	: Parent(*ga.graph, value) {}

       ANodeMap& operator=(const ANodeMap& cmap) {

 	return operator=<ANodeMap>(cmap);

       }

       template <typename CMap>

       ANodeMap& operator=(const CMap& cmap) {

         Parent::operator=(cmap);

 	return *this;

       }

     };

     template <typename _Value>

     class BNodeMap : public Graph::template ANodeMap<_Value> {

     public:

       typedef typename Graph::template ANodeMap<_Value> Parent;

       explicit BNodeMap(const SwapBpUGraphAdaptorBase<Graph>& ga) 

 	: Parent(*ga.graph) {}

       BNodeMap(const SwapBpUGraphAdaptorBase<Graph>& ga, const _Value& value)

 	: Parent(*ga.graph, value) {}

       BNodeMap& operator=(const BNodeMap& cmap) {

 	return operator=<BNodeMap>(cmap);

       }

       template <typename CMap>

       BNodeMap& operator=(const CMap& cmap) {

         Parent::operator=(cmap);

 	return *this;

       }

     };

   };

   /// \ingroup graph_adaptors

   ///

   /// \brief Bipartite graph adaptor which swaps the two nodeset.

   ///

   /// Bipartite graph adaptor which swaps the two nodeset. The adaptor's

   /// anode-set will be the original graph's bnode-set and the adaptor's

   /// bnode-set will be the original graph's anode-set.

   ///

   /// As example look at an algorithm what can be sped up with the

   /// swap bipartite undirected graph adaptor. If we want to find the

   /// maximum matching in the bipartite graph then it will be not changed

   /// if we swap the two nodesets. But the algorithm use the two nodeset

   /// different way. If we swap the nodesets it provides different

   /// running time. We run a test on random bipartite graphs with

   /// different rate of the anode-set size and bnode-set size.

   /// We always made graphs with 10000 nodes and 20000 edges and we

   /// computed the maximum cardinality matching with the Hopcroft-Karp 

   /// algorithm.

   ///

   /// The next diagram shows the running time of the tests. If the anode-set

   /// is smaller than the bnode-set the running time is better than with 

   /// the swapped graph. Other conclusion is that the running time

   /// is greater when the two nodesets size are nearly equal. 

   ///

   /// \image html swap_test.png

   /// \image latex swap_test.eps "Swapping nodesets" width=\textwidth

   /// 

   /// The next part shows how can we swap the two nodeset:

   ///

   ///\code

   /// typedef SwapBpUGraphAdaptor<BpUGraph> SBpUGraph;

   /// SBpUGraph sbpugraph(bpugraph);

   /// MaxBipartiteMatching<SBpUGraph> sbpumatch(sbpugraph);

   ///\endcode

   template <typename _BpUGraph>

   class SwapBpUGraphAdaptor 

     : public BpUGraphAdaptorExtender<SwapBpUGraphAdaptorBase<_BpUGraph> > { 

   public:

     typedef _BpUGraph Graph;

     typedef BpUGraphAdaptorExtender<SwapBpUGraphAdaptorBase<_BpUGraph> > 

     Parent;

   protected:

     SwapBpUGraphAdaptor() : Parent() {}

   public:

     /// \brief Construct a swapped graph.

     ///

     /// Construct a swapped graph.

     explicit SwapBpUGraphAdaptor(Graph& _graph) { setGraph(_graph); }

   };

   template <typename _BpUGraph, 

             typename _ANMatchingMap, typename _BNMatchingMap>

   class MatchingBpUGraphAdaptorBase 

     : public BpUGraphAdaptorBase<const _BpUGraph>

   {

   public:

     typedef _BpUGraph Graph;

     typedef _ANMatchingMap ANodeMatchingMap;

     typedef _BNMatchingMap BNodeMatchingMap;

     typedef BpUGraphAdaptorBase<const _BpUGraph> Parent;

   protected:

     MatchingBpUGraphAdaptorBase() {}

     void setANodeMatchingMap(ANodeMatchingMap& _anode_matching) {

       anode_matching = &_anode_matching;

     }

     void setBNodeMatchingMap(BNodeMatchingMap& _bnode_matching) {

       bnode_matching = &_bnode_matching;

     }

   public:

     typedef typename Parent::Node Node;

     typedef typename Parent::Edge Edge;

     void firstOut(Edge& edge, const Node& node) const {

       if (Parent::aNode(node)) {

         Parent::firstOut(edge, node);

         if (edge != INVALID && (*anode_matching)[node] == edge) {

           Parent::nextOut(edge);

         }

       } else {

         edge = (*bnode_matching)[node] != INVALID ?

           Parent::direct((*bnode_matching)[node], false) : INVALID;

       }

     }

     void nextOut(Edge& edge) const {

       if (Parent::aNode(Parent::source(edge))) {

         Parent::nextOut(edge);

         if (edge != INVALID && (*anode_matching)[Parent::aNode(edge)] == edge) {

           Parent::nextOut(edge);

         }

       } else {

         edge = INVALID;

       }

     }

     void firstIn(Edge& edge, const Node& node) const {

       if (Parent::aNode(node)) {

         edge = (*bnode_matching)[node] != INVALID ?

           Parent::direct((*anode_matching)[node], false) : INVALID;

       } else {

         Parent::firstIn(edge, node);

         if (edge != INVALID && (*bnode_matching)[node] == edge) {

           Parent::nextIn(edge);

         }

       }

     }

     void nextIn(Edge& edge) const {

       if (Parent::aNode(Parent::target(edge))) {

         edge = INVALID;

       } else {

         Parent::nextIn(edge);

         if (edge != INVALID && (*bnode_matching)[Parent::bNode(edge)] == edge) {

           Parent::nextIn(edge);

         }

       }

     } 

   private:

     ANodeMatchingMap* anode_matching;

     BNodeMatchingMap* bnode_matching;

   };

   /// \ingroup graph_adaptors

   ///

   /// \brief Bipartite graph adaptor to implement matching algorithms.

   ///

   /// Bipartite graph adaptor to implement matchings. It implements

   /// the residual graph of the matching.

   template <typename _BpUGraph, 

             typename _ANMatchingMap = 

             typename _BpUGraph::template ANodeMap<typename _BpUGraph::UEdge>, 

             typename _BNMatchingMap =

             typename _BpUGraph::template BNodeMap<typename _BpUGraph::UEdge> >

   class MatchingBpUGraphAdaptor 

     : public BpUGraphAdaptorExtender<

     MatchingBpUGraphAdaptorBase<_BpUGraph, _ANMatchingMap, _BNMatchingMap> > 

   { 

   public:

     typedef _BpUGraph BpUGraph;

     typedef _BpUGraph Graph;

     typedef _ANMatchingMap ANodeMatchingMap;

     typedef _BNMatchingMap BNodeMatchingMap;

     typedef BpUGraphAdaptorExtender<

       MatchingBpUGraphAdaptorBase<BpUGraph, 

                                   ANodeMatchingMap, BNodeMatchingMap> > 

     Parent;

   protected:

     MatchingBpUGraphAdaptor() : Parent() {}

   public:

     MatchingBpUGraphAdaptor(const Graph& _graph, 

                             ANodeMatchingMap& _anode_matching,

                             BNodeMatchingMap& _bnode_matching) {

       setGraph(_graph);

       setANodeMatchingMap(_anode_matching);

       setBNodeMatchingMap(_bnode_matching);

     }

   };

 }

 #endif