Index: lemon/concepts/maps.h =================================================================== --- lemon/concepts/maps.h (revision 39) +++ lemon/concepts/maps.h (revision 51) @@ -49,4 +49,5 @@ /// Returns the value associated with a key. + /// Returns the value associated with a key. /// \bug Value shouldn't need to be default constructible. /// @@ -114,5 +115,5 @@ }; - /// Read/Writable map concept + /// Read/writable map concept /// Read/writable map concept. @@ -147,4 +148,5 @@ /// Dereferable map concept. /// + /// \todo Rethink this concept. template class ReferenceMap : public ReadWriteMap @@ -166,12 +168,11 @@ public: - ///Returns a reference to the value associated to a key. + ///Returns a reference to the value associated with a key. Reference operator[](const Key &) { return tmp; } - ///Returns a const reference to the value associated to a key. + ///Returns a const reference to the value associated with a key. ConstReference operator[](const Key &) const { return tmp; } /// Sets the value associated with a key. void set(const Key &k,const Value &t) { operator[](k)=t; } - /// \todo Rethink this concept. template struct ReferenceMapConcept { Index: lemon/maps.h =================================================================== --- lemon/maps.h (revision 44) +++ lemon/maps.h (revision 51) @@ -82,6 +82,7 @@ /// Constant map. - /// This is a readable map which assigns a specified value to each key. - /// In other aspects it is equivalent to the \c NullMap. + /// This is a \ref concepts::ReadMap "readable" map which assigns a + /// specified value to each key. + /// In other aspects it is equivalent to \c NullMap. template class ConstMap : public MapBase { @@ -134,6 +135,7 @@ /// Constant map with inlined constant value. - /// This is a readable map which assigns a specified value to each key. - /// In other aspects it is equivalent to the \c NullMap. + /// This is a \ref concepts::ReadMap "readable" map which assigns a + /// specified value to each key. + /// In other aspects it is equivalent to \c NullMap. template class ConstMap > : public MapBase { @@ -150,5 +152,5 @@ }; - ///Returns a \c ConstMap class + ///Returns a \c ConstMap class with inlined value ///This function just returns a \c ConstMap class with inlined value. @@ -159,23 +161,26 @@ } - ///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(). + ///It meets the \ref concepts::ReferenceMap "ReferenceMap" concept. template > - class StdMap { + class StdMap : public MapBase { template friend class StdMap; public: - typedef True ReferenceMapTag; + typedef MapBase Parent; ///Key type - typedef K Key; + typedef typename Parent::Key Key; ///Value type - typedef T Value; + typedef typename Parent::Value Value; ///Reference Type typedef T& Reference; ///Const reference type typedef const T& ConstReference; + + typedef True ReferenceMapTag; private: @@ -189,11 +194,11 @@ /// Constructor with specified default value StdMap(const T& value = T()) : _value(value) {} - /// \brief Constructs the map from an appropriate std::map, and explicitly - /// specifies a default value. + /// \brief Constructs the map from an appropriate \c std::map, and + /// explicitly specifies a default value. template StdMap(const std::map &map, const T& value = T()) : _map(map.begin(), map.end()), _value(value) {} - /// \brief Constructs a map from an other StdMap. + /// \brief Constructs a map from an other \ref StdMap. template StdMap(const StdMap &c) @@ -240,15 +245,37 @@ }; + + ///Returns a \c StdMap class + + ///This function just returns a \c StdMap class with specified + ///default value. + ///\relates StdMap + template > + inline StdMap stdMap(const V& value = V()) { + return StdMap(value); + } + + ///Returns a \c StdMap class created from an appropriate std::map + + ///This function just returns a \c StdMap class created from an + ///appropriate std::map. + ///\relates StdMap + template > + inline StdMap stdMap( const std::map &map, + const V& value = V() ) { + return StdMap(map, value); + } /// \brief Map for storing values for keys from the range [0..size-1] /// - /// The current map has the [0..size-1] keyset and the values + /// This map has the [0..size-1] keyset and the values /// are stored in a \c std::vector container. It can be used with /// some data structures, for example \c UnionFind, \c BinHeap, when - /// the used items are small integer numbers. + /// the used items are small integer numbers. + /// This map meets the \ref concepts::ReferenceMap "ReferenceMap" concept. /// /// \todo Revise its name template - class IntegerMap { + class IntegerMap : public MapBase { template @@ -257,13 +284,15 @@ public: + typedef MapBase Parent; + ///\e + typedef typename Parent::Key Key; + ///\e + typedef typename Parent::Value Value; + ///\e + typedef T& Reference; + ///\e + typedef const T& ConstReference; + typedef True ReferenceMapTag; - ///\e - typedef int Key; - ///\e - typedef T Value; - ///\e - typedef T& Reference; - ///\e - typedef const T& ConstReference; private: @@ -277,10 +306,10 @@ IntegerMap(int size = 0, const T& value = T()) : _vector(size, value) {} - /// \brief Constructs the map from an appropriate std::vector. + /// \brief Constructs the map from an appropriate \c std::vector. template IntegerMap(const std::vector& vector) : _vector(vector.begin(), vector.end()) {} - /// \brief Constructs a map from an other IntegerMap. + /// \brief Constructs a map from an other \ref IntegerMap. template IntegerMap(const IntegerMap &c) @@ -314,4 +343,13 @@ }; + + ///Returns an \c IntegerMap class + + ///This function just returns an \c IntegerMap class. + ///\relates IntegerMap + template + inline IntegerMap integerMap(int size = 0, const T& value = T()) { + return IntegerMap(size, value); + } /// @} @@ -350,5 +388,5 @@ ///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. @@ -367,7 +405,5 @@ ConvertMap(const M &_m) : m(_m) {}; - /// \brief The subscript operator. - /// - /// The subscript operator. + ///\e Value operator[](const Key& k) const {return m[k];} }; @@ -406,8 +442,17 @@ Value operator[](Key k) const {return m[k];} }; + + ///Returns a \c SimpleMap class + + ///This function just returns a \c SimpleMap class. + ///\relates SimpleMap + template + inline SimpleMap simpleMap(const M &m) { + return SimpleMap(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 @@ -434,10 +479,19 @@ }; + ///Returns a \c SimpleWriteMap class + + ///This function just returns a \c SimpleWriteMap class. + ///\relates SimpleWriteMap + template + inline SimpleWriteMap simpleWriteMap(M &m) { + return SimpleWriteMap(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. + ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1. template class AddMap : public MapBase { @@ -459,5 +513,5 @@ ///This function just returns an \c AddMap class. - ///\todo How to call these type of functions? + ///\todo Extend the documentation: how to call these type of functions? /// ///\relates AddMap @@ -469,5 +523,5 @@ ///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. @@ -505,5 +559,5 @@ ///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. @@ -551,5 +605,5 @@ ///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. @@ -584,5 +638,5 @@ ///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. @@ -614,5 +668,5 @@ ///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. @@ -650,5 +704,5 @@ ///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 @@ -698,5 +752,5 @@ ///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. @@ -728,5 +782,5 @@ ///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, @@ -779,5 +833,5 @@ ///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. @@ -852,5 +906,5 @@ ///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. @@ -874,5 +928,5 @@ ///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. @@ -916,5 +970,5 @@ ///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. @@ -950,5 +1004,5 @@ ///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. /// @@ -956,5 +1010,6 @@ ///\c Key and \c Value. ///In most cases they have to be given explicitly because a - ///functor typically does not provide such typedefs. + ///functor typically does not provide \c argument_type and + ///\c result_type typedefs. /// ///Parameter \c F is the type of the used functor. @@ -981,6 +1036,7 @@ ///This function just returns a \c FunctorMap class. /// - ///It is specialized for adaptable function classes and - ///C++ functions. + ///This function is specialized for adaptable binary function + ///classes and C++ functions. + /// ///\relates FunctorMap template inline @@ -1005,8 +1061,8 @@ ///This class Converts a map to an STL style (unary) functor. - ///that is it provides an operator() to read its values. + ///That is it provides an operator() 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. operator[] and the \c Key and \c Value typedefs also exist. /// @@ -1040,12 +1096,12 @@ } - ///Applies all map setting operations to two maps - - ///This map has two \c concepts::ReadMap "readable map" + ///Just readable version of \ref ForkWriteMap + + ///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 \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. + ///The \c Key and \c Value of \c M2 must be convertible from those of \c M1. /// ///\sa ForkWriteMap @@ -1070,12 +1126,12 @@ ///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. + ///The \c Key and \c Value of \c M2 must be convertible from those of \c M1. /// ///\sa ForkMap @@ -1121,7 +1177,7 @@ ///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. + ///Its \c Key is inherited from \c M, its \c Value is \c bool. /// ///\sa NotWriteMap @@ -1142,8 +1198,8 @@ ///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. + ///Its \c Key is inherited from \c M, its \c Value is \c bool. /// ///\sa NotMap @@ -1210,13 +1266,13 @@ /// \brief Writable bool map for logging each \c true assigned element /// - /// Writable bool map for logging each \c true assigned element, i.e it - /// copies all the keys set to \c true to the given iterator. + /// A \ref concepts::ReadWriteMap "read-write" bool map for logging + /// 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 - /// algorithm directly - /// to the standard output. + /// The following example shows how you can write the edges found by + /// the \ref Prim algorithm directly to the standard output. ///\code /// typedef IdMap EdgeIdMap;