RhodeCode

    ///\brief The type of the map that stores the last

    ///arcs of the shortest paths.

    /// 

    ///The type of the map that stores the last

    ///arcs of the shortest paths.

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    ///

    typedef NullMap<typename Digraph::Node,typename GR::Arc> PredMap;

    ///Instantiates a PredMap.

    ///This function instantiates a \ref PredMap. 

    ///\param g is the digraph, to which we would like to define the PredMap.

    ///\todo The digraph alone may be insufficient to initialize

#ifdef DOXYGEN

    static PredMap *createPredMap(const GR &g) 

#else

    static PredMap *createPredMap(const GR &) 

#endif

    {

      return new PredMap();

    }

    ///The type of the map that indicates which nodes are processed.

    ///The type of the map that indicates which nodes are processed.

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    ///\todo named parameter to set this type, function to read and write.

    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;

    ///Instantiates a ProcessedMap.

    ///This function instantiates a \ref ProcessedMap. 

    ///\param g is the digraph, to which

    ///we would like to define the \ref ProcessedMap

#ifdef DOXYGEN

    static ProcessedMap *createProcessedMap(const GR &g)

#else

    static ProcessedMap *createProcessedMap(const GR &)

#endif

    {

      return new ProcessedMap();

    }

    ///The type of the map that indicates which nodes are reached.

    ///The type of the map that indicates which nodes are reached.

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    ///\todo named parameter to set this type, function to read and write.

    typedef typename Digraph::template NodeMap<bool> ReachedMap;

    ///Instantiates a ReachedMap.

    ///This function instantiates a \ref ReachedMap. 

    ///\param G is the digraph, to which

    ///we would like to define the \ref ReachedMap.

    static ReachedMap *createReachedMap(const GR &G)

    {

      return new ReachedMap(G);

    }

    ///The type of the map that stores the dists of the nodes.

    ///The type of the map that stores the dists of the nodes.

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    ///

    typedef NullMap<typename Digraph::Node,int> DistMap;

    ///Instantiates a DistMap.

    ///This function instantiates a \ref DistMap. 

    ///\param g is the digraph, to which we would like to define the \ref DistMap

#ifdef DOXYGEN

    static DistMap *createDistMap(const GR &g)

#else

    static DistMap *createDistMap(const GR &)

#endif

    {

      return new DistMap();

    }

  };

  /// Default traits used by \ref BfsWizard

  /// To make it easier to use Bfs algorithm

  ///we have created a wizard class.

  /// This \ref BfsWizard class needs default traits,

  ///as well as the \ref Bfs class.

  /// The \ref BfsWizardBase is a class to be the default traits of the

  /// \ref BfsWizard class.

  template<class GR>

  class BfsWizardBase : public BfsWizardDefaultTraits<GR>

  {

    typedef BfsWizardDefaultTraits<GR> Base;

  protected:

    /// Type of the nodes in the digraph.

    typedef typename Base::Digraph::Node Node;

    /// Pointer to the underlying digraph.

    void *_g;

    ///Pointer to the map of reached nodes.

    void *_reached;

    ///Pointer to the map of processed nodes.

    void *_processed;

    ///Pointer to the map of predecessors arcs.

    void *_pred;

    ///Pointer to the map of distances.

    void *_dist;

    ///Pointer to the source node.

    Node _source;

    public:

    /// Constructor.

    /// This constructor does not require parameters, therefore it initiates

    /// all of the attributes to default values (0, INVALID).

    BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),

			   _dist(0), _source(INVALID) {}

    /// Constructor.

    /// This constructor requires some parameters,

    /// listed in the parameters list.

    /// Others are initiated to 0.

    /// \param g is the initial value of  \ref _g

    /// \param s is the initial value of  \ref _source

    BfsWizardBase(const GR &g, Node s=INVALID) :

      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))), 

      _reached(0), _processed(0), _pred(0), _dist(0), _source(s) {}

  };

  /// A class to make the usage of Bfs algorithm easier

  /// This class is created to make it easier to use Bfs algorithm.

  /// It uses the functions and features of the plain \ref Bfs,

  /// but it is much simpler to use it.

  ///

  /// Simplicity means that the way to change the types defined

  /// in the traits class is based on functions that returns the new class

  /// and not on templatable built-in classes.

  /// When using the plain \ref Bfs

  /// the new class with the modified type comes from

  /// the original class by using the ::

  /// operator. In the case of \ref BfsWizard only

  /// a function have to be called and it will

  /// return the needed class.

  ///

  /// It does not have own \ref run method. When its \ref run method is called

  /// it initiates a plain \ref Bfs class, and calls the \ref Bfs::run

  /// method of it.

  template<class TR>

  class BfsWizard : public TR

  {

    typedef TR Base;

    ///The type of the underlying digraph.

    typedef typename TR::Digraph Digraph;

    //\e

    typedef typename Digraph::Node Node;

    //\e

    typedef typename Digraph::NodeIt NodeIt;

    //\e

    typedef typename Digraph::Arc Arc;

    //\e

    typedef typename Digraph::OutArcIt OutArcIt;

    ///\brief The type of the map that stores

    ///the reached nodes

    typedef typename TR::ReachedMap ReachedMap;

    ///\brief The type of the map that stores

    ///the processed nodes

    typedef typename TR::ProcessedMap ProcessedMap;

    ///\brief The type of the map that stores the last

    ///arcs of the shortest paths.

    typedef typename TR::PredMap PredMap;

    ///The type of the map that stores the dists of the nodes.

    typedef typename TR::DistMap DistMap;

  public:

    /// Constructor.

    BfsWizard() : TR() {}

    /// Constructor that requires parameters.

    /// Constructor that requires parameters.

    /// These parameters will be the default values for the traits class.

    BfsWizard(const Digraph &g, Node s=INVALID) :

      TR(g,s) {}

    ///Copy constructor

    BfsWizard(const TR &b) : TR(b) {}

    ~BfsWizard() {}

    ///Runs Bfs algorithm from a given node.

    ///Runs Bfs algorithm from a given node.

    ///The node can be given by the \ref source function.

    void run()

    {

      if(Base::_source==INVALID) throw UninitializedParameter();

      Bfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));

      if(Base::_reached)

	alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));

      if(Base::_processed) 

        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));

      if(Base::_pred) 

        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));

      if(Base::_dist) 

        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));

      alg.run(Base::_source);

    }

    ///Runs Bfs algorithm from the given node.

    ///Runs Bfs algorithm from the given node.

    ///\param s is the given source.

    void run(Node s)

    {

      Base::_source=s;

      run();

    }

    template<class T>

    struct DefPredMapBase : public Base {

      typedef T PredMap;

      static PredMap *createPredMap(const Digraph &) { return 0; };

      DefPredMapBase(const TR &b) : TR(b) {}

    };

    ///\brief \ref named-templ-param "Named parameter"

    ///function for setting PredMap

    ///

    /// \ref named-templ-param "Named parameter"

    ///function for setting PredMap

    ///

    template<class T>

    BfsWizard<DefPredMapBase<T> > predMap(const T &t) 

    {

      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));

      return BfsWizard<DefPredMapBase<T> >(*this);

    }

    template<class T>

    struct DefReachedMapBase : public Base {

      typedef T ReachedMap;

      static ReachedMap *createReachedMap(const Digraph &) { return 0; };

      DefReachedMapBase(const TR &b) : TR(b) {}

    };

    ///\brief \ref named-templ-param "Named parameter"

    ///function for setting ReachedMap

    ///

    /// \ref named-templ-param "Named parameter"

    ///function for setting ReachedMap

    ///

    template<class T>

    BfsWizard<DefReachedMapBase<T> > reachedMap(const T &t) 

    {

      return BfsWizard<DefReachedMapBase<T> >(*this);

    }

    template<class T>

    struct DefProcessedMapBase : public Base {

      typedef T ProcessedMap;

      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };

      DefProcessedMapBase(const TR &b) : TR(b) {}

    };

    ///\brief \ref named-templ-param "Named parameter"

    ///function for setting ProcessedMap

    ///

    /// \ref named-templ-param "Named parameter"

    ///function for setting ProcessedMap

    ///

    template<class T>

    BfsWizard<DefProcessedMapBase<T> > processedMap(const T &t) 

    {

      return BfsWizard<DefProcessedMapBase<T> >(*this);

    }

    template<class T>

    struct DefDistMapBase : public Base {

      typedef T DistMap;

      static DistMap *createDistMap(const Digraph &) { return 0; };

      DefDistMapBase(const TR &b) : TR(b) {}

    };

    ///\brief \ref named-templ-param "Named parameter"

    ///function for setting DistMap type

    ///

    /// \ref named-templ-param "Named parameter"

    ///function for setting DistMap type

    ///

    template<class T>

    BfsWizard<DefDistMapBase<T> > distMap(const T &t) 

    {

      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));

      return BfsWizard<DefDistMapBase<T> >(*this);

    }

    /// Sets the source node, from which the Bfs algorithm runs.

    /// Sets the source node, from which the Bfs algorithm runs.

    /// \param s is the source node.

    BfsWizard<TR> &source(Node s) 

    {

      Base::_source=s;

      return *this;

    }

  };

  ///Function type interface for Bfs algorithm.

  /// \ingroup search

  ///Function type interface for Bfs algorithm.

  ///

  ///This function also has several

  ///\ref named-templ-func-param "named parameters",

  ///they are declared as the members of class \ref BfsWizard.

  ///The following

  ///example shows how to use these parameters.

  ///\code

  ///  bfs(g,source).predMap(preds).run();

  ///\endcode

  ///\warning Don't forget to put the \ref BfsWizard::run() "run()"

  ///to the end of the parameter list.

  ///\sa BfsWizard

  ///\sa Bfs

  template<class GR>

  BfsWizard<BfsWizardBase<GR> >

  bfs(const GR &g,typename GR::Node s=INVALID)

  {

    return BfsWizard<BfsWizardBase<GR> >(g,s);

  }

#ifdef DOXYGEN

  /// \brief Visitor class for bfs.

  ///  

  /// This class defines the interface of the BfsVisit events, and

  /// it could be the base of a real Visitor class.

  template <typename _Digraph>

  struct BfsVisitor {

    typedef _Digraph Digraph;

    typedef typename Digraph::Arc Arc;

    typedef typename Digraph::Node Node;

    /// \brief Called when the arc reach a node.

    /// 

    /// It is called when the bfs find an arc which target is not

    /// reached yet.

    void discover(const Arc& arc) {}

    /// \brief Called when the node reached first time.

    /// 

    /// It is Called when the node reached first time.

    void reach(const Node& node) {}

    /// \brief Called when the arc examined but target of the arc 

    /// already discovered.

    /// 

    /// It called when the arc examined but the target of the arc 

    /// already discovered.

    void examine(const Arc& arc) {}

    /// \brief Called for the source node of the bfs.

    /// 

    /// It is called for the source node of the bfs.

    void start(const Node& node) {}

    /// \brief Called when the node processed.

    /// 

    /// It is Called when the node processed.

    void process(const Node& node) {}

  };

#else

  template <typename _Digraph>

  struct BfsVisitor {

    typedef _Digraph Digraph;

    typedef typename Digraph::Arc Arc;

    typedef typename Digraph::Node Node;

    void discover(const Arc&) {}

    void reach(const Node&) {}

    void examine(const Arc&) {}

    void start(const Node&) {}

    void process(const Node&) {}

    template <typename _Visitor>

    struct Constraints {

      void constraints() {

	Arc arc;

	Node node;

	visitor.discover(arc);

	visitor.reach(node);

	visitor.examine(arc);

	visitor.start(node);

        visitor.process(node);

      }

      _Visitor& visitor;

    };

  };

#endif

  /// \brief Default traits class of BfsVisit class.

  ///

  /// Default traits class of BfsVisit class.

  /// \tparam _Digraph Digraph type.

  template<class _Digraph>

  struct BfsVisitDefaultTraits {

    /// \brief The digraph type the algorithm runs on. 

    typedef _Digraph Digraph;

    /// \brief The type of the map that indicates which nodes are reached.

    /// 

    /// The type of the map that indicates which nodes are reached.

    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.

    /// \todo named parameter to set this type, function to read and write.

    typedef typename Digraph::template NodeMap<bool> ReachedMap;

    /// \brief Instantiates a ReachedMap.

    ///

    /// This function instantiates a \ref ReachedMap. 

    /// \param digraph is the digraph, to which

    /// we would like to define the \ref ReachedMap.

    static ReachedMap *createReachedMap(const Digraph &digraph) {

      return new ReachedMap(digraph);

    }

  };

  /// \ingroup search

  ///  

  /// \brief %BFS Visit algorithm class.

  ///  

  /// This class provides an efficient implementation of the %BFS algorithm

  /// with visitor interface.

  ///

  /// The %BfsVisit class provides an alternative interface to the Bfs

  /// class. It works with callback mechanism, the BfsVisit object calls

  /// on every bfs event the \c Visitor class member functions. 

  ///

  /// \tparam _Digraph The digraph type the algorithm runs on. The default value is

  /// \ref ListDigraph. The value of _Digraph is not used directly by Bfs, it

  /// is only passed to \ref BfsDefaultTraits.

  /// \tparam _Visitor The Visitor object for the algorithm. The 

  /// \ref BfsVisitor "BfsVisitor<_Digraph>" is an empty Visitor which

  /// does not observe the Bfs events. If you want to observe the bfs

  /// events you should implement your own Visitor class.

  /// \tparam _Traits Traits class to set various data types used by the 

  /// algorithm. The default traits class is

  /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<_Digraph>".

  /// See \ref BfsVisitDefaultTraits for the documentation of

  /// a Bfs visit traits class.

#ifdef DOXYGEN

  template <typename _Digraph, typename _Visitor, typename _Traits>

#else

  template <typename _Digraph = ListDigraph,

	    typename _Visitor = BfsVisitor<_Digraph>,

	    typename _Traits = BfsDefaultTraits<_Digraph> >

#endif

  class BfsVisit {

  public:

    /// \brief \ref Exception for uninitialized parameters.

    ///

    /// This error represents problems in the initialization

    /// of the parameters of the algorithms.

    class UninitializedParameter : public lemon::UninitializedParameter {

    public:

      virtual const char* what() const throw() 

      {

	return "lemon::BfsVisit::UninitializedParameter";

      }

    };

    typedef _Traits Traits;

    typedef typename Traits::Digraph Digraph;

    typedef _Visitor Visitor;

    ///The type of the map indicating which nodes are reached.

    typedef typename Traits::ReachedMap ReachedMap;

  private:

    typedef typename Digraph::Node Node;

    typedef typename Digraph::NodeIt NodeIt;

    typedef typename Digraph::Arc Arc;

    typedef typename Digraph::OutArcIt OutArcIt;

    /// Pointer to the underlying digraph.

    const Digraph *_digraph;

    /// Pointer to the visitor object.

    Visitor *_visitor;

    ///Pointer to the map of reached status of the nodes.

    ReachedMap *_reached;

    ///Indicates if \ref _reached is locally allocated (\c true) or not.

    bool local_reached;

    std::vector<typename Digraph::Node> _list;

    int _list_front, _list_back;

    /// \brief Creates the maps if necessary.

    ///

    /// Creates the maps if necessary.

    void create_maps() {

      if(!_reached) {

	local_reached = true;

	_reached = Traits::createReachedMap(*_digraph);

      }

    }

  protected:

    BfsVisit() {}

  public:

    typedef BfsVisit Create;

    /// \name Named template parameters

    ///@{

    template <class T>

    struct DefReachedMapTraits : public Traits {

      typedef T ReachedMap;

      static ReachedMap *createReachedMap(const Digraph &digraph) {

	throw UninitializedParameter();

      }

    };

    /// \brief \ref named-templ-param "Named parameter" for setting 

    /// ReachedMap type

    ///

    /// \ref named-templ-param "Named parameter" for setting ReachedMap type

    template <class T>

    ///\brief The type of the map that stores the last

    ///arcs of the %DFS paths.

    /// 

    ///The type of the map that stores the last

    ///arcs of the %DFS paths.

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    ///

    typedef NullMap<typename Digraph::Node,typename GR::Arc> PredMap;

    ///Instantiates a PredMap.

    ///This function instantiates a \ref PredMap. 

    ///\param g is the digraph, to which we would like to define the PredMap.

    ///\todo The digraph alone may be insufficient to initialize

#ifdef DOXYGEN

    static PredMap *createPredMap(const GR &g) 

#else

    static PredMap *createPredMap(const GR &) 

#endif

    {

      return new PredMap();

    }

    ///The type of the map that indicates which nodes are processed.

    ///The type of the map that indicates which nodes are processed.

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    ///\todo named parameter to set this type, function to read and write.

    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;

    ///Instantiates a ProcessedMap.

    ///This function instantiates a \ref ProcessedMap. 

    ///\param g is the digraph, to which

    ///we would like to define the \ref ProcessedMap

#ifdef DOXYGEN

    static ProcessedMap *createProcessedMap(const GR &g)

#else

    static ProcessedMap *createProcessedMap(const GR &)

#endif

    {

      return new ProcessedMap();

    }

    ///The type of the map that indicates which nodes are reached.

    ///The type of the map that indicates which nodes are reached.

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    ///\todo named parameter to set this type, function to read and write.

    typedef typename Digraph::template NodeMap<bool> ReachedMap;

    ///Instantiates a ReachedMap.

    ///This function instantiates a \ref ReachedMap. 

    ///\param G is the digraph, to which

    ///we would like to define the \ref ReachedMap.

    static ReachedMap *createReachedMap(const GR &G)

    {

      return new ReachedMap(G);

    }

    ///The type of the map that stores the dists of the nodes.

    ///The type of the map that stores the dists of the nodes.

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    ///

    typedef NullMap<typename Digraph::Node,int> DistMap;

    ///Instantiates a DistMap.

    ///This function instantiates a \ref DistMap. 

    ///\param g is the digraph, to which we would like to define the \ref DistMap

#ifdef DOXYGEN

    static DistMap *createDistMap(const GR &g)

#else

    static DistMap *createDistMap(const GR &)

#endif

    {

      return new DistMap();

    }

  };

  /// Default traits used by \ref DfsWizard

  /// To make it easier to use Dfs algorithm

  ///we have created a wizard class.

  /// This \ref DfsWizard class needs default traits,

  ///as well as the \ref Dfs class.

  /// The \ref DfsWizardBase is a class to be the default traits of the

  /// \ref DfsWizard class.

  template<class GR>

  class DfsWizardBase : public DfsWizardDefaultTraits<GR>

  {

    typedef DfsWizardDefaultTraits<GR> Base;

  protected:

    /// Type of the nodes in the digraph.

    typedef typename Base::Digraph::Node Node;

    /// Pointer to the underlying digraph.

    void *_g;

    ///Pointer to the map of reached nodes.

    void *_reached;

    ///Pointer to the map of processed nodes.

    void *_processed;

    ///Pointer to the map of predecessors arcs.

    void *_pred;

    ///Pointer to the map of distances.

    void *_dist;

    ///Pointer to the source node.

    Node _source;

    public:

    /// Constructor.

    /// This constructor does not require parameters, therefore it initiates

    /// all of the attributes to default values (0, INVALID).

    DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),

			   _dist(0), _source(INVALID) {}

    /// Constructor.

    /// This constructor requires some parameters,

    /// listed in the parameters list.

    /// Others are initiated to 0.

    /// \param g is the initial value of  \ref _g

    /// \param s is the initial value of  \ref _source

    DfsWizardBase(const GR &g, Node s=INVALID) :

      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))), 

      _reached(0), _processed(0), _pred(0), _dist(0), _source(s) {}

  };

  /// A class to make the usage of the Dfs algorithm easier

  /// This class is created to make it easier to use the Dfs algorithm.

  /// It uses the functions and features of the plain \ref Dfs,

  /// but it is much simpler to use it.

  ///

  /// Simplicity means that the way to change the types defined

  /// in the traits class is based on functions that returns the new class

  /// and not on templatable built-in classes.

  /// When using the plain \ref Dfs

  /// the new class with the modified type comes from

  /// the original class by using the ::

  /// operator. In the case of \ref DfsWizard only

  /// a function have to be called and it will

  /// return the needed class.

  ///

  /// It does not have own \ref run method. When its \ref run method is called

  /// it initiates a plain \ref Dfs object, and calls the \ref Dfs::run

  /// method of it.

  template<class TR>

  class DfsWizard : public TR

  {

    typedef TR Base;

    ///The type of the underlying digraph.

    typedef typename TR::Digraph Digraph;

    //\e

    typedef typename Digraph::Node Node;

    //\e

    typedef typename Digraph::NodeIt NodeIt;

    //\e

    typedef typename Digraph::Arc Arc;

    //\e

    typedef typename Digraph::OutArcIt OutArcIt;

    ///\brief The type of the map that stores

    ///the reached nodes

    typedef typename TR::ReachedMap ReachedMap;

    ///\brief The type of the map that stores

    ///the processed nodes

    typedef typename TR::ProcessedMap ProcessedMap;

    ///\brief The type of the map that stores the last

    ///arcs of the %DFS paths.

    typedef typename TR::PredMap PredMap;

    ///The type of the map that stores the distances of the nodes.

    typedef typename TR::DistMap DistMap;

  public:

    /// Constructor.

    DfsWizard() : TR() {}

    /// Constructor that requires parameters.

    /// Constructor that requires parameters.

    /// These parameters will be the default values for the traits class.

    DfsWizard(const Digraph &g, Node s=INVALID) :

      TR(g,s) {}

    ///Copy constructor

    DfsWizard(const TR &b) : TR(b) {}

    ~DfsWizard() {}

    ///Runs Dfs algorithm from a given node.

    ///Runs Dfs algorithm from a given node.

    ///The node can be given by the \ref source function.

    void run()

    {

      if(Base::_source==INVALID) throw UninitializedParameter();

      Dfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));

      if(Base::_reached) 

        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));

      if(Base::_processed) 

        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));

      if(Base::_pred) 

        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));

      if(Base::_dist) 

        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));

      alg.run(Base::_source);

    }

    ///Runs Dfs algorithm from the given node.

    ///Runs Dfs algorithm from the given node.

    ///\param s is the given source.

    void run(Node s)

    {

      Base::_source=s;

      run();

    }

    template<class T>

    struct DefPredMapBase : public Base {

      typedef T PredMap;

      static PredMap *createPredMap(const Digraph &) { return 0; };

      DefPredMapBase(const TR &b) : TR(b) {}

    };

    ///\brief \ref named-templ-param "Named parameter"

    ///function for setting PredMap type

    ///

    /// \ref named-templ-param "Named parameter"

    ///function for setting PredMap type

    ///

    template<class T>

    DfsWizard<DefPredMapBase<T> > predMap(const T &t) 

    {

      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));

      return DfsWizard<DefPredMapBase<T> >(*this);

    }

    template<class T>

    struct DefReachedMapBase : public Base {

      typedef T ReachedMap;

      static ReachedMap *createReachedMap(const Digraph &) { return 0; };

      DefReachedMapBase(const TR &b) : TR(b) {}

    };

    ///\brief \ref named-templ-param "Named parameter"

    ///function for setting ReachedMap

    ///

    /// \ref named-templ-param "Named parameter"

    ///function for setting ReachedMap

    ///

    template<class T>

    DfsWizard<DefReachedMapBase<T> > reachedMap(const T &t) 

    {

      return DfsWizard<DefReachedMapBase<T> >(*this);

    }

    template<class T>

    struct DefProcessedMapBase : public Base {

      typedef T ProcessedMap;

      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };

      DefProcessedMapBase(const TR &b) : TR(b) {}

    };

    ///\brief \ref named-templ-param "Named parameter"

    ///function for setting ProcessedMap

    ///

    /// \ref named-templ-param "Named parameter"

    ///function for setting ProcessedMap

    ///

    template<class T>

    DfsWizard<DefProcessedMapBase<T> > processedMap(const T &t) 

    {

      return DfsWizard<DefProcessedMapBase<T> >(*this);

    }

    template<class T>

    struct DefDistMapBase : public Base {

      typedef T DistMap;

      static DistMap *createDistMap(const Digraph &) { return 0; };

      DefDistMapBase(const TR &b) : TR(b) {}

    };

    ///\brief \ref named-templ-param "Named parameter"

    ///function for setting DistMap type

    ///

    /// \ref named-templ-param "Named parameter"

    ///function for setting DistMap type

    ///

    template<class T>

    DfsWizard<DefDistMapBase<T> > distMap(const T &t) 

    {

      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));

      return DfsWizard<DefDistMapBase<T> >(*this);

    }

    /// Sets the source node, from which the Dfs algorithm runs.

    /// Sets the source node, from which the Dfs algorithm runs.

    /// \param s is the source node.

    DfsWizard<TR> &source(Node s) 

    {

      Base::_source=s;

      return *this;

    }

  };

  ///Function type interface for Dfs algorithm.

  ///\ingroup search

  ///Function type interface for Dfs algorithm.

  ///

  ///This function also has several

  ///\ref named-templ-func-param "named parameters",

  ///they are declared as the members of class \ref DfsWizard.

  ///The following

  ///example shows how to use these parameters.

  ///\code

  ///  dfs(g,source).predMap(preds).run();

  ///\endcode

  ///\warning Don't forget to put the \ref DfsWizard::run() "run()"

  ///to the end of the parameter list.

  ///\sa DfsWizard

  ///\sa Dfs

  template<class GR>

  DfsWizard<DfsWizardBase<GR> >

  dfs(const GR &g,typename GR::Node s=INVALID)

  {

    return DfsWizard<DfsWizardBase<GR> >(g,s);

  }

#ifdef DOXYGEN

  /// \brief Visitor class for dfs.

  ///  

  /// It gives a simple interface for a functional interface for dfs 

  /// traversal. The traversal on a linear data structure. 

  template <typename _Digraph>

  struct DfsVisitor {

    typedef _Digraph Digraph;

    typedef typename Digraph::Arc Arc;

    typedef typename Digraph::Node Node;

    /// \brief Called when the arc reach a node.

    /// 

    /// It is called when the dfs find an arc which target is not

    /// reached yet.

    void discover(const Arc& arc) {}

    /// \brief Called when the node reached first time.

    /// 

    /// It is Called when the node reached first time.

    void reach(const Node& node) {}

    /// \brief Called when we step back on an arc.

    /// 

    /// It is called when the dfs should step back on the arc.

    void backtrack(const Arc& arc) {}

    /// \brief Called when we step back from the node.

    /// 

    /// It is called when we step back from the node.

    void leave(const Node& node) {}

    /// \brief Called when the arc examined but target of the arc 

    /// already discovered.

    /// 

    /// It called when the arc examined but the target of the arc 

    /// already discovered.

    void examine(const Arc& arc) {}

    /// \brief Called for the source node of the dfs.

    /// 

    /// It is called for the source node of the dfs.

    void start(const Node& node) {}

    /// \brief Called when we leave the source node of the dfs.

    /// 

    /// It is called when we leave the source node of the dfs.

    void stop(const Node& node) {}

  };

#else

  template <typename _Digraph>

  struct DfsVisitor {

    typedef _Digraph Digraph;

    typedef typename Digraph::Arc Arc;

    typedef typename Digraph::Node Node;

    void discover(const Arc&) {}

    void reach(const Node&) {}

    void backtrack(const Arc&) {}

    void leave(const Node&) {}

    void examine(const Arc&) {}

    void start(const Node&) {}

    void stop(const Node&) {}

    template <typename _Visitor>

    struct Constraints {

      void constraints() {

	Arc arc;

	Node node;

	visitor.discover(arc);

	visitor.reach(node);

	visitor.backtrack(arc);

	visitor.leave(node);

	visitor.examine(arc);

	visitor.start(node);

	visitor.stop(arc);

      }

      _Visitor& visitor;

    };

  };

#endif

  /// \brief Default traits class of DfsVisit class.

  ///

  /// Default traits class of DfsVisit class.

  /// \tparam _Digraph Digraph type.

  template<class _Digraph>

  struct DfsVisitDefaultTraits {

    /// \brief The digraph type the algorithm runs on. 

    typedef _Digraph Digraph;

    /// \brief The type of the map that indicates which nodes are reached.

    /// 

    /// The type of the map that indicates which nodes are reached.

    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.

    /// \todo named parameter to set this type, function to read and write.

    typedef typename Digraph::template NodeMap<bool> ReachedMap;

    /// \brief Instantiates a ReachedMap.

    ///

    /// This function instantiates a \ref ReachedMap. 

    /// \param digraph is the digraph, to which

    /// we would like to define the \ref ReachedMap.

    static ReachedMap *createReachedMap(const Digraph &digraph) {

      return new ReachedMap(digraph);

    }

  };

  /// %DFS Visit algorithm class.

  /// \ingroup search

  /// This class provides an efficient implementation of the %DFS algorithm

  /// with visitor interface.

  ///

  /// The %DfsVisit class provides an alternative interface to the Dfs

  /// class. It works with callback mechanism, the DfsVisit object calls

  /// on every dfs event the \c Visitor class member functions. 

  ///

  /// \tparam _Digraph The digraph type the algorithm runs on. The default value is

  /// \ref ListDigraph. The value of _Digraph is not used directly by Dfs, it

  /// is only passed to \ref DfsDefaultTraits.

  /// \tparam _Visitor The Visitor object for the algorithm. The 

  /// \ref DfsVisitor "DfsVisitor<_Digraph>" is an empty Visitor which

  /// does not observe the Dfs events. If you want to observe the dfs

  /// events you should implement your own Visitor class.

  /// \tparam _Traits Traits class to set various data types used by the 

  /// algorithm. The default traits class is

  /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<_Digraph>".

  /// See \ref DfsVisitDefaultTraits for the documentation of

  /// a Dfs visit traits class.

  ///

  /// \author Jacint Szabo, Alpar Juttner and Balazs Dezso

#ifdef DOXYGEN

  template <typename _Digraph, typename _Visitor, typename _Traits>

#else

  template <typename _Digraph = ListDigraph,

	    typename _Visitor = DfsVisitor<_Digraph>,

	    typename _Traits = DfsDefaultTraits<_Digraph> >

#endif

  class DfsVisit {

  public:

    /// \brief \ref Exception for uninitialized parameters.

    ///

    /// This error represents problems in the initialization

    /// of the parameters of the algorithms.

    class UninitializedParameter : public lemon::UninitializedParameter {

    public:

      virtual const char* what() const throw() 

      {

	return "lemon::DfsVisit::UninitializedParameter";

      }

    };

    typedef _Traits Traits;

    typedef typename Traits::Digraph Digraph;

    typedef _Visitor Visitor;

    ///The type of the map indicating which nodes are reached.

    typedef typename Traits::ReachedMap ReachedMap;

  private:

    typedef typename Digraph::Node Node;

    typedef typename Digraph::NodeIt NodeIt;

    typedef typename Digraph::Arc Arc;

    typedef typename Digraph::OutArcIt OutArcIt;

    /// Pointer to the underlying digraph.

    const Digraph *_digraph;

    /// Pointer to the visitor object.

    Visitor *_visitor;

    ///Pointer to the map of reached status of the nodes.

    ReachedMap *_reached;

    ///Indicates if \ref _reached is locally allocated (\c true) or not.

    bool local_reached;

    std::vector<typename Digraph::Arc> _stack;

    int _stack_head;

    /// \brief Creates the maps if necessary.

    ///

    /// Creates the maps if necessary.

    void create_maps() {

      if(!_reached) {

	local_reached = true;

	_reached = Traits::createReachedMap(*_digraph);

      }

    }

  protected:

    DfsVisit() {}

  public:

    typedef DfsVisit Create;

    /// \name Named template parameters