Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 2423)
+++ lemon/maps.h	(revision 2489)
@@ -30,7 +30,4 @@
 ///\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>
 
@@ -80,6 +77,5 @@
 
   /// This is a readable map which assigns a specified value to each key.
-  /// In other aspects it is equivalent to the \ref NullMap.
-  /// \todo set could be used to set the value.
+  /// In other aspects it is equivalent to the \c NullMap.
   template<typename K, typename T>
   class ConstMap : public MapBase<K, T> {
@@ -102,7 +98,12 @@
     ///
     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>
@@ -115,7 +116,7 @@
   };
 
-  ///Returns a \ref ConstMap class
-
-  ///This function just returns a \ref ConstMap class.
+  ///Returns a \c ConstMap class
+
+  ///This function just returns a \c ConstMap class.
   ///\relates ConstMap
   template<typename K, typename V> 
@@ -125,9 +126,11 @@
 
 
-  //\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> {
@@ -138,11 +141,13 @@
 
     ConstMap() { }
+    ///\e
     V operator[](const K&) const { return v; }
+    ///\e
     void set(const K&, const V&) { }
   };
 
-  ///Returns a \ref ConstMap class
-
-  ///This function just returns a \ref ConstMap class.
+  ///Returns a \c ConstMap class
+
+  ///This function just returns a \c ConstMap class with inlined value.
   ///\relates ConstMap
   template<typename K, typename V, V v> 
@@ -151,17 +156,15 @@
   }
 
-  /// \c std::map wrapper
-
-  /// This is essentially a wrapper for \c std::map. With addition that
-  /// you can specify a default value different from \c Value() .
-  ///
-  /// \todo Provide allocator parameter...
+  ///Map based on 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 std::map<K, T, Compare> {
-    typedef std::map<K, T, Compare> parent;
-    T v;
-    typedef typename parent::value_type PairType;
-
-  public:
+  class StdMap {
+    template <typename K1, typename T1, typename C1>
+    friend class StdMap;
+  public:
+
+    typedef True ReferenceMapTag;
     ///\e
     typedef K Key;
@@ -173,48 +176,67 @@
     typedef const T& ConstReference;
 
-
-    StdMap() : v() {}
+  private:
+    
+    typedef std::map<K, T, Compare> Map;
+    Value _value;
+    Map _map;
+
+  public:
+
     /// Constructor with specified default value
-    StdMap(const T& _v) : v(_v) {}
-
-    /// \brief Constructs the map from an appropriate std::map.
-    ///
-    /// \warning Inefficient: copies the content of \c m !
-    StdMap(const parent &m) : parent(m) {}
+    StdMap(const T& value = T()) : _value(value) {}
     /// \brief Constructs the map from an appropriate std::map, and explicitly
     /// specifies a default value.
-    ///
-    /// \warning Inefficient: copies the content of \c m !
-    StdMap(const parent &m, const T& _v) : parent(m), v(_v) {}
+    template <typename T1, typename Comp1>
+    StdMap(const std::map<Key, T1, Comp1> &map, const T& value = T()) 
+      : _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) { 
-      //FIXME; 
+    StdMap(const StdMap<Key, T1, Comp1> &c) 
+      : _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) {
-      return insert(PairType(k,v)).first -> second;
+    /// \e 
+    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 {
-      typename parent::iterator i = lower_bound(k);
-      if (i == parent::end() || parent::key_comp()(k, (*i).first))
-	return v;
-      return (*i).second;
+    /// \e 
+    void set(const Key &k, const T &t) {
+      typename Map::iterator it = _map.lower_bound(k);
+      if (it != _map.end() && !_map.key_comp()(k, it->first))
+	it->second = t;
+      else
+	_map.insert(it, std::make_pair(k, t));
     }
-    void set(const Key &k, const T &t) {
-      parent::operator[](k) = t;
-    }
-
-    /// Changes the default value of the map.
-    /// \return Returns the previous default value.
-    ///
-    /// \warning The value of some keys (which has already been queried, but
-    /// 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>
+
+    /// \e
+    void setAll(const T &t) {
+      _value = t;
+      _map.clear();
+    }    
+
+    template <typename T1, typename C1 = std::less<T1> >
     struct rebind {
-      typedef StdMap<Key, T1,Compare> other;
+      typedef StdMap<Key, T1, C1> other;
     };
   };
@@ -236,4 +258,5 @@
     typedef typename Parent::Value Value;
 
+    /// \e
     const T& operator[](const T& t) const {
       return t;
@@ -241,7 +264,7 @@
   };
 
-  ///Returns an \ref IdentityMap class
-
-  ///This function just returns an \ref IdentityMap class.
+  ///Returns an \c IdentityMap class
+
+  ///This function just returns an \c IdentityMap class.
   ///\relates IdentityMap
   template<typename T>
@@ -253,5 +276,5 @@
   ///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.
@@ -278,9 +301,8 @@
   };
   
-  ///Returns an \ref ConvertMap class
-
-  ///This function just returns an \ref ConvertMap class.
+  ///Returns an \c 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) {
@@ -290,5 +312,5 @@
   ///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
@@ -305,4 +327,5 @@
     ///Constructor
     SimpleMap(const M &_m) : m(_m) {};
+    ///\e
     Value operator[](Key k) const {return m[k];}
   };
@@ -310,5 +333,5 @@
   ///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
@@ -325,5 +348,7 @@
     ///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); }
   };
@@ -331,5 +356,5 @@
   ///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.
@@ -347,14 +372,14 @@
     ///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
-
-  ///This function just returns an \ref AddMap class.
+  ///Returns an \c 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) {
@@ -364,5 +389,5 @@
   ///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.
@@ -392,4 +417,5 @@
     ///\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;}
   };
@@ -397,5 +423,5 @@
   ///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.
@@ -425,13 +451,14 @@
     ///\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
-
-  ///This function just returns an \ref ShiftMap class.
+  ///Returns an \c 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) {
@@ -446,5 +473,5 @@
   ///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.
@@ -462,10 +489,11 @@
     ///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
-
-  ///This function just returns a \ref SubMap class.
+  ///Returns a \c SubMap class
+
+  ///This function just returns a \c SubMap class.
   ///
   ///\relates SubMap
@@ -477,5 +505,5 @@
   ///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
@@ -494,10 +522,11 @@
     ///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
-
-  ///This function just returns a \ref MulMap class.
+  ///Returns a \c MulMap class
+
+  ///This function just returns a \c MulMap class.
   ///\relates MulMap
   template<typename M1, typename M2> 
@@ -508,5 +537,5 @@
   ///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.
@@ -536,4 +565,5 @@
     ///\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];}
   };
@@ -541,5 +571,5 @@
   ///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.
@@ -560,13 +590,14 @@
     ///\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
-
-  ///This function just returns an \ref ScaleMap class.
+  ///Returns an \c 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) {
@@ -581,5 +612,5 @@
   ///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.
@@ -597,10 +628,11 @@
     ///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
-
-  ///This function just returns a \ref DivMap class.
+  ///Returns a \c DivMap class
+
+  ///This function just returns a \c DivMap class.
   ///\relates DivMap
   template<typename M1, typename M2> 
@@ -611,5 +643,5 @@
   ///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
@@ -625,5 +657,4 @@
   ///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> {
@@ -639,9 +670,10 @@
     
     typename MapTraits<M1>::ConstReturnValue
+    /// \e
     operator[](Key k) const {return m1[m2[k]];}
   };
-  ///Returns a \ref ComposeMap class
-
-  ///This function just returns a \ref ComposeMap class.
+  ///Returns a \c ComposeMap class
+
+  ///This function just returns a \c ComposeMap class.
   ///
   ///\relates ComposeMap
@@ -656,5 +688,5 @@
   ///
   ///
-  ///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
@@ -673,8 +705,6 @@
   ///to \c V.
   ///\todo Check the requirements.
-
   template<typename M1, typename M2, typename F,
-	   typename V = typename F::result_type,
-	   typename NC = False> 
+	   typename V = typename F::result_type> 
   class CombineMap : public MapBase<typename M1::Key, V> {
     const M1& m1;
@@ -687,18 +717,17 @@
 
     ///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
-
-  ///This function just returns a \ref CombineMap class.
-  ///
-  ///Only the first template parameter (the value type) must be given.
+  ///Returns a \c CombineMap class
+
+  ///This function just returns a \c CombineMap class.
   ///
   ///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
@@ -706,4 +735,7 @@
   ///addMap(m1,m2)
   ///\endcode
+  ///
+  ///This function is specialized for adaptable binary function
+  ///classes and c++ functions.
   ///
   ///\relates CombineMap
@@ -728,5 +760,5 @@
   ///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
@@ -744,4 +776,5 @@
     ///Constructor
     NegMap(const M &_m) : m(_m) {};
+    /// \e
     Value operator[](Key k) const {return -m[k];}
   };
@@ -749,5 +782,5 @@
   ///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.
@@ -764,11 +797,13 @@
     ///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
-
-  ///This function just returns a \ref NegMap class.
+  ///Returns a \c NegMap class
+
+  ///This function just returns a \c NegMap class.
   ///\relates NegMap
   template <typename M> 
@@ -784,5 +819,5 @@
   ///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
@@ -815,4 +850,5 @@
     ///Constructor
     AbsMap(const M &_m) : m(_m) {};
+    /// \e
     Value operator[](Key k) const {
       Value tmp = m[k]; 
@@ -822,7 +858,7 @@
   };
   
-  ///Returns a \ref AbsMap class
-
-  ///This function just returns a \ref AbsMap class.
+  ///Returns a \c AbsMap class
+
+  ///This function just returns a \c AbsMap class.
   ///\relates AbsMap
   template<typename M> 
@@ -833,5 +869,5 @@
   ///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.
@@ -842,10 +878,7 @@
   ///
   ///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 NC = False> 
+	   typename V = typename F::result_type> 
   class FunctorMap : public MapBase<K, V> {
     F f;
@@ -856,14 +889,15 @@
 
     ///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
-
-  ///This function just returns a \ref FunctorMap class.
-  ///
-  ///The third template parameter isn't necessary to be given.
+  ///Returns a \c FunctorMap class
+
+  ///This function just returns a \c FunctorMap class.
+  ///
+  ///It is specialized for adaptable function classes and
+  ///c++ functions.
   ///\relates FunctorMap
   template<typename K, typename V, typename F> inline 
@@ -891,7 +925,6 @@
   ///
   ///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> {
@@ -902,12 +935,10 @@
     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
@@ -915,7 +946,7 @@
   };
   
-  ///Returns a \ref MapFunctor class
-
-  ///This function just returns a \ref MapFunctor class.
+  ///Returns a \c MapFunctor class
+
+  ///This function just returns a \c MapFunctor class.
   ///\relates MapFunctor
   template<typename M> 
@@ -926,5 +957,5 @@
   ///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.
@@ -932,5 +963,4 @@
   ///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> {
@@ -944,4 +974,5 @@
     ///Constructor
     ForkMap(const M1 &_m1, const M2 &_m2) : m1(_m1), m2(_m2) {};
+    /// \e
     Value operator[](Key k) const {return m1[k];}
   };
@@ -950,7 +981,7 @@
   ///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.
@@ -958,5 +989,4 @@
   ///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> {
@@ -970,15 +1000,15 @@
     ///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
-
-  ///This function just returns an \ref ForkMap class.
-  ///\todo How to call these type of functions?
+  ///Returns an \c ForkMap class
+
+  ///This function just returns an \c ForkMap class.
   ///
   ///\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) {
@@ -997,10 +1027,9 @@
   ///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> {
@@ -1013,4 +1042,5 @@
     /// Constructor
     NotMap(const M &_m) : m(_m) {};
+    ///\e
     Value operator[](Key k) const {return !m[k];}
   };
@@ -1018,5 +1048,5 @@
   ///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.
@@ -1033,11 +1063,13 @@
     /// 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
-  
-  ///This function just returns a \ref NotMap class.
+  ///Returns a \c NotMap class
+  
+  ///This function just returns a \c NotMap class.
   ///\relates NotMap
   template <typename M> 
@@ -1278,5 +1310,4 @@
   /// }
   ///\endcode
-
   template <typename Map>
   class FillBoolMap {
@@ -1326,5 +1357,5 @@
   /// 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
