lemon-0.x: comparison lemon/maps.h

equal deleted inserted replaced

-:fe91c7bf9ade
+:875a7eb83ec1
 ///\file
 ///\ingroup maps
 ///\brief Miscellaneous property maps
 ///
-///\todo This file has the same name as the concept file in concept/,
+///\todo This file has the same name as the concept file in concepts/,
 /// and this is not easily detectable in docs...
 #include <map>
 namespace lemon {
 }
 ///Convert the \c Value of a map to another type.
-///This \ref concept::ReadMap "read only map"
+///This \ref concepts::ReadMap "read only map"
 ///converts the \c Value of a maps 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;
 return ConvertMap<M, T>(m);
 }
 ///Simple wrapping of the map
-///This \ref concept::ReadMap "read only map" returns the simple
+///This \ref concepts::ReadMap "read only map" returns the simple
 ///wrapping of the given map. Sometimes the reference maps cannot be
 ///combined with simple read maps. This map adaptor wraps the given
 ///map to simple read map.
 template<typename M>
 class SimpleMap : public MapBase<typename M::Key, typename M::Value> {
 Value operator[](Key k) const {return m[k];}
 };
 ///Simple writeable wrapping of the map
-///This \ref concept::ReadMap "read only map" returns the simple
+///This \ref concepts::ReadMap "read only 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.
 template<typename M>
 class SimpleWriteMap : public MapBase<typename M::Key, typename M::Value> {
 void set(Key k, const Value& c) { m.set(k, c); }
 };
 ///Sum of two maps
-///This \ref concept::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 will be 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 \ref concept::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 is inherited from \c M.
 ///
 ///Actually,
 ///\code
 Value operator[](Key k) const {return m[k] + v;}
 };
 ///Shift a map with a constant.
-///This \ref concept::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 is inherited from \c M.
 ///
 ///Actually,
 ///\code
 return ShiftWriteMap<M, C>(m,v);
 }
 ///Difference of two maps
-///This \ref concept::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 will be 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>
 return SubMap<M1, M2>(m1, m2);
 }
 ///Product of two maps
-///This \ref concept::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 will be inherited from \c M1.
 ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
 return MulMap<M1, M2>(m1,m2);
 }
 ///Scales a maps with a constant.
-///This \ref concept::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 is inherited from \c M.
 ///
 ///Actually,
 ///\code
 Value operator[](Key k) const {return v * m[k];}
 };
 ///Scales a maps with a constant.
-///This \ref concept::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
 ///be used as write map also if the given multiplier is not zero.
 ///Its \c Key and \c Value is inherited from \c M.
 template<typename M, typename C = typename M::Value>
 class ScaleWriteMap : public MapBase<typename M::Key, typename M::Value> {
 return ScaleWriteMap<M, C>(m,v);
 }
 ///Quotient of two maps
-///This \ref concept::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 will be 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>
 return DivMap<M1, M2>(m1,m2);
 }
 ///Composition of two maps
-///This \ref concept::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
 ///Combines of two maps using an STL (binary) functor.
 ///Combines of two maps using an STL (binary) functor.
 ///
 ///
-///This \ref concept::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,
 return combineMap<M1, M2, V (*)(K1, K2), V>(m1,m2,f);
 }
 ///Negative value of a map
-///This \ref concept::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 will be inherited from \c M.
 ///The unary \c - operator must be defined for \c Value, of course.
 Value operator[](Key k) const {return -m[k];}
 };
 ///Negative value of a map
-///This \ref concept::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 will be inherited from \c M.
 ///The unary \c - operator must be defined for \c Value, of course.
 template<typename M>
 return NegWriteMap<M>(m);
 }
 ///Absolute value of a map
-///This \ref concept::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 will be inherited
 ///from <tt>M</tt>. <tt>Value</tt>
 ///must be comparable to <tt>0</tt> and the unary <tt>-</tt>
 return AbsMap<M>(m);
 }
 ///Converts an STL style functor to a map
-///This \ref concept::ReadMap "read only map" returns the value
+///This \ref concepts::ReadMap "read only map" returns the value
 ///of a
 ///given map.
 ///
 ///Template parameters \c K and \c V will become its
 ///\c Key and \c Value. They must be given explicitely
 ///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 \ref concept::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.
 template <typename M>
 class MapFunctor : public MapBase<typename M::Key, typename M::Value> {
 const M& m;
 return MapFunctor<M>(m);
 }
 ///Applies all map setting operations to two maps
-///This map has two \ref concept::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.
 ///
 ///The \c Key and \c Value will be inherited from \c M1.
 ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
 };
 ///Applies all map setting operations to two maps
-///This map has two \ref concept::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 \ref concept::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 will be 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 \ref concept::ReadMap "read only map" returns the
+///This bool \ref concepts::ReadMap "read only map" returns the
 ///logical negation of
 ///value returned by the
 ///given map. Its \c Key and will be inherited from \c M,
 ///its Value is <tt>bool</tt>.
 Value operator[](Key k) const {return !m[k];}
 };
 ///Logical 'not' of a map with writing possibility
-///This bool \ref concept::ReadWriteMap "read-write map" returns the
+///This bool \ref concepts::ReadWriteMap "read-write map" returns the
 ///logical negation of value returned by the given map. When it is set,
 ///the opposite value is set to the original map.
 ///Its \c Key and will be inherited from \c M,
 ///its Value is <tt>bool</tt>.
 template <typename M>

changeset 2375	e30a0fdad0d7
parent 2258	741995f3dbc4
child 2391	14a343be7a5a