/* -*- C++ -*-

 *

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

 *

 * Copyright (C) 2003-2008

 * 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_DIGRAPH_ADAPTOR_H

#define LEMON_DIGRAPH_ADAPTOR_H

///\ingroup graph_adaptors

///\file

///\brief Several digraph adaptors.

///

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

#include <lemon/core.h>

#include <lemon/maps.h>

#include <lemon/bits/variant.h>

#include <lemon/bits/base_extender.h>

#include <lemon/bits/graph_adaptor_extender.h>

#include <lemon/bits/graph_extender.h>

#include <lemon/tolerance.h>

#include <algorithm>

namespace lemon {

  ///\brief Base type for the Digraph Adaptors

  ///

  ///Base type for the Digraph Adaptors

  ///

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

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

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

  ///to make easier implementing digraph adaptors. E.g. if an adaptor

  ///is considered which differs from the wrapped digraph only in some

  ///of its functions or types, then it can be derived from

  ///DigraphAdaptor, and only the differences should be implemented.

  template<typename _Digraph>

  class DigraphAdaptorBase {

  public:

    typedef _Digraph Digraph;

    typedef DigraphAdaptorBase Adaptor;

    typedef Digraph ParentDigraph;

  protected:

    Digraph* _digraph;

    DigraphAdaptorBase() : _digraph(0) { }

    void setDigraph(Digraph& digraph) { _digraph = &digraph; }

  public:

    DigraphAdaptorBase(Digraph& digraph) : _digraph(&digraph) { }

    typedef typename Digraph::Node Node;

    typedef typename Digraph::Arc Arc;

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

    void first(Arc& i) const { _digraph->first(i); }

    void firstIn(Arc& i, const Node& n) const { _digraph->firstIn(i, n); }

    void firstOut(Arc& i, const Node& n ) const { _digraph->firstOut(i, n); }

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

    void next(Arc& i) const { _digraph->next(i); }

    void nextIn(Arc& i) const { _digraph->nextIn(i); }

    void nextOut(Arc& i) const { _digraph->nextOut(i); }

    Node source(const Arc& a) const { return _digraph->source(a); }

    Node target(const Arc& a) const { return _digraph->target(a); }

    typedef NodeNumTagIndicator<Digraph> NodeNumTag;

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

    typedef EdgeNumTagIndicator<Digraph> EdgeNumTag;

    int arcNum() const { return _digraph->arcNum(); }

    typedef FindEdgeTagIndicator<Digraph> FindEdgeTag;

    Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) {

      return _digraph->findArc(u, v, prev);

    }

    Node addNode() { return _digraph->addNode(); }

    Arc addArc(const Node& u, const Node& v) { return _digraph->addArc(u, v); }

    void erase(const Node& n) const { _digraph->erase(n); }

    void erase(const Arc& a) const { _digraph->erase(a); }

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

    int id(const Node& n) const { return _digraph->id(n); }

    int id(const Arc& a) const { return _digraph->id(a); }

    Node nodeFromId(int ix) const { return _digraph->nodeFromId(ix); }

    Arc arcFromId(int ix) const { return _digraph->arcFromId(ix); }

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

    int maxArcId() const { return _digraph->maxArcId(); }

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

    NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); } 

    typedef typename ItemSetTraits<Digraph, Arc>::ItemNotifier ArcNotifier;

    ArcNotifier& notifier(Arc) const { return _digraph->notifier(Arc()); } 

    template <typename _Value>

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

    public:

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

      explicit NodeMap(const Adaptor& adaptor) 

	: Parent(*adaptor._digraph) {}

      NodeMap(const Adaptor& adaptor, const _Value& value)

	: Parent(*adaptor._digraph, value) { }

    private:

      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 ArcMap : public Digraph::template ArcMap<_Value> {

    public:

      typedef typename Digraph::template ArcMap<_Value> Parent;

      explicit ArcMap(const Adaptor& adaptor) 

	: Parent(*adaptor._digraph) {}

      ArcMap(const Adaptor& adaptor, const _Value& value)

	: Parent(*adaptor._digraph, value) {}

    private:

      ArcMap& operator=(const ArcMap& cmap) {

        return operator=<ArcMap>(cmap);

      }

      template <typename CMap>

      ArcMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

  };

  ///\ingroup graph_adaptors

  ///

  ///\brief Trivial Digraph Adaptor

  /// 

  /// This class is an adaptor which does not change the adapted

  /// digraph.  It can be used only to test the digraph adaptors.

  template <typename _Digraph>

  class DigraphAdaptor :

    public DigraphAdaptorExtender<DigraphAdaptorBase<_Digraph> > { 

  public:

    typedef _Digraph Digraph;

    typedef DigraphAdaptorExtender<DigraphAdaptorBase<_Digraph> > Parent;

  protected:

    DigraphAdaptor() : Parent() { }

  public:

    explicit DigraphAdaptor(Digraph& digraph) { setDigraph(digraph); }

  };

  /// \brief Just gives back a digraph adaptor

  ///

  /// Just gives back a digraph adaptor which 

  /// should be provide original digraph

  template<typename Digraph>

  DigraphAdaptor<const Digraph>

  digraphAdaptor(const Digraph& digraph) {

    return DigraphAdaptor<const Digraph>(digraph);

  }

  template <typename _Digraph>

  class RevDigraphAdaptorBase : public DigraphAdaptorBase<_Digraph> {

  public:

    typedef _Digraph Digraph;

    typedef DigraphAdaptorBase<_Digraph> Parent;

  protected:

    RevDigraphAdaptorBase() : Parent() { }

  public:

    typedef typename Parent::Node Node;

    typedef typename Parent::Arc Arc;

    void firstIn(Arc& a, const Node& n) const { Parent::firstOut(a, n); }

    void firstOut(Arc& a, const Node& n ) const { Parent::firstIn(a, n); }

    void nextIn(Arc& a) const { Parent::nextOut(a); }

    void nextOut(Arc& a) const { Parent::nextIn(a); }

    Node source(const Arc& a) const { return Parent::target(a); }

    Node target(const Arc& a) const { return Parent::source(a); }

    typedef FindEdgeTagIndicator<Digraph> FindEdgeTag;

    Arc findArc(const Node& u, const Node& v, 

		const Arc& prev = INVALID) {

      return Parent::findArc(v, u, prev);

    }

  };

  ///\ingroup graph_adaptors

  ///

  ///\brief A digraph adaptor which reverses the orientation of the arcs.

  ///

  /// If \c g is defined as

  ///\code

  /// ListDigraph g;

  ///\endcode

  /// then

  ///\code

  /// RevDigraphAdaptor<ListDigraph> ga(g);

  ///\endcode

  /// implements the digraph obtained from \c g by 

  /// reversing the orientation of its arcs.

  ///

  /// A good example of using RevDigraphAdaptor is to decide that the

  /// directed graph is wheter strongly connected or not. If from one

  /// node each node is reachable and from each node is reachable this

  /// node then and just then the digraph is strongly

  /// connected. Instead of this condition we use a little bit

  /// different. From one node each node ahould be reachable in the

  /// digraph and in the reversed digraph. Now this condition can be

  /// checked with the Dfs algorithm class and the RevDigraphAdaptor

  /// algorithm class.

  ///

  /// And look at the code:

  ///

  ///\code

  /// bool stronglyConnected(const Digraph& digraph) {

  ///   if (NodeIt(digraph) == INVALID) return true;

  ///   Dfs<Digraph> dfs(digraph);

  ///   dfs.run(NodeIt(digraph));

  ///   for (NodeIt it(digraph); it != INVALID; ++it) {

  ///     if (!dfs.reached(it)) {

  ///       return false;

  ///     }

  ///   }

  ///   typedef RevDigraphAdaptor<const Digraph> RDigraph;

  ///   RDigraph rdigraph(digraph);

  ///   DfsVisit<RDigraph> rdfs(rdigraph);

  ///   rdfs.run(NodeIt(digraph));

  ///   for (NodeIt it(digraph); it != INVALID; ++it) {

  ///     if (!rdfs.reached(it)) {

  ///       return false;

  ///     }

  ///   }

  ///   return true;

  /// }

  ///\endcode

  template<typename _Digraph>

  class RevDigraphAdaptor : 

    public DigraphAdaptorExtender<RevDigraphAdaptorBase<_Digraph> > {

  public:

    typedef _Digraph Digraph;

    typedef DigraphAdaptorExtender<

      RevDigraphAdaptorBase<_Digraph> > Parent;

  protected:

    RevDigraphAdaptor() { }

  public:

    explicit RevDigraphAdaptor(Digraph& digraph) { 

      Parent::setDigraph(digraph); 

    }

  };

  /// \brief Just gives back a reverse digraph adaptor

  ///

  /// Just gives back a reverse digraph adaptor

  template<typename Digraph>

  RevDigraphAdaptor<const Digraph>

  revDigraphAdaptor(const Digraph& digraph) {

    return RevDigraphAdaptor<const Digraph>(digraph);

  }

  template <typename _Digraph, typename _NodeFilterMap, 

	    typename _ArcFilterMap, bool checked = true>

  class SubDigraphAdaptorBase : public DigraphAdaptorBase<_Digraph> {

  public:

    typedef _Digraph Digraph;

    typedef _NodeFilterMap NodeFilterMap;

    typedef _ArcFilterMap ArcFilterMap;

    typedef SubDigraphAdaptorBase Adaptor;

    typedef DigraphAdaptorBase<_Digraph> Parent;

  protected:

    NodeFilterMap* _node_filter;

    ArcFilterMap* _arc_filter;

    SubDigraphAdaptorBase() 

      : Parent(), _node_filter(0), _arc_filter(0) { }

    void setNodeFilterMap(NodeFilterMap& node_filter) {

      _node_filter = &node_filter;

    }

    void setArcFilterMap(ArcFilterMap& arc_filter) {

      _arc_filter = &arc_filter;

    }

  public:

    typedef typename Parent::Node Node;

    typedef typename Parent::Arc Arc;

    void first(Node& i) const { 

      Parent::first(i); 

      while (i != INVALID && !(*_node_filter)[i]) Parent::next(i); 

    }

    void first(Arc& i) const { 

      Parent::first(i); 

      while (i != INVALID && (!(*_arc_filter)[i] 

	     || !(*_node_filter)[Parent::source(i)]

	     || !(*_node_filter)[Parent::target(i)])) Parent::next(i); 

    }

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

      Parent::firstIn(i, n); 

      while (i != INVALID && (!(*_arc_filter)[i] 

	     || !(*_node_filter)[Parent::source(i)])) Parent::nextIn(i); 

    }

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

      Parent::firstOut(i, n); 

      while (i != INVALID && (!(*_arc_filter)[i] 

	     || !(*_node_filter)[Parent::target(i)])) Parent::nextOut(i); 

    }

    void next(Node& i) const { 

      Parent::next(i); 

      while (i != INVALID && !(*_node_filter)[i]) Parent::next(i); 

    }

    void next(Arc& i) const { 

      Parent::next(i); 

      while (i != INVALID && (!(*_arc_filter)[i] 

	     || !(*_node_filter)[Parent::source(i)]

	     || !(*_node_filter)[Parent::target(i)])) Parent::next(i); 

    }

    void nextIn(Arc& i) const { 

      Parent::nextIn(i); 

      while (i != INVALID && (!(*_arc_filter)[i] 

	     || !(*_node_filter)[Parent::source(i)])) Parent::nextIn(i); 

    }

    void nextOut(Arc& i) const { 

      Parent::nextOut(i); 

      while (i != INVALID && (!(*_arc_filter)[i] 

	     || !(*_node_filter)[Parent::target(i)])) Parent::nextOut(i); 

    }

    ///\e

    /// This function hides \c n in the digraph, i.e. the iteration 

    /// jumps over it. This is done by simply setting the value of \c n  

    /// to be false in the corresponding node-map.

    void hide(const Node& n) const { _node_filter->set(n, false); }

    ///\e

    /// This function hides \c a in the digraph, i.e. the iteration 

    /// jumps over it. This is done by simply setting the value of \c a

    /// to be false in the corresponding arc-map.

    void hide(const Arc& a) const { _arc_filter->set(a, false); }

    ///\e

    /// The value of \c n is set to be true in the node-map which stores 

    /// hide information. If \c n was hidden previuosly, then it is shown 

    /// again

     void unHide(const Node& n) const { _node_filter->set(n, true); }

    ///\e

    /// The value of \c a is set to be true in the arc-map which stores 

    /// hide information. If \c a was hidden previuosly, then it is shown 

    /// again

    void unHide(const Arc& a) const { _arc_filter->set(a, true); }

    /// Returns true if \c n is hidden.

    ///\e

    ///

    bool hidden(const Node& n) const { return !(*_node_filter)[n]; }

    /// Returns true if \c a is hidden.

    ///\e

    ///

    bool hidden(const Arc& a) const { return !(*_arc_filter)[a]; }

    typedef False NodeNumTag;

    typedef False EdgeNumTag;

    typedef FindEdgeTagIndicator<Digraph> FindEdgeTag;

    Arc findArc(const Node& source, const Node& target, 

		const Arc& prev = INVALID) {

      if (!(*_node_filter)[source] || !(*_node_filter)[target]) {

        return INVALID;

      }

      Arc arc = Parent::findArc(source, target, prev);

      while (arc != INVALID && !(*_arc_filter)[arc]) {

        arc = Parent::findArc(source, target, arc);

      }

      return arc;

    }

    template <typename _Value>

    class NodeMap : public SubMapExtender<Adaptor, 

        typename Parent::template NodeMap<_Value> > {

    public:

      typedef _Value Value;

      typedef SubMapExtender<Adaptor, typename Parent::

                             template NodeMap<Value> > MapParent;

      NodeMap(const Adaptor& adaptor) 

	: MapParent(adaptor) {}

      NodeMap(const Adaptor& adaptor, const Value& value) 

	: MapParent(adaptor, value) {}

    private:

      NodeMap& operator=(const NodeMap& cmap) {

	return operator=<NodeMap>(cmap);

      }

      template <typename CMap>

      NodeMap& operator=(const CMap& cmap) {

        MapParent::operator=(cmap);

	return *this;

      }

    };

    template <typename _Value>

    class ArcMap : public SubMapExtender<Adaptor, 

	typename Parent::template ArcMap<_Value> > {

    public:

      typedef _Value Value;

      typedef SubMapExtender<Adaptor, typename Parent::

                             template ArcMap<Value> > MapParent;

      ArcMap(const Adaptor& adaptor) 

	: MapParent(adaptor) {}

      ArcMap(const Adaptor& adaptor, const Value& value) 

	: MapParent(adaptor, value) {}

    private:

      ArcMap& operator=(const ArcMap& cmap) {

	return operator=<ArcMap>(cmap);

      }

      template <typename CMap>

      ArcMap& operator=(const CMap& cmap) {

        MapParent::operator=(cmap);

	return *this;

      }

    };

  };

  template <typename _Digraph, typename _NodeFilterMap, typename _ArcFilterMap>

  class SubDigraphAdaptorBase<_Digraph, _NodeFilterMap, _ArcFilterMap, false> 

    : public DigraphAdaptorBase<_Digraph> {

  public:

    typedef _Digraph Digraph;

    typedef _NodeFilterMap NodeFilterMap;

    typedef _ArcFilterMap ArcFilterMap;

    typedef SubDigraphAdaptorBase Adaptor;

    typedef DigraphAdaptorBase<Digraph> Parent;

  protected:

    NodeFilterMap* _node_filter;

    ArcFilterMap* _arc_filter;

    SubDigraphAdaptorBase() 

      : Parent(), _node_filter(0), _arc_filter(0) { }

    void setNodeFilterMap(NodeFilterMap& node_filter) {

      _node_filter = &node_filter;

    }

    void setArcFilterMap(ArcFilterMap& arc_filter) {

      _arc_filter = &arc_filter;

    }

  public:

    typedef typename Parent::Node Node;

    typedef typename Parent::Arc Arc;

    void first(Node& i) const { 

      Parent::first(i); 

      while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); 

    }

    void first(Arc& i) const { 

      Parent::first(i); 

      while (i!=INVALID && !(*_arc_filter)[i]) Parent::next(i); 

    }

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

      Parent::firstIn(i, n); 

      while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextIn(i); 

    }

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

      Parent::firstOut(i, n); 

      while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextOut(i); 

    }

    void next(Node& i) const { 

      Parent::next(i); 

      while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); 

    }

    void next(Arc& i) const { 

      Parent::next(i); 

      while (i!=INVALID && !(*_arc_filter)[i]) Parent::next(i); 

    }

    void nextIn(Arc& i) const { 

      Parent::nextIn(i); 

      while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextIn(i); 

    }

    void nextOut(Arc& i) const { 

      Parent::nextOut(i); 

      while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextOut(i); 

    }

    ///\e

    /// This function hides \c n in the digraph, i.e. the iteration 

    /// jumps over it. This is done by simply setting the value of \c n  

    /// to be false in the corresponding node-map.

    void hide(const Node& n) const { _node_filter->set(n, false); }

    ///\e

    /// This function hides \c e in the digraph, i.e. the iteration 

    /// jumps over it. This is done by simply setting the value of \c e  

    /// to be false in the corresponding arc-map.

    void hide(const Arc& e) const { _arc_filter->set(e, false); }

    ///\e

    /// The value of \c n is set to be true in the node-map which stores 

    /// hide information. If \c n was hidden previuosly, then it is shown 

    /// again

     void unHide(const Node& n) const { _node_filter->set(n, true); }

    ///\e

    /// The value of \c e is set to be true in the arc-map which stores 

    /// hide information. If \c e was hidden previuosly, then it is shown 

    /// again

    void unHide(const Arc& e) const { _arc_filter->set(e, true); }

    /// Returns true if \c n is hidden.

    ///\e

    ///

    bool hidden(const Node& n) const { return !(*_node_filter)[n]; }

    /// Returns true if \c n is hidden.

    ///\e

    ///

    bool hidden(const Arc& e) const { return !(*_arc_filter)[e]; }

    typedef False NodeNumTag;

    typedef False EdgeNumTag;

    typedef FindEdgeTagIndicator<Digraph> FindEdgeTag;

    Arc findArc(const Node& source, const Node& target, 

		  const Arc& prev = INVALID) {

      if (!(*_node_filter)[source] || !(*_node_filter)[target]) {

        return INVALID;

      }

      Arc arc = Parent::findArc(source, target, prev);

      while (arc != INVALID && !(*_arc_filter)[arc]) {

        arc = Parent::findArc(source, target, arc);

      }

      return arc;

    }

    template <typename _Value>

    class NodeMap : public SubMapExtender<Adaptor, 

        typename Parent::template NodeMap<_Value> > {

    public:

      typedef _Value Value;

      typedef SubMapExtender<Adaptor, typename Parent::

                             template NodeMap<Value> > MapParent;

      NodeMap(const Adaptor& adaptor) 

	: MapParent(adaptor) {}

      NodeMap(const Adaptor& adaptor, const Value& value) 

	: MapParent(adaptor, value) {}

    private:

      NodeMap& operator=(const NodeMap& cmap) {

	return operator=<NodeMap>(cmap);

      }

      template <typename CMap>

      NodeMap& operator=(const CMap& cmap) {

        MapParent::operator=(cmap);

	return *this;

      }

    };

    template <typename _Value>

    class ArcMap : public SubMapExtender<Adaptor, 

	typename Parent::template ArcMap<_Value> > {

    public:

      typedef _Value Value;

      typedef SubMapExtender<Adaptor, typename Parent::

                             template ArcMap<Value> > MapParent;

      ArcMap(const Adaptor& adaptor) 

	: MapParent(adaptor) {}

      ArcMap(const Adaptor& adaptor, const Value& value) 

	: MapParent(adaptor, value) {}

    private:

      ArcMap& operator=(const ArcMap& cmap) {

	return operator=<ArcMap>(cmap);

      }

      template <typename CMap>

      ArcMap& operator=(const CMap& cmap) {

        MapParent::operator=(cmap);

	return *this;

      }

    };

  };

  /// \ingroup graph_adaptors

  ///

  /// \brief A digraph adaptor for hiding nodes and arcs from a digraph.

  /// 

  /// SubDigraphAdaptor shows the digraph with filtered node-set and 

  /// arc-set. If the \c checked parameter is true then it filters the arcset

  /// to do not get invalid arcs without source or target.

  /// Let \f$ G=(V, A) \f$ be a directed digraph

  /// and suppose that the digraph instance \c g of type ListDigraph

  /// implements \f$ G \f$.

  /// Let moreover \f$ b_V \f$ and \f$ b_A \f$ be bool-valued functions resp.

  /// on the node-set and arc-set.

  /// SubDigraphAdaptor<...>::NodeIt iterates 

  /// on the node-set \f$ \{v\in V : b_V(v)=true\} \f$ and 

  /// SubDigraphAdaptor<...>::ArcIt iterates 

  /// on the arc-set \f$ \{e\in A : b_A(e)=true\} \f$. Similarly, 

  /// SubDigraphAdaptor<...>::OutArcIt and

  /// SubDigraphAdaptor<...>::InArcIt iterates 

  /// only on arcs leaving and entering a specific node which have true value.

  /// 

  /// If the \c checked template parameter is false then we have to

  /// note that the node-iterator cares only the filter on the

  /// node-set, and the arc-iterator cares only the filter on the

  /// arc-set.  This way the arc-map should filter all arcs which's

  /// source or target is filtered by the node-filter.

  ///\code

  /// typedef ListDigraph Digraph;

  /// DIGRAPH_TYPEDEFS(Digraph);

  /// Digraph g;

  /// Node u=g.addNode(); //node of id 0

  /// Node v=g.addNode(); //node of id 1

  /// Arc a=g.addArc(u, v); //arc of id 0

  /// Arc f=g.addArc(v, u); //arc of id 1

  /// BoolNodeMap nm(g, true);

  /// nm.set(u, false);

  /// BoolArcMap am(g, true);

  /// am.set(a, false);

  /// typedef SubDigraphAdaptor<Digraph, BoolNodeMap, BoolArcMap> SubGA;

  /// SubGA ga(g, nm, am);

  /// for (SubGA::NodeIt n(ga); n!=INVALID; ++n)

  ///   std::cout << g.id(n) << std::endl;

  /// std::cout << ":-)" << std::endl;

  /// for (SubGA::ArcIt a(ga); a!=INVALID; ++a) 

  ///   std::cout << g.id(a) << std::endl;

  ///\endcode

  /// The output of the above code is the following.

  ///\code

  /// 1

  /// :-)

  /// 1

  ///\endcode

  /// Note that \c n is of type \c SubGA::NodeIt, but it can be converted to

  /// \c Digraph::Node that is why \c g.id(n) can be applied.

  /// 

  /// For other examples see also the documentation of

  /// NodeSubDigraphAdaptor and ArcSubDigraphAdaptor.

  template<typename _Digraph, 

	   typename _NodeFilterMap = typename _Digraph::template NodeMap<bool>, 

	   typename _ArcFilterMap = typename _Digraph::template ArcMap<bool>, 

	   bool checked = true>

  class SubDigraphAdaptor : 

    public DigraphAdaptorExtender<

    SubDigraphAdaptorBase<_Digraph, _NodeFilterMap, _ArcFilterMap, checked> > {

  public:

    typedef _Digraph Digraph;

    typedef _NodeFilterMap NodeFilterMap;

    typedef _ArcFilterMap ArcFilterMap;

    typedef DigraphAdaptorExtender<

      SubDigraphAdaptorBase<Digraph, NodeFilterMap, ArcFilterMap, checked> >

    Parent;

  protected:

    SubDigraphAdaptor() { }

  public:

    SubDigraphAdaptor(Digraph& digraph, NodeFilterMap& node_filter, 

		      ArcFilterMap& arc_filter) { 

      setDigraph(digraph);

      setNodeFilterMap(node_filter);

      setArcFilterMap(arc_filter);

    }

  };

  /// \brief Just gives back a sub digraph adaptor

  ///

  /// Just gives back a sub digraph adaptor

  template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>

  SubDigraphAdaptor<const Digraph, NodeFilterMap, ArcFilterMap>

  subDigraphAdaptor(const Digraph& digraph, 

		    NodeFilterMap& nfm, ArcFilterMap& afm) {

    return SubDigraphAdaptor<const Digraph, NodeFilterMap, ArcFilterMap>

      (digraph, nfm, afm);

  }

  template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>

  SubDigraphAdaptor<const Digraph, const NodeFilterMap, ArcFilterMap>

  subDigraphAdaptor(const Digraph& digraph, 

                   NodeFilterMap& nfm, ArcFilterMap& afm) {

    return SubDigraphAdaptor<const Digraph, const NodeFilterMap, ArcFilterMap>

      (digraph, nfm, afm);

  }

  template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>

  SubDigraphAdaptor<const Digraph, NodeFilterMap, const ArcFilterMap>

  subDigraphAdaptor(const Digraph& digraph, 

                   NodeFilterMap& nfm, ArcFilterMap& afm) {

    return SubDigraphAdaptor<const Digraph, NodeFilterMap, const ArcFilterMap>

      (digraph, nfm, afm);

  }

  template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>

  SubDigraphAdaptor<const Digraph, const NodeFilterMap, const ArcFilterMap>

  subDigraphAdaptor(const Digraph& digraph, 

                   NodeFilterMap& nfm, ArcFilterMap& afm) {

    return SubDigraphAdaptor<const Digraph, const NodeFilterMap, 

      const ArcFilterMap>(digraph, nfm, afm);

  }

  ///\ingroup graph_adaptors

  ///

  ///\brief An adaptor for hiding nodes from a digraph.

  ///

  ///An adaptor for hiding nodes from a digraph.  This adaptor

  ///specializes SubDigraphAdaptor in the way that only the node-set

  ///can be filtered. In usual case the checked parameter is true, we

  ///get the induced subgraph. But if the checked parameter is false

  ///then we can filter only isolated nodes.

  template<typename _Digraph, 

	   typename _NodeFilterMap = typename _Digraph::template NodeMap<bool>, 

	   bool checked = true>

  class NodeSubDigraphAdaptor : 

    public SubDigraphAdaptor<_Digraph, _NodeFilterMap, 

			     ConstMap<typename _Digraph::Arc, bool>, checked> {

  public:

    typedef _Digraph Digraph;

    typedef _NodeFilterMap NodeFilterMap;

    typedef SubDigraphAdaptor<Digraph, NodeFilterMap, 

			      ConstMap<typename Digraph::Arc, bool>, checked> 

    Parent;

  protected:

    ConstMap<typename Digraph::Arc, bool> const_true_map;

    NodeSubDigraphAdaptor() : const_true_map(true) {

      Parent::setArcFilterMap(const_true_map);

    }

  public:

    NodeSubDigraphAdaptor(Digraph& _digraph, NodeFilterMap& node_filter) : 

      Parent(), const_true_map(true) { 

      Parent::setDigraph(_digraph);

      Parent::setNodeFilterMap(node_filter);

      Parent::setArcFilterMap(const_true_map);

    }

  };

  /// \brief Just gives back a \c NodeSubDigraphAdaptor

  ///

  /// Just gives back a \c NodeSubDigraphAdaptor

  template<typename Digraph, typename NodeFilterMap>

  NodeSubDigraphAdaptor<const Digraph, NodeFilterMap>

  nodeSubDigraphAdaptor(const Digraph& digraph, NodeFilterMap& nfm) {

    return NodeSubDigraphAdaptor<const Digraph, NodeFilterMap>(digraph, nfm);

  }

  template<typename Digraph, typename NodeFilterMap>

  NodeSubDigraphAdaptor<const Digraph, const NodeFilterMap>

  nodeSubDigraphAdaptor(const Digraph& digraph, const NodeFilterMap& nfm) {

    return NodeSubDigraphAdaptor<const Digraph, const NodeFilterMap>

      (digraph, nfm);

  }

  ///\ingroup graph_adaptors

  ///

  ///\brief An adaptor for hiding arcs from a digraph.

  ///

  ///An adaptor for hiding arcs from a digraph. This adaptor

  ///specializes SubDigraphAdaptor in the way that only the arc-set

  ///can be filtered. The usefulness of this adaptor is demonstrated

  ///in the problem of searching a maximum number of arc-disjoint

  ///shortest paths between two nodes \c s and \c t. Shortest here

  ///means being shortest w.r.t.  non-negative arc-lengths. Note that

  ///the comprehension of the presented solution need's some

  ///elementary knowlarc from combinatorial optimization.

  ///

  ///If a single shortest path is to be searched between \c s and \c

  ///t, then this can be done easily by applying the Dijkstra

  ///algorithm. What happens, if a maximum number of arc-disjoint

  ///shortest paths is to be computed. It can be proved that an arc

  ///can be in a shortest path if and only if it is tight with respect

  ///to the potential function computed by Dijkstra.  Moreover, any

  ///path containing only such arcs is a shortest one.  Thus we have

  ///to compute a maximum number of arc-disjoint paths between \c s

  ///and \c t in the digraph which has arc-set all the tight arcs. The

  ///computation will be demonstrated on the following digraph, which

  ///is read from the dimacs file \c sub_digraph_adaptor_demo.dim.

  ///The full source code is available in \ref

  ///sub_digraph_adaptor_demo.cc.  If you are interested in more demo

  ///programs, you can use \ref dim_to_dot.cc to generate .dot files

  ///from dimacs files.  The .dot file of the following figure was

  ///generated by the demo program \ref dim_to_dot.cc.

  ///

  ///\dot

  ///didigraph lemon_dot_example {

  ///node [ shape=ellipse, fontname=Helvetica, fontsize=10 ];

  ///n0 [ label="0 (s)" ];

  ///n1 [ label="1" ];

  ///n2 [ label="2" ];

  ///n3 [ label="3" ];

  ///n4 [ label="4" ];

  ///n5 [ label="5" ];

  ///n6 [ label="6 (t)" ];

  ///arc [ shape=ellipse, fontname=Helvetica, fontsize=10 ];

  ///n5 ->  n6 [ label="9, length:4" ];

  ///n4 ->  n6 [ label="8, length:2" ];

  ///n3 ->  n5 [ label="7, length:1" ];

  ///n2 ->  n5 [ label="6, length:3" ];

  ///n2 ->  n6 [ label="5, length:5" ];

  ///n2 ->  n4 [ label="4, length:2" ];

  ///n1 ->  n4 [ label="3, length:3" ];

  ///n0 ->  n3 [ label="2, length:1" ];

  ///n0 ->  n2 [ label="1, length:2" ];

  ///n0 ->  n1 [ label="0, length:3" ];

  ///}

  ///\enddot

  ///

  ///\code

  ///Digraph g;

  ///Node s, t;

  ///LengthMap length(g);

  ///

  ///readDimacs(std::cin, g, length, s, t);

  ///

  ///cout << "arcs with lengths (of form id, source--length->target): " << endl;

  ///for(ArcIt e(g); e!=INVALID; ++e) 

  ///  cout << g.id(e) << ", " << g.id(g.source(e)) << "--" 

  ///       << length[e] << "->" << g.id(g.target(e)) << endl;

  ///

  ///cout << "s: " << g.id(s) << " t: " << g.id(t) << endl;

  ///\endcode

  ///Next, the potential function is computed with Dijkstra.

  ///\code

  ///typedef Dijkstra<Digraph, LengthMap> Dijkstra;

  ///Dijkstra dijkstra(g, length);

  ///dijkstra.run(s);

  ///\endcode

  ///Next, we consrtruct a map which filters the arc-set to the tight arcs.

  ///\code

  ///typedef TightArcFilterMap<Digraph, const Dijkstra::DistMap, LengthMap> 

  ///  TightArcFilter;

  ///TightArcFilter tight_arc_filter(g, dijkstra.distMap(), length);

  ///

  ///typedef ArcSubDigraphAdaptor<Digraph, TightArcFilter> SubGA;

  ///SubGA ga(g, tight_arc_filter);

  ///\endcode

  ///Then, the maximum nimber of arc-disjoint \c s-\c t paths are computed 

  ///with a max flow algorithm Preflow.

  ///\code

  ///ConstMap<Arc, int> const_1_map(1);

  ///Digraph::ArcMap<int> flow(g, 0);

  ///

  ///Preflow<SubGA, ConstMap<Arc, int>, Digraph::ArcMap<int> > 

  ///  preflow(ga, const_1_map, s, t);

  ///preflow.run();

  ///\endcode

  ///Last, the output is:

  ///\code  

  ///cout << "maximum number of arc-disjoint shortest path: " 

  ///     << preflow.flowValue() << endl;

  ///cout << "arcs of the maximum number of arc-disjoint shortest s-t paths: " 

  ///     << endl;

  ///for(ArcIt e(g); e!=INVALID; ++e) 

  ///  if (preflow.flow(e))

  ///    cout << " " << g.id(g.source(e)) << "--"

  ///         << length[e] << "->" << g.id(g.target(e)) << endl;

  ///\endcode

  ///The program has the following (expected :-)) output:

  ///\code

  ///arcs with lengths (of form id, source--length->target):

  /// 9, 5--4->6

  /// 8, 4--2->6

  /// 7, 3--1->5

  /// 6, 2--3->5

  /// 5, 2--5->6

  /// 4, 2--2->4

  /// 3, 1--3->4

  /// 2, 0--1->3

  /// 1, 0--2->2

  /// 0, 0--3->1

  ///s: 0 t: 6

  ///maximum number of arc-disjoint shortest path: 2

  ///arcs of the maximum number of arc-disjoint shortest s-t paths:

  /// 9, 5--4->6

  /// 8, 4--2->6

  /// 7, 3--1->5

  /// 4, 2--2->4

  /// 2, 0--1->3

  /// 1, 0--2->2

  ///\endcode

  template<typename _Digraph, typename _ArcFilterMap>

  class ArcSubDigraphAdaptor : 

    public SubDigraphAdaptor<_Digraph, ConstMap<typename _Digraph::Node, bool>, 

			     _ArcFilterMap, false> {

  public:

    typedef _Digraph Digraph;

    typedef _ArcFilterMap ArcFilterMap;

    typedef SubDigraphAdaptor<Digraph, ConstMap<typename Digraph::Node, bool>, 

			      ArcFilterMap, false> Parent;

  protected:

    ConstMap<typename Digraph::Node, bool> const_true_map;

    ArcSubDigraphAdaptor() : const_true_map(true) {

      Parent::setNodeFilterMap(const_true_map);

    }

  public:

    ArcSubDigraphAdaptor(Digraph& digraph, ArcFilterMap& arc_filter) 

      : Parent(), const_true_map(true) { 

      Parent::setDigraph(digraph);

      Parent::setNodeFilterMap(const_true_map);

      Parent::setArcFilterMap(arc_filter);

    }

  };