COIN-OR::LEMON - Graph Library

Changeset 29:0cb4ba427bfd in lemon-1.0 for lemon/maps.h


Ignore:
Timestamp:
01/04/08 08:08:50 (12 years ago)
Author:
Peter Kovacs <kpeter@…>
Branch:
default
Phase:
public
Message:

Several doc improvements and fixes in maps.h.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/maps.h

    r26 r29  
    5353  /// Null map. (a.k.a. DoNothingMap)
    5454
    55   /// If you have to provide a map only for its type definitions,
    56   /// or if you have to provide a writable map, but
    57   /// data written to it will sent to <tt>/dev/null</tt>...
     55  /// This map can be used if you have to provide a map only for
     56  /// its type definitions, or if you have to provide a writable map,
     57  /// but data written to it is not required (i.e. it will be sent to
     58  /// <tt>/dev/null</tt>).
    5859  template<typename K, typename T>
    5960  class NullMap : public MapBase<K, T> {
     
    6970  };
    7071
     72  ///Returns a \c NullMap class
     73
     74  ///This function just returns a \c NullMap class.
     75  ///\relates NullMap
    7176  template <typename K, typename V>
    7277  NullMap<K, V> nullMap() {
     
    9196    /// Default constructor
    9297
     98    /// Default constructor.
    9399    /// The value of the map will be uninitialized.
    94100    /// (More exactly it will be default constructed.)
    95101    ConstMap() {}
    96     ///\e
    97 
    98     /// \param _v The initial value of the map.
    99     ///
     102   
     103    /// Constructor with specified initial value
     104
     105    /// Constructor with specified initial value.
     106    /// \param _v is the initial value of the map.
    100107    ConstMap(const T &_v) : v(_v) {}
    101108   
     
    159166  ///Map based on std::map
    160167
    161   ///This is essentially a wrapper for \c std::map. With addition that
    162   ///you can specify a default value different from \c Value() .
     168  ///This is essentially a wrapper for \c std::map with addition that
     169  ///you can specify a default value different from \c Value().
    163170  template <typename K, typename T, typename Compare = std::less<K> >
    164171  class StdMap {
     
    322329  /// @{
    323330
    324   /// \brief Identity mapping.
    325   ///
    326   /// This mapping gives back the given key as value without any
     331  /// \brief Identity map.
     332  ///
     333  /// This map gives back the given key as value without any
    327334  /// modification.
    328335  template <typename T>
     
    353360  ///
    354361  ///This \c concepts::ReadMap "read only map"
    355   ///converts the \c Value of a maps to type \c T.
     362  ///converts the \c Value of a map to type \c T.
    356363  ///Its \c Key is inherited from \c M.
    357364  template <typename M, typename T>
     
    365372    ///Constructor
    366373
    367     ///Constructor
    368     ///\param _m is the underlying map
     374    ///Constructor.
     375    ///\param _m is the underlying map.
    369376    ConvertMap(const M &_m) : m(_m) {};
    370377
     
    375382  };
    376383 
    377   ///Returns an \c ConvertMap class
    378 
    379   ///This function just returns an \c ConvertMap class.
     384  ///Returns a \c ConvertMap class
     385
     386  ///This function just returns a \c ConvertMap class.
    380387  ///\relates ConvertMap
    381388  template<typename T, typename M>
     
    384391  }
    385392
    386   ///Simple wrapping of the map
     393  ///Simple wrapping of a map
    387394
    388395  ///This \c concepts::ReadMap "read only map" returns the simple
     
    391398  ///map to simple read map.
    392399  ///
    393   /// \todo Revise the misleading name
     400  ///\sa SimpleWriteMap
     401  ///
     402  /// \todo Revise the misleading name
    394403  template<typename M>
    395404  class SimpleMap : public MapBase<typename M::Key, typename M::Value> {
     
    407416  };
    408417
    409   ///Simple writeable wrapping of the map
     418  ///Simple writable wrapping of the map
    410419
    411420  ///This \c concepts::WriteMap "write map" returns the simple
     
    414423  ///given map to simple read-write map.
    415424  ///
     425  ///\sa SimpleMap
     426  ///
    416427  /// \todo Revise the misleading name
    417428  template<typename M>
     
    435446
    436447  ///This \c concepts::ReadMap "read only map" returns the sum of the two
    437   ///given maps. Its \c Key and \c Value will be inherited from \c M1.
     448  ///given maps.
     449  ///Its \c Key and \c Value are inherited from \c M1.
    438450  ///The \c Key and \c Value of M2 must be convertible to those of \c M1.
    439 
    440451  template<typename M1, typename M2>
    441452  class AddMap : public MapBase<typename M1::Key, typename M1::Value> {
     
    469480  ///This \c concepts::ReadMap "read only map" returns the sum of the
    470481  ///given map and a constant value.
    471   ///Its \c Key and \c Value is inherited from \c M.
     482  ///Its \c Key and \c Value are inherited from \c M.
    472483  ///
    473484  ///Actually,
     
    475486  ///  ShiftMap<X> sh(x,v);
    476487  ///\endcode
    477   ///is equivalent with
     488  ///is equivalent to
    478489  ///\code
    479490  ///  ConstMap<X::Key, X::Value> c_tmp(v);
    480491  ///  AddMap<X, ConstMap<X::Key, X::Value> > sh(x,v);
    481492  ///\endcode
     493  ///
     494  ///\sa ShiftWriteMap
    482495  template<typename M, typename C = typename M::Value>
    483496  class ShiftMap : public MapBase<typename M::Key, typename M::Value> {
     
    491504    ///Constructor
    492505
    493     ///Constructor
    494     ///\param _m is the undelying map
    495     ///\param _v is the shift value
     506    ///Constructor.
     507    ///\param _m is the undelying map.
     508    ///\param _v is the shift value.
    496509    ShiftMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
    497510    ///\e
     
    499512  };
    500513
    501   ///Shift a map with a constant. This map is also writable.
     514  ///Shift a map with a constant (ReadWrite version).
    502515
    503516  ///This \c concepts::ReadWriteMap "read-write map" returns the sum of the
    504517  ///given map and a constant value. It makes also possible to write the map.
    505   ///Its \c Key and \c Value is inherited from \c M.
    506   ///
    507   ///Actually,
    508   ///\code
    509   ///  ShiftMap<X> sh(x,v);
    510   ///\endcode
    511   ///is equivalent with
    512   ///\code
    513   ///  ConstMap<X::Key, X::Value> c_tmp(v);
    514   ///  AddMap<X, ConstMap<X::Key, X::Value> > sh(x,v);
    515   ///\endcode
     518  ///Its \c Key and \c Value are inherited from \c M.
     519  ///
     520  ///\sa ShiftMap
    516521  template<typename M, typename C = typename M::Value>
    517522  class ShiftWriteMap : public MapBase<typename M::Key, typename M::Value> {
     
    525530    ///Constructor
    526531
    527     ///Constructor
    528     ///\param _m is the undelying map
    529     ///\param _v is the shift value
     532    ///Constructor.
     533    ///\param _m is the undelying map.
     534    ///\param _v is the shift value.
    530535    ShiftWriteMap(M &_m, const C &_v ) : m(_m), v(_v) {};
    531536    /// \e
     
    535540  };
    536541 
    537   ///Returns an \c ShiftMap class
    538 
    539   ///This function just returns an \c ShiftMap class.
     542  ///Returns a \c ShiftMap class
     543
     544  ///This function just returns a \c ShiftMap class.
    540545  ///\relates ShiftMap
    541546  template<typename M, typename C>
     
    544549  }
    545550
     551  ///Returns a \c ShiftWriteMap class
     552
     553  ///This function just returns a \c ShiftWriteMap class.
     554  ///\relates ShiftWriteMap
    546555  template<typename M, typename C>
    547556  inline ShiftWriteMap<M, C> shiftMap(M &m,const C &v) {
     
    552561
    553562  ///This \c concepts::ReadMap "read only map" returns the difference
    554   ///of the values of the two
    555   ///given maps. Its \c Key and \c Value will be inherited from \c M1.
     563  ///of the values of the two given maps.
     564  ///Its \c Key and \c Value are inherited from \c M1.
    556565  ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
    557566  ///
     
    585594
    586595  ///This \c concepts::ReadMap "read only map" returns the product of the
    587   ///values of the two
    588   ///given
    589   ///maps. Its \c Key and \c Value will be inherited from \c M1.
     596  ///values of the two given maps.
     597  ///Its \c Key and \c Value are inherited from \c M1.
    590598  ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
    591 
    592599  template<typename M1, typename M2>
    593600  class MulMap : public MapBase<typename M1::Key, typename M1::Value> {
     
    614621  }
    615622 
    616   ///Scales a maps with a constant.
     623  ///Scales a map with a constant.
    617624
    618625  ///This \c concepts::ReadMap "read only map" returns the value of the
    619626  ///given map multiplied from the left side with a constant value.
    620   ///Its \c Key and \c Value is inherited from \c M.
     627  ///Its \c Key and \c Value are inherited from \c M.
    621628  ///
    622629  ///Actually,
     
    624631  ///  ScaleMap<X> sc(x,v);
    625632  ///\endcode
    626   ///is equivalent with
     633  ///is equivalent to
    627634  ///\code
    628635  ///  ConstMap<X::Key, X::Value> c_tmp(v);
    629636  ///  MulMap<X, ConstMap<X::Key, X::Value> > sc(x,v);
    630637  ///\endcode
     638  ///
     639  ///\sa ScaleWriteMap
    631640  template<typename M, typename C = typename M::Value>
    632641  class ScaleMap : public MapBase<typename M::Key, typename M::Value> {
     
    640649    ///Constructor
    641650
    642     ///Constructor
    643     ///\param _m is the undelying map
    644     ///\param _v is the scaling value
     651    ///Constructor.
     652    ///\param _m is the undelying map.
     653    ///\param _v is the scaling value.
    645654    ScaleMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
    646655    /// \e
     
    648657  };
    649658
    650   ///Scales a maps with a constant (ReadWrite version).
     659  ///Scales a map with a constant (ReadWrite version).
    651660
    652661  ///This \c concepts::ReadWriteMap "read-write map" returns the value of the
    653662  ///given map multiplied from the left side with a constant value. It can
    654   ///be used as write map also if the given multiplier is not zero.
    655   ///Its \c Key and \c Value is inherited from \c M.
     663  ///also be used as write map if the \c / operator is defined between
     664  ///\c Value and \c C and the given multiplier is not zero.
     665  ///Its \c Key and \c Value are inherited from \c M.
     666  ///
     667  ///\sa ScaleMap
    656668  template<typename M, typename C = typename M::Value>
    657669  class ScaleWriteMap : public MapBase<typename M::Key, typename M::Value> {
     
    665677    ///Constructor
    666678
    667     ///Constructor
    668     ///\param _m is the undelying map
    669     ///\param _v is the scaling value
     679    ///Constructor.
     680    ///\param _m is the undelying map.
     681    ///\param _v is the scaling value.
    670682    ScaleWriteMap(M &_m, const C &_v ) : m(_m), v(_v) {};
    671683    /// \e
     
    675687  };
    676688 
    677   ///Returns an \c ScaleMap class
    678 
    679   ///This function just returns an \c ScaleMap class.
     689  ///Returns a \c ScaleMap class
     690
     691  ///This function just returns a \c ScaleMap class.
    680692  ///\relates ScaleMap
    681693  template<typename M, typename C>
     
    684696  }
    685697
     698  ///Returns a \c ScaleWriteMap class
     699
     700  ///This function just returns a \c ScaleWriteMap class.
     701  ///\relates ScaleWriteMap
    686702  template<typename M, typename C>
    687703  inline ScaleWriteMap<M, C> scaleMap(M &m,const C &v) {
     
    692708
    693709  ///This \c concepts::ReadMap "read only map" returns the quotient of the
    694   ///values of the two
    695   ///given maps. Its \c Key and \c Value will be inherited from \c M1.
     710  ///values of the two given maps.
     711  ///Its \c Key and \c Value are inherited from \c M1.
    696712  ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
    697 
    698713  template<typename M1, typename M2>
    699714  class DivMap : public MapBase<typename M1::Key, typename M1::Value> {
     
    723738
    724739  ///This \c concepts::ReadMap "read only map" returns the composition of
    725   ///two
    726   ///given maps. That is to say, if \c m1 is of type \c M1 and \c m2 is
    727   ///of \c M2,
     740  ///two given maps.
     741  ///That is to say, if \c m1 is of type \c M1 and \c m2 is of \c M2,
    728742  ///then for
    729743  ///\code
    730744  ///  ComposeMap<M1, M2> cm(m1,m2);
    731745  ///\endcode
    732   /// <tt>cm[x]</tt> will be equal to <tt>m1[m2[x]]</tt>
    733   ///
    734   ///Its \c Key is inherited from \c M2 and its \c Value is from
    735   ///\c M1.
    736   ///The \c M2::Value must be convertible to \c M1::Key.
     746  /// <tt>cm[x]</tt> will be equal to <tt>m1[m2[x]]</tt>.
     747  ///
     748  ///Its \c Key is inherited from \c M2 and its \c Value is from \c M1.
     749  ///\c M2::Value must be convertible to \c M1::Key.
     750  ///
     751  ///\sa CombineMap
     752  ///
    737753  ///\todo Check the requirements.
    738754  template <typename M1, typename M2>
     
    758774    operator[](Key k) const {return m1[m2[k]];}
    759775  };
     776
    760777  ///Returns a \c ComposeMap class
    761778
    762779  ///This function just returns a \c ComposeMap class.
    763   ///
    764780  ///\relates ComposeMap
    765781  template <typename M1, typename M2>
     
    768784  }
    769785 
    770   ///Combines of two maps using an STL (binary) functor.
    771 
    772   ///Combines of two maps using an STL (binary) functor.
    773   ///
     786  ///Combine of two maps using an STL (binary) functor.
     787
     788  ///Combine of two maps using an STL (binary) functor.
    774789  ///
    775790  ///This \c concepts::ReadMap "read only map" takes two maps and a
    776   ///binary functor and returns the composition of
    777   ///the two
     791  ///binary functor and returns the composition of the two
    778792  ///given maps unsing the functor.
    779793  ///That is to say, if \c m1 and \c m2 is of type \c M1 and \c M2
    780   ///and \c f is of \c F,
    781   ///then for
     794  ///and \c f is of \c F, then for
    782795  ///\code
    783   ///  CombineMap<M1, M2,F,V> cm(m1,m2,f);
     796  ///  CombineMap<M1,M2,F,V> cm(m1,m2,f);
    784797  ///\endcode
    785798  /// <tt>cm[x]</tt> will be equal to <tt>f(m1[x],m2[x])</tt>
    786799  ///
    787800  ///Its \c Key is inherited from \c M1 and its \c Value is \c V.
    788   ///The \c M2::Value and \c M1::Value must be convertible to the corresponding
     801  ///\c M2::Value and \c M1::Value must be convertible to the corresponding
    789802  ///input parameter of \c F and the return type of \c F must be convertible
    790803  ///to \c V.
     804  ///
     805  ///\sa ComposeMap
     806  ///
    791807  ///\todo Check the requirements.
    792808  template<typename M1, typename M2, typename F,
     
    816832  ///combineMap<double>(m1,m2,std::plus<double>())
    817833  ///\endcode
    818   ///is equivalent with
     834  ///is equivalent to
    819835  ///\code
    820836  ///addMap(m1,m2)
     
    822838  ///
    823839  ///This function is specialized for adaptable binary function
    824   ///classes and c++ functions.
     840  ///classes and C++ functions.
    825841  ///
    826842  ///\relates CombineMap
     
    846862
    847863  ///This \c concepts::ReadMap "read only map" returns the negative
    848   ///value of the
    849   ///value returned by the
    850   ///given map. Its \c Key and \c Value will be inherited from \c M.
     864  ///value of the value returned by the given map.
     865  ///Its \c Key and \c Value are inherited from \c M.
    851866  ///The unary \c - operator must be defined for \c Value, of course.
    852 
     867  ///
     868  ///\sa NegWriteMap
    853869  template<typename M>
    854870  class NegMap : public MapBase<typename M::Key, typename M::Value> {
     
    868884
    869885  ///This \c concepts::ReadWriteMap "read-write map" returns the negative
    870   ///value of the value returned by the
    871   ///given map. Its \c Key and \c Value will be inherited from \c M.
     886  ///value of the value returned by the given map.
     887  ///Its \c Key and \c Value are inherited from \c M.
    872888  ///The unary \c - operator must be defined for \c Value, of course.
    873 
     889  ///
     890  /// \sa NegMap
    874891  template<typename M>
    875892  class NegWriteMap : public MapBase<typename M::Key, typename M::Value> {
     
    897914  }
    898915
     916  ///Returns a \c NegWriteMap class
     917
     918  ///This function just returns a \c NegWriteMap class.
     919  ///\relates NegWriteMap
    899920  template <typename M>
    900921  inline NegWriteMap<M> negMap(M &m) {
     
    905926
    906927  ///This \c concepts::ReadMap "read only map" returns the absolute value
    907   ///of the
    908   ///value returned by the
    909   ///given map. Its \c Key and \c Value will be inherited
    910   ///from <tt>M</tt>. <tt>Value</tt>
    911   ///must be comparable to <tt>0</tt> and the unary <tt>-</tt>
     928  ///of the value returned by the given map.
     929  ///Its \c Key and \c Value are inherited from \c M.
     930  ///\c Value must be comparable to \c 0 and the unary \c -
    912931  ///operator must be defined for it, of course.
    913   ///
    914 
    915932  template<typename M>
    916933  class AbsMap : public MapBase<typename M::Key, typename M::Value> {
     
    931948  };
    932949 
    933   ///Returns a \c AbsMap class
    934 
    935   ///This function just returns a \c AbsMap class.
     950  ///Returns an \c AbsMap class
     951
     952  ///This function just returns an \c AbsMap class.
    936953  ///\relates AbsMap
    937954  template<typename M>
     
    943960
    944961  ///This \c concepts::ReadMap "read only map" returns the value
    945   ///of a
    946   ///given map.
     962  ///of a given functor.
    947963  ///
    948964  ///Template parameters \c K and \c V will become its
    949   ///\c Key and \c Value. They must be given explicitely
     965  ///\c Key and \c Value. They must be given explicitly
    950966  ///because a functor does not provide such typedefs.
    951967  ///
    952968  ///Parameter \c F is the type of the used functor.
     969  ///
     970  ///\sa MapFunctor
    953971  template<typename F,
    954972           typename K = typename F::argument_type,
     
    972990  ///
    973991  ///It is specialized for adaptable function classes and
    974   ///c++ functions.
     992  ///C++ functions.
    975993  ///\relates FunctorMap
    976994  template<typename K, typename V, typename F> inline
     
    10001018  ///a ususal \c concepts::ReadMap "readable map",
    10011019  ///i.e. <tt>operator[]</tt> and the \c Key and \c Value typedefs also exist.
     1020  ///
     1021  ///\sa FunctorMap
    10021022  template <typename M>
    10031023  class MapFunctor : public MapBase<typename M::Key, typename M::Value> {
     
    10341054  ///first map. This class is the just readable map type of the ForkWriteMap.
    10351055  ///
    1036   ///The \c Key and \c Value will be inherited from \c M1.
     1056  ///The \c Key and \c Value are inherited from \c M1.
    10371057  ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
     1058  ///
     1059  ///\sa ForkWriteMap
    10381060  ///
    10391061  /// \todo Why is it needed?
     
    10621084  ///corresponding values of \c M1.
    10631085  ///
    1064   ///The \c Key and \c Value will be inherited from \c M1.
     1086  ///The \c Key and \c Value are inherited from \c M1.
    10651087  ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
     1088  ///
     1089  ///\sa ForkMap
    10661090  template<typename  M1, typename M2>
    10671091  class ForkWriteMap : public MapBase<typename M1::Key, typename M1::Value> {
     
    10811105  };
    10821106 
    1083   ///Returns an \c ForkMap class
    1084 
    1085   ///This function just returns an \c ForkMap class.
    1086   ///
     1107  ///Returns a \c ForkMap class
     1108
     1109  ///This function just returns a \c ForkMap class.
    10871110  ///\relates ForkMap
    10881111  template <typename M1, typename M2>
     
    10911114  }
    10921115
     1116  ///Returns a \c ForkWriteMap class
     1117
     1118  ///This function just returns a \c ForkWriteMap class.
     1119  ///\relates ForkWriteMap
    10931120  template <typename M1, typename M2>
    10941121  inline ForkWriteMap<M1, M2> forkMap(M1 &m1, M2 &m2) {
     
    11031130 
    11041131  ///This bool \c concepts::ReadMap "read only map" returns the
    1105   ///logical negation of
    1106   ///value returned by the
    1107   ///given map. Its \c Key and will be inherited from \c M,
    1108   ///its Value is <tt>bool</tt>.
     1132  ///logical negation of the value returned by the given map.
     1133  ///Its \c Key is inherited from \c M, its Value is \c bool.
     1134  ///
     1135  ///\sa NotWriteMap
    11091136  template <typename M>
    11101137  class NotMap : public MapBase<typename M::Key, bool> {
     
    11241151 
    11251152  ///This bool \c concepts::ReadWriteMap "read-write map" returns the
    1126   ///logical negation of value returned by the given map. When it is set,
     1153  ///logical negation of the value returned by the given map. When it is set,
    11271154  ///the opposite value is set to the original map.
    1128   ///Its \c Key and will be inherited from \c M,
    1129   ///its Value is <tt>bool</tt>.
     1155  ///Its \c Key is inherited from \c M, its Value is \c bool.
     1156  ///
     1157  ///\sa NotMap
    11301158  template <typename M>
    11311159  class NotWriteMap : public MapBase<typename M::Key, bool> {
     
    11531181  }
    11541182 
     1183  ///Returns a \c NotWriteMap class
     1184 
     1185  ///This function just returns a \c NotWriteMap class.
     1186  ///\relates NotWriteMap
    11551187  template <typename M>
    11561188  inline NotWriteMap<M> notMap(M &m) {
     
    11841216 
    11851217
    1186   /// \brief Writable bool map for logging each true assigned elements
    1187   ///
    1188   /// Writable bool map for logging each true assigned elements, i.e it
    1189   /// copies all the keys set to true to the given iterator.
     1218  /// \brief Writable bool map for logging each \c true assigned element
     1219  ///
     1220  /// Writable bool map for logging each \c true assigned element, i.e it
     1221  /// copies all the keys set to \c true to the given iterator.
    11901222  ///
    11911223  /// \note The container of the iterator should contain space
     
    12081240  ///\endcode
    12091241  ///
    1210   ///\todo Revise the name of this class and the relates ones.
     1242  ///\sa BackInserterBoolMap
     1243  ///
     1244  ///\todo Revise the name of this class and the related ones.
    12111245  template <typename _Iterator,
    12121246            typename _Functor =
     
    12361270    }
    12371271
    1238     /// Setter function of the map
     1272    /// The \c set function of the map
    12391273    void set(const Key& key, Value value) const {
    12401274      if (value) {
     
    12491283  };
    12501284
    1251   /// \brief Writable bool map for logging each true assigned elements in
    1252   /// a back insertable container
    1253   ///
    1254   /// Writable bool map for logging each true assigned elements by pushing
    1255   /// back them into a back insertable container.
     1285  /// \brief Writable bool map for logging each \c true assigned element in
     1286  /// a back insertable container.
     1287  ///
     1288  /// Writable bool map for logging each \c true assigned element by pushing
     1289  /// them into a back insertable container.
    12561290  /// It can be used to retrieve the items into a standard
    12571291  /// container. The next example shows how you can store the
     
    12631297  /// prim(graph, cost, inserter_map);
    12641298  ///\endcode
     1299  ///
     1300  ///\sa StoreBoolMap
     1301  ///\sa FrontInserterBoolMap
     1302  ///\sa InserterBoolMap
    12651303  template <typename Container,
    12661304            typename Functor =
     
    12761314      : container(_container), functor(_functor) {}
    12771315
    1278     /// Setter function of the map
     1316    /// The \c set function of the map
    12791317    void set(const Key& key, Value value) {
    12801318      if (value) {
     
    12881326  };
    12891327
    1290   /// \brief Writable bool map for storing each true assignments in
     1328  /// \brief Writable bool map for logging each \c true assigned element in
    12911329  /// a front insertable container.
    12921330  ///
    1293   /// Writable bool map for storing each true assignment in a front
    1294   /// insertable container. It will push front all the keys set to \c true into
    1295   /// the container. For example see the BackInserterBoolMap.
     1331  /// Writable bool map for logging each \c true assigned element by pushing
     1332  /// them into a front insertable container.
     1333  /// It can be used to retrieve the items into a standard
     1334  /// container. For example see \ref BackInserterBoolMap.
     1335  ///
     1336  ///\sa BackInserterBoolMap
     1337  ///\sa InserterBoolMap
    12961338  template <typename Container,
    12971339            typename Functor =
     
    13071349      : container(_container), functor(_functor) {}
    13081350
    1309     /// Setter function of the map
     1351    /// The \c set function of the map
    13101352    void set(const Key& key, Value value) {
    13111353      if (value) {
     
    13191361  };
    13201362
    1321   /// \brief Writable bool map for storing each true assigned elements in
     1363  /// \brief Writable bool map for storing each \c true assigned element in
    13221364  /// an insertable container.
    13231365  ///
    1324   /// Writable bool map for storing each true assigned elements in an
     1366  /// Writable bool map for storing each \c true assigned element in an
    13251367  /// insertable container. It will insert all the keys set to \c true into
    13261368  /// the container.
     
    13341376  /// stronglyConnectedCutArcs(digraph, cost, inserter_map);
    13351377  ///\endcode
     1378  ///
     1379  ///\sa BackInserterBoolMap
     1380  ///\sa FrontInserterBoolMap
    13361381  template <typename Container,
    13371382            typename Functor =
     
    13421387    typedef bool Value;
    13431388
    1344     /// Constructor
     1389    /// Constructor with specified iterator
     1390   
     1391    /// Constructor with specified iterator.
     1392    /// \param _container The container for storing the elements.
     1393    /// \param _it The elements will be inserted before this iterator.
     1394    /// \param _functor The functor that is used when an element is stored.
    13451395    InserterBoolMap(Container& _container, typename Container::iterator _it,
    13461396                    const Functor& _functor = Functor())
     
    13481398
    13491399    /// Constructor
     1400
     1401    /// Constructor without specified iterator.
     1402    /// The elements will be inserted before <tt>_container.end()</tt>.
     1403    /// \param _container The container for storing the elements.
     1404    /// \param _functor The functor that is used when an element is stored.
    13501405    InserterBoolMap(Container& _container, const Functor& _functor = Functor())
    13511406      : container(_container), it(_container.end()), functor(_functor) {}
    13521407
    1353     /// Setter function of the map
     1408    /// The \c set function of the map
    13541409    void set(const Key& key, Value value) {
    13551410      if (value) {
     
    13651420  };
    13661421
    1367   /// \brief Fill the true set elements with a given value.
    1368   ///
    1369   /// Writable bool map to fill the elements set to \c true with a given value.
    1370   /// The value can set
    1371   /// the container.
     1422  /// \brief Writable bool map for filling each \c true assigned element with a
     1423  /// given value.
     1424  ///
     1425  /// Writable bool map for filling each \c true assigned element with a
     1426  /// given value. The value can set the container.
    13721427  ///
    13731428  /// The following code finds the connected components of a graph
     
    14191474    }
    14201475
    1421     /// Set function of the map
     1476    /// The \c set function of the map
    14221477    void set(const Key& key, Value value) {
    14231478      if (value) {
     
    14321487
    14331488
    1434   /// \brief Writable bool map which stores the sequence number of
    1435   /// true assignments. 
     1489  /// \brief Writable bool map for storing the sequence number of
     1490  /// \c true assignments. 
    14361491  ///
    1437   /// Writable bool map which stores for each true assigned elements 
     1492  /// Writable bool map that stores for each \c true assigned elements 
    14381493  /// the sequence number of this setting.
    14391494  /// It makes it easy to calculate the leaving
Note: See TracChangeset for help on using the changeset viewer.