COIN-OR::LEMON - Graph Library

Changeset 2489:48dddc283cfc in lemon-0.x for lemon


Ignore:
Timestamp:
10/09/07 17:46:12 (12 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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/maps.h

    r2423 r2489  
    3030///\brief Miscellaneous property maps
    3131///
    32 ///\todo This file has the same name as the concept file in concepts/,
    33 /// and this is not easily detectable in docs...
    34 
    3532#include <map>
    3633
     
    8077
    8178  /// This is a readable map which assigns a specified value to each key.
    82   /// In other aspects it is equivalent to the \ref NullMap.
    83   /// \todo set could be used to set the value.
     79  /// In other aspects it is equivalent to the \c NullMap.
    8480  template<typename K, typename T>
    8581  class ConstMap : public MapBase<K, T> {
     
    10298    ///
    10399    ConstMap(const T &_v) : v(_v) {}
    104 
     100   
     101    ///\e
    105102    T operator[](const K&) const { return v; }
    106     void set(const K&, const T&) {}
     103
     104    ///\e
     105    void setAll(const T &t) {
     106      v = t;
     107    }   
    107108
    108109    template<typename T1>
     
    115116  };
    116117
    117   ///Returns a \ref ConstMap class
    118 
    119   ///This function just returns a \ref ConstMap class.
     118  ///Returns a \c ConstMap class
     119
     120  ///This function just returns a \c ConstMap class.
    120121  ///\relates ConstMap
    121122  template<typename K, typename V>
     
    125126
    126127
    127   //\todo to document later
    128128  template<typename T, T v>
    129129  struct Const { };
    130130
    131   //\todo to document later
     131  /// Constant map with inlined constant value.
     132
     133  /// This is a readable map which assigns a specified value to each key.
     134  /// In other aspects it is equivalent to the \c NullMap.
    132135  template<typename K, typename V, V v>
    133136  class ConstMap<K, Const<V, v> > : public MapBase<K, V> {
     
    138141
    139142    ConstMap() { }
     143    ///\e
    140144    V operator[](const K&) const { return v; }
     145    ///\e
    141146    void set(const K&, const V&) { }
    142147  };
    143148
    144   ///Returns a \ref ConstMap class
    145 
    146   ///This function just returns a \ref ConstMap class.
     149  ///Returns a \c ConstMap class
     150
     151  ///This function just returns a \c ConstMap class with inlined value.
    147152  ///\relates ConstMap
    148153  template<typename K, typename V, V v>
     
    151156  }
    152157
    153   /// \c std::map wrapper
    154 
    155   /// This is essentially a wrapper for \c std::map. With addition that
    156   /// you can specify a default value different from \c Value() .
    157   ///
    158   /// \todo Provide allocator parameter...
     158  ///Map based on std::map
     159
     160  ///This is essentially a wrapper for \c std::map. With addition that
     161  ///you can specify a default value different from \c Value() .
    159162  template <typename K, typename T, typename Compare = std::less<K> >
    160   class StdMap : public std::map<K, T, Compare> {
    161     typedef std::map<K, T, Compare> parent;
    162     T v;
    163     typedef typename parent::value_type PairType;
    164 
    165   public:
     163  class StdMap {
     164    template <typename K1, typename T1, typename C1>
     165    friend class StdMap;
     166  public:
     167
     168    typedef True ReferenceMapTag;
    166169    ///\e
    167170    typedef K Key;
     
    173176    typedef const T& ConstReference;
    174177
    175 
    176     StdMap() : v() {}
     178  private:
     179   
     180    typedef std::map<K, T, Compare> Map;
     181    Value _value;
     182    Map _map;
     183
     184  public:
     185
    177186    /// Constructor with specified default value
    178     StdMap(const T& _v) : v(_v) {}
    179 
    180     /// \brief Constructs the map from an appropriate std::map.
    181     ///
    182     /// \warning Inefficient: copies the content of \c m !
    183     StdMap(const parent &m) : parent(m) {}
     187    StdMap(const T& value = T()) : _value(value) {}
    184188    /// \brief Constructs the map from an appropriate std::map, and explicitly
    185189    /// specifies a default value.
    186     ///
    187     /// \warning Inefficient: copies the content of \c m !
    188     StdMap(const parent &m, const T& _v) : parent(m), v(_v) {}
     190    template <typename T1, typename Comp1>
     191    StdMap(const std::map<Key, T1, Comp1> &map, const T& value = T())
     192      : _map(map.begin(), map.end()), _value(value) {}
    189193   
     194    /// \brief Constructs a map from an other StdMap.
    190195    template<typename T1, typename Comp1>
    191     StdMap(const StdMap<Key, T1,Comp1> &m, const T &_v) {
    192       //FIXME;
     196    StdMap(const StdMap<Key, T1, Comp1> &c)
     197      : _map(c._map.begin(), c._map.end()), _value(c._value) {}
     198
     199  private:
     200
     201    StdMap& operator=(const StdMap&);
     202
     203  public:
     204
     205    ///\e
     206    Reference operator[](const Key &k) {
     207      typename Map::iterator it = _map.lower_bound(k);
     208      if (it != _map.end() && !_map.key_comp()(k, it->first))
     209        return it->second;
     210      else
     211        return _map.insert(it, std::make_pair(k, _value))->second;
    193212    }
    194213
    195     Reference operator[](const Key &k) {
    196       return insert(PairType(k,v)).first -> second;
     214    /// \e
     215    ConstReference operator[](const Key &k) const {
     216      typename Map::const_iterator it = _map.find(k);
     217      if (it != _map.end())
     218        return it->second;
     219      else
     220        return _value;
    197221    }
    198222
    199     ConstReference operator[](const Key &k) const {
    200       typename parent::iterator i = lower_bound(k);
    201       if (i == parent::end() || parent::key_comp()(k, (*i).first))
    202         return v;
    203       return (*i).second;
     223    /// \e
     224    void set(const Key &k, const T &t) {
     225      typename Map::iterator it = _map.lower_bound(k);
     226      if (it != _map.end() && !_map.key_comp()(k, it->first))
     227        it->second = t;
     228      else
     229        _map.insert(it, std::make_pair(k, t));
    204230    }
    205     void set(const Key &k, const T &t) {
    206       parent::operator[](k) = t;
    207     }
    208 
    209     /// Changes the default value of the map.
    210     /// \return Returns the previous default value.
    211     ///
    212     /// \warning The value of some keys (which has already been queried, but
    213     /// the value has been unchanged from the default) may change!
    214     T setDefault(const T &_v) { T old=v; v=_v; return old; }
    215 
    216     template<typename T1>
     231
     232    /// \e
     233    void setAll(const T &t) {
     234      _value = t;
     235      _map.clear();
     236    }   
     237
     238    template <typename T1, typename C1 = std::less<T1> >
    217239    struct rebind {
    218       typedef StdMap<Key, T1,Compare> other;
     240      typedef StdMap<Key, T1, C1> other;
    219241    };
    220242  };
     
    236258    typedef typename Parent::Value Value;
    237259
     260    /// \e
    238261    const T& operator[](const T& t) const {
    239262      return t;
     
    241264  };
    242265
    243   ///Returns an \ref IdentityMap class
    244 
    245   ///This function just returns an \ref IdentityMap class.
     266  ///Returns an \c IdentityMap class
     267
     268  ///This function just returns an \c IdentityMap class.
    246269  ///\relates IdentityMap
    247270  template<typename T>
     
    253276  ///Convert the \c Value of a map to another type.
    254277
    255   ///This \ref concepts::ReadMap "read only map"
     278  ///This \c concepts::ReadMap "read only map"
    256279  ///converts the \c Value of a maps to type \c T.
    257280  ///Its \c Key is inherited from \c M.
     
    278301  };
    279302 
    280   ///Returns an \ref ConvertMap class
    281 
    282   ///This function just returns an \ref ConvertMap class.
     303  ///Returns an \c ConvertMap class
     304
     305  ///This function just returns an \c ConvertMap class.
    283306  ///\relates ConvertMap
    284   ///\todo The order of the template parameters are changed.
    285307  template<typename T, typename M>
    286308  inline ConvertMap<M, T> convertMap(const M &m) {
     
    290312  ///Simple wrapping of the map
    291313
    292   ///This \ref concepts::ReadMap "read only map" returns the simple
     314  ///This \c concepts::ReadMap "read only map" returns the simple
    293315  ///wrapping of the given map. Sometimes the reference maps cannot be
    294316  ///combined with simple read maps. This map adaptor wraps the given
     
    305327    ///Constructor
    306328    SimpleMap(const M &_m) : m(_m) {};
     329    ///\e
    307330    Value operator[](Key k) const {return m[k];}
    308331  };
     
    310333  ///Simple writeable wrapping of the map
    311334
    312   ///This \ref concepts::ReadMap "read only map" returns the simple
     335  ///This \c concepts::ReadMap "read only map" returns the simple
    313336  ///wrapping of the given map. Sometimes the reference maps cannot be
    314337  ///combined with simple read-write maps. This map adaptor wraps the
     
    325348    ///Constructor
    326349    SimpleWriteMap(M &_m) : m(_m) {};
     350    ///\e
    327351    Value operator[](Key k) const {return m[k];}
     352    ///\e
    328353    void set(Key k, const Value& c) { m.set(k, c); }
    329354  };
     
    331356  ///Sum of two maps
    332357
    333   ///This \ref concepts::ReadMap "read only map" returns the sum of the two
     358  ///This \c concepts::ReadMap "read only map" returns the sum of the two
    334359  ///given maps. Its \c Key and \c Value will be inherited from \c M1.
    335360  ///The \c Key and \c Value of M2 must be convertible to those of \c M1.
     
    347372    ///Constructor
    348373    AddMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
     374    ///\e
    349375    Value operator[](Key k) const {return m1[k]+m2[k];}
    350376  };
    351377 
    352   ///Returns an \ref AddMap class
    353 
    354   ///This function just returns an \ref AddMap class.
     378  ///Returns an \c AddMap class
     379
     380  ///This function just returns an \c AddMap class.
    355381  ///\todo How to call these type of functions?
    356382  ///
    357383  ///\relates AddMap
    358   ///\todo Wrong scope in Doxygen when \c \\relates is used
    359384  template<typename M1, typename M2>
    360385  inline AddMap<M1, M2> addMap(const M1 &m1,const M2 &m2) {
     
    364389  ///Shift a map with a constant.
    365390
    366   ///This \ref concepts::ReadMap "read only map" returns the sum of the
     391  ///This \c concepts::ReadMap "read only map" returns the sum of the
    367392  ///given map and a constant value.
    368393  ///Its \c Key and \c Value is inherited from \c M.
     
    392417    ///\param _v is the shift value
    393418    ShiftMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
     419    ///\e
    394420    Value operator[](Key k) const {return m[k] + v;}
    395421  };
     
    397423  ///Shift a map with a constant.
    398424
    399   ///This \ref concepts::ReadWriteMap "read-write map" returns the sum of the
     425  ///This \c concepts::ReadWriteMap "read-write map" returns the sum of the
    400426  ///given map and a constant value. It makes also possible to write the map.
    401427  ///Its \c Key and \c Value is inherited from \c M.
     
    425451    ///\param _v is the shift value
    426452    ShiftWriteMap(M &_m, const C &_v ) : m(_m), v(_v) {};
     453    /// \e
    427454    Value operator[](Key k) const {return m[k] + v;}
     455    /// \e
    428456    void set(Key k, const Value& c) { m.set(k, c - v); }
    429457  };
    430458 
    431   ///Returns an \ref ShiftMap class
    432 
    433   ///This function just returns an \ref ShiftMap class.
     459  ///Returns an \c ShiftMap class
     460
     461  ///This function just returns an \c ShiftMap class.
    434462  ///\relates ShiftMap
    435   ///\todo A better name is required.
    436463  template<typename M, typename C>
    437464  inline ShiftMap<M, C> shiftMap(const M &m,const C &v) {
     
    446473  ///Difference of two maps
    447474
    448   ///This \ref concepts::ReadMap "read only map" returns the difference
     475  ///This \c concepts::ReadMap "read only map" returns the difference
    449476  ///of the values of the two
    450477  ///given maps. Its \c Key and \c Value will be inherited from \c M1.
     
    462489    ///Constructor
    463490    SubMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
     491    /// \e
    464492    Value operator[](Key k) const {return m1[k]-m2[k];}
    465493  };
    466494 
    467   ///Returns a \ref SubMap class
    468 
    469   ///This function just returns a \ref SubMap class.
     495  ///Returns a \c SubMap class
     496
     497  ///This function just returns a \c SubMap class.
    470498  ///
    471499  ///\relates SubMap
     
    477505  ///Product of two maps
    478506
    479   ///This \ref concepts::ReadMap "read only map" returns the product of the
     507  ///This \c concepts::ReadMap "read only map" returns the product of the
    480508  ///values of the two
    481509  ///given
     
    494522    ///Constructor
    495523    MulMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
     524    /// \e
    496525    Value operator[](Key k) const {return m1[k]*m2[k];}
    497526  };
    498527 
    499   ///Returns a \ref MulMap class
    500 
    501   ///This function just returns a \ref MulMap class.
     528  ///Returns a \c MulMap class
     529
     530  ///This function just returns a \c MulMap class.
    502531  ///\relates MulMap
    503532  template<typename M1, typename M2>
     
    508537  ///Scales a maps with a constant.
    509538
    510   ///This \ref concepts::ReadMap "read only map" returns the value of the
     539  ///This \c concepts::ReadMap "read only map" returns the value of the
    511540  ///given map multiplied from the left side with a constant value.
    512541  ///Its \c Key and \c Value is inherited from \c M.
     
    536565    ///\param _v is the scaling value
    537566    ScaleMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
     567    /// \e
    538568    Value operator[](Key k) const {return v * m[k];}
    539569  };
     
    541571  ///Scales a maps with a constant.
    542572
    543   ///This \ref concepts::ReadWriteMap "read-write map" returns the value of the
     573  ///This \c concepts::ReadWriteMap "read-write map" returns the value of the
    544574  ///given map multiplied from the left side with a constant value. It can
    545575  ///be used as write map also if the given multiplier is not zero.
     
    560590    ///\param _v is the scaling value
    561591    ScaleWriteMap(M &_m, const C &_v ) : m(_m), v(_v) {};
     592    /// \e
    562593    Value operator[](Key k) const {return v * m[k];}
     594    /// \e
    563595    void set(Key k, const Value& c) { m.set(k, c / v);}
    564596  };
    565597 
    566   ///Returns an \ref ScaleMap class
    567 
    568   ///This function just returns an \ref ScaleMap class.
     598  ///Returns an \c ScaleMap class
     599
     600  ///This function just returns an \c ScaleMap class.
    569601  ///\relates ScaleMap
    570   ///\todo A better name is required.
    571602  template<typename M, typename C>
    572603  inline ScaleMap<M, C> scaleMap(const M &m,const C &v) {
     
    581612  ///Quotient of two maps
    582613
    583   ///This \ref concepts::ReadMap "read only map" returns the quotient of the
     614  ///This \c concepts::ReadMap "read only map" returns the quotient of the
    584615  ///values of the two
    585616  ///given maps. Its \c Key and \c Value will be inherited from \c M1.
     
    597628    ///Constructor
    598629    DivMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
     630    /// \e
    599631    Value operator[](Key k) const {return m1[k]/m2[k];}
    600632  };
    601633 
    602   ///Returns a \ref DivMap class
    603 
    604   ///This function just returns a \ref DivMap class.
     634  ///Returns a \c DivMap class
     635
     636  ///This function just returns a \c DivMap class.
    605637  ///\relates DivMap
    606638  template<typename M1, typename M2>
     
    611643  ///Composition of two maps
    612644
    613   ///This \ref concepts::ReadMap "read only map" returns the composition of
     645  ///This \c concepts::ReadMap "read only map" returns the composition of
    614646  ///two
    615647  ///given maps. That is to say, if \c m1 is of type \c M1 and \c m2 is
     
    625657  ///The \c M2::Value must be convertible to \c M1::Key.
    626658  ///\todo Check the requirements.
    627 
    628659  template <typename M1, typename M2>
    629660  class ComposeMap : public MapBase<typename M2::Key, typename M1::Value> {
     
    639670   
    640671    typename MapTraits<M1>::ConstReturnValue
     672    /// \e
    641673    operator[](Key k) const {return m1[m2[k]];}
    642674  };
    643   ///Returns a \ref ComposeMap class
    644 
    645   ///This function just returns a \ref ComposeMap class.
     675  ///Returns a \c ComposeMap class
     676
     677  ///This function just returns a \c ComposeMap class.
    646678  ///
    647679  ///\relates ComposeMap
     
    656688  ///
    657689  ///
    658   ///This \ref concepts::ReadMap "read only map" takes two maps and a
     690  ///This \c concepts::ReadMap "read only map" takes two maps and a
    659691  ///binary functor and returns the composition of
    660692  ///the two
     
    673705  ///to \c V.
    674706  ///\todo Check the requirements.
    675 
    676707  template<typename M1, typename M2, typename F,
    677            typename V = typename F::result_type,
    678            typename NC = False>
     708           typename V = typename F::result_type>
    679709  class CombineMap : public MapBase<typename M1::Key, V> {
    680710    const M1& m1;
     
    687717
    688718    ///Constructor
    689     CombineMap(const M1 &_m1,const M2 &_m2,const F &_f)
     719    CombineMap(const M1 &_m1,const M2 &_m2,const F &_f = F())
    690720      : m1(_m1), m2(_m2), f(_f) {};
     721    /// \e
    691722    Value operator[](Key k) const {return f(m1[k],m2[k]);}
    692723  };
    693724 
    694   ///Returns a \ref CombineMap class
    695 
    696   ///This function just returns a \ref CombineMap class.
    697   ///
    698   ///Only the first template parameter (the value type) must be given.
     725  ///Returns a \c CombineMap class
     726
     727  ///This function just returns a \c CombineMap class.
    699728  ///
    700729  ///For example if \c m1 and \c m2 are both \c double valued maps, then
    701730  ///\code
    702   ///combineMap<double>(m1,m2,std::plus<double>)
     731  ///combineMap<double>(m1,m2,std::plus<double>())
    703732  ///\endcode
    704733  ///is equivalent with
     
    706735  ///addMap(m1,m2)
    707736  ///\endcode
     737  ///
     738  ///This function is specialized for adaptable binary function
     739  ///classes and c++ functions.
    708740  ///
    709741  ///\relates CombineMap
     
    728760  ///Negative value of a map
    729761
    730   ///This \ref concepts::ReadMap "read only map" returns the negative
     762  ///This \c concepts::ReadMap "read only map" returns the negative
    731763  ///value of the
    732764  ///value returned by the
     
    744776    ///Constructor
    745777    NegMap(const M &_m) : m(_m) {};
     778    /// \e
    746779    Value operator[](Key k) const {return -m[k];}
    747780  };
     
    749782  ///Negative value of a map
    750783
    751   ///This \ref concepts::ReadWriteMap "read-write map" returns the negative
     784  ///This \c concepts::ReadWriteMap "read-write map" returns the negative
    752785  ///value of the value returned by the
    753786  ///given map. Its \c Key and \c Value will be inherited from \c M.
     
    764797    ///Constructor
    765798    NegWriteMap(M &_m) : m(_m) {};
     799    /// \e
    766800    Value operator[](Key k) const {return -m[k];}
     801    /// \e
    767802    void set(Key k, const Value& v) { m.set(k, -v); }
    768803  };
    769804
    770   ///Returns a \ref NegMap class
    771 
    772   ///This function just returns a \ref NegMap class.
     805  ///Returns a \c NegMap class
     806
     807  ///This function just returns a \c NegMap class.
    773808  ///\relates NegMap
    774809  template <typename M>
     
    784819  ///Absolute value of a map
    785820
    786   ///This \ref concepts::ReadMap "read only map" returns the absolute value
     821  ///This \c concepts::ReadMap "read only map" returns the absolute value
    787822  ///of the
    788823  ///value returned by the
     
    815850    ///Constructor
    816851    AbsMap(const M &_m) : m(_m) {};
     852    /// \e
    817853    Value operator[](Key k) const {
    818854      Value tmp = m[k];
     
    822858  };
    823859 
    824   ///Returns a \ref AbsMap class
    825 
    826   ///This function just returns a \ref AbsMap class.
     860  ///Returns a \c AbsMap class
     861
     862  ///This function just returns a \c AbsMap class.
    827863  ///\relates AbsMap
    828864  template<typename M>
     
    833869  ///Converts an STL style functor to a map
    834870
    835   ///This \ref concepts::ReadMap "read only map" returns the value
     871  ///This \c concepts::ReadMap "read only map" returns the value
    836872  ///of a
    837873  ///given map.
     
    842878  ///
    843879  ///Parameter \c F is the type of the used functor.
    844  
    845 
    846880  template<typename F,
    847881           typename K = typename F::argument_type,
    848            typename V = typename F::result_type,
    849            typename NC = False>
     882           typename V = typename F::result_type>
    850883  class FunctorMap : public MapBase<K, V> {
    851884    F f;
     
    856889
    857890    ///Constructor
    858     FunctorMap(const F &_f) : f(_f) {}
    859 
     891    FunctorMap(const F &_f = F()) : f(_f) {}
     892    /// \e
    860893    Value operator[](Key k) const { return f(k);}
    861894  };
    862895 
    863   ///Returns a \ref FunctorMap class
    864 
    865   ///This function just returns a \ref FunctorMap class.
    866   ///
    867   ///The third template parameter isn't necessary to be given.
     896  ///Returns a \c FunctorMap class
     897
     898  ///This function just returns a \c FunctorMap class.
     899  ///
     900  ///It is specialized for adaptable function classes and
     901  ///c++ functions.
    868902  ///\relates FunctorMap
    869903  template<typename K, typename V, typename F> inline
     
    891925  ///
    892926  ///For the sake of convenience it also works as
    893   ///a ususal \ref concepts::ReadMap "readable map",
     927  ///a ususal \c concepts::ReadMap "readable map",
    894928  ///i.e. <tt>operator[]</tt> and the \c Key and \c Value typedefs also exist.
    895 
    896929  template <typename M>
    897930  class MapFunctor : public MapBase<typename M::Key, typename M::Value> {
     
    902935    typedef typename Parent::Value Value;
    903936
    904     ///\e
    905937    typedef typename M::Key argument_type;
    906     ///\e
    907938    typedef typename M::Value result_type;
    908939
    909940    ///Constructor
    910941    MapFunctor(const M &_m) : m(_m) {};
    911     ///Returns a value of the map
     942    ///\e
    912943    Value operator()(Key k) const {return m[k];}
    913944    ///\e
     
    915946  };
    916947 
    917   ///Returns a \ref MapFunctor class
    918 
    919   ///This function just returns a \ref MapFunctor class.
     948  ///Returns a \c MapFunctor class
     949
     950  ///This function just returns a \c MapFunctor class.
    920951  ///\relates MapFunctor
    921952  template<typename M>
     
    926957  ///Applies all map setting operations to two maps
    927958
    928   ///This map has two \ref concepts::ReadMap "readable map"
     959  ///This map has two \c concepts::ReadMap "readable map"
    929960  ///parameters and each read request will be passed just to the
    930961  ///first map. This class is the just readable map type of the ForkWriteMap.
     
    932963  ///The \c Key and \c Value will be inherited from \c M1.
    933964  ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
    934 
    935965  template<typename  M1, typename M2>
    936966  class ForkMap : public MapBase<typename M1::Key, typename M1::Value> {
     
    944974    ///Constructor
    945975    ForkMap(const M1 &_m1, const M2 &_m2) : m1(_m1), m2(_m2) {};
     976    /// \e
    946977    Value operator[](Key k) const {return m1[k];}
    947978  };
     
    950981  ///Applies all map setting operations to two maps
    951982
    952   ///This map has two \ref concepts::WriteMap "writable map"
     983  ///This map has two \c concepts::WriteMap "writable map"
    953984  ///parameters and each write request will be passed to both of them.
    954   ///If \c M1 is also \ref concepts::ReadMap "readable",
     985  ///If \c M1 is also \c concepts::ReadMap "readable",
    955986  ///then the read operations will return the
    956987  ///corresponding values of \c M1.
     
    958989  ///The \c Key and \c Value will be inherited from \c M1.
    959990  ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
    960 
    961991  template<typename  M1, typename M2>
    962992  class ForkWriteMap : public MapBase<typename M1::Key, typename M1::Value> {
     
    9701000    ///Constructor
    9711001    ForkWriteMap(M1 &_m1, M2 &_m2) : m1(_m1), m2(_m2) {};
     1002    ///\e
    9721003    Value operator[](Key k) const {return m1[k];}
     1004    ///\e
    9731005    void set(Key k, const Value &v) {m1.set(k,v); m2.set(k,v);}
    9741006  };
    9751007 
    976   ///Returns an \ref ForkMap class
    977 
    978   ///This function just returns an \ref ForkMap class.
    979   ///\todo How to call these type of functions?
     1008  ///Returns an \c ForkMap class
     1009
     1010  ///This function just returns an \c ForkMap class.
    9801011  ///
    9811012  ///\relates ForkMap
    982   ///\todo Wrong scope in Doxygen when \c \\relates is used
    9831013  template <typename M1, typename M2>
    9841014  inline ForkMap<M1, M2> forkMap(const M1 &m1, const M2 &m2) {
     
    9971027  ///Logical 'not' of a map
    9981028 
    999   ///This bool \ref concepts::ReadMap "read only map" returns the
     1029  ///This bool \c concepts::ReadMap "read only map" returns the
    10001030  ///logical negation of
    10011031  ///value returned by the
    10021032  ///given map. Its \c Key and will be inherited from \c M,
    10031033  ///its Value is <tt>bool</tt>.
    1004 
    10051034  template <typename M>
    10061035  class NotMap : public MapBase<typename M::Key, bool> {
     
    10131042    /// Constructor
    10141043    NotMap(const M &_m) : m(_m) {};
     1044    ///\e
    10151045    Value operator[](Key k) const {return !m[k];}
    10161046  };
     
    10181048  ///Logical 'not' of a map with writing possibility
    10191049 
    1020   ///This bool \ref concepts::ReadWriteMap "read-write map" returns the
     1050  ///This bool \c concepts::ReadWriteMap "read-write map" returns the
    10211051  ///logical negation of value returned by the given map. When it is set,
    10221052  ///the opposite value is set to the original map.
     
    10331063    /// Constructor
    10341064    NotWriteMap(M &_m) : m(_m) {};
     1065    ///\e
    10351066    Value operator[](Key k) const {return !m[k];}
     1067    ///\e
    10361068    void set(Key k, bool v) { m.set(k, !v); }
    10371069  };
    10381070 
    1039   ///Returns a \ref NotMap class
    1040  
    1041   ///This function just returns a \ref NotMap class.
     1071  ///Returns a \c NotMap class
     1072 
     1073  ///This function just returns a \c NotMap class.
    10421074  ///\relates NotMap
    10431075  template <typename M>
     
    12781310  /// }
    12791311  ///\endcode
    1280 
    12811312  template <typename Map>
    12821313  class FillBoolMap {
     
    13261357  /// Writable bool map which stores for each true assigned elements 
    13271358  /// the setting order number. It make easy to calculate the leaving
    1328   /// order of the nodes in the \ref dfs "Dfs" algorithm.
     1359  /// order of the nodes in the \c Dfs algorithm.
    13291360  ///
    13301361  ///\code
Note: See TracChangeset for help on using the changeset viewer.