Changeset 2489:48dddc283cfc in lemon-0.x

Timestamp:

10/09/07 17:46:12 (17 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3328

Message:

Bug fix and redesign StdMap?
Improving map adaptors documentations

Files:

• doc/groups.dox (modified) (2 diffs)
• lemon/maps.h (modified) (64 diffs)

doc/groups.dox

@@ -98 +98 @@
 addition, multiplication etc.) or e.g. convert a map to another one
 of different Value type.
+
+The typical usage of this classes is the passing implicit maps to
+algorithms.  If a function type algorithm is called then the function
+type map adaptors can be used comfortable. For example let's see the
+usage of map adaptors with the \c graphToEps() function:
+\code
+  Color nodeColor(int deg) {
+    if (deg >= 2) {
+      return Color(0.5, 0.0, 0.5);
+    } else if (deg == 1) {
+      return Color(1.0, 0.5, 1.0);
+    } else {
+      return Color(0.0, 0.0, 0.0);
+    }
+  }
+  
+  Graph::NodeMap<int> degree_map(graph);
+  
+  graphToEps(graph, "graph.eps")
+    .coords(coords).scaleToA4().undirected()
+    .nodeColors(composeMap(functorMap(nodeColor), degree_map)) 
+    .run();
+\endcode 
+The \c functorMap() function makes an \c int to \c Color map from the
+\e nodeColor() function. The \c composeMap() compose the \e degree_map
+and the previous created map. The composed map is proper function to
+get color of each node.
+
+The usage with class type algorithms is little bit harder. In this
+case the function type map adaptors can not be used, because the
+function map adaptors give back temporarly objects.
+\code
+  Graph graph;
+  
+  typedef Graph::EdgeMap<double> DoubleEdgeMap;
+  DoubleEdgeMap length(graph);
+  DoubleEdgeMap speed(graph);
+  
+  typedef DivMap<DoubleEdgeMap, DoubleEdgeMap> TimeMap;
+  
+  TimeMap time(length, speed);
+  
+  Dijkstra<Graph, TimeMap> dijkstra(graph, time);
+  dijkstra.run(source, target);
+\endcode
+
+We have a length map and a maximum speed map on a graph. The minimum
+time to pass the edge can be calculated as the division of the two
+maps which can be done implicitly with the \c DivMap template
+class. We use the implicit minimum time map as the length map of the
+\c Dijkstra algorithm.
 */
 
@@ -116 +167 @@
 to work with paths.
 
-All of them have the same interface, especially they can be built or extended
-using a standard Builder subclass. This make is easy to have e.g. the Dijkstra
-algorithm to store its result in any kind of path structure.
+All of them have similar interfaces, and it can be copied easily with
+assignment operator and copy constructor. This make it easy and
+efficient to have e.g. the Dijkstra algorithm to store its result in
+any kind of path structure.
 
 \sa lemon::concepts::Path

lemon/maps.h

@@ -30 +30 @@
 ///\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 +77 @@
 
   /// 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 +98 @@
     ///
     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 +116 @@
   };
 
-  ///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 +126 @@
 
 
-  //\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 +141 @@
 
     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 +156 @@
   }
 
-  /// \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 +176 @@
     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 +258 @@
     typedef typename Parent::Value Value;
 
+    /// \e
     const T& operator[](const T& t) const {
       return t;
@@ -241 +264 @@
   };
 
-  ///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 +276 @@
   ///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 +301 @@
   };
   
-  ///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 +312 @@
   ///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 +327 @@
     ///Constructor
     SimpleMap(const M &_m) : m(_m) {};
+    ///\e
     Value operator[](Key k) const {return m[k];}
   };
@@ -310 +333 @@
   ///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 +348 @@
     ///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 +356 @@
   ///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 +372 @@
     ///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 +389 @@
   ///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 +417 @@
     ///\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 +423 @@
   ///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 +451 @@
     ///\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 +473 @@
   ///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 +489 @@
     ///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 +505 @@
   ///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 +522 @@
     ///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 +537 @@
   ///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 +565 @@
     ///\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 +571 @@
   ///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 +590 @@
     ///\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 +612 @@
   ///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 +628 @@
     ///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 +643 @@
   ///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 +657 @@
   ///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 +670 @@
     
     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 +688 @@
   ///
   ///
-  ///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 +705 @@
   ///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 +717 @@
 
     ///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 +735 @@
   ///addMap(m1,m2)
   ///\endcode
+  ///
+  ///This function is specialized for adaptable binary function
+  ///classes and c++ functions.
   ///
   ///\relates CombineMap
@@ -728 +760 @@
   ///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 +776 @@
     ///Constructor
     NegMap(const M &_m) : m(_m) {};
+    /// \e
     Value operator[](Key k) const {return -m[k];}
   };
@@ -749 +782 @@
   ///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 +797 @@
     ///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 +819 @@
   ///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 +850 @@
     ///Constructor
     AbsMap(const M &_m) : m(_m) {};
+    /// \e
     Value operator[](Key k) const {
       Value tmp = m[k]; 
@@ -822 +858 @@
   };
   
-  ///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 +869 @@
   ///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 +878 @@
   ///
   ///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 +889 @@
 
     ///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 +925 @@
   ///
   ///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 +935 @@
     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 +946 @@
   };
   
-  ///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 +957 @@
   ///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 +963 @@
   ///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 +974 @@
     ///Constructor
     ForkMap(const M1 &_m1, const M2 &_m2) : m1(_m1), m2(_m2) {};
+    /// \e
     Value operator[](Key k) const {return m1[k];}
   };
@@ -950 +981 @@
   ///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 +989 @@
   ///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 +1000 @@
     ///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 +1027 @@
   ///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 +1042 @@
     /// Constructor
     NotMap(const M &_m) : m(_m) {};
+    ///\e
     Value operator[](Key k) const {return !m[k];}
   };
@@ -1018 +1048 @@
   ///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 +1063 @@
     /// 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 +1310 @@
   /// }
   ///\endcode
-
   template <typename Map>
   class FillBoolMap {
@@ -1326 +1357 @@
   /// 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