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

equal deleted inserted replaced

-:e304063824dc
+:370a65be8358
 ///\file
 ///\ingroup maps
 ///\brief Miscellaneous property maps
 ///
-///\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 {
 /// \addtogroup maps
 /// Constant map.
 /// This is a readable map which assigns a specified value to each key.
-/// In other aspects it is equivalent to the \ref NullMap.
+/// In other aspects it is equivalent to the \c NullMap.
-/// \todo set could be used to set the value.
 template<typename K, typename T>
 class ConstMap : public MapBase<K, T> {
 private:
 T v;
 public:
 ///\e
 /// \param _v The initial value of the map.
 ///
 ConstMap(const T &_v) : v(_v) {}
+///\e
 T operator[](const K&) const { return v; }
-void set(const K&, const T&) {}
+///\e
+void setAll(const T &t) {
+v = t;
+}
 template<typename T1>
 struct rebind {
 typedef ConstMap<K, T1> other;
 };
 template<typename T1>
 ConstMap(const ConstMap<K, T1> &, const T &_v) : v(_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);
 }
-//\todo to document later
 template<typename T, T v>
 struct Const { };
-//\todo to document later
+/// 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.
 template<typename K, typename V, V v>
 class ConstMap<K, Const<V, v> > : public MapBase<K, V> {
 public:
 typedef MapBase<K, V> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ConstMap() { }
+///\e
 V operator[](const K&) const { return v; }
+///\e
 void set(const K&, const 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 with inlined value.
 ///\relates ConstMap
 template<typename K, typename V, V v>
 inline ConstMap<K, Const<V, v> > constMap() {
 return ConstMap<K, Const<V, v> >();
 }
-/// \c std::map wrapper
+///Map based on std::map
-/// This is essentially a wrapper for \c std::map. With addition that
+///This is essentially a wrapper for \c std::map. With addition that
-/// you can specify a default value different from \c Value() .
+///you can specify a default value different from \c Value() .
-///
-/// \todo Provide allocator parameter...
 template <typename K, typename T, typename Compare = std::less<K> >
-class StdMap : public std::map<K, T, Compare> {
+class StdMap {
-typedef std::map<K, T, Compare> parent;
+template <typename K1, typename T1, typename C1>
-T v;
+friend class StdMap;
-typedef typename parent::value_type PairType;
+public:
-public:
+typedef True ReferenceMapTag;
 ///\e
 typedef K Key;
 ///\e
 typedef T Value;
 ///\e
 typedef T& Reference;
 ///\e
 typedef const T& ConstReference;
+private:
-StdMap() : v() {}
+typedef std::map<K, T, Compare> Map;
+Value _value;
+Map _map;
+public:
 /// Constructor with specified default value
-StdMap(const T& _v) : v(_v) {}
+StdMap(const T& value = T()) : _value(value) {}
-/// \brief Constructs the map from an appropriate std::map.
-///
-/// \warning Inefficient: copies the content of \c m !
-StdMap(const parent &m) : parent(m) {}
 /// \brief Constructs the map from an appropriate std::map, and explicitly
 /// specifies a default value.
-///
+template <typename T1, typename Comp1>
-/// \warning Inefficient: copies the content of \c m !
+StdMap(const std::map<Key, T1, Comp1> &map, const T& value = T())
-StdMap(const parent &m, const T& _v) : parent(m), v(_v) {}
+: _map(map.begin(), map.end()), _value(value) {}
+/// \brief Constructs a map from an other StdMap.
 template<typename T1, typename Comp1>
-StdMap(const StdMap<Key, T1,Comp1> &m, const T &_v) {
+StdMap(const StdMap<Key, T1, Comp1> &c)
-//FIXME;
+: _map(c._map.begin(), c._map.end()), _value(c._value) {}
+private:
+StdMap& operator=(const StdMap&);
+public:
+///\e
+Reference operator[](const Key &k) {
+typename Map::iterator it = _map.lower_bound(k);
+if (it != _map.end() && !_map.key_comp()(k, it->first))
+	return it->second;
+else
+	return _map.insert(it, std::make_pair(k, _value))->second;
 }
-Reference operator[](const Key &k) {
+/// \e
-return insert(PairType(k,v)).first -> second;
+ConstReference operator[](const Key &k) const {
+typename Map::const_iterator it = _map.find(k);
+if (it != _map.end())
+	return it->second;
+else
+	return _value;
 }
-ConstReference operator[](const Key &k) const {
+/// \e
-typename parent::iterator i = lower_bound(k);
+void set(const Key &k, const T &t) {
-if (i == parent::end() || parent::key_comp()(k, (*i).first))
+typename Map::iterator it = _map.lower_bound(k);
-	return v;
+if (it != _map.end() && !_map.key_comp()(k, it->first))
-return (*i).second;
+	it->second = t;
+else
+	_map.insert(it, std::make_pair(k, t));
 }
-void set(const Key &k, const T &t) {
-parent::operator[](k) = t;
+/// \e
-}
+void setAll(const T &t) {
+_value = t;
-/// Changes the default value of the map.
+_map.clear();
-/// \return Returns the previous default value.
+}
-///
-/// \warning The value of some keys (which has already been queried, but
+template <typename T1, typename C1 = std::less<T1> >
-/// the value has been unchanged from the default) may change!
-T setDefault(const T &_v) { T old=v; v=_v; return old; }
-template<typename T1>
 struct rebind {
-typedef StdMap<Key, T1,Compare> other;
+typedef StdMap<Key, T1, C1> other;
 };
 };
 /// @}
 public:
 typedef MapBase<T, T> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
+/// \e
 const T& operator[](const T& t) const {
 return t;
 }
 };
-///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>();
 }
 ///Convert the \c Value of a map to another type.
-///This \ref concepts::ReadMap "read only map"
+///This \c 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;
 /// \param k The key
 /// \return The target of the edge
 Value operator[](const Key& k) const {return m[k];}
 };
-///Returns an \ref ConvertMap class
+///Returns an \c ConvertMap class
-///This function just returns an \ref ConvertMap class.
+///This function just returns an \c ConvertMap class.
 ///\relates ConvertMap
-///\todo The order of the template parameters are changed.
 template<typename T, typename M>
 inline ConvertMap<M, T> convertMap(const M &m) {
 return ConvertMap<M, T>(m);
 }
 ///Simple wrapping of the map
-///This \ref concepts::ReadMap "read only map" returns the simple
+///This \c 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> {
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 SimpleMap(const M &_m) : m(_m) {};
+///\e
 Value operator[](Key k) const {return m[k];}
 };
 ///Simple writeable wrapping of the map
-///This \ref concepts::ReadMap "read only map" returns the simple
+///This \c 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> {
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 SimpleWriteMap(M &_m) : m(_m) {};
+///\e
 Value operator[](Key k) const {return m[k];}
+///\e
 void set(Key k, const Value& c) { m.set(k, c); }
 };
 ///Sum of two maps
-///This \ref concepts::ReadMap "read only map" returns the sum of the two
+///This \c 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> {
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 AddMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
+///\e
 Value operator[](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.
 ///\todo How to call these type of functions?
 ///
 ///\relates AddMap
-///\todo Wrong scope in Doxygen when \c \\relates is used
 template<typename M1, typename M2>
 inline AddMap<M1, M2> addMap(const M1 &m1,const M2 &m2) {
 return AddMap<M1, M2>(m1,m2);
 }
 ///Shift a map with a constant.
-///This \ref concepts::ReadMap "read only map" returns the sum of the
+///This \c 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
 ///Constructor
 ///\param _m is the undelying map
 ///\param _v is the shift value
 ShiftMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
+///\e
 Value operator[](Key k) const {return m[k] + v;}
 };
 ///Shift a map with a constant.
-///This \ref concepts::ReadWriteMap "read-write map" returns the sum of the
+///This \c 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
 ///Constructor
 ///\param _m is the undelying map
 ///\param _v is the shift value
 ShiftWriteMap(M &_m, const C &_v ) : m(_m), v(_v) {};
+/// \e
 Value operator[](Key k) const {return m[k] + v;}
+/// \e
 void set(Key k, const Value& c) { m.set(k, c - v); }
 };
-///Returns an \ref ShiftMap class
+///Returns an \c ShiftMap class
-///This function just returns an \ref ShiftMap class.
+///This function just returns an \c ShiftMap class.
 ///\relates ShiftMap
-///\todo A better name is required.
 template<typename M, typename C>
 inline ShiftMap<M, C> shiftMap(const M &m,const C &v) {
 return ShiftMap<M, C>(m,v);
 }
 return ShiftWriteMap<M, C>(m,v);
 }
 ///Difference of two maps
-///This \ref concepts::ReadMap "read only map" returns the difference
+///This \c 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>
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 SubMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
+/// \e
 Value operator[](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.
 ///
 ///\relates SubMap
 template<typename M1, typename M2>
 inline SubMap<M1, M2> subMap(const M1 &m1, const M2 &m2) {
 return SubMap<M1, M2>(m1, m2);
 }
 ///Product of two maps
-///This \ref concepts::ReadMap "read only map" returns the product of the
+///This \c 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.
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 MulMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
+/// \e
 Value operator[](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.
 ///\relates MulMap
 template<typename M1, typename M2>
 inline MulMap<M1, M2> mulMap(const M1 &m1,const M2 &m2) {
 return MulMap<M1, M2>(m1,m2);
 }
 ///Scales a maps with a constant.
-///This \ref concepts::ReadMap "read only map" returns the value of the
+///This \c 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
 ///Constructor
 ///\param _m is the undelying map
 ///\param _v is the scaling value
 ScaleMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
+/// \e
 Value operator[](Key k) const {return v * m[k];}
 };
 ///Scales a maps with a constant.
-///This \ref concepts::ReadWriteMap "read-write map" returns the value of the
+///This \c 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> {
 ///Constructor
 ///\param _m is the undelying map
 ///\param _v is the scaling value
 ScaleWriteMap(M &_m, const C &_v ) : m(_m), v(_v) {};
+/// \e
 Value operator[](Key k) const {return v * m[k];}
+/// \e
 void set(Key k, const Value& c) { m.set(k, c / v);}
 };
-///Returns an \ref ScaleMap class
+///Returns an \c ScaleMap class
-///This function just returns an \ref ScaleMap class.
+///This function just returns an \c ScaleMap class.
 ///\relates ScaleMap
-///\todo A better name is required.
 template<typename M, typename C>
 inline ScaleMap<M, C> scaleMap(const M &m,const C &v) {
 return ScaleMap<M, C>(m,v);
 }
 return ScaleWriteMap<M, C>(m,v);
 }
 ///Quotient of two maps
-///This \ref concepts::ReadMap "read only map" returns the quotient of the
+///This \c 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>
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 DivMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
+/// \e
 Value operator[](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.
 ///\relates DivMap
 template<typename M1, typename M2>
 inline DivMap<M1, M2> divMap(const M1 &m1,const M2 &m2) {
 return DivMap<M1, M2>(m1,m2);
 }
 ///Composition of two maps
-///This \ref concepts::ReadMap "read only map" returns the composition of
+///This \c 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
 ///
 ///Its \c Key is inherited from \c M2 and its \c Value is from
 ///\c M1.
 ///The \c M2::Value must be convertible to \c M1::Key.
 ///\todo Check the requirements.
 template <typename M1, typename M2>
 class ComposeMap : public MapBase<typename M2::Key, typename M1::Value> {
 const M1& m1;
 const M2& m2;
 public:
 ///Constructor
 ComposeMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
 typename MapTraits<M1>::ConstReturnValue
+/// \e
 operator[](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.
 ///
 ///\relates ComposeMap
 template <typename M1, typename M2>
 inline ComposeMap<M1, M2> composeMap(const M1 &m1,const M2 &m2) {
 return ComposeMap<M1, M2>(m1,m2);
 ///Combines of two maps using an STL (binary) functor.
 ///Combines of two maps using an STL (binary) functor.
 ///
 ///
-///This \ref concepts::ReadMap "read only map" takes two maps and a
+///This \c 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,
 ///Its \c Key is inherited from \c M1 and its \c Value is \c V.
 ///The \c M2::Value and \c M1::Value must be convertible to the corresponding
 ///input parameter of \c F and the return type of \c F must be convertible
 ///to \c V.
 ///\todo Check the requirements.
 template<typename M1, typename M2, typename F,
-	   typename V = typename F::result_type,
+	   typename V = typename F::result_type>
-	   typename NC = False>
 class CombineMap : public MapBase<typename M1::Key, V> {
 const M1& m1;
 const M2& m2;
 F f;
 public:
 typedef MapBase<typename M1::Key, V> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
-CombineMap(const M1 &_m1,const M2 &_m2,const F &_f)
+CombineMap(const M1 &_m1,const M2 &_m2,const F &_f = F())
 : m1(_m1), m2(_m2), f(_f) {};
+/// \e
 Value operator[](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.
-///
-///Only the first template parameter (the value type) must be given.
 ///
 ///For example if \c m1 and \c m2 are both \c double valued maps, then
 ///\code
-///combineMap<double>(m1,m2,std::plus<double>)
+///combineMap<double>(m1,m2,std::plus<double>())
 ///\endcode
 ///is equivalent with
 ///\code
 ///addMap(m1,m2)
 ///\endcode
+///
+///This function is specialized for adaptable binary function
+///classes and c++ functions.
 ///
 ///\relates CombineMap
 template<typename M1, typename M2, typename F, typename V>
 inline CombineMap<M1, M2, F, V>
 combineMap(const M1& m1,const M2& m2, const F& f) {
 return combineMap<M1, M2, V (*)(K1, K2), V>(m1,m2,f);
 }
 ///Negative value of a map
-///This \ref concepts::ReadMap "read only map" returns the negative
+///This \c 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.
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 NegMap(const M &_m) : m(_m) {};
+/// \e
 Value operator[](Key k) const {return -m[k];}
 };
 ///Negative value of a map
-///This \ref concepts::ReadWriteMap "read-write map" returns the negative
+///This \c 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>
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 NegWriteMap(M &_m) : m(_m) {};
+/// \e
 Value operator[](Key k) const {return -m[k];}
+/// \e
 void set(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.
 ///\relates NegMap
 template <typename M>
 inline NegMap<M> negMap(const M &m) {
 return NegMap<M>(m);
 }
 return NegWriteMap<M>(m);
 }
 ///Absolute value of a map
-///This \ref concepts::ReadMap "read only map" returns the absolute value
+///This \c 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>
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 AbsMap(const M &_m) : m(_m) {};
+/// \e
 Value operator[](Key k) const {
 Value tmp = m[k];
 return tmp >= 0 ? tmp : -tmp;
 }
 };
-///Returns a \ref AbsMap class
+///Returns a \c AbsMap class
-///This function just returns a \ref AbsMap class.
+///This function just returns a \c AbsMap class.
 ///\relates AbsMap
 template<typename M>
 inline AbsMap<M> absMap(const M &m) {
 return AbsMap<M>(m);
 }
 ///Converts an STL style functor to a map
-///This \ref concepts::ReadMap "read only map" returns the value
+///This \c 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
 ///because a functor does not provide such typedefs.
 ///
 ///Parameter \c F is the type of the used functor.
 template<typename F,
 	   typename K = typename F::argument_type,
-	   typename V = typename F::result_type,
+	   typename V = typename F::result_type>
-	   typename NC = False>
 class FunctorMap : public MapBase<K, V> {
 F f;
 public:
 typedef MapBase<K, V> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
-FunctorMap(const F &_f) : f(_f) {}
+FunctorMap(const F &_f = F()) : f(_f) {}
+/// \e
 Value operator[](Key k) const { return f(k);}
 };
-///Returns a \ref FunctorMap class
+///Returns a \c FunctorMap class
-///This function just returns a \ref FunctorMap class.
+///This function just returns a \c FunctorMap class.
 ///
-///The third template parameter isn't necessary to be given.
+///It is specialized for adaptable function classes and
+///c++ functions.
 ///\relates FunctorMap
 template<typename K, typename V, typename F> inline
 FunctorMap<F, K, V> functorMap(const F &f) {
 return FunctorMap<F, K, V>(f);
 }
 ///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 concepts::ReadMap "readable map",
+///a ususal \c 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;
 public:
 typedef MapBase<typename M::Key, typename M::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
-///\e
 typedef typename M::Key argument_type;
-///\e
 typedef typename M::Value result_type;
 ///Constructor
 MapFunctor(const M &_m) : m(_m) {};
-///Returns a value of the map
+///\e
 Value operator()(Key k) const {return m[k];}
 ///\e
 Value operator[](Key k) const {return m[k];}
 };
-///Returns a \ref MapFunctor class
+///Returns a \c MapFunctor class
-///This function just returns a \ref MapFunctor class.
+///This function just returns a \c MapFunctor class.
 ///\relates MapFunctor
 template<typename M>
 inline MapFunctor<M> mapFunctor(const M &m) {
 return MapFunctor<M>(m);
 }
 ///Applies all map setting operations to two maps
-///This map has two \ref concepts::ReadMap "readable map"
+///This map has two \c 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.
 template<typename  M1, typename M2>
 class ForkMap : public MapBase<typename M1::Key, typename M1::Value> {
 const M1& m1;
 const M2& m2;
 public:
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 ForkMap(const M1 &_m1, const M2 &_m2) : m1(_m1), m2(_m2) {};
+/// \e
 Value operator[](Key k) const {return m1[k];}
 };
 ///Applies all map setting operations to two maps
-///This map has two \ref concepts::WriteMap "writable map"
+///This map has two \c concepts::WriteMap "writable map"
 ///parameters and each write request will be passed to both of them.
-///If \c M1 is also \ref concepts::ReadMap "readable",
+///If \c M1 is also \c 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.
 template<typename  M1, typename M2>
 class ForkWriteMap : public MapBase<typename M1::Key, typename M1::Value> {
 M1& m1;
 M2& m2;
 public:
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 ForkWriteMap(M1 &_m1, M2 &_m2) : m1(_m1), m2(_m2) {};
+///\e
 Value operator[](Key k) const {return m1[k];}
+///\e
 void set(Key k, const Value &v) {m1.set(k,v); m2.set(k,v);}
 };
-///Returns an \ref ForkMap class
+///Returns an \c ForkMap class
-///This function just returns an \ref ForkMap class.
+///This function just returns an \c ForkMap class.
-///\todo How to call these type of functions?
 ///
 ///\relates ForkMap
-///\todo Wrong scope in Doxygen when \c \\relates is used
 template <typename M1, typename M2>
 inline ForkMap<M1, M2> forkMap(const M1 &m1, const M2 &m2) {
 return ForkMap<M1, M2>(m1,m2);
 }
 /* ************* BOOL MAPS ******************* */
 ///Logical 'not' of a map
-///This bool \ref concepts::ReadMap "read only map" returns the
+///This bool \c 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>.
 template <typename M>
 class NotMap : public MapBase<typename M::Key, bool> {
 const M& m;
 public:
 typedef MapBase<typename M::Key, bool> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 /// Constructor
 NotMap(const M &_m) : m(_m) {};
+///\e
 Value operator[](Key k) const {return !m[k];}
 };
 ///Logical 'not' of a map with writing possibility
-///This bool \ref concepts::ReadWriteMap "read-write map" returns the
+///This bool \c 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>
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 /// Constructor
 NotWriteMap(M &_m) : m(_m) {};
+///\e
 Value operator[](Key k) const {return !m[k];}
+///\e
 void set(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.
 ///\relates NotMap
 template <typename M>
 inline NotMap<M> notMap(const M &m) {
 return NotMap<M>(m);
 }
 ///     dfs.start();
 ///     ++filler.fillValue();
 ///   }
 /// }
 ///\endcode
 template <typename Map>
 class FillBoolMap {
 public:
 typedef typename Map::Key Key;
 typedef bool Value;
 /// \brief Writable bool map which stores for each true assigned elements
 /// the setting order number.
 ///
 /// Writable bool map which stores for each true assigned elements
 /// the setting order number. It make easy to calculate the leaving
-/// order of the nodes in the \ref dfs "Dfs" algorithm.
+/// order of the nodes in the \c Dfs algorithm.
 ///
 ///\code
 /// typedef Graph::NodeMap<int> OrderMap;
 /// OrderMap order(graph);
 /// typedef SettingOrderBoolMap<OrderMap> OrderSetterMap;

changeset 2499	c97596611d59
parent 2423	02fedd6652c6
child 2511	a99186a9b6b0