lemon-1.0: comparison lemon/maps.h

equal deleted inserted replaced

-:678500f790f8
+:741aa1b3732b
 template<typename K, typename V, V v>
 inline ConstMap<K, Const<V, v> > constMap() {
 return ConstMap<K, Const<V, v> >();
 }
-///Map based on std::map
+///Map based on \c std::map
 ///This is essentially a wrapper for \c std::map with addition that
 ///you can specify a default value different from \c Value().
 template <typename K, typename T, typename Compare = std::less<K> >
 class StdMap : public MapBase<K, T> {
 _map.clear();
 }
 };
-///Returns a \ref StdMap class
+///Returns a \c StdMap class
-///This function just returns a \ref StdMap class with specified
+///This function just returns a \c StdMap class with specified
 ///default value.
 ///\relates StdMap
 template<typename K, typename V, typename Compare = std::less<K> >
 inline StdMap<K, V, Compare> stdMap(const V& value = V()) {
 return StdMap<K, V, Compare>(value);
 }
-///Returns a \ref StdMap class created from an appropriate std::map
+///Returns a \c StdMap class created from an appropriate std::map
-///This function just returns a \ref StdMap class created from an
+///This function just returns a \c StdMap class created from an
 ///appropriate std::map.
 ///\relates StdMap
 template<typename K, typename V, typename Compare = std::less<K> >
 inline StdMap<K, V, Compare> stdMap( const std::map<K, V, Compare> &map,
 const V& value = V() ) {
 _vector[k] = t;
 }
 };
-///Returns an \ref IntegerMap class
+///Returns an \c IntegerMap class
-///This function just returns an \ref IntegerMap class.
+///This function just returns an \c IntegerMap class.
 ///\relates IntegerMap
 template<typename T>
 inline IntegerMap<T> integerMap(int size = 0, const T& value = T()) {
 return IntegerMap<T>(size, value);
 }
 ///\brief Convert the \c Value of a map to another type using
 ///the default conversion.
 ///
-///This \c concepts::ReadMap "read only map"
+///This \ref concepts::ReadMap "read only map"
 ///converts the \c Value of a map to type \c T.
 ///Its \c Key is inherited from \c M.
 template <typename M, typename T>
 class ConvertMap : public MapBase<typename M::Key, T> {
 const M& m;
 SimpleMap(const M &_m) : m(_m) {};
 ///\e
 Value operator[](Key k) const {return m[k];}
 };
-///Returns a \ref SimpleMap class
+///Returns a \c SimpleMap class
-///This function just returns a \ref SimpleMap class.
+///This function just returns a \c SimpleMap class.
 ///\relates SimpleMap
 template<typename M>
 inline SimpleMap<M> simpleMap(const M &m) {
 return SimpleMap<M>(m);
 }
 ///Simple writable wrapping of a map
-///This \ref concepts::WriteMap "write map" returns the simple
+///This \ref concepts::ReadWriteMap "read-write map" returns the simple
 ///wrapping of the given map. Sometimes the reference maps cannot be
 ///combined with simple read-write maps. This map adaptor wraps the
 ///given map to simple read-write map.
 ///
 ///\sa SimpleMap
 Value operator[](Key k) const {return m[k];}
 ///\e
 void set(Key k, const Value& c) { m.set(k, c); }
 };
-///Returns a \ref SimpleWriteMap class
+///Returns a \c SimpleWriteMap class
-///This function just returns a \ref SimpleWriteMap class.
+///This function just returns a \c SimpleWriteMap class.
 ///\relates SimpleWriteMap
 template<typename M>
 inline SimpleWriteMap<M> simpleWriteMap(M &m) {
 return SimpleWriteMap<M>(m);
 }
 ///Sum of two maps
-///This \c concepts::ReadMap "read only map" returns the sum of the two
+///This \ref concepts::ReadMap "read only map" returns the sum of the two
 ///given maps.
 ///Its \c Key and \c Value are inherited from \c M1.
 ///The \c Key and \c Value of M2 must be convertible to those of \c M1.
 template<typename M1, typename M2>
 class AddMap : public MapBase<typename M1::Key, typename M1::Value> {
 return AddMap<M1, M2>(m1,m2);
 }
 ///Shift a map with a constant.
-///This \c concepts::ReadMap "read only map" returns the sum of the
+///This \ref concepts::ReadMap "read only map" returns the sum of the
 ///given map and a constant value.
 ///Its \c Key and \c Value are inherited from \c M.
 ///
 ///Actually,
 ///\code
 Value operator[](Key k) const {return m[k] + v;}
 };
 ///Shift a map with a constant (ReadWrite version).
-///This \c concepts::ReadWriteMap "read-write map" returns the sum of the
+///This \ref concepts::ReadWriteMap "read-write map" returns the sum of the
 ///given map and a constant value. It makes also possible to write the map.
 ///Its \c Key and \c Value are inherited from \c M.
 ///
 ///\sa ShiftMap
 template<typename M, typename C = typename M::Value>
 return ShiftWriteMap<M, C>(m,v);
 }
 ///Difference of two maps
-///This \c concepts::ReadMap "read only map" returns the difference
+///This \ref concepts::ReadMap "read only map" returns the difference
 ///of the values of the two given maps.
 ///Its \c Key and \c Value are inherited from \c M1.
 ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
 ///
 /// \todo Revise the misleading name
 return SubMap<M1, M2>(m1, m2);
 }
 ///Product of two maps
-///This \c concepts::ReadMap "read only map" returns the product of the
+///This \ref concepts::ReadMap "read only map" returns the product of the
 ///values of the two given maps.
 ///Its \c Key and \c Value are inherited from \c M1.
 ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
 template<typename M1, typename M2>
 class MulMap : public MapBase<typename M1::Key, typename M1::Value> {
 return MulMap<M1, M2>(m1,m2);
 }
 ///Scales a map with a constant.
-///This \c concepts::ReadMap "read only map" returns the value of the
+///This \ref concepts::ReadMap "read only map" returns the value of the
 ///given map multiplied from the left side with a constant value.
 ///Its \c Key and \c Value are inherited from \c M.
 ///
 ///Actually,
 ///\code
 Value operator[](Key k) const {return v * m[k];}
 };
 ///Scales a map with a constant (ReadWrite version).
-///This \c concepts::ReadWriteMap "read-write map" returns the value of the
+///This \ref concepts::ReadWriteMap "read-write map" returns the value of the
 ///given map multiplied from the left side with a constant value. It can
 ///also be used as write map if the \c / operator is defined between
 ///\c Value and \c C and the given multiplier is not zero.
 ///Its \c Key and \c Value are inherited from \c M.
 ///
 return ScaleWriteMap<M, C>(m,v);
 }
 ///Quotient of two maps
-///This \c concepts::ReadMap "read only map" returns the quotient of the
+///This \ref concepts::ReadMap "read only map" returns the quotient of the
 ///values of the two given maps.
 ///Its \c Key and \c Value are inherited from \c M1.
 ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
 template<typename M1, typename M2>
 class DivMap : public MapBase<typename M1::Key, typename M1::Value> {
 return DivMap<M1, M2>(m1,m2);
 }
 ///Composition of two maps
-///This \c concepts::ReadMap "read only map" returns the composition of
+///This \ref concepts::ReadMap "read only map" returns the composition of
 ///two given maps.
 ///That is to say, if \c m1 is of type \c M1 and \c m2 is of \c M2,
 ///then for
 ///\code
 ///  ComposeMap<M1, M2> cm(m1,m2);
 ///Combine of two maps using an STL (binary) functor.
 ///Combine of two maps using an STL (binary) functor.
 ///
-///This \c concepts::ReadMap "read only map" takes two maps and a
+///This \ref concepts::ReadMap "read only map" takes two maps and a
 ///binary functor and returns the composition of the two
 ///given maps unsing the functor.
 ///That is to say, if \c m1 and \c m2 is of type \c M1 and \c M2
 ///and \c f is of \c F, then for
 ///\code
 return combineMap<M1, M2, V (*)(K1, K2), V>(m1,m2,f);
 }
 ///Negative value of a map
-///This \c concepts::ReadMap "read only map" returns the negative
+///This \ref concepts::ReadMap "read only map" returns the negative
 ///value of the value returned by the given map.
 ///Its \c Key and \c Value are inherited from \c M.
 ///The unary \c - operator must be defined for \c Value, of course.
 ///
 ///\sa NegWriteMap
 Value operator[](Key k) const {return -m[k];}
 };
 ///Negative value of a map (ReadWrite version)
-///This \c concepts::ReadWriteMap "read-write map" returns the negative
+///This \ref concepts::ReadWriteMap "read-write map" returns the negative
 ///value of the value returned by the given map.
 ///Its \c Key and \c Value are inherited from \c M.
 ///The unary \c - operator must be defined for \c Value, of course.
 ///
 /// \sa NegMap
 return NegWriteMap<M>(m);
 }
 ///Absolute value of a map
-///This \c concepts::ReadMap "read only map" returns the absolute value
+///This \ref concepts::ReadMap "read only map" returns the absolute value
 ///of the value returned by the given map.
 ///Its \c Key and \c Value are inherited from \c M.
 ///\c Value must be comparable to \c 0 and the unary \c -
 ///operator must be defined for it, of course.
 template<typename M>
 return AbsMap<M>(m);
 }
 ///Converts an STL style functor to a map
-///This \c concepts::ReadMap "read only map" returns the value
+///This \ref concepts::ReadMap "read only map" returns the value
 ///of a given functor.
 ///
 ///Template parameters \c K and \c V will become its
 ///\c Key and \c Value.
 ///In most cases they have to be given explicitly because a
 ///This class Converts a map to an STL style (unary) functor.
 ///that is it provides an <tt>operator()</tt> to read its values.
 ///
 ///For the sake of convenience it also works as
-///a ususal \c concepts::ReadMap "readable map",
+///a ususal \ref concepts::ReadMap "readable map",
 ///i.e. <tt>operator[]</tt> and the \c Key and \c Value typedefs also exist.
 ///
 ///\sa FunctorMap
 template <typename M>
 class MapFunctor : public MapBase<typename M::Key, typename M::Value> {
 return MapFunctor<M>(m);
 }
 ///Applies all map setting operations to two maps
-///This map has two \c concepts::ReadMap "readable map"
+///This map has two \ref concepts::ReadMap "readable map"
 ///parameters and each read request will be passed just to the
-///first map. This class is the just readable map type of the ForkWriteMap.
+///first map. This class is the just readable map type of the \c ForkWriteMap.
 ///
 ///The \c Key and \c Value are inherited from \c M1.
 ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
 ///
 ///\sa ForkWriteMap
 };
 ///Applies all map setting operations to two maps
-///This map has two \c concepts::WriteMap "writable map"
+///This map has two \ref concepts::WriteMap "writable map"
 ///parameters and each write request will be passed to both of them.
-///If \c M1 is also \c concepts::ReadMap "readable",
+///If \c M1 is also \ref concepts::ReadMap "readable",
 ///then the read operations will return the
 ///corresponding values of \c M1.
 ///
 ///The \c Key and \c Value are inherited from \c M1.
 ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
 /* ************* BOOL MAPS ******************* */
 ///Logical 'not' of a map
-///This bool \c concepts::ReadMap "read only map" returns the
+///This bool \ref concepts::ReadMap "read only map" returns the
 ///logical negation of the value returned by the given map.
 ///Its \c Key is inherited from \c M, its Value is \c bool.
 ///
 ///\sa NotWriteMap
 template <typename M>
 Value operator[](Key k) const {return !m[k];}
 };
 ///Logical 'not' of a map (ReadWrie version)
-///This bool \c concepts::ReadWriteMap "read-write map" returns the
+///This bool \ref concepts::ReadWriteMap "read-write map" returns the
 ///logical negation of the value returned by the given map. When it is set,
 ///the opposite value is set to the original map.
 ///Its \c Key is inherited from \c M, its Value is \c bool.
 ///
 ///\sa NotMap
 }
 /// \brief Writable bool map for logging each \c true assigned element
 ///
-/// Writable bool map for logging each \c true assigned element, i.e it
+/// A \ref concepts::ReadWriteMap "read-write" bool map for logging
-/// copies all the keys set to \c true to the given iterator.
+/// each \c true assigned element, i.e it/ copies all the keys set
+/// to \c true to the given iterator.
 ///
 /// \note The container of the iterator should contain space
 /// for each element.
 ///
 /// The following example shows how you can write the edges found by the Prim

changeset 46	b6dd98b57d71
parent 45	bc69cdfe171c
child 47	3750b8ebc91e