RhodeCode

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

    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;

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

    static PredMap *createPredMap(const Digraph &g)

    {

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

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

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

#ifdef DOXYGEN

    static ProcessedMap *createProcessedMap(const Digraph &g)

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

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

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

    static ReachedMap *createReachedMap(const Digraph &g)

    {

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

    typedef typename Digraph::template NodeMap<int> DistMap;

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

    static DistMap *createDistMap(const Digraph &g)

    {

    };

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

    ///

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

    template <class T>

    struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {

    };

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

    ///

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

    template <class T>

    struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {

    };

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

    ///

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

    template <class T>

    struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {

    };

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

    ///

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

    template <class T>

    struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {

    };

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

    ///

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

    ///If you don't set it explicitly, it will be automatically allocated.

    struct SetStandardProcessedMap :

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

    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;

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

    static PredMap *createPredMap(const Digraph &g)

    {

    ///By default it is a NullMap.

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

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

#ifdef DOXYGEN

    static ProcessedMap *createProcessedMap(const Digraph &g)

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

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

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

    static ReachedMap *createReachedMap(const Digraph &g)

    {

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

    typedef typename Digraph::template NodeMap<int> DistMap;

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

    static DistMap *createDistMap(const Digraph &g)

    {

  };

  /// To make it easier to use Bfs algorithm

    };

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

    ///

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

    template<class T>

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

    };

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

    ///

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

    template<class T>

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

    };

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

    ///

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

    template<class T>

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

    };

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

    ///

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

    template<class T>

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

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

    ///

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

    static ReachedMap *createReachedMap(const Digraph &digraph) {

      return new ReachedMap(digraph);

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

    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;

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

    static PredMap *createPredMap(const Digraph &g)

    {

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

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

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

#ifdef DOXYGEN

    static ProcessedMap *createProcessedMap(const Digraph &g)

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

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

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

    static ReachedMap *createReachedMap(const Digraph &g)

    {

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

    typedef typename Digraph::template NodeMap<int> DistMap;

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

    static DistMap *createDistMap(const Digraph &g)

    {

    };

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

    ///

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

    template <class T>

    struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {

    };

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

    ///

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

    template <class T>

    struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {

    };

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

    ///

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

    template <class T>

    struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {

    };

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

    ///

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

    template <class T>

    struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {

    };

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

    ///

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

    ///If you don't set it explicitly, it will be automatically allocated.

    struct SetStandardProcessedMap :

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

    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;

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

    static PredMap *createPredMap(const Digraph &g)

    {

    ///By default it is a NullMap.

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

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

#ifdef DOXYGEN

    static ProcessedMap *createProcessedMap(const Digraph &g)

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

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

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

    static ReachedMap *createReachedMap(const Digraph &g)

    {

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

    typedef typename Digraph::template NodeMap<int> DistMap;

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

    static DistMap *createDistMap(const Digraph &g)

    {

    };

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

    ///

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

    template<class T>

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

    };

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

    ///

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

    template<class T>

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

    };

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

    ///

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

    template<class T>

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

    };

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

    ///

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

    template<class T>

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

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

    ///

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

    static ReachedMap *createReachedMap(const Digraph &digraph) {

      return new ReachedMap(digraph);

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

    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;

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

    static PredMap *createPredMap(const Digraph &g)

    {

    ///By default it is a NullMap.

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

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

#ifdef DOXYGEN

    static ProcessedMap *createProcessedMap(const Digraph &g)

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

    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;

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

    static DistMap *createDistMap(const Digraph &g)

    {

    };

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

    ///

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

    template <class T>

    struct SetPredMap

    };

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

    ///

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

    template <class T>

    struct SetDistMap

    };

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

    ///

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

    template <class T>

    struct SetProcessedMap

    };

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

    ///

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

    ///If you don't set it explicitly, it will be automatically allocated.

    struct SetStandardProcessedMap

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

    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;

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

    static PredMap *createPredMap(const Digraph &g)

    {

    ///By default it is a NullMap.

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

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

#ifdef DOXYGEN

    static ProcessedMap *createProcessedMap(const Digraph &g)

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

    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;

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

    static DistMap *createDistMap(const Digraph &g)

    {

    };

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

    ///

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

    template<class T>

    DijkstraWizard<SetPredMapBase<T> > predMap(const T &t)

    };

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

    ///

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

    template<class T>

    DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)

    };

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

    ///

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

    template<class T>

    DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t)

  };

  /// \relates NullMap

  template <typename K, typename V>

  /// value to each key.

  ///

  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"

  /// concept, but it absorbs the data written to it.

  };

  /// \relates ConstMap

  template<typename K, typename V>

  /// value to each key.

  ///

  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"

  /// concept, but it absorbs the data written to it.

  };

  /// constant value.

  /// \relates ConstMap

  };

  /// \relates IdentityMap

  template<typename T>

  /// values to integer keys from the range <tt>[0..size-1]</tt>.

  /// It can be used with some data structures, for example

  /// integers. This map conforms the \ref concepts::ReferenceMap

  /// "ReferenceMap" concept.

      : _vector(vector.begin(), vector.end()) {}

    template <typename V1>

    RangeMap(const RangeMap<V1> &c)

  };

  /// \relates RangeMap

  template<typename V>

  }

  /// \c std::vector

  /// appropriate \c std::vector.

  /// \relates RangeMap

      : _map(map.begin(), map.end()), _value(value) {}

    template<typename V1, typename Comp1>

    SparseMap(const SparseMap<Key, V1, Comp1> &c)

  };

  /// default value.

  /// \relates SparseMap

  }

  /// \c std::map

  /// appropriate \c std::map.

  /// \relates SparseMap

  };

  ///

  /// If \c m1 and \c m2 are maps and the \c Value type of \c m2 is

  };

  ///

  /// For example, if \c m1 and \c m2 are both maps with \c double

  };

  ///

  /// This function is specialized for adaptable binary function

  };

  /// \relates MapToFunctor

  template<typename M>

  };

  /// \relates ConvertMap

  template<typename V, typename M>

  };

  /// \relates ForkMap

  template <typename M1, typename M2>

  };

  ///

  /// For example, if \c m1 and \c m2 are both maps with \c double

  };

  ///

  /// For example, if \c m1 and \c m2 are both maps with \c double

  };

  ///

  /// For example, if \c m1 and \c m2 are both maps with \c double

  };

  ///

  /// For example, if \c m1 and \c m2 are both maps with \c double

  };

  ///

  /// For example, if \c m is a map with \c double values and \c v is

  }

  ///

  /// For example, if \c m is a map with \c double values and \c v is

  };

  ///

  /// For example, if \c m is a map with \c double values and \c v is

  }

  ///

  /// For example, if \c m is a map with \c double values and \c v is

  };

  ///

  /// For example, if \c m is a map with \c double values, then

  }

  ///

  /// For example, if \c m is a map with \c double values, then

  };

  ///

  /// For example, if \c m is a map with \c double values, then

  };

  /// \relates TrueMap

  template<typename K>

  };

  /// \relates FalseMap

  template<typename K>

  };

  ///

  /// For example, if \c m1 and \c m2 are both maps with \c bool values,

  };

  ///

  /// For example, if \c m1 and \c m2 are both maps with \c bool values,

  };

  ///

  /// For example, if \c m is a map with \c bool values, then

  }

  ///

  /// For example, if \c m is a map with \c bool values, then

  };

  ///

  /// For example, if \c m1 and \c m2 are maps with keys and values of

  };

  ///

  /// For example, if \c m1 and \c m2 are maps with keys and values of

  };

  ///

  /// The most important usage of it is storing certain nodes or arcs

  /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so

  /// it cannot be used when a readable map is needed, for example as

  ///

  /// \relates LoggerBoolMap

  };

  ///

  /// \relates SourceMap

  template <typename Digraph>

  };

  ///

  /// \relates TargetMap

  template <typename Digraph>

  };

  ///

  /// \relates ForwardMap

  template <typename Graph>

  };

  /// \relates BackwardMap

  template <typename Graph>