RhodeCode

    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>

    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) {}