COIN-OR::LEMON - Graph Library

Changeset 80:15968e25ca08 in lemon-1.0 for lemon


Ignore:
Timestamp:
03/15/08 21:07:24 (12 years ago)
Author:
Peter Kovacs <kpeter@…>
Branch:
default
Phase:
public
Message:

Overall clean-up in maps.h

logical maps.

  • Small fixes and improvements in the code.
  • Fix the typedefs of RangeMap? to work correctly with bool type, too.
  • Rename template parameters, function parameters, and private members

in many classes to be uniform and to avoid parameter names starting
with underscore.

  • Use Key and Value types instead of K and V template parameters in

public functions.

  • Extend the documentation with examples (e.g. for basic arithmetic and

logical maps).

InserterBoolMap?, FillBoolMap?, SettingOrderBoolMap? are almost unchanged,
since they will be removed.

  • Also improve maps_test.cc to correctly check every map class, every

constructor, and every creator function.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/maps.h

    r54 r80  
    2525
    2626#include <lemon/bits/utility.h>
    27 // #include <lemon/bits/traits.h>
     27#include <lemon/bits/traits.h>
    2828
    2929///\file
    3030///\ingroup maps
    3131///\brief Miscellaneous property maps
    32 ///
     32
    3333#include <map>
    3434
     
    4040  /// Base class of maps.
    4141
    42   /// Base class of maps.
    43   /// It provides the necessary <tt>typedef</tt>s required by the map concept.
    44   template<typename K, typename T>
     42  /// Base class of maps. It provides the necessary type definitions
     43  /// required by the map %concepts.
     44  template<typename K, typename V>
    4545  class MapBase {
    4646  public:
    47     /// The key type of the map.
     47    /// \biref The key type of the map.
    4848    typedef K Key;
    49     /// The value type of the map. (The type of objects associated with the keys).
    50     typedef T Value;
    51   };
     49    /// \brief The value type of the map.
     50    /// (The type of objects associated with the keys).
     51    typedef V Value;
     52  };
     53
    5254
    5355  /// Null map. (a.k.a. DoNothingMap)
    5456
    5557  /// 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  /// its type definitions, or if you have to provide a writable map,
     59  /// but data written to it is not required (i.e. it will be sent to
    5860  /// <tt>/dev/null</tt>).
    59   template<typename K, typename T>
    60   class NullMap : public MapBase<K, T> {
    61   public:
    62     typedef MapBase<K, T> Parent;
    63     typedef typename Parent::Key Key;
    64     typedef typename Parent::Value Value;
    65    
     61  /// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     62  ///
     63  /// \sa ConstMap
     64  template<typename K, typename V>
     65  class NullMap : public MapBase<K, V> {
     66  public:
     67    typedef MapBase<K, V> Parent;
     68    typedef typename Parent::Key Key;
     69    typedef typename Parent::Value Value;
     70
    6671    /// Gives back a default constructed element.
    67     T operator[](const K&) const { return T(); }
     72    Value operator[](const Key&) const { return Value(); }
    6873    /// Absorbs the value.
    69     void set(const K&, const T&) {}
    70   };
    71 
    72   ///Returns a \c NullMap class
    73 
    74   ///This function just returns a \c NullMap class.
    75   ///\relates NullMap
    76   template <typename K, typename V> 
     74    void set(const Key&, const Value&) {}
     75  };
     76
     77  /// Returns a \ref NullMap class
     78
     79  /// This function just returns a \ref NullMap class.
     80  /// \relates NullMap
     81  template <typename K, typename V>
    7782  NullMap<K, V> nullMap() {
    7883    return NullMap<K, V>();
     
    8287  /// Constant map.
    8388
    84   /// This is a \ref concepts::ReadMap "readable" map which assigns a 
     89  /// This is a \ref concepts::ReadMap "readable" map which assigns a
    8590  /// specified value to each key.
    86   /// In other aspects it is equivalent to \c NullMap.
    87   template<typename K, typename T>
    88   class ConstMap : public MapBase<K, T> {
     91  ///
     92  /// In other aspects it is equivalent to \ref NullMap.
     93  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
     94  /// concept, but it absorbs the data written to it.
     95  ///
     96  /// The simplest way of using this map is through the constMap()
     97  /// function.
     98  ///
     99  /// \sa NullMap
     100  /// \sa IdentityMap
     101  template<typename K, typename V>
     102  class ConstMap : public MapBase<K, V> {
    89103  private:
    90     T v;
    91   public:
    92 
    93     typedef MapBase<K, T> Parent;
     104    V _value;
     105  public:
     106    typedef MapBase<K, V> Parent;
    94107    typedef typename Parent::Key Key;
    95108    typedef typename Parent::Value Value;
     
    98111
    99112    /// Default constructor.
    100     /// The value of the map will be uninitialized.
    101     /// (More exactly it will be default constructed.)
     113    /// The value of the map will be default constructed.
    102114    ConstMap() {}
    103    
     115
    104116    /// Constructor with specified initial value
    105117
    106118    /// Constructor with specified initial value.
    107     /// \param _v is the initial value of the map.
    108     ConstMap(const T &_v) : v(_v) {}
    109    
    110     ///\e
    111     T operator[](const K&) const { return v; }
    112 
    113     ///\e
    114     void setAll(const T &t) {
    115       v = t;
    116     }   
    117 
    118     template<typename T1>
    119     ConstMap(const ConstMap<K, T1> &, const T &_v) : v(_v) {}
    120   };
    121 
    122   ///Returns a \c ConstMap class
    123 
    124   ///This function just returns a \c ConstMap class.
    125   ///\relates ConstMap
    126   template<typename K, typename V>
     119    /// \param v is the initial value of the map.
     120    ConstMap(const Value &v) : _value(v) {}
     121
     122    /// Gives back the specified value.
     123    Value operator[](const Key&) const { return _value; }
     124
     125    /// Absorbs the value.
     126    void set(const Key&, const Value&) {}
     127
     128    /// Sets the value that is assigned to each key.
     129    void setAll(const Value &v) {
     130      _value = v;
     131    }
     132
     133    template<typename V1>
     134    ConstMap(const ConstMap<K, V1> &, const Value &v) : _value(v) {}
     135  };
     136
     137  /// Returns a \ref ConstMap class
     138
     139  /// This function just returns a \ref ConstMap class.
     140  /// \relates ConstMap
     141  template<typename K, typename V>
    127142  inline ConstMap<K, V> constMap(const V &v) {
    128143    return ConstMap<K, V>(v);
     
    131146
    132147  template<typename T, T v>
    133   struct Const { };
     148  struct Const {};
    134149
    135150  /// Constant map with inlined constant value.
    136151
    137   /// This is a \ref concepts::ReadMap "readable" map which assigns a 
     152  /// This is a \ref concepts::ReadMap "readable" map which assigns a
    138153  /// specified value to each key.
    139   /// In other aspects it is equivalent to \c NullMap.
     154  ///
     155  /// In other aspects it is equivalent to \ref NullMap.
     156  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
     157  /// concept, but it absorbs the data written to it.
     158  ///
     159  /// The simplest way of using this map is through the constMap()
     160  /// function.
     161  ///
     162  /// \sa NullMap
     163  /// \sa IdentityMap
    140164  template<typename K, typename V, V v>
    141165  class ConstMap<K, Const<V, v> > : public MapBase<K, V> {
     
    145169    typedef typename Parent::Value Value;
    146170
    147     ConstMap() { }
    148     ///\e
    149     V operator[](const K&) const { return v; }
    150     ///\e
    151     void set(const K&, const V&) { }
    152   };
    153 
    154   ///Returns a \c ConstMap class with inlined value
    155 
    156   ///This function just returns a \c ConstMap class with inlined value.
    157   ///\relates ConstMap
    158   template<typename K, typename V, V v>
     171    /// Constructor.
     172    ConstMap() {}
     173
     174    /// Gives back the specified value.
     175    Value operator[](const Key&) const { return v; }
     176
     177    /// Absorbs the value.
     178    void set(const Key&, const Value&) {}
     179  };
     180
     181  /// Returns a \ref ConstMap class with inlined constant value
     182
     183  /// This function just returns a \ref ConstMap class with inlined
     184  /// constant value.
     185  /// \relates ConstMap
     186  template<typename K, typename V, V v>
    159187  inline ConstMap<K, Const<V, v> > constMap() {
    160188    return ConstMap<K, Const<V, v> >();
    161189  }
    162190
    163   ///Map based on \c std::map
    164 
    165   ///This is essentially a wrapper for \c std::map with addition that
    166   ///you can specify a default value different from \c Value().
    167   ///It meets the \ref concepts::ReferenceMap "ReferenceMap" concept.
    168   template <typename K, typename T, typename Compare = std::less<K> >
    169   class StdMap : public MapBase<K, T> {
    170     template <typename K1, typename T1, typename C1>
    171     friend class StdMap;
    172   public:
    173 
    174     typedef MapBase<K, T> Parent;
    175     ///Key type
    176     typedef typename Parent::Key Key;
    177     ///Value type
    178     typedef typename Parent::Value Value;
    179     ///Reference Type
    180     typedef T& Reference;
    181     ///Const reference type
    182     typedef const T& ConstReference;
     191
     192  /// \brief Identity map.
     193  ///
     194  /// This map gives back the given key as value without any
     195  /// modification.
     196  ///
     197  /// \sa ConstMap
     198  template <typename T>
     199  class IdentityMap : public MapBase<T, T> {
     200  public:
     201    typedef MapBase<T, T> Parent;
     202    typedef typename Parent::Key Key;
     203    typedef typename Parent::Value Value;
     204
     205    /// Gives back the given value without any modification.
     206    const T& operator[](const T& t) const {
     207      return t;
     208    }
     209  };
     210
     211  /// Returns an \ref IdentityMap class
     212
     213  /// This function just returns an \ref IdentityMap class.
     214  /// \relates IdentityMap
     215  template<typename T>
     216  inline IdentityMap<T> identityMap() {
     217    return IdentityMap<T>();
     218  }
     219
     220
     221  /// \brief Map for storing values for integer keys from the range
     222  /// <tt>[0..size-1]</tt>.
     223  ///
     224  /// This map is essentially a wrapper for \c std::vector. It assigns
     225  /// values to integer keys from the range <tt>[0..size-1]</tt>.
     226  /// It can be used with some data structures, for example
     227  /// \ref UnionFind, \ref BinHeap, when the used items are small
     228  /// integers. This map conforms the \ref concepts::ReferenceMap
     229  /// "ReferenceMap" concept.
     230  ///
     231  /// The simplest way of using this map is through the rangeMap()
     232  /// function.
     233  template <typename V>
     234  class RangeMap : public MapBase<int, V> {
     235    template <typename V1>
     236    friend class RangeMap;
     237  private:
     238
     239    typedef std::vector<V> Vector;
     240    Vector _vector;
     241
     242  public:
     243
     244    typedef MapBase<int, V> Parent;
     245    /// Key type
     246    typedef typename Parent::Key Key;
     247    /// Value type
     248    typedef typename Parent::Value Value;
     249    /// Reference type
     250    typedef typename Vector::reference Reference;
     251    /// Const reference type
     252    typedef typename Vector::const_reference ConstReference;
    183253
    184254    typedef True ReferenceMapTag;
    185255
     256  public:
     257
     258    /// Constructor with specified default value.
     259    RangeMap(int size = 0, const Value &value = Value())
     260      : _vector(size, value) {}
     261
     262    /// Constructs the map from an appropriate \c std::vector.
     263    template <typename V1>
     264    RangeMap(const std::vector<V1>& vector)
     265      : _vector(vector.begin(), vector.end()) {}
     266
     267    /// Constructs the map from another \ref RangeMap.
     268    template <typename V1>
     269    RangeMap(const RangeMap<V1> &c)
     270      : _vector(c._vector.begin(), c._vector.end()) {}
     271
     272    /// Returns the size of the map.
     273    int size() {
     274      return _vector.size();
     275    }
     276
     277    /// Resizes the map.
     278
     279    /// Resizes the underlying \c std::vector container, so changes the
     280    /// keyset of the map.
     281    /// \param size The new size of the map. The new keyset will be the
     282    /// range <tt>[0..size-1]</tt>.
     283    /// \param value The default value to assign to the new keys.
     284    void resize(int size, const Value &value = Value()) {
     285      _vector.resize(size, value);
     286    }
     287
    186288  private:
    187    
    188     typedef std::map<K, T, Compare> Map;
     289
     290    RangeMap& operator=(const RangeMap&);
     291
     292  public:
     293
     294    ///\e
     295    Reference operator[](const Key &k) {
     296      return _vector[k];
     297    }
     298
     299    ///\e
     300    ConstReference operator[](const Key &k) const {
     301      return _vector[k];
     302    }
     303
     304    ///\e
     305    void set(const Key &k, const Value &v) {
     306      _vector[k] = v;
     307    }
     308  };
     309
     310  /// Returns a \ref RangeMap class
     311
     312  /// This function just returns a \ref RangeMap class.
     313  /// \relates RangeMap
     314  template<typename V>
     315  inline RangeMap<V> rangeMap(int size = 0, const V &value = V()) {
     316    return RangeMap<V>(size, value);
     317  }
     318
     319  /// \brief Returns a \ref RangeMap class created from an appropriate
     320  /// \c std::vector
     321
     322  /// This function just returns a \ref RangeMap class created from an
     323  /// appropriate \c std::vector.
     324  /// \relates RangeMap
     325  template<typename V>
     326  inline RangeMap<V> rangeMap(const std::vector<V> &vector) {
     327    return RangeMap<V>(vector);
     328  }
     329
     330
     331  /// Map type based on \c std::map
     332
     333  /// This map is essentially a wrapper for \c std::map with addition
     334  /// that you can specify a default value for the keys that are not
     335  /// stored actually. This value can be different from the default
     336  /// contructed value (i.e. \c %Value()).
     337  /// This type conforms the \ref concepts::ReferenceMap "ReferenceMap"
     338  /// concept.
     339  ///
     340  /// This map is useful if a default value should be assigned to most of
     341  /// the keys and different values should be assigned only to a few
     342  /// keys (i.e. the map is "sparse").
     343  /// The name of this type also refers to this important usage.
     344  ///
     345  /// Apart form that this map can be used in many other cases since it
     346  /// is based on \c std::map, which is a general associative container.
     347  /// However keep in mind that it is usually not as efficient as other
     348  /// maps.
     349  ///
     350  /// The simplest way of using this map is through the sparseMap()
     351  /// function.
     352  template <typename K, typename V, typename Compare = std::less<K> >
     353  class SparseMap : public MapBase<K, V> {
     354    template <typename K1, typename V1, typename C1>
     355    friend class SparseMap;
     356  public:
     357
     358    typedef MapBase<K, V> Parent;
     359    /// Key type
     360    typedef typename Parent::Key Key;
     361    /// Value type
     362    typedef typename Parent::Value Value;
     363    /// Reference type
     364    typedef Value& Reference;
     365    /// Const reference type
     366    typedef const Value& ConstReference;
     367
     368    typedef True ReferenceMapTag;
     369
     370  private:
     371
     372    typedef std::map<K, V, Compare> Map;
     373    Map _map;
    189374    Value _value;
    190     Map _map;
    191 
    192   public:
    193 
    194     /// Constructor with specified default value
    195     StdMap(const T& value = T()) : _value(value) {}
    196     /// \brief Constructs the map from an appropriate \c std::map, and
     375
     376  public:
     377
     378    /// \brief Constructor with specified default value.
     379    SparseMap(const Value &value = Value()) : _value(value) {}
     380    /// \brief Constructs the map from an appropriate \c std::map, and
    197381    /// explicitly specifies a default value.
    198     template <typename T1, typename Comp1>
    199     StdMap(const std::map<Key, T1, Comp1> &map, const T& value = T())
     382    template <typename V1, typename Comp1>
     383    SparseMap(const std::map<Key, V1, Comp1> &map,
     384              const Value &value = Value())
    200385      : _map(map.begin(), map.end()), _value(value) {}
    201    
    202     /// \brief Constructs a map from an other \ref StdMap.
    203     template<typename T1, typename Comp1>
    204     StdMap(const StdMap<Key, T1, Comp1> &c)
     386
     387    /// \brief Constructs the map from another \ref SparseMap.
     388    template<typename V1, typename Comp1>
     389    SparseMap(const SparseMap<Key, V1, Comp1> &c)
    205390      : _map(c._map.begin(), c._map.end()), _value(c._value) {}
    206391
    207392  private:
    208393
    209     StdMap& operator=(const StdMap&);
     394    SparseMap& operator=(const SparseMap&);
    210395
    211396  public:
     
    220405    }
    221406
    222     /// \e
     407    ///\e
    223408    ConstReference operator[](const Key &k) const {
    224409      typename Map::const_iterator it = _map.find(k);
     
    229414    }
    230415
    231     /// \e
    232     void set(const Key &k, const T &t) {
     416    ///\e
     417    void set(const Key &k, const Value &v) {
    233418      typename Map::iterator it = _map.lower_bound(k);
    234419      if (it != _map.end() && !_map.key_comp()(k, it->first))
    235         it->second = t;
     420        it->second = v;
    236421      else
    237         _map.insert(it, std::make_pair(k, t));
    238     }
    239 
    240     /// \e
    241     void setAll(const T &t) {
    242       _value = t;
     422        _map.insert(it, std::make_pair(k, v));
     423    }
     424
     425    ///\e
     426    void setAll(const Value &v) {
     427      _value = v;
    243428      _map.clear();
    244     }   
    245 
    246   };
    247  
    248   ///Returns a \c StdMap class
    249 
    250   ///This function just returns a \c StdMap class with specified
    251   ///default value.
    252   ///\relates StdMap
    253   template<typename K, typename V, typename Compare>
    254   inline StdMap<K, V, Compare> stdMap(const V& value = V()) {
    255     return StdMap<K, V, Compare>(value);
    256   }
    257  
    258   ///Returns a \c StdMap class
    259 
    260   ///This function just returns a \c StdMap class with specified
    261   ///default value.
    262   ///\relates StdMap
    263   template<typename K, typename V>
    264   inline StdMap<K, V, std::less<K> > stdMap(const V& value = V()) {
    265     return StdMap<K, V, std::less<K> >(value);
    266   }
    267  
    268   ///Returns a \c StdMap class created from an appropriate std::map
    269 
    270   ///This function just returns a \c StdMap class created from an
    271   ///appropriate std::map.
    272   ///\relates StdMap
    273   template<typename K, typename V, typename Compare>
    274   inline StdMap<K, V, Compare> stdMap( const std::map<K, V, Compare> &map,
    275                                        const V& value = V() ) {
    276     return StdMap<K, V, Compare>(map, value);
    277   }
    278 
    279   ///Returns a \c StdMap class created from an appropriate std::map
    280 
    281   ///This function just returns a \c StdMap class created from an
    282   ///appropriate std::map.
    283   ///\relates StdMap
    284   template<typename K, typename V>
    285   inline StdMap<K, V, std::less<K> > stdMap( const std::map<K, V, std::less<K> > &map,
    286                                              const V& value = V() ) {
    287     return StdMap<K, V, std::less<K> >(map, value);
    288   }
    289 
    290   /// \brief Map for storing values for keys from the range <tt>[0..size-1]</tt>
    291   ///
    292   /// This map has the <tt>[0..size-1]</tt> keyset and the values
    293   /// are stored in a \c std::vector<T>  container. It can be used with
    294   /// some data structures, for example \c UnionFind, \c BinHeap, when
    295   /// the used items are small integer numbers.
    296   /// This map meets the \ref concepts::ReferenceMap "ReferenceMap" concept.
    297   ///
    298   /// \todo Revise its name
    299   template <typename T>
    300   class IntegerMap : public MapBase<int, T> {
    301 
    302     template <typename T1>
    303     friend class IntegerMap;
    304 
    305   public:
    306 
    307     typedef MapBase<int, T> Parent;
    308     ///\e
    309     typedef typename Parent::Key Key;
    310     ///\e
    311     typedef typename Parent::Value Value;
    312     ///\e
    313     typedef T& Reference;
    314     ///\e
    315     typedef const T& ConstReference;
    316 
    317     typedef True ReferenceMapTag;
    318 
    319   private:
    320    
    321     typedef std::vector<T> Vector;
    322     Vector _vector;
    323 
    324   public:
    325 
    326     /// Constructor with specified default value
    327     IntegerMap(int size = 0, const T& value = T()) : _vector(size, value) {}
    328 
    329     /// \brief Constructs the map from an appropriate \c std::vector.
    330     template <typename T1>
    331     IntegerMap(const std::vector<T1>& vector)
    332       : _vector(vector.begin(), vector.end()) {}
    333    
    334     /// \brief Constructs a map from an other \ref IntegerMap.
    335     template <typename T1>
    336     IntegerMap(const IntegerMap<T1> &c)
    337       : _vector(c._vector.begin(), c._vector.end()) {}
    338 
    339     /// \brief Resize the container
    340     void resize(int size, const T& value = T()) {
    341       _vector.resize(size, value);
    342     }
    343 
    344   private:
    345 
    346     IntegerMap& operator=(const IntegerMap&);
    347 
    348   public:
    349 
    350     ///\e
    351     Reference operator[](Key k) {
    352       return _vector[k];
    353     }
    354 
    355     /// \e
    356     ConstReference operator[](Key k) const {
    357       return _vector[k];
    358     }
    359 
    360     /// \e
    361     void set(const Key &k, const T& t) {
    362       _vector[k] = t;
    363     }
    364 
    365   };
    366  
    367   ///Returns an \c IntegerMap class
    368 
    369   ///This function just returns an \c IntegerMap class.
    370   ///\relates IntegerMap
    371   template<typename T>
    372   inline IntegerMap<T> integerMap(int size = 0, const T& value = T()) {
    373     return IntegerMap<T>(size, value);
     429    }
     430  };
     431
     432  /// Returns a \ref SparseMap class
     433
     434  /// This function just returns a \ref SparseMap class with specified
     435  /// default value.
     436  /// \relates SparseMap
     437  template<typename K, typename V, typename Compare>
     438  inline SparseMap<K, V, Compare> sparseMap(const V& value = V()) {
     439    return SparseMap<K, V, Compare>(value);
     440  }
     441
     442  template<typename K, typename V>
     443  inline SparseMap<K, V, std::less<K> > sparseMap(const V& value = V()) {
     444    return SparseMap<K, V, std::less<K> >(value);
     445  }
     446
     447  /// \brief Returns a \ref SparseMap class created from an appropriate
     448  /// \c std::map
     449
     450  /// This function just returns a \ref SparseMap class created from an
     451  /// appropriate \c std::map.
     452  /// \relates SparseMap
     453  template<typename K, typename V, typename Compare>
     454  inline SparseMap<K, V, Compare>
     455    sparseMap(const std::map<K, V, Compare> &map, const V& value = V())
     456  {
     457    return SparseMap<K, V, Compare>(map, value);
    374458  }
    375459
     
    379463  /// @{
    380464
    381   /// \brief Identity map.
    382   ///
    383   /// This map gives back the given key as value without any
    384   /// modification.
    385   template <typename T>
    386   class IdentityMap : public MapBase<T, T> {
    387   public:
    388     typedef MapBase<T, T> Parent;
    389     typedef typename Parent::Key Key;
    390     typedef typename Parent::Value Value;
    391 
    392     /// \e
    393     const T& operator[](const T& t) const {
    394       return t;
    395     }
    396   };
    397 
    398   ///Returns an \c IdentityMap class
    399 
    400   ///This function just returns an \c IdentityMap class.
    401   ///\relates IdentityMap
    402   template<typename T>
    403   inline IdentityMap<T> identityMap() {
    404     return IdentityMap<T>();
    405   }
    406  
    407 
    408   ///\brief Convert the \c Value of a map to another type using
    409   ///the default conversion.
    410   ///
    411   ///This \ref concepts::ReadMap "read only map"
    412   ///converts the \c Value of a map to type \c T.
    413   ///Its \c Key is inherited from \c M.
    414   template <typename M, typename T>
    415   class ConvertMap : public MapBase<typename M::Key, T> {
    416     const M& m;
    417   public:
    418     typedef MapBase<typename M::Key, T> Parent;
    419     typedef typename Parent::Key Key;
    420     typedef typename Parent::Value Value;
    421 
    422     ///Constructor
    423 
    424     ///Constructor.
    425     ///\param _m is the underlying map.
    426     ConvertMap(const M &_m) : m(_m) {};
    427 
    428     ///\e
    429     Value operator[](const Key& k) const {return m[k];}
    430   };
    431  
    432   ///Returns a \c ConvertMap class
    433 
    434   ///This function just returns a \c ConvertMap class.
    435   ///\relates ConvertMap
    436   template<typename T, typename M>
    437   inline ConvertMap<M, T> convertMap(const M &m) {
    438     return ConvertMap<M, T>(m);
    439   }
    440 
    441   ///Simple wrapping of a map
    442 
    443   ///This \ref concepts::ReadMap "read only map" returns the simple
    444   ///wrapping of the given map. Sometimes the reference maps cannot be
    445   ///combined with simple read maps. This map adaptor wraps the given
    446   ///map to simple read map.
    447   ///
    448   ///\sa SimpleWriteMap
    449   ///
    450   /// \todo Revise the misleading name
    451   template<typename M>
    452   class SimpleMap : public MapBase<typename M::Key, typename M::Value> {
    453     const M& m;
    454 
     465  /// Composition of two maps
     466
     467  /// This \ref concepts::ReadMap "read only map" returns the
     468  /// composition of two given maps. That is to say, if \c m1 is of
     469  /// type \c M1 and \c m2 is of \c M2, then for
     470  /// \code
     471  ///   ComposeMap<M1, M2> cm(m1,m2);
     472  /// \endcode
     473  /// <tt>cm[x]</tt> will be equal to <tt>m1[m2[x]]</tt>.
     474  ///
     475  /// The \c Key type of the map is inherited from \c M2 and the
     476  /// \c Value type is from \c M1.
     477  /// \c M2::Value must be convertible to \c M1::Key.
     478  ///
     479  /// The simplest way of using this map is through the composeMap()
     480  /// function.
     481  ///
     482  /// \sa CombineMap
     483  ///
     484  /// \todo Check the requirements.
     485  template <typename M1, typename M2>
     486  class ComposeMap : public MapBase<typename M2::Key, typename M1::Value> {
     487    const M1 &_m1;
     488    const M2 &_m2;
     489  public:
     490    typedef MapBase<typename M2::Key, typename M1::Value> Parent;
     491    typedef typename Parent::Key Key;
     492    typedef typename Parent::Value Value;
     493
     494    /// Constructor
     495    ComposeMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
     496
     497    /// \e
     498    typename MapTraits<M1>::ConstReturnValue
     499    operator[](const Key &k) const { return _m1[_m2[k]]; }
     500  };
     501
     502  /// Returns a \ref ComposeMap class
     503
     504  /// This function just returns a \ref ComposeMap class.
     505  ///
     506  /// If \c m1 and \c m2 are maps and the \c Value type of \c m2 is
     507  /// convertible to the \c Key of \c m1, then <tt>composeMap(m1,m2)[x]</tt>
     508  /// will be equal to <tt>m1[m2[x]]</tt>.
     509  ///
     510  /// \relates ComposeMap
     511  template <typename M1, typename M2>
     512  inline ComposeMap<M1, M2> composeMap(const M1 &m1, const M2 &m2) {
     513    return ComposeMap<M1, M2>(m1, m2);
     514  }
     515
     516
     517  /// Combination of two maps using an STL (binary) functor.
     518
     519  /// This \ref concepts::ReadMap "read only map" takes two maps and a
     520  /// binary functor and returns the combination of the two given maps
     521  /// using the functor.
     522  /// That is to say, if \c m1 is of type \c M1 and \c m2 is of \c M2
     523  /// and \c f is of \c F, then for
     524  /// \code
     525  ///   CombineMap<M1,M2,F,V> cm(m1,m2,f);
     526  /// \endcode
     527  /// <tt>cm[x]</tt> will be equal to <tt>f(m1[x],m2[x])</tt>.
     528  ///
     529  /// The \c Key type of the map is inherited from \c M1 (\c M1::Key
     530  /// must be convertible to \c M2::Key) and the \c Value type is \c V.
     531  /// \c M2::Value and \c M1::Value must be convertible to the
     532  /// corresponding input parameter of \c F and the return type of \c F
     533  /// must be convertible to \c V.
     534  ///
     535  /// The simplest way of using this map is through the combineMap()
     536  /// function.
     537  ///
     538  /// \sa ComposeMap
     539  ///
     540  /// \todo Check the requirements.
     541  template<typename M1, typename M2, typename F,
     542           typename V = typename F::result_type>
     543  class CombineMap : public MapBase<typename M1::Key, V> {
     544    const M1 &_m1;
     545    const M2 &_m2;
     546    F _f;
     547  public:
     548    typedef MapBase<typename M1::Key, V> Parent;
     549    typedef typename Parent::Key Key;
     550    typedef typename Parent::Value Value;
     551
     552    /// Constructor
     553    CombineMap(const M1 &m1, const M2 &m2, const F &f = F())
     554      : _m1(m1), _m2(m2), _f(f) {}
     555    /// \e
     556    Value operator[](const Key &k) const { return _f(_m1[k],_m2[k]); }
     557  };
     558
     559  /// Returns a \ref CombineMap class
     560
     561  /// This function just returns a \ref CombineMap class.
     562  ///
     563  /// For example, if \c m1 and \c m2 are both maps with \c double
     564  /// values, then
     565  /// \code
     566  ///   combineMap(m1,m2,std::plus<double>())
     567  /// \endcode
     568  /// is equivalent to
     569  /// \code
     570  ///   addMap(m1,m2)
     571  /// \endcode
     572  ///
     573  /// This function is specialized for adaptable binary function
     574  /// classes and C++ functions.
     575  ///
     576  /// \relates CombineMap
     577  template<typename M1, typename M2, typename F, typename V>
     578  inline CombineMap<M1, M2, F, V>
     579  combineMap(const M1 &m1, const M2 &m2, const F &f) {
     580    return CombineMap<M1, M2, F, V>(m1,m2,f);
     581  }
     582
     583  template<typename M1, typename M2, typename F>
     584  inline CombineMap<M1, M2, F, typename F::result_type>
     585  combineMap(const M1 &m1, const M2 &m2, const F &f) {
     586    return combineMap<M1, M2, F, typename F::result_type>(m1,m2,f);
     587  }
     588
     589  template<typename M1, typename M2, typename K1, typename K2, typename V>
     590  inline CombineMap<M1, M2, V (*)(K1, K2), V>
     591  combineMap(const M1 &m1, const M2 &m2, V (*f)(K1, K2)) {
     592    return combineMap<M1, M2, V (*)(K1, K2), V>(m1,m2,f);
     593  }
     594
     595
     596  /// Converts an STL style (unary) functor to a map
     597
     598  /// This \ref concepts::ReadMap "read only map" returns the value
     599  /// of a given functor. Actually, it just wraps the functor and
     600  /// provides the \c Key and \c Value typedefs.
     601  ///
     602  /// Template parameters \c K and \c V will become its \c Key and
     603  /// \c Value. In most cases they have to be given explicitly because
     604  /// a functor typically does not provide \c argument_type and
     605  /// \c result_type typedefs.
     606  /// Parameter \c F is the type of the used functor.
     607  ///
     608  /// The simplest way of using this map is through the functorToMap()
     609  /// function.
     610  ///
     611  /// \sa MapToFunctor
     612  template<typename F,
     613           typename K = typename F::argument_type,
     614           typename V = typename F::result_type>
     615  class FunctorToMap : public MapBase<K, V> {
     616    const F &_f;
     617  public:
     618    typedef MapBase<K, V> Parent;
     619    typedef typename Parent::Key Key;
     620    typedef typename Parent::Value Value;
     621
     622    /// Constructor
     623    FunctorToMap(const F &f = F()) : _f(f) {}
     624    /// \e
     625    Value operator[](const Key &k) const { return _f(k); }
     626  };
     627
     628  /// Returns a \ref FunctorToMap class
     629
     630  /// This function just returns a \ref FunctorToMap class.
     631  ///
     632  /// This function is specialized for adaptable binary function
     633  /// classes and C++ functions.
     634  ///
     635  /// \relates FunctorToMap
     636  template<typename K, typename V, typename F>
     637  inline FunctorToMap<F, K, V> functorToMap(const F &f) {
     638    return FunctorToMap<F, K, V>(f);
     639  }
     640
     641  template <typename F>
     642  inline FunctorToMap<F, typename F::argument_type, typename F::result_type>
     643    functorToMap(const F &f)
     644  {
     645    return FunctorToMap<F, typename F::argument_type,
     646      typename F::result_type>(f);
     647  }
     648
     649  template <typename K, typename V>
     650  inline FunctorToMap<V (*)(K), K, V> functorToMap(V (*f)(K)) {
     651    return FunctorToMap<V (*)(K), K, V>(f);
     652  }
     653
     654
     655  /// Converts a map to an STL style (unary) functor
     656
     657  /// This class converts a map to an STL style (unary) functor.
     658  /// That is it provides an <tt>operator()</tt> to read its values.
     659  ///
     660  /// For the sake of convenience it also works as a usual
     661  /// \ref concepts::ReadMap "readable map", i.e. <tt>operator[]</tt>
     662  /// and the \c Key and \c Value typedefs also exist.
     663  ///
     664  /// The simplest way of using this map is through the mapToFunctor()
     665  /// function.
     666  ///
     667  ///\sa FunctorToMap
     668  template <typename M>
     669  class MapToFunctor : public MapBase<typename M::Key, typename M::Value> {
     670    const M &_m;
    455671  public:
    456672    typedef MapBase<typename M::Key, typename M::Value> Parent;
     
    458674    typedef typename Parent::Value Value;
    459675
    460     ///Constructor
    461     SimpleMap(const M &_m) : m(_m) {};
    462     ///\e
    463     Value operator[](Key k) const {return m[k];}
    464   };
    465  
    466   ///Returns a \c SimpleMap class
    467 
    468   ///This function just returns a \c SimpleMap class.
    469   ///\relates SimpleMap
     676    typedef typename Parent::Key argument_type;
     677    typedef typename Parent::Value result_type;
     678
     679    /// Constructor
     680    MapToFunctor(const M &m) : _m(m) {}
     681    /// \e
     682    Value operator()(const Key &k) const { return _m[k]; }
     683    /// \e
     684    Value operator[](const Key &k) const { return _m[k]; }
     685  };
     686
     687  /// Returns a \ref MapToFunctor class
     688
     689  /// This function just returns a \ref MapToFunctor class.
     690  /// \relates MapToFunctor
    470691  template<typename M>
    471   inline SimpleMap<M> simpleMap(const M &m) {
    472     return SimpleMap<M>(m);
    473   }
    474 
    475   ///Simple writable wrapping of a map
    476 
    477   ///This \ref concepts::ReadWriteMap "read-write map" returns the simple
    478   ///wrapping of the given map. Sometimes the reference maps cannot be
    479   ///combined with simple read-write maps. This map adaptor wraps the
    480   ///given map to simple read-write map.
    481   ///
    482   ///\sa SimpleMap
    483   ///
    484   /// \todo Revise the misleading name
    485   template<typename M>
    486   class SimpleWriteMap : public MapBase<typename M::Key, typename M::Value> {
    487     M& m;
    488 
     692  inline MapToFunctor<M> mapToFunctor(const M &m) {
     693    return MapToFunctor<M>(m);
     694  }
     695
     696
     697  /// \brief Map adaptor to convert the \c Value type of a map to
     698  /// another type using the default conversion.
     699
     700  /// Map adaptor to convert the \c Value type of a \ref concepts::ReadMap
     701  /// "readable map" to another type using the default conversion.
     702  /// The \c Key type of it is inherited from \c M and the \c Value
     703  /// type is \c V.
     704  /// This type conforms the \ref concepts::ReadMap "ReadMap" concept.
     705  ///
     706  /// The simplest way of using this map is through the convertMap()
     707  /// function.
     708  template <typename M, typename V>
     709  class ConvertMap : public MapBase<typename M::Key, V> {
     710    const M &_m;
     711  public:
     712    typedef MapBase<typename M::Key, V> Parent;
     713    typedef typename Parent::Key Key;
     714    typedef typename Parent::Value Value;
     715
     716    /// Constructor
     717
     718    /// Constructor.
     719    /// \param m The underlying map.
     720    ConvertMap(const M &m) : _m(m) {}
     721
     722    /// \e
     723    Value operator[](const Key &k) const { return _m[k]; }
     724  };
     725
     726  /// Returns a \ref ConvertMap class
     727
     728  /// This function just returns a \ref ConvertMap class.
     729  /// \relates ConvertMap
     730  template<typename V, typename M>
     731  inline ConvertMap<M, V> convertMap(const M &map) {
     732    return ConvertMap<M, V>(map);
     733  }
     734
     735
     736  /// Applies all map setting operations to two maps
     737
     738  /// This map has two \ref concepts::WriteMap "writable map" parameters
     739  /// and each write request will be passed to both of them.
     740  /// If \c M1 is also \ref concepts::ReadMap "readable", then the read
     741  /// operations will return the corresponding values of \c M1.
     742  ///
     743  /// The \c Key and \c Value types are inherited from \c M1.
     744  /// The \c Key and \c Value of \c M2 must be convertible from those
     745  /// of \c M1.
     746  ///
     747  /// The simplest way of using this map is through the forkMap()
     748  /// function.
     749  template<typename  M1, typename M2>
     750  class ForkMap : public MapBase<typename M1::Key, typename M1::Value> {
     751    M1 &_m1;
     752    M2 &_m2;
     753  public:
     754    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
     755    typedef typename Parent::Key Key;
     756    typedef typename Parent::Value Value;
     757
     758    /// Constructor
     759    ForkMap(M1 &m1, M2 &m2) : _m1(m1), _m2(m2) {}
     760    /// Returns the value associated with the given key in the first map.
     761    Value operator[](const Key &k) const { return _m1[k]; }
     762    /// Sets the value associated with the given key in both maps.
     763    void set(const Key &k, const Value &v) { _m1.set(k,v); _m2.set(k,v); }
     764  };
     765
     766  /// Returns a \ref ForkMap class
     767
     768  /// This function just returns a \ref ForkMap class.
     769  /// \relates ForkMap
     770  template <typename M1, typename M2>
     771  inline ForkMap<M1,M2> forkMap(M1 &m1, M2 &m2) {
     772    return ForkMap<M1,M2>(m1,m2);
     773  }
     774
     775
     776  /// Simple wrapping of a map
     777
     778  /// This \ref concepts::ReadMap "read only map" returns the simple
     779  /// wrapping of the given map. Sometimes the reference maps cannot be
     780  /// combined with simple read maps. This map adaptor wraps the given
     781  /// map to simple read map.
     782  ///
     783  /// The simplest way of using this map is through the wrapMap()
     784  /// function.
     785  ///
     786  /// \sa WrapWriteMap
     787  template<typename M>
     788  class WrapMap : public MapBase<typename M::Key, typename M::Value> {
     789    const M &_m;
    489790  public:
    490791    typedef MapBase<typename M::Key, typename M::Value> Parent;
     
    492793    typedef typename Parent::Value Value;
    493794
    494     ///Constructor
    495     SimpleWriteMap(M &_m) : m(_m) {};
    496     ///\e
    497     Value operator[](Key k) const {return m[k];}
    498     ///\e
    499     void set(Key k, const Value& c) { m.set(k, c); }
    500   };
    501 
    502   ///Returns a \c SimpleWriteMap class
    503 
    504   ///This function just returns a \c SimpleWriteMap class.
    505   ///\relates SimpleWriteMap
     795    /// Constructor
     796    WrapMap(const M &m) : _m(m) {}
     797    /// \e
     798    Value operator[](const Key &k) const { return _m[k]; }
     799  };
     800
     801  /// Returns a \ref WrapMap class
     802
     803  /// This function just returns a \ref WrapMap class.
     804  /// \relates WrapMap
    506805  template<typename M>
    507   inline SimpleWriteMap<M> simpleWriteMap(M &m) {
    508     return SimpleWriteMap<M>(m);
    509   }
    510 
    511   ///Sum of two maps
    512 
    513   ///This \ref concepts::ReadMap "read only map" returns the sum of the two
    514   ///given maps.
    515   ///Its \c Key and \c Value are inherited from \c M1.
    516   ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
    517   template<typename M1, typename M2>
     806  inline WrapMap<M> wrapMap(const M &map) {
     807    return WrapMap<M>(map);
     808  }
     809
     810
     811  /// Simple writable wrapping of a map
     812
     813  /// This \ref concepts::ReadWriteMap "read-write map" returns the simple
     814  /// wrapping of the given map. Sometimes the reference maps cannot be
     815  /// combined with simple read-write maps. This map adaptor wraps the
     816  /// given map to simple read-write map.
     817  ///
     818  /// The simplest way of using this map is through the wrapWriteMap()
     819  /// function.
     820  ///
     821  /// \sa WrapMap
     822  template<typename M>
     823  class WrapWriteMap : public MapBase<typename M::Key, typename M::Value> {
     824    M &_m;
     825  public:
     826    typedef MapBase<typename M::Key, typename M::Value> Parent;
     827    typedef typename Parent::Key Key;
     828    typedef typename Parent::Value Value;
     829
     830    /// Constructor
     831    WrapWriteMap(M &m) : _m(m) {}
     832    /// \e
     833    Value operator[](const Key &k) const { return _m[k]; }
     834    /// \e
     835    void set(const Key &k, const Value &c) { _m.set(k, c); }
     836  };
     837
     838  ///Returns a \ref WrapWriteMap class
     839
     840  ///This function just returns a \ref WrapWriteMap class.
     841  ///\relates WrapWriteMap
     842  template<typename M>
     843  inline WrapWriteMap<M> wrapWriteMap(M &map) {
     844    return WrapWriteMap<M>(map);
     845  }
     846
     847
     848  /// Sum of two maps
     849
     850  /// This \ref concepts::ReadMap "read only map" returns the sum
     851  /// of the values of the two given maps.
     852  /// Its \c Key and \c Value types are inherited from \c M1.
     853  /// The \c Key and \c Value of \c M2 must be convertible to those of
     854  /// \c M1.
     855  ///
     856  /// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for
     857  /// \code
     858  ///   AddMap<M1,M2> am(m1,m2);
     859  /// \endcode
     860  /// <tt>am[x]</tt> will be equal to <tt>m1[x]+m2[x]</tt>.
     861  ///
     862  /// The simplest way of using this map is through the addMap()
     863  /// function.
     864  ///
     865  /// \sa SubMap, MulMap, DivMap
     866  /// \sa ShiftMap, ShiftWriteMap
     867  template<typename M1, typename M2>
    518868  class AddMap : public MapBase<typename M1::Key, typename M1::Value> {
    519     const M1& m1;
    520     const M2& m2;
    521 
     869    const M1 &_m1;
     870    const M2 &_m2;
    522871  public:
    523872    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
     
    525874    typedef typename Parent::Value Value;
    526875
    527     ///Constructor
    528     AddMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
    529     ///\e
    530     Value operator[](Key k) const {return m1[k]+m2[k];}
    531   };
    532  
    533   ///Returns an \c AddMap class
    534 
    535   ///This function just returns an \c AddMap class.
    536   ///\todo Extend the documentation: how to call these type of functions?
    537   ///
    538   ///\relates AddMap
    539   template<typename M1, typename M2>
    540   inline AddMap<M1, M2> addMap(const M1 &m1,const M2 &m2) {
     876    /// Constructor
     877    AddMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
     878    /// \e
     879    Value operator[](const Key &k) const { return _m1[k]+_m2[k]; }
     880  };
     881
     882  /// Returns an \ref AddMap class
     883
     884  /// This function just returns an \ref AddMap class.
     885  ///
     886  /// For example, if \c m1 and \c m2 are both maps with \c double
     887  /// values, then <tt>addMap(m1,m2)[x]</tt> will be equal to
     888  /// <tt>m1[x]+m2[x]</tt>.
     889  ///
     890  /// \relates AddMap
     891  template<typename M1, typename M2>
     892  inline AddMap<M1, M2> addMap(const M1 &m1, const M2 &m2) {
    541893    return AddMap<M1, M2>(m1,m2);
    542894  }
    543895
    544   ///Shift a map with a constant.
    545 
    546   ///This \ref concepts::ReadMap "read only map" returns the sum of the
    547   ///given map and a constant value.
    548   ///Its \c Key and \c Value are inherited from \c M.
    549   ///
    550   ///Actually,
    551   ///\code
    552   ///  ShiftMap<X> sh(x,v);
    553   ///\endcode
    554   ///is equivalent to
    555   ///\code
    556   ///  ConstMap<X::Key, X::Value> c_tmp(v);
    557   ///  AddMap<X, ConstMap<X::Key, X::Value> > sh(x,v);
    558   ///\endcode
    559   ///
    560   ///\sa ShiftWriteMap
    561   template<typename M, typename C = typename M::Value>
    562   class ShiftMap : public MapBase<typename M::Key, typename M::Value> {
    563     const M& m;
    564     C v;
    565   public:
    566     typedef MapBase<typename M::Key, typename M::Value> Parent;
    567     typedef typename Parent::Key Key;
    568     typedef typename Parent::Value Value;
    569 
    570     ///Constructor
    571 
    572     ///Constructor.
    573     ///\param _m is the undelying map.
    574     ///\param _v is the shift value.
    575     ShiftMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
    576     ///\e
    577     Value operator[](Key k) const {return m[k] + v;}
    578   };
    579 
    580   ///Shift a map with a constant (ReadWrite version).
    581 
    582   ///This \ref concepts::ReadWriteMap "read-write map" returns the sum of the
    583   ///given map and a constant value. It makes also possible to write the map.
    584   ///Its \c Key and \c Value are inherited from \c M.
    585   ///
    586   ///\sa ShiftMap
    587   template<typename M, typename C = typename M::Value>
    588   class ShiftWriteMap : public MapBase<typename M::Key, typename M::Value> {
    589     M& m;
    590     C v;
    591   public:
    592     typedef MapBase<typename M::Key, typename M::Value> Parent;
    593     typedef typename Parent::Key Key;
    594     typedef typename Parent::Value Value;
    595 
    596     ///Constructor
    597 
    598     ///Constructor.
    599     ///\param _m is the undelying map.
    600     ///\param _v is the shift value.
    601     ShiftWriteMap(M &_m, const C &_v ) : m(_m), v(_v) {};
    602     /// \e
    603     Value operator[](Key k) const {return m[k] + v;}
    604     /// \e
    605     void set(Key k, const Value& c) { m.set(k, c - v); }
    606   };
    607  
    608   ///Returns a \c ShiftMap class
    609 
    610   ///This function just returns a \c ShiftMap class.
    611   ///\relates ShiftMap
    612   template<typename M, typename C>
    613   inline ShiftMap<M, C> shiftMap(const M &m,const C &v) {
    614     return ShiftMap<M, C>(m,v);
    615   }
    616 
    617   ///Returns a \c ShiftWriteMap class
    618 
    619   ///This function just returns a \c ShiftWriteMap class.
    620   ///\relates ShiftWriteMap
    621   template<typename M, typename C>
    622   inline ShiftWriteMap<M, C> shiftMap(M &m,const C &v) {
    623     return ShiftWriteMap<M, C>(m,v);
    624   }
    625 
    626   ///Difference of two maps
    627 
    628   ///This \ref concepts::ReadMap "read only map" returns the difference
    629   ///of the values of the two given maps.
    630   ///Its \c Key and \c Value are inherited from \c M1.
    631   ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
    632   ///
    633   /// \todo Revise the misleading name
    634   template<typename M1, typename M2>
     896
     897  /// Difference of two maps
     898
     899  /// This \ref concepts::ReadMap "read only map" returns the difference
     900  /// of the values of the two given maps.
     901  /// Its \c Key and \c Value types are inherited from \c M1.
     902  /// The \c Key and \c Value of \c M2 must be convertible to those of
     903  /// \c M1.
     904  ///
     905  /// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for
     906  /// \code
     907  ///   SubMap<M1,M2> sm(m1,m2);
     908  /// \endcode
     909  /// <tt>sm[x]</tt> will be equal to <tt>m1[x]-m2[x]</tt>.
     910  ///
     911  /// The simplest way of using this map is through the subMap()
     912  /// function.
     913  ///
     914  /// \sa AddMap, MulMap, DivMap
     915  template<typename M1, typename M2>
    635916  class SubMap : public MapBase<typename M1::Key, typename M1::Value> {
    636     const M1& m1;
    637     const M2& m2;
     917    const M1 &_m1;
     918    const M2 &_m2;
    638919  public:
    639920    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
     
    641922    typedef typename Parent::Value Value;
    642923
    643     ///Constructor
    644     SubMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
    645     /// \e
    646     Value operator[](Key k) const {return m1[k]-m2[k];}
    647   };
    648  
    649   ///Returns a \c SubMap class
    650 
    651   ///This function just returns a \c SubMap class.
    652   ///
    653   ///\relates SubMap
    654   template<typename M1, typename M2>
     924    /// Constructor
     925    SubMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
     926    /// \e
     927    Value operator[](const Key &k) const { return _m1[k]-_m2[k]; }
     928  };
     929
     930  /// Returns a \ref SubMap class
     931
     932  /// This function just returns a \ref SubMap class.
     933  ///
     934  /// For example, if \c m1 and \c m2 are both maps with \c double
     935  /// values, then <tt>subMap(m1,m2)[x]</tt> will be equal to
     936  /// <tt>m1[x]-m2[x]</tt>.
     937  ///
     938  /// \relates SubMap
     939  template<typename M1, typename M2>
    655940  inline SubMap<M1, M2> subMap(const M1 &m1, const M2 &m2) {
    656     return SubMap<M1, M2>(m1, m2);
    657   }
    658 
    659   ///Product of two maps
    660 
    661   ///This \ref concepts::ReadMap "read only map" returns the product of the
    662   ///values of the two given maps.
    663   ///Its \c Key and \c Value are inherited from \c M1.
    664   ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
    665   template<typename M1, typename M2>
     941    return SubMap<M1, M2>(m1,m2);
     942  }
     943
     944
     945  /// Product of two maps
     946
     947  /// This \ref concepts::ReadMap "read only map" returns the product
     948  /// of the values of the two given maps.
     949  /// Its \c Key and \c Value types are inherited from \c M1.
     950  /// The \c Key and \c Value of \c M2 must be convertible to those of
     951  /// \c M1.
     952  ///
     953  /// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for
     954  /// \code
     955  ///   MulMap<M1,M2> mm(m1,m2);
     956  /// \endcode
     957  /// <tt>mm[x]</tt> will be equal to <tt>m1[x]*m2[x]</tt>.
     958  ///
     959  /// The simplest way of using this map is through the mulMap()
     960  /// function.
     961  ///
     962  /// \sa AddMap, SubMap, DivMap
     963  /// \sa ScaleMap, ScaleWriteMap
     964  template<typename M1, typename M2>
    666965  class MulMap : public MapBase<typename M1::Key, typename M1::Value> {
    667     const M1& m1;
    668     const M2& m2;
     966    const M1 &_m1;
     967    const M2 &_m2;
    669968  public:
    670969    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
     
    672971    typedef typename Parent::Value Value;
    673972
    674     ///Constructor
    675     MulMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
    676     /// \e
    677     Value operator[](Key k) const {return m1[k]*m2[k];}
    678   };
    679  
    680   ///Returns a \c MulMap class
    681 
    682   ///This function just returns a \c MulMap class.
    683   ///\relates MulMap
    684   template<typename M1, typename M2>
     973    /// Constructor
     974    MulMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
     975    /// \e
     976    Value operator[](const Key &k) const { return _m1[k]*_m2[k]; }
     977  };
     978
     979  /// Returns a \ref MulMap class
     980
     981  /// This function just returns a \ref MulMap class.
     982  ///
     983  /// For example, if \c m1 and \c m2 are both maps with \c double
     984  /// values, then <tt>mulMap(m1,m2)[x]</tt> will be equal to
     985  /// <tt>m1[x]*m2[x]</tt>.
     986  ///
     987  /// \relates MulMap
     988  template<typename M1, typename M2>
    685989  inline MulMap<M1, M2> mulMap(const M1 &m1,const M2 &m2) {
    686990    return MulMap<M1, M2>(m1,m2);
    687991  }
    688  
    689   ///Scales a map with a constant.
    690 
    691   ///This \ref concepts::ReadMap "read only map" returns the value of the
    692   ///given map multiplied from the left side with a constant value.
    693   ///Its \c Key and \c Value are inherited from \c M.
    694   ///
    695   ///Actually,
    696   ///\code
    697   ///  ScaleMap<X> sc(x,v);
    698   ///\endcode
    699   ///is equivalent to
    700   ///\code
    701   ///  ConstMap<X::Key, X::Value> c_tmp(v);
    702   ///  MulMap<X, ConstMap<X::Key, X::Value> > sc(x,v);
    703   ///\endcode
    704   ///
    705   ///\sa ScaleWriteMap
    706   template<typename M, typename C = typename M::Value>
    707   class ScaleMap : public MapBase<typename M::Key, typename M::Value> {
    708     const M& m;
    709     C v;
    710   public:
    711     typedef MapBase<typename M::Key, typename M::Value> Parent;
    712     typedef typename Parent::Key Key;
    713     typedef typename Parent::Value Value;
    714 
    715     ///Constructor
    716 
    717     ///Constructor.
    718     ///\param _m is the undelying map.
    719     ///\param _v is the scaling value.
    720     ScaleMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
    721     /// \e
    722     Value operator[](Key k) const {return v * m[k];}
    723   };
    724 
    725   ///Scales a map with a constant (ReadWrite version).
    726 
    727   ///This \ref concepts::ReadWriteMap "read-write map" returns the value of the
    728   ///given map multiplied from the left side with a constant value. It can
    729   ///also be used as write map if the \c / operator is defined between
    730   ///\c Value and \c C and the given multiplier is not zero.
    731   ///Its \c Key and \c Value are inherited from \c M.
    732   ///
    733   ///\sa ScaleMap
    734   template<typename M, typename C = typename M::Value>
    735   class ScaleWriteMap : public MapBase<typename M::Key, typename M::Value> {
    736     M& m;
    737     C v;
    738   public:
    739     typedef MapBase<typename M::Key, typename M::Value> Parent;
    740     typedef typename Parent::Key Key;
    741     typedef typename Parent::Value Value;
    742 
    743     ///Constructor
    744 
    745     ///Constructor.
    746     ///\param _m is the undelying map.
    747     ///\param _v is the scaling value.
    748     ScaleWriteMap(M &_m, const C &_v ) : m(_m), v(_v) {};
    749     /// \e
    750     Value operator[](Key k) const {return v * m[k];}
    751     /// \e
    752     void set(Key k, const Value& c) { m.set(k, c / v);}
    753   };
    754  
    755   ///Returns a \c ScaleMap class
    756 
    757   ///This function just returns a \c ScaleMap class.
    758   ///\relates ScaleMap
    759   template<typename M, typename C>
    760   inline ScaleMap<M, C> scaleMap(const M &m,const C &v) {
    761     return ScaleMap<M, C>(m,v);
    762   }
    763 
    764   ///Returns a \c ScaleWriteMap class
    765 
    766   ///This function just returns a \c ScaleWriteMap class.
    767   ///\relates ScaleWriteMap
    768   template<typename M, typename C>
    769   inline ScaleWriteMap<M, C> scaleMap(M &m,const C &v) {
    770     return ScaleWriteMap<M, C>(m,v);
    771   }
    772 
    773   ///Quotient of two maps
    774 
    775   ///This \ref concepts::ReadMap "read only map" returns the quotient of the
    776   ///values of the two given maps.
    777   ///Its \c Key and \c Value are inherited from \c M1.
    778   ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
    779   template<typename M1, typename M2>
     992
     993
     994  /// Quotient of two maps
     995
     996  /// This \ref concepts::ReadMap "read only map" returns the quotient
     997  /// of the values of the two given maps.
     998  /// Its \c Key and \c Value types are inherited from \c M1.
     999  /// The \c Key and \c Value of \c M2 must be convertible to those of
     1000  /// \c M1.
     1001  ///
     1002  /// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for
     1003  /// \code
     1004  ///   DivMap<M1,M2> dm(m1,m2);
     1005  /// \endcode
     1006  /// <tt>dm[x]</tt> will be equal to <tt>m1[x]/m2[x]</tt>.
     1007  ///
     1008  /// The simplest way of using this map is through the divMap()
     1009  /// function.
     1010  ///
     1011  /// \sa AddMap, SubMap, MulMap
     1012  template<typename M1, typename M2>
    7801013  class DivMap : public MapBase<typename M1::Key, typename M1::Value> {
    781     const M1& m1;
    782     const M2& m2;
     1014    const M1 &_m1;
     1015    const M2 &_m2;
    7831016  public:
    7841017    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
     
    7861019    typedef typename Parent::Value Value;
    7871020
    788     ///Constructor
    789     DivMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
    790     /// \e
    791     Value operator[](Key k) const {return m1[k]/m2[k];}
    792   };
    793  
    794   ///Returns a \c DivMap class
    795 
    796   ///This function just returns a \c DivMap class.
    797   ///\relates DivMap
    798   template<typename M1, typename M2>
     1021    /// Constructor
     1022    DivMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
     1023    /// \e
     1024    Value operator[](const Key &k) const { return _m1[k]/_m2[k]; }
     1025  };
     1026
     1027  /// Returns a \ref DivMap class
     1028
     1029  /// This function just returns a \ref DivMap class.
     1030  ///
     1031  /// For example, if \c m1 and \c m2 are both maps with \c double
     1032  /// values, then <tt>divMap(m1,m2)[x]</tt> will be equal to
     1033  /// <tt>m1[x]/m2[x]</tt>.
     1034  ///
     1035  /// \relates DivMap
     1036  template<typename M1, typename M2>
    7991037  inline DivMap<M1, M2> divMap(const M1 &m1,const M2 &m2) {
    8001038    return DivMap<M1, M2>(m1,m2);
    8011039  }
    802  
    803   ///Composition of two maps
    804 
    805   ///This \ref concepts::ReadMap "read only map" returns the composition of
    806   ///two given maps.
    807   ///That is to say, if \c m1 is of type \c M1 and \c m2 is of \c M2,
    808   ///then for
    809   ///\code
    810   ///  ComposeMap<M1, M2> cm(m1,m2);
    811   ///\endcode
    812   /// <tt>cm[x]</tt> will be equal to <tt>m1[m2[x]]</tt>.
    813   ///
    814   ///Its \c Key is inherited from \c M2 and its \c Value is from \c M1.
    815   ///\c M2::Value must be convertible to \c M1::Key.
    816   ///
    817   ///\sa CombineMap
    818   ///
    819   ///\todo Check the requirements.
    820   template <typename M1, typename M2>
    821   class ComposeMap : public MapBase<typename M2::Key, typename M1::Value> {
    822     const M1& m1;
    823     const M2& m2;
    824   public:
    825     typedef MapBase<typename M2::Key, typename M1::Value> Parent;
    826     typedef typename Parent::Key Key;
    827     typedef typename Parent::Value Value;
    828 
    829     ///Constructor
    830     ComposeMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
    831    
    832     /// \e
    833 
    834 
    835     /// \todo Use the  MapTraits once it is ported.
    836     ///
    837 
    838     //typename MapTraits<M1>::ConstReturnValue
    839     typename M1::Value
    840     operator[](Key k) const {return m1[m2[k]];}
    841   };
    842 
    843   ///Returns a \c ComposeMap class
    844 
    845   ///This function just returns a \c ComposeMap class.
    846   ///\relates ComposeMap
    847   template <typename M1, typename M2>
    848   inline ComposeMap<M1, M2> composeMap(const M1 &m1,const M2 &m2) {
    849     return ComposeMap<M1, M2>(m1,m2);
    850   }
    851  
    852   ///Combine of two maps using an STL (binary) functor.
    853 
    854   ///Combine of two maps using an STL (binary) functor.
    855   ///
    856   ///This \ref concepts::ReadMap "read only map" takes two maps and a
    857   ///binary functor and returns the composition of the two
    858   ///given maps unsing the functor.
    859   ///That is to say, if \c m1 and \c m2 is of type \c M1 and \c M2
    860   ///and \c f is of \c F, then for
    861   ///\code
    862   ///  CombineMap<M1,M2,F,V> cm(m1,m2,f);
    863   ///\endcode
    864   /// <tt>cm[x]</tt> will be equal to <tt>f(m1[x],m2[x])</tt>
    865   ///
    866   ///Its \c Key is inherited from \c M1 and its \c Value is \c V.
    867   ///\c M2::Value and \c M1::Value must be convertible to the corresponding
    868   ///input parameter of \c F and the return type of \c F must be convertible
    869   ///to \c V.
    870   ///
    871   ///\sa ComposeMap
    872   ///
    873   ///\todo Check the requirements.
    874   template<typename M1, typename M2, typename F,
    875            typename V = typename F::result_type>
    876   class CombineMap : public MapBase<typename M1::Key, V> {
    877     const M1& m1;
    878     const M2& m2;
    879     F f;
    880   public:
    881     typedef MapBase<typename M1::Key, V> Parent;
    882     typedef typename Parent::Key Key;
    883     typedef typename Parent::Value Value;
    884 
    885     ///Constructor
    886     CombineMap(const M1 &_m1,const M2 &_m2,const F &_f = F())
    887       : m1(_m1), m2(_m2), f(_f) {};
    888     /// \e
    889     Value operator[](Key k) const {return f(m1[k],m2[k]);}
    890   };
    891  
    892   ///Returns a \c CombineMap class
    893 
    894   ///This function just returns a \c CombineMap class.
    895   ///
    896   ///For example if \c m1 and \c m2 are both \c double valued maps, then
    897   ///\code
    898   ///combineMap(m1,m2,std::plus<double>())
    899   ///\endcode
    900   ///is equivalent to
    901   ///\code
    902   ///addMap(m1,m2)
    903   ///\endcode
    904   ///
    905   ///This function is specialized for adaptable binary function
    906   ///classes and C++ functions.
    907   ///
    908   ///\relates CombineMap
    909   template<typename M1, typename M2, typename F, typename V>
    910   inline CombineMap<M1, M2, F, V>
    911   combineMap(const M1& m1,const M2& m2, const F& f) {
    912     return CombineMap<M1, M2, F, V>(m1,m2,f);
    913   }
    914 
    915   template<typename M1, typename M2, typename F>
    916   inline CombineMap<M1, M2, F, typename F::result_type>
    917   combineMap(const M1& m1, const M2& m2, const F& f) {
    918     return combineMap<M1, M2, F, typename F::result_type>(m1,m2,f);
    919   }
    920 
    921   template<typename M1, typename M2, typename K1, typename K2, typename V>
    922   inline CombineMap<M1, M2, V (*)(K1, K2), V>
    923   combineMap(const M1 &m1, const M2 &m2, V (*f)(K1, K2)) {
    924     return combineMap<M1, M2, V (*)(K1, K2), V>(m1,m2,f);
    925   }
    926 
    927   ///Negative value of a map
    928 
    929   ///This \ref concepts::ReadMap "read only map" returns the negative
    930   ///value of the value returned by the given map.
    931   ///Its \c Key and \c Value are inherited from \c M.
    932   ///The unary \c - operator must be defined for \c Value, of course.
    933   ///
    934   ///\sa NegWriteMap
    935   template<typename M>
     1040
     1041
     1042  /// Shifts a map with a constant.
     1043
     1044  /// This \ref concepts::ReadMap "read only map" returns the sum of
     1045  /// the given map and a constant value (i.e. it shifts the map with
     1046  /// the constant). Its \c Key and \c Value are inherited from \c M.
     1047  ///
     1048  /// Actually,
     1049  /// \code
     1050  ///   ShiftMap<M> sh(m,v);
     1051  /// \endcode
     1052  /// is equivalent to
     1053  /// \code
     1054  ///   ConstMap<M::Key, M::Value> cm(v);
     1055  ///   AddMap<M, ConstMap<M::Key, M::Value> > sh(m,cm);
     1056  /// \endcode
     1057  ///
     1058  /// The simplest way of using this map is through the shiftMap()
     1059  /// function.
     1060  ///
     1061  /// \sa ShiftWriteMap
     1062  template<typename M, typename C = typename M::Value>
     1063  class ShiftMap : public MapBase<typename M::Key, typename M::Value> {
     1064    const M &_m;
     1065    C _v;
     1066  public:
     1067    typedef MapBase<typename M::Key, typename M::Value> Parent;
     1068    typedef typename Parent::Key Key;
     1069    typedef typename Parent::Value Value;
     1070
     1071    /// Constructor
     1072
     1073    /// Constructor.
     1074    /// \param m The undelying map.
     1075    /// \param v The constant value.
     1076    ShiftMap(const M &m, const C &v) : _m(m), _v(v) {}
     1077    /// \e
     1078    Value operator[](const Key &k) const { return _m[k]+_v; }
     1079  };
     1080
     1081  /// Shifts a map with a constant (read-write version).
     1082
     1083  /// This \ref concepts::ReadWriteMap "read-write map" returns the sum
     1084  /// of the given map and a constant value (i.e. it shifts the map with
     1085  /// the constant). Its \c Key and \c Value are inherited from \c M.
     1086  /// It makes also possible to write the map.
     1087  ///
     1088  /// The simplest way of using this map is through the shiftWriteMap()
     1089  /// function.
     1090  ///
     1091  /// \sa ShiftMap
     1092  template<typename M, typename C = typename M::Value>
     1093  class ShiftWriteMap : public MapBase<typename M::Key, typename M::Value> {
     1094    M &_m;
     1095    C _v;
     1096  public:
     1097    typedef MapBase<typename M::Key, typename M::Value> Parent;
     1098    typedef typename Parent::Key Key;
     1099    typedef typename Parent::Value Value;
     1100
     1101    /// Constructor
     1102
     1103    /// Constructor.
     1104    /// \param m The undelying map.
     1105    /// \param v The constant value.
     1106    ShiftWriteMap(M &m, const C &v) : _m(m), _v(v) {}
     1107    /// \e
     1108    Value operator[](const Key &k) const { return _m[k]+_v; }
     1109    /// \e
     1110    void set(const Key &k, const Value &v) { _m.set(k, v-_v); }
     1111  };
     1112
     1113  /// Returns a \ref ShiftMap class
     1114
     1115  /// This function just returns a \ref ShiftMap class.
     1116  ///
     1117  /// For example, if \c m is a map with \c double values and \c v is
     1118  /// \c double, then <tt>shiftMap(m,v)[x]</tt> will be equal to
     1119  /// <tt>m[x]+v</tt>.
     1120  ///
     1121  /// \relates ShiftMap
     1122  template<typename M, typename C>
     1123  inline ShiftMap<M, C> shiftMap(const M &m, const C &v) {
     1124    return ShiftMap<M, C>(m,v);
     1125  }
     1126
     1127  /// Returns a \ref ShiftWriteMap class
     1128
     1129  /// This function just returns a \ref ShiftWriteMap class.
     1130  ///
     1131  /// For example, if \c m is a map with \c double values and \c v is
     1132  /// \c double, then <tt>shiftWriteMap(m,v)[x]</tt> will be equal to
     1133  /// <tt>m[x]+v</tt>.
     1134  /// Moreover it makes also possible to write the map.
     1135  ///
     1136  /// \relates ShiftWriteMap
     1137  template<typename M, typename C>
     1138  inline ShiftWriteMap<M, C> shiftWriteMap(M &m, const C &v) {
     1139    return ShiftWriteMap<M, C>(m,v);
     1140  }
     1141
     1142
     1143  /// Scales a map with a constant.
     1144
     1145  /// This \ref concepts::ReadMap "read only map" returns the value of
     1146  /// the given map multiplied from the left side with a constant value.
     1147  /// Its \c Key and \c Value are inherited from \c M.
     1148  ///
     1149  /// Actually,
     1150  /// \code
     1151  ///   ScaleMap<M> sc(m,v);
     1152  /// \endcode
     1153  /// is equivalent to
     1154  /// \code
     1155  ///   ConstMap<M::Key, M::Value> cm(v);
     1156  ///   MulMap<ConstMap<M::Key, M::Value>, M> sc(cm,m);
     1157  /// \endcode
     1158  ///
     1159  /// The simplest way of using this map is through the scaleMap()
     1160  /// function.
     1161  ///
     1162  /// \sa ScaleWriteMap
     1163  template<typename M, typename C = typename M::Value>
     1164  class ScaleMap : public MapBase<typename M::Key, typename M::Value> {
     1165    const M &_m;
     1166    C _v;
     1167  public:
     1168    typedef MapBase<typename M::Key, typename M::Value> Parent;
     1169    typedef typename Parent::Key Key;
     1170    typedef typename Parent::Value Value;
     1171
     1172    /// Constructor
     1173
     1174    /// Constructor.
     1175    /// \param m The undelying map.
     1176    /// \param v The constant value.
     1177    ScaleMap(const M &m, const C &v) : _m(m), _v(v) {}
     1178    /// \e
     1179    Value operator[](const Key &k) const { return _v*_m[k]; }
     1180  };
     1181
     1182  /// Scales a map with a constant (read-write version).
     1183
     1184  /// This \ref concepts::ReadWriteMap "read-write map" returns the value of
     1185  /// the given map multiplied from the left side with a constant value.
     1186  /// Its \c Key and \c Value are inherited from \c M.
     1187  /// It can also be used as write map if the \c / operator is defined
     1188  /// between \c Value and \c C and the given multiplier is not zero.
     1189  ///
     1190  /// The simplest way of using this map is through the scaleWriteMap()
     1191  /// function.
     1192  ///
     1193  /// \sa ScaleMap
     1194  template<typename M, typename C = typename M::Value>
     1195  class ScaleWriteMap : public MapBase<typename M::Key, typename M::Value> {
     1196    M &_m;
     1197    C _v;
     1198  public:
     1199    typedef MapBase<typename M::Key, typename M::Value> Parent;
     1200    typedef typename Parent::Key Key;
     1201    typedef typename Parent::Value Value;
     1202
     1203    /// Constructor
     1204
     1205    /// Constructor.
     1206    /// \param m The undelying map.
     1207    /// \param v The constant value.
     1208    ScaleWriteMap(M &m, const C &v) : _m(m), _v(v) {}
     1209    /// \e
     1210    Value operator[](const Key &k) const { return _v*_m[k]; }
     1211    /// \e
     1212    void set(const Key &k, const Value &v) { _m.set(k, v/_v); }
     1213  };
     1214
     1215  /// Returns a \ref ScaleMap class
     1216
     1217  /// This function just returns a \ref ScaleMap class.
     1218  ///
     1219  /// For example, if \c m is a map with \c double values and \c v is
     1220  /// \c double, then <tt>scaleMap(m,v)[x]</tt> will be equal to
     1221  /// <tt>v*m[x]</tt>.
     1222  ///
     1223  /// \relates ScaleMap
     1224  template<typename M, typename C>
     1225  inline ScaleMap<M, C> scaleMap(const M &m, const C &v) {
     1226    return ScaleMap<M, C>(m,v);
     1227  }
     1228
     1229  /// Returns a \ref ScaleWriteMap class
     1230
     1231  /// This function just returns a \ref ScaleWriteMap class.
     1232  ///
     1233  /// For example, if \c m is a map with \c double values and \c v is
     1234  /// \c double, then <tt>scaleWriteMap(m,v)[x]</tt> will be equal to
     1235  /// <tt>v*m[x]</tt>.
     1236  /// Moreover it makes also possible to write the map.
     1237  ///
     1238  /// \relates ScaleWriteMap
     1239  template<typename M, typename C>
     1240  inline ScaleWriteMap<M, C> scaleWriteMap(M &m, const C &v) {
     1241    return ScaleWriteMap<M, C>(m,v);
     1242  }
     1243
     1244
     1245  /// Negative of a map
     1246
     1247  /// This \ref concepts::ReadMap "read only map" returns the negative
     1248  /// of the values of the given map (using the unary \c - operator).
     1249  /// Its \c Key and \c Value are inherited from \c M.
     1250  ///
     1251  /// If M::Value is \c int, \c double etc., then
     1252  /// \code
     1253  ///   NegMap<M> neg(m);
     1254  /// \endcode
     1255  /// is equivalent to
     1256  /// \code
     1257  ///   ScaleMap<M> neg(m,-1);
     1258  /// \endcode
     1259  ///
     1260  /// The simplest way of using this map is through the negMap()
     1261  /// function.
     1262  ///
     1263  /// \sa NegWriteMap
     1264  template<typename M>
    9361265  class NegMap : public MapBase<typename M::Key, typename M::Value> {
    937     const M& m;
     1266    const M& _m;
    9381267  public:
    9391268    typedef MapBase<typename M::Key, typename M::Value> Parent;
     
    9411270    typedef typename Parent::Value Value;
    9421271
    943     ///Constructor
    944     NegMap(const M &_m) : m(_m) {};
    945     /// \e
    946     Value operator[](Key k) const {return -m[k];}
    947   };
    948  
    949   ///Negative value of a map (ReadWrite version)
    950 
    951   ///This \ref concepts::ReadWriteMap "read-write map" returns the negative
    952   ///value of the value returned by the given map.
    953   ///Its \c Key and \c Value are inherited from \c M.
    954   ///The unary \c - operator must be defined for \c Value, of course.
     1272    /// Constructor
     1273    NegMap(const M &m) : _m(m) {}
     1274    /// \e
     1275    Value operator[](const Key &k) const { return -_m[k]; }
     1276  };
     1277
     1278  /// Negative of a map (read-write version)
     1279
     1280  /// This \ref concepts::ReadWriteMap "read-write map" returns the
     1281  /// negative of the values of the given map (using the unary \c -
     1282  /// operator).
     1283  /// Its \c Key and \c Value are inherited from \c M.
     1284  /// It makes also possible to write the map.
     1285  ///
     1286  /// If M::Value is \c int, \c double etc., then
     1287  /// \code
     1288  ///   NegWriteMap<M> neg(m);
     1289  /// \endcode
     1290  /// is equivalent to
     1291  /// \code
     1292  ///   ScaleWriteMap<M> neg(m,-1);
     1293  /// \endcode
     1294  ///
     1295  /// The simplest way of using this map is through the negWriteMap()
     1296  /// function.
    9551297  ///
    9561298  /// \sa NegMap
    957   template<typename M> 
     1299  template<typename M>
    9581300  class NegWriteMap : public MapBase<typename M::Key, typename M::Value> {
    959     M& m;
     1301    M &_m;
    9601302  public:
    9611303    typedef MapBase<typename M::Key, typename M::Value> Parent;
     
    9631305    typedef typename Parent::Value Value;
    9641306
    965     ///Constructor
    966     NegWriteMap(M &_m) : m(_m) {};
    967     /// \e
    968     Value operator[](Key k) const {return -m[k];}
    969     /// \e
    970     void set(Key k, const Value& v) { m.set(k, -v); }
    971   };
    972 
    973   ///Returns a \c NegMap class
    974 
    975   ///This function just returns a \c NegMap class.
    976   ///\relates NegMap
    977   template <typename M>
     1307    /// Constructor
     1308    NegWriteMap(M &m) : _m(m) {}
     1309    /// \e
     1310    Value operator[](const Key &k) const { return -_m[k]; }
     1311    /// \e
     1312    void set(const Key &k, const Value &v) { _m.set(k, -v); }
     1313  };
     1314
     1315  /// Returns a \ref NegMap class
     1316
     1317  /// This function just returns a \ref NegMap class.
     1318  ///
     1319  /// For example, if \c m is a map with \c double values, then
     1320  /// <tt>negMap(m)[x]</tt> will be equal to <tt>-m[x]</tt>.
     1321  ///
     1322  /// \relates NegMap
     1323  template <typename M>
    9781324  inline NegMap<M> negMap(const M &m) {
    9791325    return NegMap<M>(m);
    9801326  }
    9811327
    982   ///Returns a \c NegWriteMap class
    983 
    984   ///This function just returns a \c NegWriteMap class.
    985   ///\relates NegWriteMap
    986   template <typename M>
    987   inline NegWriteMap<M> negMap(M &m) {
     1328  /// Returns a \ref NegWriteMap class
     1329
     1330  /// This function just returns a \ref NegWriteMap class.
     1331  ///
     1332  /// For example, if \c m is a map with \c double values, then
     1333  /// <tt>negWriteMap(m)[x]</tt> will be equal to <tt>-m[x]</tt>.
     1334  /// Moreover it makes also possible to write the map.
     1335  ///
     1336  /// \relates NegWriteMap
     1337  template <typename M>
     1338  inline NegWriteMap<M> negWriteMap(M &m) {
    9881339    return NegWriteMap<M>(m);
    9891340  }
    9901341
    991   ///Absolute value of a map
    992 
    993   ///This \ref concepts::ReadMap "read only map" returns the absolute value
    994   ///of the value returned by the given map.
    995   ///Its \c Key and \c Value are inherited from \c M.
    996   ///\c Value must be comparable to \c 0 and the unary \c -
    997   ///operator must be defined for it, of course.
    998   template<typename M>
     1342
     1343  /// Absolute value of a map
     1344
     1345  /// This \ref concepts::ReadMap "read only map" returns the absolute
     1346  /// value of the values of the given map.
     1347  /// Its \c Key and \c Value are inherited from \c M.
     1348  /// \c Value must be comparable to \c 0 and the unary \c -
     1349  /// operator must be defined for it, of course.
     1350  ///
     1351  /// The simplest way of using this map is through the absMap()
     1352  /// function.
     1353  template<typename M>
    9991354  class AbsMap : public MapBase<typename M::Key, typename M::Value> {
    1000     const M& m;
     1355    const M &_m;
    10011356  public:
    10021357    typedef MapBase<typename M::Key, typename M::Value> Parent;
     
    10041359    typedef typename Parent::Value Value;
    10051360
    1006     ///Constructor
    1007     AbsMap(const M &_m) : m(_m) {};
    1008     /// \e
    1009     Value operator[](Key k) const {
    1010       Value tmp = m[k];
     1361    /// Constructor
     1362    AbsMap(const M &m) : _m(m) {}
     1363    /// \e
     1364    Value operator[](const Key &k) const {
     1365      Value tmp = _m[k];
    10111366      return tmp >= 0 ? tmp : -tmp;
    10121367    }
    10131368
    10141369  };
    1015  
    1016   ///Returns an \c AbsMap class
    1017 
    1018   ///This function just returns an \c AbsMap class.
    1019   ///\relates AbsMap
    1020   template<typename M>
     1370
     1371  /// Returns an \ref AbsMap class
     1372
     1373  /// This function just returns an \ref AbsMap class.
     1374  ///
     1375  /// For example, if \c m is a map with \c double values, then
     1376  /// <tt>absMap(m)[x]</tt> will be equal to <tt>m[x]</tt> if
     1377  /// it is positive or zero and <tt>-m[x]</tt> if <tt>m[x]</tt> is
     1378  /// negative.
     1379  ///
     1380  /// \relates AbsMap
     1381  template<typename M>
    10211382  inline AbsMap<M> absMap(const M &m) {
    10221383    return AbsMap<M>(m);
    10231384  }
    10241385
    1025   ///Converts an STL style functor to a map
    1026 
    1027   ///This \ref concepts::ReadMap "read only map" returns the value
    1028   ///of a given functor.
    1029   ///
    1030   ///Template parameters \c K and \c V will become its
    1031   ///\c Key and \c Value.
    1032   ///In most cases they have to be given explicitly because a
    1033   ///functor typically does not provide \c argument_type and
    1034   ///\c result_type typedefs.
    1035   ///
    1036   ///Parameter \c F is the type of the used functor.
    1037   ///
    1038   ///\sa MapFunctor
    1039   template<typename F,
    1040            typename K = typename F::argument_type,
    1041            typename V = typename F::result_type>
    1042   class FunctorMap : public MapBase<K, V> {
    1043     F f;
    1044   public:
    1045     typedef MapBase<K, V> Parent;
    1046     typedef typename Parent::Key Key;
    1047     typedef typename Parent::Value Value;
    1048 
    1049     ///Constructor
    1050     FunctorMap(const F &_f = F()) : f(_f) {}
    1051     /// \e
    1052     Value operator[](Key k) const { return f(k);}
    1053   };
    1054  
    1055   ///Returns a \c FunctorMap class
    1056 
    1057   ///This function just returns a \c FunctorMap class.
    1058   ///
    1059   ///This function is specialized for adaptable binary function
    1060   ///classes and C++ functions.
    1061   ///
    1062   ///\relates FunctorMap
    1063   template<typename K, typename V, typename F> inline
    1064   FunctorMap<F, K, V> functorMap(const F &f) {
    1065     return FunctorMap<F, K, V>(f);
    1066   }
    1067 
    1068   template <typename F> inline
    1069   FunctorMap<F, typename F::argument_type, typename F::result_type>
    1070   functorMap(const F &f) {
    1071     return FunctorMap<F, typename F::argument_type,
    1072       typename F::result_type>(f);
    1073   }
    1074 
    1075   template <typename K, typename V> inline
    1076   FunctorMap<V (*)(K), K, V> functorMap(V (*f)(K)) {
    1077     return FunctorMap<V (*)(K), K, V>(f);
    1078   }
    1079 
    1080 
    1081   ///Converts a map to an STL style (unary) functor
    1082 
    1083   ///This class Converts a map to an STL style (unary) functor.
    1084   ///That is it provides an <tt>operator()</tt> to read its values.
    1085   ///
    1086   ///For the sake of convenience it also works as
    1087   ///a ususal \ref concepts::ReadMap "readable map",
    1088   ///i.e. <tt>operator[]</tt> and the \c Key and \c Value typedefs also exist.
    1089   ///
    1090   ///\sa FunctorMap
    1091   template <typename M>
    1092   class MapFunctor : public MapBase<typename M::Key, typename M::Value> {
    1093     const M& m;
    1094   public:
    1095     typedef MapBase<typename M::Key, typename M::Value> Parent;
    1096     typedef typename Parent::Key Key;
    1097     typedef typename Parent::Value Value;
    1098 
    1099     typedef typename M::Key argument_type;
    1100     typedef typename M::Value result_type;
    1101 
    1102     ///Constructor
    1103     MapFunctor(const M &_m) : m(_m) {};
    1104     ///\e
    1105     Value operator()(Key k) const {return m[k];}
    1106     ///\e
    1107     Value operator[](Key k) const {return m[k];}
    1108   };
    1109  
    1110   ///Returns a \c MapFunctor class
    1111 
    1112   ///This function just returns a \c MapFunctor class.
    1113   ///\relates MapFunctor
    1114   template<typename M>
    1115   inline MapFunctor<M> mapFunctor(const M &m) {
    1116     return MapFunctor<M>(m);
    1117   }
    1118 
    1119   ///Just readable version of \ref ForkWriteMap
    1120 
    1121   ///This map has two \ref concepts::ReadMap "readable map"
    1122   ///parameters and each read request will be passed just to the
    1123   ///first map. This class is the just readable map type of \c ForkWriteMap.
    1124   ///
    1125   ///The \c Key and \c Value are inherited from \c M1.
    1126   ///The \c Key and \c Value of \c M2 must be convertible from those of \c M1.
    1127   ///
    1128   ///\sa ForkWriteMap
    1129   ///
    1130   /// \todo Why is it needed?
    1131   template<typename  M1, typename M2>
    1132   class ForkMap : public MapBase<typename M1::Key, typename M1::Value> {
    1133     const M1& m1;
    1134     const M2& m2;
    1135   public:
    1136     typedef MapBase<typename M1::Key, typename M1::Value> Parent;
    1137     typedef typename Parent::Key Key;
    1138     typedef typename Parent::Value Value;
    1139 
    1140     ///Constructor
    1141     ForkMap(const M1 &_m1, const M2 &_m2) : m1(_m1), m2(_m2) {};
    1142     /// \e
    1143     Value operator[](Key k) const {return m1[k];}
    1144   };
    1145 
    1146 
    1147   ///Applies all map setting operations to two maps
    1148 
    1149   ///This map has two \ref concepts::WriteMap "writable map"
    1150   ///parameters and each write request will be passed to both of them.
    1151   ///If \c M1 is also \ref concepts::ReadMap "readable",
    1152   ///then the read operations will return the
    1153   ///corresponding values of \c M1.
    1154   ///
    1155   ///The \c Key and \c Value are inherited from \c M1.
    1156   ///The \c Key and \c Value of \c M2 must be convertible from those of \c M1.
    1157   ///
    1158   ///\sa ForkMap
    1159   template<typename  M1, typename M2>
    1160   class ForkWriteMap : public MapBase<typename M1::Key, typename M1::Value> {
    1161     M1& m1;
    1162     M2& m2;
    1163   public:
    1164     typedef MapBase<typename M1::Key, typename M1::Value> Parent;
    1165     typedef typename Parent::Key Key;
    1166     typedef typename Parent::Value Value;
    1167 
    1168     ///Constructor
    1169     ForkWriteMap(M1 &_m1, M2 &_m2) : m1(_m1), m2(_m2) {};
    1170     ///\e
    1171     Value operator[](Key k) const {return m1[k];}
    1172     ///\e
    1173     void set(Key k, const Value &v) {m1.set(k,v); m2.set(k,v);}
    1174   };
    1175  
    1176   ///Returns a \c ForkMap class
    1177 
    1178   ///This function just returns a \c ForkMap class.
    1179   ///\relates ForkMap
    1180   template <typename M1, typename M2>
    1181   inline ForkMap<M1, M2> forkMap(const M1 &m1, const M2 &m2) {
    1182     return ForkMap<M1, M2>(m1,m2);
    1183   }
    1184 
    1185   ///Returns a \c ForkWriteMap class
    1186 
    1187   ///This function just returns a \c ForkWriteMap class.
    1188   ///\relates ForkWriteMap
    1189   template <typename M1, typename M2>
    1190   inline ForkWriteMap<M1, M2> forkMap(M1 &m1, M2 &m2) {
    1191     return ForkWriteMap<M1, M2>(m1,m2);
    1192   }
    1193 
    1194 
    1195  
    1196   /* ************* BOOL MAPS ******************* */
    1197  
    1198   ///Logical 'not' of a map
    1199  
    1200   ///This bool \ref concepts::ReadMap "read only map" returns the
    1201   ///logical negation of the value returned by the given map.
    1202   ///Its \c Key is inherited from \c M, its \c Value is \c bool.
    1203   ///
    1204   ///\sa NotWriteMap
    1205   template <typename M>
     1386
     1387  /// Logical 'not' of a map
     1388
     1389  /// This \ref concepts::ReadMap "read only map" returns the logical
     1390  /// negation of the values of the given map.
     1391  /// Its \c Key is inherited from \c M and its \c Value is \c bool.
     1392  ///
     1393  /// The simplest way of using this map is through the notMap()
     1394  /// function.
     1395  ///
     1396  /// \sa NotWriteMap
     1397  template <typename M>
    12061398  class NotMap : public MapBase<typename M::Key, bool> {
    1207     const M& m;
     1399    const M &_m;
    12081400  public:
    12091401    typedef MapBase<typename M::Key, bool> Parent;
     
    12121404
    12131405    /// Constructor
    1214     NotMap(const M &_m) : m(_m) {};
    1215     ///\e
    1216     Value operator[](Key k) const {return !m[k];}
    1217   };
    1218 
    1219   ///Logical 'not' of a map (ReadWrie version)
    1220  
    1221   ///This bool \ref concepts::ReadWriteMap "read-write map" returns the
    1222   ///logical negation of the value returned by the given map. When it is set,
    1223   ///the opposite value is set to the original map.
    1224   ///Its \c Key is inherited from \c M, its \c Value is \c bool.
    1225   ///
    1226   ///\sa NotMap
    1227   template <typename M>
     1406    NotMap(const M &m) : _m(m) {}
     1407    /// \e
     1408    Value operator[](const Key &k) const { return !_m[k]; }
     1409  };
     1410
     1411  /// Logical 'not' of a map (read-write version)
     1412
     1413  /// This \ref concepts::ReadWriteMap "read-write map" returns the
     1414  /// logical negation of the values of the given map.
     1415  /// Its \c Key is inherited from \c M and its \c Value is \c bool.
     1416  /// It makes also possible to write the map. When a value is set,
     1417  /// the opposite value is set to the original map.
     1418  ///
     1419  /// The simplest way of using this map is through the notWriteMap()
     1420  /// function.
     1421  ///
     1422  /// \sa NotMap
     1423  template <typename M>
    12281424  class NotWriteMap : public MapBase<typename M::Key, bool> {
    1229     M& m;
     1425    M &_m;
    12301426  public:
    12311427    typedef MapBase<typename M::Key, bool> Parent;
     
    12341430
    12351431    /// Constructor
    1236     NotWriteMap(M &_m) : m(_m) {};
    1237     ///\e
    1238     Value operator[](Key k) const {return !m[k];}
    1239     ///\e
    1240     void set(Key k, bool v) { m.set(k, !v); }
    1241   };
    1242  
    1243   ///Returns a \c NotMap class
    1244  
    1245   ///This function just returns a \c NotMap class.
    1246   ///\relates NotMap
    1247   template <typename M>
     1432    NotWriteMap(M &m) : _m(m) {}
     1433    /// \e
     1434    Value operator[](const Key &k) const { return !_m[k]; }
     1435    /// \e
     1436    void set(const Key &k, bool v) { _m.set(k, !v); }
     1437  };
     1438
     1439  /// Returns a \ref NotMap class
     1440
     1441  /// This function just returns a \ref NotMap class.
     1442  ///
     1443  /// For example, if \c m is a map with \c bool values, then
     1444  /// <tt>notMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
     1445  ///
     1446  /// \relates NotMap
     1447  template <typename M>
    12481448  inline NotMap<M> notMap(const M &m) {
    12491449    return NotMap<M>(m);
    12501450  }
    1251  
    1252   ///Returns a \c NotWriteMap class
    1253  
    1254   ///This function just returns a \c NotWriteMap class.
    1255   ///\relates NotWriteMap
    1256   template <typename M>
    1257   inline NotWriteMap<M> notMap(M &m) {
     1451
     1452  /// Returns a \ref NotWriteMap class
     1453
     1454  /// This function just returns a \ref NotWriteMap class.
     1455  ///
     1456  /// For example, if \c m is a map with \c bool values, then
     1457  /// <tt>notWriteMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
     1458  /// Moreover it makes also possible to write the map.
     1459  ///
     1460  /// \relates NotWriteMap
     1461  template <typename M>
     1462  inline NotWriteMap<M> notWriteMap(M &m) {
    12581463    return NotWriteMap<M>(m);
    12591464  }
     1465
    12601466
    12611467  namespace _maps_bits {
     
    12771483    template <typename _Iterator>
    12781484    struct IteratorTraits<_Iterator,
    1279       typename exists<typename _Iterator::container_type>::type> 
     1485      typename exists<typename _Iterator::container_type>::type>
    12801486    {
    12811487      typedef typename _Iterator::container_type::value_type Value;
     
    12831489
    12841490  }
    1285  
     1491
    12861492
    12871493  /// \brief Writable bool map for logging each \c true assigned element
    12881494  ///
    1289   /// A \ref concepts::ReadWriteMap "read-write" bool map for logging 
    1290   /// each \c true assigned element, i.e it copies all the keys set 
     1495  /// A \ref concepts::ReadWriteMap "read-write" bool map for logging
     1496  /// each \c true assigned element, i.e it copies all the keys set
    12911497  /// to \c true to the given iterator.
    12921498  ///
    1293   /// \note The container of the iterator should contain space 
     1499  /// \note The container of the iterator should contain space
    12941500  /// for each element.
    12951501  ///
    1296   /// The following example shows how you can write the edges found by 
     1502  /// The following example shows how you can write the edges found by
    12971503  /// the \ref Prim algorithm directly to the standard output.
    1298   ///\code
    1299   /// typedef IdMap<Graph, Edge> EdgeIdMap;
    1300   /// EdgeIdMap edgeId(graph);
    1301   ///
    1302   /// typedef MapFunctor<EdgeIdMap> EdgeIdFunctor;
    1303   /// EdgeIdFunctor edgeIdFunctor(edgeId);
    1304   ///
    1305   /// StoreBoolMap<ostream_iterator<int>, EdgeIdFunctor>
    1306   ///   writerMap(ostream_iterator<int>(cout, " "), edgeIdFunctor);
    1307   ///
    1308   /// prim(graph, cost, writerMap);
    1309   ///\endcode
    1310   ///
    1311   ///\sa BackInserterBoolMap
    1312   ///\sa FrontInserterBoolMap
    1313   ///\sa InserterBoolMap
    1314   ///
    1315   ///\todo Revise the name of this class and the related ones.
    1316   template <typename _Iterator, 
     1504  /// \code
     1505  ///   typedef IdMap<Graph, Edge> EdgeIdMap;
     1506  ///   EdgeIdMap edgeId(graph);
     1507  ///
     1508  ///   typedef MapToFunctor<EdgeIdMap> EdgeIdFunctor;
     1509  ///   EdgeIdFunctor edgeIdFunctor(edgeId);
     1510  ///
     1511  ///   StoreBoolMap<ostream_iterator<int>, EdgeIdFunctor>
     1512  ///     writerMap(ostream_iterator<int>(cout, " "), edgeIdFunctor);
     1513  ///
     1514  ///   prim(graph, cost, writerMap);
     1515  /// \endcode
     1516  ///
     1517  /// \sa BackInserterBoolMap
     1518  /// \sa FrontInserterBoolMap
     1519  /// \sa InserterBoolMap
     1520  ///
     1521  /// \todo Revise the name of this class and the related ones.
     1522  template <typename _Iterator,
    13171523            typename _Functor =
    13181524            _maps_bits::Identity<typename _maps_bits::
     
    13281534
    13291535    /// Constructor
    1330     StoreBoolMap(Iterator it, const Functor& functor = Functor()) 
     1536    StoreBoolMap(Iterator it, const Functor& functor = Functor())
    13311537      : _begin(it), _end(it), _functor(functor) {}
    13321538
     
    13351541      return _begin;
    13361542    }
    1337  
     1543
    13381544    /// Gives back the the 'after the last' iterator
    13391545    Iterator end() const {
     
    13411547    }
    13421548
    1343     /// The \c set function of the map
     1549    /// The set function of the map
    13441550    void set(const Key& key, Value value) const {
    13451551      if (value) {
     
    13471553      }
    13481554    }
    1349    
     1555
    13501556  private:
    13511557    Iterator _begin;
     
    13541560  };
    13551561
    1356   /// \brief Writable bool map for logging each \c true assigned element in 
     1562  /// \brief Writable bool map for logging each \c true assigned element in
    13571563  /// a back insertable container.
    13581564  ///
     
    13631569  /// edges found by the Prim algorithm in a vector.
    13641570  ///
    1365   ///\code
    1366   /// vector<Edge> span_tree_edges;
    1367   /// BackInserterBoolMap<vector<Edge> > inserter_map(span_tree_edges);
    1368   /// prim(graph, cost, inserter_map);
    1369   ///\endcode
    1370   ///
    1371   ///\sa StoreBoolMap
    1372   ///\sa FrontInserterBoolMap
    1373   ///\sa InserterBoolMap
     1571  /// \code
     1572  ///   vector<Edge> span_tree_edges;
     1573  ///   BackInserterBoolMap<vector<Edge> > inserter_map(span_tree_edges);
     1574  ///   prim(graph, cost, inserter_map);
     1575  /// \endcode
     1576  ///
     1577  /// \sa StoreBoolMap
     1578  /// \sa FrontInserterBoolMap
     1579  /// \sa InserterBoolMap
    13741580  template <typename Container,
    13751581            typename Functor =
     
    13811587
    13821588    /// Constructor
    1383     BackInserterBoolMap(Container& _container, 
    1384                         const Functor& _functor = Functor()) 
     1589    BackInserterBoolMap(Container& _container,
     1590                        const Functor& _functor = Functor())
    13851591      : container(_container), functor(_functor) {}
    13861592
    1387     /// The \c set function of the map
     1593    /// The set function of the map
    13881594    void set(const Key& key, Value value) {
    13891595      if (value) {
     
    13911597      }
    13921598    }
    1393    
     1599
    13941600  private:
    13951601    Container& container;
     
    13971603  };
    13981604
    1399   /// \brief Writable bool map for logging each \c true assigned element in 
     1605  /// \brief Writable bool map for logging each \c true assigned element in
    14001606  /// a front insertable container.
    14011607  ///
     
    14051611  /// container. For example see \ref BackInserterBoolMap.
    14061612  ///
    1407   ///\sa BackInserterBoolMap
    1408   ///\sa InserterBoolMap
     1613  /// \sa BackInserterBoolMap
     1614  /// \sa InserterBoolMap
    14091615  template <typename Container,
    14101616            typename Functor =
     
    14171623    /// Constructor
    14181624    FrontInserterBoolMap(Container& _container,
    1419                          const Functor& _functor = Functor()) 
     1625                         const Functor& _functor = Functor())
    14201626      : container(_container), functor(_functor) {}
    14211627
    1422     /// The \c set function of the map
     1628    /// The set function of the map
    14231629    void set(const Key& key, Value value) {
    14241630      if (value) {
     
    14261632      }
    14271633    }
    1428    
     1634
    14291635  private:
    1430     Container& container;   
     1636    Container& container;
    14311637    Functor functor;
    14321638  };
    14331639
    1434   /// \brief Writable bool map for storing each \c true assigned element in 
     1640  /// \brief Writable bool map for storing each \c true assigned element in
    14351641  /// an insertable container.
    14361642  ///
    1437   /// Writable bool map for storing each \c true assigned element in an 
     1643  /// Writable bool map for storing each \c true assigned element in an
    14381644  /// insertable container. It will insert all the keys set to \c true into
    14391645  /// the container.
     
    14421648  /// connected components in a set you can use the next code:
    14431649  ///
    1444   ///\code
    1445   /// set<Arc> cut_arcs;
    1446   /// InserterBoolMap<set<Arc> > inserter_map(cut_arcs);
    1447   /// stronglyConnectedCutArcs(digraph, cost, inserter_map);
    1448   ///\endcode
    1449   ///
    1450   ///\sa BackInserterBoolMap
    1451   ///\sa FrontInserterBoolMap
     1650  /// \code
     1651  ///   set<Arc> cut_arcs;
     1652  ///   InserterBoolMap<set<Arc> > inserter_map(cut_arcs);
     1653  ///   stronglyConnectedCutArcs(digraph, cost, inserter_map);
     1654  /// \endcode
     1655  ///
     1656  /// \sa BackInserterBoolMap
     1657  /// \sa FrontInserterBoolMap
    14521658  template <typename Container,
    14531659            typename Functor =
     
    14591665
    14601666    /// Constructor with specified iterator
    1461    
     1667
    14621668    /// Constructor with specified iterator.
    14631669    /// \param _container The container for storing the elements.
     
    14651671    /// \param _functor The functor that is used when an element is stored.
    14661672    InserterBoolMap(Container& _container, typename Container::iterator _it,
    1467                     const Functor& _functor = Functor()) 
     1673                    const Functor& _functor = Functor())
    14681674      : container(_container), it(_it), functor(_functor) {}
    14691675
     
    14771683      : container(_container), it(_container.end()), functor(_functor) {}
    14781684
    1479     /// The \c set function of the map
     1685    /// The set function of the map
    14801686    void set(const Key& key, Value value) {
    14811687      if (value) {
     
    14841690      }
    14851691    }
    1486    
     1692
    14871693  private:
    14881694    Container& container;
     
    14911697  };
    14921698
    1493   /// \brief Writable bool map for filling each \c true assigned element with a 
     1699  /// \brief Writable bool map for filling each \c true assigned element with a
    14941700  /// given value.
    14951701  ///
    1496   /// Writable bool map for filling each \c true assigned element with a 
     1702  /// Writable bool map for filling each \c true assigned element with a
    14971703  /// given value. The value can set the container.
    14981704  ///
    14991705  /// The following code finds the connected components of a graph
    15001706  /// and stores it in the \c comp map:
    1501   ///\code
    1502   /// typedef Graph::NodeMap<int> ComponentMap;
    1503   /// ComponentMap comp(graph);
    1504   /// typedef FillBoolMap<Graph::NodeMap<int> > ComponentFillerMap;
    1505   /// ComponentFillerMap filler(comp, 0);
    1506   ///
    1507   /// Dfs<Graph>::DefProcessedMap<ComponentFillerMap>::Create dfs(graph);
    1508   /// dfs.processedMap(filler);
    1509   /// dfs.init();
    1510   /// for (NodeIt it(graph); it != INVALID; ++it) {
    1511   ///   if (!dfs.reached(it)) {
    1512   ///     dfs.addSource(it);
    1513   ///     dfs.start();
    1514   ///     ++filler.fillValue();
     1707  /// \code
     1708  ///   typedef Graph::NodeMap<int> ComponentMap;
     1709  ///   ComponentMap comp(graph);
     1710  ///   typedef FillBoolMap<Graph::NodeMap<int> > ComponentFillerMap;
     1711  ///   ComponentFillerMap filler(comp, 0);
     1712  ///
     1713  ///   Dfs<Graph>::DefProcessedMap<ComponentFillerMap>::Create dfs(graph);
     1714  ///   dfs.processedMap(filler);
     1715  ///   dfs.init();
     1716  ///   for (NodeIt it(graph); it != INVALID; ++it) {
     1717  ///     if (!dfs.reached(it)) {
     1718  ///       dfs.addSource(it);
     1719  ///       dfs.start();
     1720  ///       ++filler.fillValue();
     1721  ///     }
    15151722  ///   }
    1516   /// }
    1517   ///\endcode
     1723  /// \endcode
    15181724  template <typename Map>
    15191725  class FillBoolMap {
     
    15231729
    15241730    /// Constructor
    1525     FillBoolMap(Map& _map, const typename Map::Value& _fill) 
     1731    FillBoolMap(Map& _map, const typename Map::Value& _fill)
    15261732      : map(_map), fill(_fill) {}
    15271733
    15281734    /// Constructor
    1529     FillBoolMap(Map& _map) 
     1735    FillBoolMap(Map& _map)
    15301736      : map(_map), fill() {}
    15311737
     
    15331739    const typename Map::Value& fillValue() const {
    15341740      return fill;
    1535     } 
     1741    }
    15361742
    15371743    /// Gives back the current fill value
    15381744    typename Map::Value& fillValue() {
    15391745      return fill;
    1540     } 
     1746    }
    15411747
    15421748    /// Sets the current fill value
    15431749    void fillValue(const typename Map::Value& _fill) {
    15441750      fill = _fill;
    1545     } 
    1546 
    1547     /// The \c set function of the map
     1751    }
     1752
     1753    /// The set function of the map
    15481754    void set(const Key& key, Value value) {
    15491755      if (value) {
     
    15511757      }
    15521758    }
    1553    
     1759
    15541760  private:
    15551761    Map& map;
     
    15581764
    15591765
    1560   /// \brief Writable bool map for storing the sequence number of 
    1561   /// \c true assignments. 
    1562   /// 
    1563   /// Writable bool map that stores for each \c true assigned elements 
     1766  /// \brief Writable bool map for storing the sequence number of
     1767  /// \c true assignments.
     1768  ///
     1769  /// Writable bool map that stores for each \c true assigned elements
    15641770  /// the sequence number of this setting.
    15651771  /// It makes it easy to calculate the leaving
    1566   /// order of the nodes in the \c Dfs algorithm.
    1567   ///
    1568   ///\code
    1569   /// typedef Digraph::NodeMap<int> OrderMap;
    1570   /// OrderMap order(digraph);
    1571   /// typedef SettingOrderBoolMap<OrderMap> OrderSetterMap;
    1572   /// OrderSetterMap setter(order);
    1573   /// Dfs<Digraph>::DefProcessedMap<OrderSetterMap>::Create dfs(digraph);
    1574   /// dfs.processedMap(setter);
    1575   /// dfs.init();
    1576   /// for (NodeIt it(digraph); it != INVALID; ++it) {
    1577   ///   if (!dfs.reached(it)) {
    1578   ///     dfs.addSource(it);
    1579   ///     dfs.start();
     1772  /// order of the nodes in the \ref Dfs algorithm.
     1773  ///
     1774  /// \code
     1775  ///   typedef Digraph::NodeMap<int> OrderMap;
     1776  ///   OrderMap order(digraph);
     1777  ///   typedef SettingOrderBoolMap<OrderMap> OrderSetterMap;
     1778  ///   OrderSetterMap setter(order);
     1779  ///   Dfs<Digraph>::DefProcessedMap<OrderSetterMap>::Create dfs(digraph);
     1780  ///   dfs.processedMap(setter);
     1781  ///   dfs.init();
     1782  ///   for (NodeIt it(digraph); it != INVALID; ++it) {
     1783  ///     if (!dfs.reached(it)) {
     1784  ///       dfs.addSource(it);
     1785  ///       dfs.start();
     1786  ///     }
    15801787  ///   }
    1581   /// }
    1582   ///\endcode
     1788  /// \endcode
    15831789  ///
    15841790  /// The storing of the discovering order is more difficult because the
     
    15861792  /// order map is not readable. Thus we must use the fork map:
    15871793  ///
    1588   ///\code
    1589   /// typedef Digraph::NodeMap<int> OrderMap;
    1590   /// OrderMap order(digraph);
    1591   /// typedef SettingOrderBoolMap<OrderMap> OrderSetterMap;
    1592   /// OrderSetterMap setter(order);
    1593   /// typedef Digraph::NodeMap<bool> StoreMap;
    1594   /// StoreMap store(digraph);
    1595   ///
    1596   /// typedef ForkWriteMap<StoreMap, OrderSetterMap> ReachedMap;
    1597   /// ReachedMap reached(store, setter);
    1598   ///
    1599   /// Dfs<Digraph>::DefReachedMap<ReachedMap>::Create dfs(digraph);
    1600   /// dfs.reachedMap(reached);
    1601   /// dfs.init();
    1602   /// for (NodeIt it(digraph); it != INVALID; ++it) {
    1603   ///   if (!dfs.reached(it)) {
    1604   ///     dfs.addSource(it);
    1605   ///     dfs.start();
     1794  /// \code
     1795  ///   typedef Digraph::NodeMap<int> OrderMap;
     1796  ///   OrderMap order(digraph);
     1797  ///   typedef SettingOrderBoolMap<OrderMap> OrderSetterMap;
     1798  ///   OrderSetterMap setter(order);
     1799  ///   typedef Digraph::NodeMap<bool> StoreMap;
     1800  ///   StoreMap store(digraph);
     1801  ///
     1802  ///   typedef ForkMap<StoreMap, OrderSetterMap> ReachedMap;
     1803  ///   ReachedMap reached(store, setter);
     1804  ///
     1805  ///   Dfs<Digraph>::DefReachedMap<ReachedMap>::Create dfs(digraph);
     1806  ///   dfs.reachedMap(reached);
     1807  ///   dfs.init();
     1808  ///   for (NodeIt it(digraph); it != INVALID; ++it) {
     1809  ///     if (!dfs.reached(it)) {
     1810  ///       dfs.addSource(it);
     1811  ///       dfs.start();
     1812  ///     }
    16061813  ///   }
    1607   /// }
    1608   ///\endcode
     1814  /// \endcode
    16091815  template <typename Map>
    16101816  class SettingOrderBoolMap {
     
    16141820
    16151821    /// Constructor
    1616     SettingOrderBoolMap(Map& _map) 
     1822    SettingOrderBoolMap(Map& _map)
    16171823      : map(_map), counter(0) {}
    16181824
     
    16221828    }
    16231829
    1624     /// The \c set function of the map
     1830    /// The set function of the map
    16251831    void set(const Key& key, Value value) {
    16261832      if (value) {
     
    16281834      }
    16291835    }
    1630    
     1836
    16311837  private:
    16321838    Map& map;
Note: See TracChangeset for help on using the changeset viewer.