lemon-1.0: comparison lemon/maps.h

equal deleted inserted replaced

-:beb20f54b1ae
+:8e974931d22e
 /// Base class of maps. It provides the necessary type definitions
 /// required by the map %concepts.
 template<typename K, typename V>
 class MapBase {
 public:
-/// \biref The key type of the map.
+/// \brief The key type of the map.
 typedef K Key;
 /// \brief The value type of the map.
 /// (The type of objects associated with the keys).
 typedef V Value;
 };
 Value operator[](const Key&) const { return Value(); }
 /// Absorbs the value.
 void set(const Key&, const Value&) {}
 };
-/// Returns a \ref NullMap class
+/// Returns a \c NullMap class
-/// This function just returns a \ref NullMap class.
+/// This function just returns a \c NullMap class.
 /// \relates NullMap
 template <typename K, typename V>
 NullMap<K, V> nullMap() {
 return NullMap<K, V>();
 }
 /// Constant map.
 /// This \ref concepts::ReadMap "readable map" assigns a specified
 /// value to each key.
 ///
-/// In other aspects it is equivalent to \ref NullMap.
+/// In other aspects it is equivalent to \c NullMap.
 /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
 /// concept, but it absorbs the data written to it.
 ///
 /// The simplest way of using this map is through the constMap()
 /// function.
 template<typename V1>
 ConstMap(const ConstMap<K, V1> &, const Value &v) : _value(v) {}
 };
-/// Returns a \ref ConstMap class
+/// Returns a \c ConstMap class
-/// This function just returns a \ref ConstMap class.
+/// This function just returns a \c ConstMap class.
 /// \relates ConstMap
 template<typename K, typename V>
 inline ConstMap<K, V> constMap(const V &v) {
 return ConstMap<K, V>(v);
 }
 /// Constant map with inlined constant value.
 /// This \ref concepts::ReadMap "readable map" assigns a specified
 /// value to each key.
 ///
-/// In other aspects it is equivalent to \ref NullMap.
+/// In other aspects it is equivalent to \c NullMap.
 /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
 /// concept, but it absorbs the data written to it.
 ///
 /// The simplest way of using this map is through the constMap()
 /// function.
 /// Absorbs the value.
 void set(const Key&, const Value&) {}
 };
-/// Returns a \ref ConstMap class with inlined constant value
+/// Returns a \c ConstMap class with inlined constant value
-/// This function just returns a \ref ConstMap class with inlined
+/// This function just returns a \c ConstMap class with inlined
 /// constant value.
 /// \relates ConstMap
 template<typename K, typename V, V v>
 inline ConstMap<K, Const<V, v> > constMap() {
 return ConstMap<K, Const<V, v> >();
 Value operator[](const Key &k) const {
 return k;
 }
 };
-/// Returns an \ref IdentityMap class
+/// Returns an \c IdentityMap class
-/// This function just returns an \ref IdentityMap class.
+/// This function just returns an \c IdentityMap class.
 /// \relates IdentityMap
 template<typename T>
 inline IdentityMap<T> identityMap() {
 return IdentityMap<T>();
 }
 /// <tt>[0..size-1]</tt>.
 ///
 /// This map is essentially a wrapper for \c std::vector. It assigns
 /// values to integer keys from the range <tt>[0..size-1]</tt>.
 /// It can be used with some data structures, for example
-/// \ref UnionFind, \ref BinHeap, when the used items are small
+/// \c UnionFind, \c BinHeap, when the used items are small
 /// integers. This map conforms the \ref concepts::ReferenceMap
 /// "ReferenceMap" concept.
 ///
 /// The simplest way of using this map is through the rangeMap()
 /// function.
 /// Constructs the map from an appropriate \c std::vector.
 template <typename V1>
 RangeMap(const std::vector<V1>& vector)
 : _vector(vector.begin(), vector.end()) {}
-/// Constructs the map from another \ref RangeMap.
+/// Constructs the map from another \c RangeMap.
 template <typename V1>
 RangeMap(const RangeMap<V1> &c)
 : _vector(c._vector.begin(), c._vector.end()) {}
 /// Returns the size of the map.
 void set(const Key &k, const Value &v) {
 _vector[k] = v;
 }
 };
-/// Returns a \ref RangeMap class
+/// Returns a \c RangeMap class
-/// This function just returns a \ref RangeMap class.
+/// This function just returns a \c RangeMap class.
 /// \relates RangeMap
 template<typename V>
 inline RangeMap<V> rangeMap(int size = 0, const V &value = V()) {
 return RangeMap<V>(size, value);
 }
-/// \brief Returns a \ref RangeMap class created from an appropriate
+/// \brief Returns a \c RangeMap class created from an appropriate
 /// \c std::vector
-/// This function just returns a \ref RangeMap class created from an
+/// This function just returns a \c RangeMap class created from an
 /// appropriate \c std::vector.
 /// \relates RangeMap
 template<typename V>
 inline RangeMap<V> rangeMap(const std::vector<V> &vector) {
 return RangeMap<V>(vector);
 template <typename V1, typename Comp1>
 SparseMap(const std::map<Key, V1, Comp1> &map,
 const Value &value = Value())
 : _map(map.begin(), map.end()), _value(value) {}
-/// \brief Constructs the map from another \ref SparseMap.
+/// \brief Constructs the map from another \c SparseMap.
 template<typename V1, typename Comp1>
 SparseMap(const SparseMap<Key, V1, Comp1> &c)
 : _map(c._map.begin(), c._map.end()), _value(c._value) {}
 private:
 _value = v;
 _map.clear();
 }
 };
-/// Returns a \ref SparseMap class
+/// Returns a \c SparseMap class
-/// This function just returns a \ref SparseMap class with specified
+/// This function just returns a \c SparseMap class with specified
 /// default value.
 /// \relates SparseMap
 template<typename K, typename V, typename Compare>
 inline SparseMap<K, V, Compare> sparseMap(const V& value = V()) {
 return SparseMap<K, V, Compare>(value);
 template<typename K, typename V>
 inline SparseMap<K, V, std::less<K> > sparseMap(const V& value = V()) {
 return SparseMap<K, V, std::less<K> >(value);
 }
-/// \brief Returns a \ref SparseMap class created from an appropriate
+/// \brief Returns a \c SparseMap class created from an appropriate
 /// \c std::map
-/// This function just returns a \ref SparseMap class created from an
+/// This function just returns a \c SparseMap class created from an
 /// appropriate \c std::map.
 /// \relates SparseMap
 template<typename K, typename V, typename Compare>
 inline SparseMap<K, V, Compare>
 sparseMap(const std::map<K, V, Compare> &map, const V& value = V())
 /// \e
 typename MapTraits<M1>::ConstReturnValue
 operator[](const Key &k) const { return _m1[_m2[k]]; }
 };
-/// Returns a \ref ComposeMap class
+/// Returns a \c ComposeMap class
-/// This function just returns a \ref ComposeMap class.
+/// This function just returns a \c ComposeMap class.
 ///
 /// If \c m1 and \c m2 are maps and the \c Value type of \c m2 is
 /// convertible to the \c Key of \c m1, then <tt>composeMap(m1,m2)[x]</tt>
 /// will be equal to <tt>m1[m2[x]]</tt>.
 ///
 : _m1(m1), _m2(m2), _f(f) {}
 /// \e
 Value operator[](const Key &k) const { return _f(_m1[k],_m2[k]); }
 };
-/// Returns a \ref CombineMap class
+/// Returns a \c CombineMap class
-/// This function just returns a \ref CombineMap class.
+/// This function just returns a \c CombineMap class.
 ///
 /// For example, if \c m1 and \c m2 are both maps with \c double
 /// values, then
 /// \code
 ///   combineMap(m1,m2,std::plus<double>())
 FunctorToMap(const F &f = F()) : _f(f) {}
 /// \e
 Value operator[](const Key &k) const { return _f(k); }
 };
-/// Returns a \ref FunctorToMap class
+/// Returns a \c FunctorToMap class
-/// This function just returns a \ref FunctorToMap class.
+/// This function just returns a \c FunctorToMap class.
 ///
 /// This function is specialized for adaptable binary function
 /// classes and C++ functions.
 ///
 /// \relates FunctorToMap
 Value operator()(const Key &k) const { return _m[k]; }
 /// \e
 Value operator[](const Key &k) const { return _m[k]; }
 };
-/// Returns a \ref MapToFunctor class
+/// Returns a \c MapToFunctor class
-/// This function just returns a \ref MapToFunctor class.
+/// This function just returns a \c MapToFunctor class.
 /// \relates MapToFunctor
 template<typename M>
 inline MapToFunctor<M> mapToFunctor(const M &m) {
 return MapToFunctor<M>(m);
 }
 /// \e
 Value operator[](const Key &k) const { return _m[k]; }
 };
-/// Returns a \ref ConvertMap class
+/// Returns a \c ConvertMap class
-/// This function just returns a \ref ConvertMap class.
+/// This function just returns a \c ConvertMap class.
 /// \relates ConvertMap
 template<typename V, typename M>
 inline ConvertMap<M, V> convertMap(const M &map) {
 return ConvertMap<M, V>(map);
 }
 Value operator[](const Key &k) const { return _m1[k]; }
 /// Sets the value associated with the given key in both maps.
 void set(const Key &k, const Value &v) { _m1.set(k,v); _m2.set(k,v); }
 };
-/// Returns a \ref ForkMap class
+/// Returns a \c ForkMap class
-/// This function just returns a \ref ForkMap class.
+/// This function just returns a \c ForkMap class.
 /// \relates ForkMap
 template <typename M1, typename M2>
 inline ForkMap<M1,M2> forkMap(M1 &m1, M2 &m2) {
 return ForkMap<M1,M2>(m1,m2);
 }
 AddMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 /// \e
 Value operator[](const Key &k) const { return _m1[k]+_m2[k]; }
 };
-/// Returns an \ref AddMap class
+/// Returns an \c AddMap class
-/// This function just returns an \ref AddMap class.
+/// This function just returns an \c AddMap class.
 ///
 /// For example, if \c m1 and \c m2 are both maps with \c double
 /// values, then <tt>addMap(m1,m2)[x]</tt> will be equal to
 /// <tt>m1[x]+m2[x]</tt>.
 ///
 SubMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 /// \e
 Value operator[](const Key &k) const { return _m1[k]-_m2[k]; }
 };
-/// Returns a \ref SubMap class
+/// Returns a \c SubMap class
-/// This function just returns a \ref SubMap class.
+/// This function just returns a \c SubMap class.
 ///
 /// For example, if \c m1 and \c m2 are both maps with \c double
 /// values, then <tt>subMap(m1,m2)[x]</tt> will be equal to
 /// <tt>m1[x]-m2[x]</tt>.
 ///
 MulMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
 /// \e
 Value operator[](const Key &k) const { return _m1[k]*_m2[k]; }
 };
-/// Returns a \ref MulMap class
+/// Returns a \c MulMap class
-/// This function just returns a \ref MulMap class.
+/// This function just returns a \c MulMap class.
 ///
 /// For example, if \c m1 and \c m2 are both maps with \c double
 /// values, then <tt>mulMap(m1,m2)[x]</tt> will be equal to
 /// <tt>m1[x]*m2[x]</tt>.
 ///
 DivMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
 /// \e
 Value operator[](const Key &k) const { return _m1[k]/_m2[k]; }
 };
-/// Returns a \ref DivMap class
+/// Returns a \c DivMap class
-/// This function just returns a \ref DivMap class.
+/// This function just returns a \c DivMap class.
 ///
 /// For example, if \c m1 and \c m2 are both maps with \c double
 /// values, then <tt>divMap(m1,m2)[x]</tt> will be equal to
 /// <tt>m1[x]/m2[x]</tt>.
 ///
 Value operator[](const Key &k) const { return _m[k]+_v; }
 /// \e
 void set(const Key &k, const Value &v) { _m.set(k, v-_v); }
 };
-/// Returns a \ref ShiftMap class
+/// Returns a \c ShiftMap class
-/// This function just returns a \ref ShiftMap class.
+/// This function just returns a \c ShiftMap class.
 ///
 /// For example, if \c m is a map with \c double values and \c v is
 /// \c double, then <tt>shiftMap(m,v)[x]</tt> will be equal to
 /// <tt>m[x]+v</tt>.
 ///
 template<typename M, typename C>
 inline ShiftMap<M, C> shiftMap(const M &m, const C &v) {
 return ShiftMap<M, C>(m,v);
 }
-/// Returns a \ref ShiftWriteMap class
+/// Returns a \c ShiftWriteMap class
-/// This function just returns a \ref ShiftWriteMap class.
+/// This function just returns a \c ShiftWriteMap class.
 ///
 /// For example, if \c m is a map with \c double values and \c v is
 /// \c double, then <tt>shiftWriteMap(m,v)[x]</tt> will be equal to
 /// <tt>m[x]+v</tt>.
 /// Moreover it makes also possible to write the map.
 Value operator[](const Key &k) const { return _v*_m[k]; }
 /// \e
 void set(const Key &k, const Value &v) { _m.set(k, v/_v); }
 };
-/// Returns a \ref ScaleMap class
+/// Returns a \c ScaleMap class
-/// This function just returns a \ref ScaleMap class.
+/// This function just returns a \c ScaleMap class.
 ///
 /// For example, if \c m is a map with \c double values and \c v is
 /// \c double, then <tt>scaleMap(m,v)[x]</tt> will be equal to
 /// <tt>v*m[x]</tt>.
 ///
 template<typename M, typename C>
 inline ScaleMap<M, C> scaleMap(const M &m, const C &v) {
 return ScaleMap<M, C>(m,v);
 }
-/// Returns a \ref ScaleWriteMap class
+/// Returns a \c ScaleWriteMap class
-/// This function just returns a \ref ScaleWriteMap class.
+/// This function just returns a \c ScaleWriteMap class.
 ///
 /// For example, if \c m is a map with \c double values and \c v is
 /// \c double, then <tt>scaleWriteMap(m,v)[x]</tt> will be equal to
 /// <tt>v*m[x]</tt>.
 /// Moreover it makes also possible to write the map.
 Value operator[](const Key &k) const { return -_m[k]; }
 /// \e
 void set(const Key &k, const Value &v) { _m.set(k, -v); }
 };
-/// Returns a \ref NegMap class
+/// Returns a \c NegMap class
-/// This function just returns a \ref NegMap class.
+/// This function just returns a \c NegMap class.
 ///
 /// For example, if \c m is a map with \c double values, then
 /// <tt>negMap(m)[x]</tt> will be equal to <tt>-m[x]</tt>.
 ///
 /// \relates NegMap
 template <typename M>
 inline NegMap<M> negMap(const M &m) {
 return NegMap<M>(m);
 }
-/// Returns a \ref NegWriteMap class
+/// Returns a \c NegWriteMap class
-/// This function just returns a \ref NegWriteMap class.
+/// This function just returns a \c NegWriteMap class.
 ///
 /// For example, if \c m is a map with \c double values, then
 /// <tt>negWriteMap(m)[x]</tt> will be equal to <tt>-m[x]</tt>.
 /// Moreover it makes also possible to write the map.
 ///
 return tmp >= 0 ? tmp : -tmp;
 }
 };
-/// Returns an \ref AbsMap class
+/// Returns an \c AbsMap class
-/// This function just returns an \ref AbsMap class.
+/// This function just returns an \c AbsMap class.
 ///
 /// For example, if \c m is a map with \c double values, then
 /// <tt>absMap(m)[x]</tt> will be equal to <tt>m[x]</tt> if
 /// it is positive or zero and <tt>-m[x]</tt> if <tt>m[x]</tt> is
 /// negative.
 /// Gives back \c true.
 Value operator[](const Key&) const { return true; }
 };
-/// Returns a \ref TrueMap class
+/// Returns a \c TrueMap class
-/// This function just returns a \ref TrueMap class.
+/// This function just returns a \c TrueMap class.
 /// \relates TrueMap
 template<typename K>
 inline TrueMap<K> trueMap() {
 return TrueMap<K>();
 }
 /// Gives back \c false.
 Value operator[](const Key&) const { return false; }
 };
-/// Returns a \ref FalseMap class
+/// Returns a \c FalseMap class
-/// This function just returns a \ref FalseMap class.
+/// This function just returns a \c FalseMap class.
 /// \relates FalseMap
 template<typename K>
 inline FalseMap<K> falseMap() {
 return FalseMap<K>();
 }
 AndMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 /// \e
 Value operator[](const Key &k) const { return _m1[k]&&_m2[k]; }
 };
-/// Returns an \ref AndMap class
+/// Returns an \c AndMap class
-/// This function just returns an \ref AndMap class.
+/// This function just returns an \c AndMap class.
 ///
 /// For example, if \c m1 and \c m2 are both maps with \c bool values,
 /// then <tt>andMap(m1,m2)[x]</tt> will be equal to
 /// <tt>m1[x]&&m2[x]</tt>.
 ///
 OrMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 /// \e
 Value operator[](const Key &k) const { return _m1[k]||_m2[k]; }
 };
-/// Returns an \ref OrMap class
+/// Returns an \c OrMap class
-/// This function just returns an \ref OrMap class.
+/// This function just returns an \c OrMap class.
 ///
 /// For example, if \c m1 and \c m2 are both maps with \c bool values,
 /// then <tt>orMap(m1,m2)[x]</tt> will be equal to
 /// <tt>m1[x]||m2[x]</tt>.
 ///
 Value operator[](const Key &k) const { return !_m[k]; }
 /// \e
 void set(const Key &k, bool v) { _m.set(k, !v); }
 };
-/// Returns a \ref NotMap class
+/// Returns a \c NotMap class
-/// This function just returns a \ref NotMap class.
+/// This function just returns a \c NotMap class.
 ///
 /// For example, if \c m is a map with \c bool values, then
 /// <tt>notMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
 ///
 /// \relates NotMap
 template <typename M>
 inline NotMap<M> notMap(const M &m) {
 return NotMap<M>(m);
 }
-/// Returns a \ref NotWriteMap class
+/// Returns a \c NotWriteMap class
-/// This function just returns a \ref NotWriteMap class.
+/// This function just returns a \c NotWriteMap class.
 ///
 /// For example, if \c m is a map with \c bool values, then
 /// <tt>notWriteMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
 /// Moreover it makes also possible to write the map.
 ///
 EqualMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 /// \e
 Value operator[](const Key &k) const { return _m1[k]==_m2[k]; }
 };
-/// Returns an \ref EqualMap class
+/// Returns an \c EqualMap class
-/// This function just returns an \ref EqualMap class.
+/// This function just returns an \c EqualMap class.
 ///
 /// For example, if \c m1 and \c m2 are maps with keys and values of
 /// the same type, then <tt>equalMap(m1,m2)[x]</tt> will be equal to
 /// <tt>m1[x]==m2[x]</tt>.
 ///
 LessMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 /// \e
 Value operator[](const Key &k) const { return _m1[k]<_m2[k]; }
 };
-/// Returns an \ref LessMap class
+/// Returns an \c LessMap class
-/// This function just returns an \ref LessMap class.
+/// This function just returns an \c LessMap class.
 ///
 /// For example, if \c m1 and \c m2 are maps with keys and values of
 /// the same type, then <tt>lessMap(m1,m2)[x]</tt> will be equal to
 /// <tt>m1[x]<m2[x]</tt>.
 ///
 {
 typedef typename _Iterator::container_type::value_type Value;
 };
 }
+/// @}
+/// \addtogroup maps
+/// @{
 /// \brief Writable bool map for logging each \c true assigned element
 ///
 /// A \ref concepts::WriteMap "writable" bool map for logging
 /// each \c true assigned element, i.e it copies subsequently each
 private:
 Iterator _begin;
 Iterator _end;
 };
-/// Returns a \ref LoggerBoolMap class
+/// Returns a \c LoggerBoolMap class
-/// This function just returns a \ref LoggerBoolMap class.
+/// This function just returns a \c LoggerBoolMap class.
 ///
 /// The most important usage of it is storing certain nodes or arcs
 /// that were marked \c true by an algorithm.
 /// For example it makes easier to store the nodes in the processing
 /// order of Dfs algorithm, as the following examples show.
 /// \note The container of the iterator must contain enough space
 /// for the elements or the iterator should be an inserter iterator.
 ///
 /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so
 /// it cannot be used when a readable map is needed, for example as
-/// \c ReachedMap for \ref Bfs, \ref Dfs and \ref Dijkstra algorithms.
+/// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.
 ///
 /// \relates LoggerBoolMap
 template<typename Iterator>
 inline LoggerBoolMap<Iterator> loggerBoolMap(Iterator it) {
 return LoggerBoolMap<Iterator>(it);
 }
+/// @}
+/// \addtogroup graph_maps
+/// @{
 /// Provides an immutable and unique id for each item in the graph.
 /// The IdMap class provides a unique and immutable id for each item of the
 /// same type (e.g. node) in the graph. This id is <ul><li>\b unique:
 typedef typename Digraph::Arc Key;
 /// \brief Constructor
 ///
 /// Constructor
-/// \param _digraph The digraph that the map belongs to.
+/// \param digraph The digraph that the map belongs to.
 explicit SourceMap(const Digraph& digraph) : _digraph(digraph) {}
 /// \brief The subscript operator.
 ///
 /// The subscript operator.
 private:
 const Digraph& _digraph;
 };
-/// \brief Returns a \ref SourceMap class.
+/// \brief Returns a \c SourceMap class.
 ///
-/// This function just returns an \ref SourceMap class.
+/// This function just returns an \c SourceMap class.
 /// \relates SourceMap
 template <typename Digraph>
 inline SourceMap<Digraph> sourceMap(const Digraph& digraph) {
 return SourceMap<Digraph>(digraph);
 }
 typedef typename Digraph::Arc Key;
 /// \brief Constructor
 ///
 /// Constructor
-/// \param _digraph The digraph that the map belongs to.
+/// \param digraph The digraph that the map belongs to.
 explicit TargetMap(const Digraph& digraph) : _digraph(digraph) {}
 /// \brief The subscript operator.
 ///
 /// The subscript operator.
 private:
 const Digraph& _digraph;
 };
-/// \brief Returns a \ref TargetMap class.
+/// \brief Returns a \c TargetMap class.
 ///
-/// This function just returns a \ref TargetMap class.
+/// This function just returns a \c TargetMap class.
 /// \relates TargetMap
 template <typename Digraph>
 inline TargetMap<Digraph> targetMap(const Digraph& digraph) {
 return TargetMap<Digraph>(digraph);
 }
 typedef typename Graph::Edge Key;
 /// \brief Constructor
 ///
 /// Constructor
-/// \param _graph The graph that the map belongs to.
+/// \param graph The graph that the map belongs to.
 explicit ForwardMap(const Graph& graph) : _graph(graph) {}
 /// \brief The subscript operator.
 ///
 /// The subscript operator.
 private:
 const Graph& _graph;
 };
-/// \brief Returns a \ref ForwardMap class.
+/// \brief Returns a \c ForwardMap class.
 ///
-/// This function just returns an \ref ForwardMap class.
+/// This function just returns an \c ForwardMap class.
 /// \relates ForwardMap
 template <typename Graph>
 inline ForwardMap<Graph> forwardMap(const Graph& graph) {
 return ForwardMap<Graph>(graph);
 }
 typedef typename Graph::Edge Key;
 /// \brief Constructor
 ///
 /// Constructor
-/// \param _graph The graph that the map belongs to.
+/// \param graph The graph that the map belongs to.
 explicit BackwardMap(const Graph& graph) : _graph(graph) {}
 /// \brief The subscript operator.
 ///
 /// The subscript operator.
 private:
 const Graph& _graph;
 };
-/// \brief Returns a \ref BackwardMap class
+/// \brief Returns a \c BackwardMap class
-/// This function just returns a \ref BackwardMap class.
+/// This function just returns a \c BackwardMap class.
 /// \relates BackwardMap
 template <typename Graph>
 inline BackwardMap<Graph> backwardMap(const Graph& graph) {
 return BackwardMap<Graph>(graph);
 }

branch	1.0
changeset 329	b802094f96fd
parent 301	fafece417795
parent 318	2cc60866a0c9