lemon-1.0: comparison lemon/maps.h

equal deleted inserted replaced

-:6dc55bcc6051
+:baaa8318e7df
 #include <iterator>
 #include <functional>
 #include <vector>
 #include <lemon/bits/utility.h>
-// #include <lemon/bits/traits.h>
+#include <lemon/bits/traits.h>
 ///\file
 ///\ingroup maps
 ///\brief Miscellaneous property maps
-///
 #include <map>
 namespace lemon {
 /// \addtogroup maps
 /// @{
 /// Base class of maps.
-/// Base class of maps.
+/// Base class of maps. It provides the necessary type definitions
-/// It provides the necessary <tt>typedef</tt>s required by the map concept.
+/// required by the map %concepts.
-template<typename K, typename T>
+template<typename K, typename V>
 class MapBase {
 public:
-/// The key type of the map.
+/// \biref The key type of the map.
 typedef K Key;
-/// The value type of the map. (The type of objects associated with the keys).
+/// \brief The value type of the map.
-typedef T Value;
+/// (The type of objects associated with the keys).
-};
+typedef V Value;
+};
 /// Null map. (a.k.a. DoNothingMap)
 /// This map can be used if you have to provide a map only for
 /// its type definitions, or if you have to provide a writable map,
 /// but data written to it is not required (i.e. it will be sent to
 /// <tt>/dev/null</tt>).
-template<typename K, typename T>
+/// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
-class NullMap : public MapBase<K, T> {
+///
-public:
+/// \sa ConstMap
-typedef MapBase<K, T> Parent;
+template<typename K, typename V>
-typedef typename Parent::Key Key;
+class NullMap : public MapBase<K, V> {
-typedef typename Parent::Value Value;
+public:
+typedef MapBase<K, V> Parent;
+typedef typename Parent::Key Key;
+typedef typename Parent::Value Value;
 /// Gives back a default constructed element.
-T operator[](const K&) const { return T(); }
+Value operator[](const Key&) const { return Value(); }
 /// Absorbs the value.
-void set(const K&, const T&) {}
+void set(const Key&, const Value&) {}
 };
-///Returns a \c NullMap class
+/// Returns a \ref NullMap class
-///This function just returns a \c NullMap class.
+/// This function just returns a \ref NullMap class.
-///\relates NullMap
+/// \relates NullMap
 template <typename K, typename V>
 NullMap<K, V> nullMap() {
 return NullMap<K, V>();
 }
 /// Constant map.
 /// This is a \ref concepts::ReadMap "readable" map which assigns a
 /// specified value to each key.
-/// In other aspects it is equivalent to \c NullMap.
+///
-template<typename K, typename T>
+/// In other aspects it is equivalent to \ref NullMap.
-class ConstMap : public MapBase<K, T> {
+/// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
+/// concept, but it absorbs the data written to it.
+///
+/// The simplest way of using this map is through the constMap()
+/// function.
+///
+/// \sa NullMap
+/// \sa IdentityMap
+template<typename K, typename V>
+class ConstMap : public MapBase<K, V> {
 private:
-T v;
+V _value;
 public:
+typedef MapBase<K, V> Parent;
-typedef MapBase<K, T> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 /// Default constructor
 /// Default constructor.
-/// The value of the map will be uninitialized.
+/// The value of the map will be default constructed.
-/// (More exactly it will be default constructed.)
 ConstMap() {}
 /// Constructor with specified initial value
 /// Constructor with specified initial value.
-/// \param _v is the initial value of the map.
+/// \param v is the initial value of the map.
-ConstMap(const T &_v) : v(_v) {}
+ConstMap(const Value &v) : _value(v) {}
-///\e
+/// Gives back the specified value.
-T operator[](const K&) const { return v; }
+Value operator[](const Key&) const { return _value; }
-///\e
+/// Absorbs the value.
-void setAll(const T &t) {
+void set(const Key&, const Value&) {}
-v = t;
-}
+/// Sets the value that is assigned to each key.
+void setAll(const Value &v) {
-template<typename T1>
+_value = v;
-ConstMap(const ConstMap<K, T1> &, const T &_v) : v(_v) {}
+}
-};
+template<typename V1>
-///Returns a \c ConstMap class
+ConstMap(const ConstMap<K, V1> &, const Value &v) : _value(v) {}
+};
-///This function just returns a \c ConstMap class.
-///\relates ConstMap
+/// Returns a \ref ConstMap class
-template<typename K, typename V>
+/// This function just returns a \ref ConstMap class.
+/// \relates ConstMap
+template<typename K, typename V>
 inline ConstMap<K, V> constMap(const V &v) {
 return ConstMap<K, V>(v);
 }
 template<typename T, T v>
-struct Const { };
+struct Const {};
 /// Constant map with inlined constant value.
 /// This is a \ref concepts::ReadMap "readable" map which assigns a
 /// specified value to each key.
-/// In other aspects it is equivalent to \c NullMap.
+///
+/// In other aspects it is equivalent to \ref NullMap.
+/// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
+/// concept, but it absorbs the data written to it.
+///
+/// The simplest way of using this map is through the constMap()
+/// function.
+///
+/// \sa NullMap
+/// \sa IdentityMap
 template<typename K, typename V, V v>
 class ConstMap<K, Const<V, v> > : public MapBase<K, V> {
 public:
 typedef MapBase<K, V> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
-ConstMap() { }
+/// Constructor.
-///\e
+ConstMap() {}
-V operator[](const K&) const { return v; }
-///\e
+/// Gives back the specified value.
-void set(const K&, const V&) { }
+Value operator[](const Key&) const { return v; }
-};
+/// Absorbs the value.
-///Returns a \c ConstMap class with inlined value
+void set(const Key&, const Value&) {}
+};
-///This function just returns a \c ConstMap class with inlined value.
-///\relates ConstMap
+/// Returns a \ref ConstMap class with inlined constant value
-template<typename K, typename V, V v>
+/// This function just returns a \ref ConstMap class with inlined
+/// constant value.
+/// \relates ConstMap
+template<typename K, typename V, V v>
 inline ConstMap<K, Const<V, v> > constMap() {
 return ConstMap<K, Const<V, v> >();
 }
-///Map based on \c std::map
+/// \brief Identity map.
-///This is essentially a wrapper for \c std::map with addition that
+///
-///you can specify a default value different from \c Value().
+/// This map gives back the given key as value without any
-///It meets the \ref concepts::ReferenceMap "ReferenceMap" concept.
+/// modification.
-template <typename K, typename T, typename Compare = std::less<K> >
+///
-class StdMap : public MapBase<K, T> {
+/// \sa ConstMap
-template <typename K1, typename T1, typename C1>
+template <typename T>
-friend class StdMap;
+class IdentityMap : public MapBase<T, T> {
 public:
+typedef MapBase<T, T> Parent;
-typedef MapBase<K, T> Parent;
+typedef typename Parent::Key Key;
-///Key type
+typedef typename Parent::Value Value;
-typedef typename Parent::Key Key;
-///Value type
+/// Gives back the given value without any modification.
-typedef typename Parent::Value Value;
+const T& operator[](const T& t) const {
-///Reference Type
+return t;
-typedef T& Reference;
+}
-///Const reference type
+};
-typedef const T& ConstReference;
+/// Returns an \ref IdentityMap class
+/// This function just returns an \ref IdentityMap class.
+/// \relates IdentityMap
+template<typename T>
+inline IdentityMap<T> identityMap() {
+return IdentityMap<T>();
+}
+/// \brief Map for storing values for integer keys from the range
+/// <tt>[0..size-1]</tt>.
+///
+/// This map is essentially a wrapper for \c std::vector. It assigns
+/// values to integer keys from the range <tt>[0..size-1]</tt>.
+/// It can be used with some data structures, for example
+/// \ref UnionFind, \ref BinHeap, when the used items are small
+/// integers. This map conforms the \ref concepts::ReferenceMap
+/// "ReferenceMap" concept.
+///
+/// The simplest way of using this map is through the rangeMap()
+/// function.
+template <typename V>
+class RangeMap : public MapBase<int, V> {
+template <typename V1>
+friend class RangeMap;
+private:
+typedef std::vector<V> Vector;
+Vector _vector;
+public:
+typedef MapBase<int, V> Parent;
+/// Key type
+typedef typename Parent::Key Key;
+/// Value type
+typedef typename Parent::Value Value;
+/// Reference type
+typedef typename Vector::reference Reference;
+/// Const reference type
+typedef typename Vector::const_reference ConstReference;
 typedef True ReferenceMapTag;
+public:
+/// Constructor with specified default value.
+RangeMap(int size = 0, const Value &value = Value())
+: _vector(size, value) {}
+/// Constructs the map from an appropriate \c std::vector.
+template <typename V1>
+RangeMap(const std::vector<V1>& vector)
+: _vector(vector.begin(), vector.end()) {}
+/// Constructs the map from another \ref RangeMap.
+template <typename V1>
+RangeMap(const RangeMap<V1> &c)
+: _vector(c._vector.begin(), c._vector.end()) {}
+/// Returns the size of the map.
+int size() {
+return _vector.size();
+}
+/// Resizes the map.
+/// Resizes the underlying \c std::vector container, so changes the
+/// keyset of the map.
+/// \param size The new size of the map. The new keyset will be the
+/// range <tt>[0..size-1]</tt>.
+/// \param value The default value to assign to the new keys.
+void resize(int size, const Value &value = Value()) {
+_vector.resize(size, value);
+}
 private:
-typedef std::map<K, T, Compare> Map;
+RangeMap& operator=(const RangeMap&);
+public:
+///\e
+Reference operator[](const Key &k) {
+return _vector[k];
+}
+///\e
+ConstReference operator[](const Key &k) const {
+return _vector[k];
+}
+///\e
+void set(const Key &k, const Value &v) {
+_vector[k] = v;
+}
+};
+/// Returns a \ref RangeMap class
+/// This function just returns a \ref RangeMap class.
+/// \relates RangeMap
+template<typename V>
+inline RangeMap<V> rangeMap(int size = 0, const V &value = V()) {
+return RangeMap<V>(size, value);
+}
+/// \brief Returns a \ref RangeMap class created from an appropriate
+/// \c std::vector
+/// This function just returns a \ref RangeMap class created from an
+/// appropriate \c std::vector.
+/// \relates RangeMap
+template<typename V>
+inline RangeMap<V> rangeMap(const std::vector<V> &vector) {
+return RangeMap<V>(vector);
+}
+/// Map type based on \c std::map
+/// This map is essentially a wrapper for \c std::map with addition
+/// that you can specify a default value for the keys that are not
+/// stored actually. This value can be different from the default
+/// contructed value (i.e. \c %Value()).
+/// This type conforms the \ref concepts::ReferenceMap "ReferenceMap"
+/// concept.
+///
+/// This map is useful if a default value should be assigned to most of
+/// the keys and different values should be assigned only to a few
+/// keys (i.e. the map is "sparse").
+/// The name of this type also refers to this important usage.
+///
+/// Apart form that this map can be used in many other cases since it
+/// is based on \c std::map, which is a general associative container.
+/// However keep in mind that it is usually not as efficient as other
+/// maps.
+///
+/// The simplest way of using this map is through the sparseMap()
+/// function.
+template <typename K, typename V, typename Compare = std::less<K> >
+class SparseMap : public MapBase<K, V> {
+template <typename K1, typename V1, typename C1>
+friend class SparseMap;
+public:
+typedef MapBase<K, V> Parent;
+/// Key type
+typedef typename Parent::Key Key;
+/// Value type
+typedef typename Parent::Value Value;
+/// Reference type
+typedef Value& Reference;
+/// Const reference type
+typedef const Value& ConstReference;
+typedef True ReferenceMapTag;
+private:
+typedef std::map<K, V, Compare> Map;
+Map _map;
 Value _value;
-Map _map;
+public:
-public:
+/// \brief Constructor with specified default value.
-/// Constructor with specified default value
+SparseMap(const Value &value = Value()) : _value(value) {}
-StdMap(const T& value = T()) : _value(value) {}
+/// \brief Constructs the map from an appropriate \c std::map, and
-/// \brief Constructs the map from an appropriate \c std::map, and
 /// explicitly specifies a default value.
-template <typename T1, typename Comp1>
+template <typename V1, typename Comp1>
-StdMap(const std::map<Key, T1, Comp1> &map, const T& value = T())
+SparseMap(const std::map<Key, V1, Comp1> &map,
+const Value &value = Value())
 : _map(map.begin(), map.end()), _value(value) {}
-/// \brief Constructs a map from an other \ref StdMap.
+/// \brief Constructs the map from another \ref SparseMap.
-template<typename T1, typename Comp1>
+template<typename V1, typename Comp1>
-StdMap(const StdMap<Key, T1, Comp1> &c)
+SparseMap(const SparseMap<Key, V1, Comp1> &c)
 : _map(c._map.begin(), c._map.end()), _value(c._value) {}
 private:
-StdMap& operator=(const StdMap&);
+SparseMap& operator=(const SparseMap&);
 public:
 ///\e
 Reference operator[](const Key &k) {
 	return it->second;
 else
 	return _map.insert(it, std::make_pair(k, _value))->second;
 }
-/// \e
+///\e
 ConstReference operator[](const Key &k) const {
 typename Map::const_iterator it = _map.find(k);
 if (it != _map.end())
 	return it->second;
 else
 	return _value;
 }
-/// \e
+///\e
-void set(const Key &k, const T &t) {
+void set(const Key &k, const Value &v) {
 typename Map::iterator it = _map.lower_bound(k);
 if (it != _map.end() && !_map.key_comp()(k, it->first))
-	it->second = t;
+	it->second = v;
 else
-	_map.insert(it, std::make_pair(k, t));
+	_map.insert(it, std::make_pair(k, v));
 }
-/// \e
+///\e
-void setAll(const T &t) {
+void setAll(const Value &v) {
-_value = t;
+_value = v;
 _map.clear();
 }
+};
-};
+/// Returns a \ref SparseMap class
-///Returns a \c StdMap class
+/// This function just returns a \ref SparseMap class with specified
-///This function just returns a \c StdMap class with specified
+/// default value.
-///default value.
+/// \relates SparseMap
-///\relates StdMap
+template<typename K, typename V, typename Compare>
-template<typename K, typename V, typename Compare>
+inline SparseMap<K, V, Compare> sparseMap(const V& value = V()) {
-inline StdMap<K, V, Compare> stdMap(const V& value = V()) {
+return SparseMap<K, V, Compare>(value);
-return StdMap<K, V, Compare>(value);
+}
-}
+template<typename K, typename V>
-///Returns a \c StdMap class
+inline SparseMap<K, V, std::less<K> > sparseMap(const V& value = V()) {
+return SparseMap<K, V, std::less<K> >(value);
-///This function just returns a \c StdMap class with specified
+}
-///default value.
-///\relates StdMap
+/// \brief Returns a \ref SparseMap class created from an appropriate
-template<typename K, typename V>
+/// \c std::map
-inline StdMap<K, V, std::less<K> > stdMap(const V& value = V()) {
-return StdMap<K, V, std::less<K> >(value);
+/// This function just returns a \ref SparseMap class created from an
-}
+/// appropriate \c std::map.
+/// \relates SparseMap
-///Returns a \c StdMap class created from an appropriate std::map
+template<typename K, typename V, typename Compare>
+inline SparseMap<K, V, Compare>
-///This function just returns a \c StdMap class created from an
+sparseMap(const std::map<K, V, Compare> &map, const V& value = V())
-///appropriate std::map.
+{
-///\relates StdMap
+return SparseMap<K, V, Compare>(map, value);
-template<typename K, typename V, typename Compare>
-inline StdMap<K, V, Compare> stdMap( const std::map<K, V, Compare> &map,
-const V& value = V() ) {
-return StdMap<K, V, Compare>(map, value);
-}
-///Returns a \c StdMap class created from an appropriate std::map
-///This function just returns a \c StdMap class created from an
-///appropriate std::map.
-///\relates StdMap
-template<typename K, typename V>
-inline StdMap<K, V, std::less<K> > stdMap( const std::map<K, V, std::less<K> > &map,
-const V& value = V() ) {
-return StdMap<K, V, std::less<K> >(map, value);
-}
-/// \brief Map for storing values for keys from the range <tt>[0..size-1]</tt>
-///
-/// This map has the <tt>[0..size-1]</tt> keyset and the values
-/// are stored in a \c std::vector<T>  container. It can be used with
-/// some data structures, for example \c UnionFind, \c BinHeap, when
-/// the used items are small integer numbers.
-/// This map meets the \ref concepts::ReferenceMap "ReferenceMap" concept.
-///
-/// \todo Revise its name
-template <typename T>
-class IntegerMap : public MapBase<int, T> {
-template <typename T1>
-friend class IntegerMap;
-public:
-typedef MapBase<int, T> Parent;
-///\e
-typedef typename Parent::Key Key;
-///\e
-typedef typename Parent::Value Value;
-///\e
-typedef T& Reference;
-///\e
-typedef const T& ConstReference;
-typedef True ReferenceMapTag;
-private:
-typedef std::vector<T> Vector;
-Vector _vector;
-public:
-/// Constructor with specified default value
-IntegerMap(int size = 0, const T& value = T()) : _vector(size, value) {}
-/// \brief Constructs the map from an appropriate \c std::vector.
-template <typename T1>
-IntegerMap(const std::vector<T1>& vector)
-: _vector(vector.begin(), vector.end()) {}
-/// \brief Constructs a map from an other \ref IntegerMap.
-template <typename T1>
-IntegerMap(const IntegerMap<T1> &c)
-: _vector(c._vector.begin(), c._vector.end()) {}
-/// \brief Resize the container
-void resize(int size, const T& value = T()) {
-_vector.resize(size, value);
-}
-private:
-IntegerMap& operator=(const IntegerMap&);
-public:
-///\e
-Reference operator[](Key k) {
-return _vector[k];
-}
-/// \e
-ConstReference operator[](Key k) const {
-return _vector[k];
-}
-/// \e
-void set(const Key &k, const T& t) {
-_vector[k] = t;
-}
-};
-///Returns an \c IntegerMap class
-///This function just returns an \c IntegerMap class.
-///\relates IntegerMap
-template<typename T>
-inline IntegerMap<T> integerMap(int size = 0, const T& value = T()) {
-return IntegerMap<T>(size, value);
 }
 /// @}
 /// \addtogroup map_adaptors
 /// @{
-/// \brief Identity map.
+/// Composition of two maps
-///
-/// This map gives back the given key as value without any
+/// This \ref concepts::ReadMap "read only map" returns the
-/// modification.
+/// composition of two given maps. That is to say, if \c m1 is of
-template <typename T>
+/// type \c M1 and \c m2 is of \c M2, then for
-class IdentityMap : public MapBase<T, T> {
+/// \code
-public:
+///   ComposeMap<M1, M2> cm(m1,m2);
-typedef MapBase<T, T> Parent;
+/// \endcode
-typedef typename Parent::Key Key;
+/// <tt>cm[x]</tt> will be equal to <tt>m1[m2[x]]</tt>.
-typedef typename Parent::Value Value;
+///
+/// The \c Key type of the map is inherited from \c M2 and the
-/// \e
+/// \c Value type is from \c M1.
-const T& operator[](const T& t) const {
+/// \c M2::Value must be convertible to \c M1::Key.
-return t;
+///
-}
+/// The simplest way of using this map is through the composeMap()
-};
+/// function.
+///
-///Returns an \c IdentityMap class
+/// \sa CombineMap
+///
-///This function just returns an \c IdentityMap class.
+/// \todo Check the requirements.
-///\relates IdentityMap
+template <typename M1, typename M2>
-template<typename T>
+class ComposeMap : public MapBase<typename M2::Key, typename M1::Value> {
-inline IdentityMap<T> identityMap() {
+const M1 &_m1;
-return IdentityMap<T>();
+const M2 &_m2;
-}
+public:
+typedef MapBase<typename M2::Key, typename M1::Value> Parent;
+typedef typename Parent::Key Key;
-///\brief Convert the \c Value of a map to another type using
+typedef typename Parent::Value Value;
-///the default conversion.
-///
+/// Constructor
-///This \ref concepts::ReadMap "read only map"
+ComposeMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-///converts the \c Value of a map to type \c T.
-///Its \c Key is inherited from \c M.
+/// \e
-template <typename M, typename T>
+typename MapTraits<M1>::ConstReturnValue
-class ConvertMap : public MapBase<typename M::Key, T> {
+operator[](const Key &k) const { return _m1[_m2[k]]; }
-const M& m;
+};
-public:
-typedef MapBase<typename M::Key, T> Parent;
+/// Returns a \ref ComposeMap class
-typedef typename Parent::Key Key;
-typedef typename Parent::Value Value;
+/// This function just returns a \ref ComposeMap class.
+///
-///Constructor
+/// If \c m1 and \c m2 are maps and the \c Value type of \c m2 is
+/// convertible to the \c Key of \c m1, then <tt>composeMap(m1,m2)[x]</tt>
-///Constructor.
+/// will be equal to <tt>m1[m2[x]]</tt>.
-///\param _m is the underlying map.
+///
-ConvertMap(const M &_m) : m(_m) {};
+/// \relates ComposeMap
+template <typename M1, typename M2>
-///\e
+inline ComposeMap<M1, M2> composeMap(const M1 &m1, const M2 &m2) {
-Value operator[](const Key& k) const {return m[k];}
+return ComposeMap<M1, M2>(m1, m2);
-};
+}
-///Returns a \c ConvertMap class
+/// Combination of two maps using an STL (binary) functor.
-///This function just returns a \c ConvertMap class.
-///\relates ConvertMap
+/// This \ref concepts::ReadMap "read only map" takes two maps and a
-template<typename T, typename M>
+/// binary functor and returns the combination of the two given maps
-inline ConvertMap<M, T> convertMap(const M &m) {
+/// using the functor.
-return ConvertMap<M, T>(m);
+/// That is to say, if \c m1 is of type \c M1 and \c m2 is of \c M2
-}
+/// and \c f is of \c F, then for
+/// \code
-///Simple wrapping of a map
+///   CombineMap<M1,M2,F,V> cm(m1,m2,f);
+/// \endcode
-///This \ref concepts::ReadMap "read only map" returns the simple
+/// <tt>cm[x]</tt> will be equal to <tt>f(m1[x],m2[x])</tt>.
-///wrapping of the given map. Sometimes the reference maps cannot be
+///
-///combined with simple read maps. This map adaptor wraps the given
+/// The \c Key type of the map is inherited from \c M1 (\c M1::Key
-///map to simple read map.
+/// must be convertible to \c M2::Key) and the \c Value type is \c V.
-///
+/// \c M2::Value and \c M1::Value must be convertible to the
-///\sa SimpleWriteMap
+/// corresponding input parameter of \c F and the return type of \c F
-///
+/// must be convertible to \c V.
-/// \todo Revise the misleading name
+///
-template<typename M>
+/// The simplest way of using this map is through the combineMap()
-class SimpleMap : public MapBase<typename M::Key, typename M::Value> {
+/// function.
-const M& m;
+///
+/// \sa ComposeMap
+///
+/// \todo Check the requirements.
+template<typename M1, typename M2, typename F,
+	   typename V = typename F::result_type>
+class CombineMap : public MapBase<typename M1::Key, V> {
+const M1 &_m1;
+const M2 &_m2;
+F _f;
+public:
+typedef MapBase<typename M1::Key, V> Parent;
+typedef typename Parent::Key Key;
+typedef typename Parent::Value Value;
+/// Constructor
+CombineMap(const M1 &m1, const M2 &m2, const F &f = F())
+: _m1(m1), _m2(m2), _f(f) {}
+/// \e
+Value operator[](const Key &k) const { return _f(_m1[k],_m2[k]); }
+};
+/// Returns a \ref CombineMap class
+/// This function just returns a \ref CombineMap class.
+///
+/// For example, if \c m1 and \c m2 are both maps with \c double
+/// values, then
+/// \code
+///   combineMap(m1,m2,std::plus<double>())
+/// \endcode
+/// is equivalent to
+/// \code
+///   addMap(m1,m2)
+/// \endcode
+///
+/// This function is specialized for adaptable binary function
+/// classes and C++ functions.
+///
+/// \relates CombineMap
+template<typename M1, typename M2, typename F, typename V>
+inline CombineMap<M1, M2, F, V>
+combineMap(const M1 &m1, const M2 &m2, const F &f) {
+return CombineMap<M1, M2, F, V>(m1,m2,f);
+}
+template<typename M1, typename M2, typename F>
+inline CombineMap<M1, M2, F, typename F::result_type>
+combineMap(const M1 &m1, const M2 &m2, const F &f) {
+return combineMap<M1, M2, F, typename F::result_type>(m1,m2,f);
+}
+template<typename M1, typename M2, typename K1, typename K2, typename V>
+inline CombineMap<M1, M2, V (*)(K1, K2), V>
+combineMap(const M1 &m1, const M2 &m2, V (*f)(K1, K2)) {
+return combineMap<M1, M2, V (*)(K1, K2), V>(m1,m2,f);
+}
+/// Converts an STL style (unary) functor to a map
+/// This \ref concepts::ReadMap "read only map" returns the value
+/// of a given functor. Actually, it just wraps the functor and
+/// provides the \c Key and \c Value typedefs.
+///
+/// Template parameters \c K and \c V will become its \c Key and
+/// \c Value. In most cases they have to be given explicitly because
+/// a functor typically does not provide \c argument_type and
+/// \c result_type typedefs.
+/// Parameter \c F is the type of the used functor.
+///
+/// The simplest way of using this map is through the functorToMap()
+/// function.
+///
+/// \sa MapToFunctor
+template<typename F,
+	   typename K = typename F::argument_type,
+	   typename V = typename F::result_type>
+class FunctorToMap : public MapBase<K, V> {
+const F &_f;
+public:
+typedef MapBase<K, V> Parent;
+typedef typename Parent::Key Key;
+typedef typename Parent::Value Value;
+/// Constructor
+FunctorToMap(const F &f = F()) : _f(f) {}
+/// \e
+Value operator[](const Key &k) const { return _f(k); }
+};
+/// Returns a \ref FunctorToMap class
+/// This function just returns a \ref FunctorToMap class.
+///
+/// This function is specialized for adaptable binary function
+/// classes and C++ functions.
+///
+/// \relates FunctorToMap
+template<typename K, typename V, typename F>
+inline FunctorToMap<F, K, V> functorToMap(const F &f) {
+return FunctorToMap<F, K, V>(f);
+}
+template <typename F>
+inline FunctorToMap<F, typename F::argument_type, typename F::result_type>
+functorToMap(const F &f)
+{
+return FunctorToMap<F, typename F::argument_type,
+typename F::result_type>(f);
+}
+template <typename K, typename V>
+inline FunctorToMap<V (*)(K), K, V> functorToMap(V (*f)(K)) {
+return FunctorToMap<V (*)(K), K, V>(f);
+}
+/// Converts a map to an STL style (unary) functor
+/// This class converts a map to an STL style (unary) functor.
+/// That is it provides an <tt>operator()</tt> to read its values.
+///
+/// For the sake of convenience it also works as a usual
+/// \ref concepts::ReadMap "readable map", i.e. <tt>operator[]</tt>
+/// and the \c Key and \c Value typedefs also exist.
+///
+/// The simplest way of using this map is through the mapToFunctor()
+/// function.
+///
+///\sa FunctorToMap
+template <typename M>
+class MapToFunctor : public MapBase<typename M::Key, typename M::Value> {
+const M &_m;
 public:
 typedef MapBase<typename M::Key, typename M::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
-///Constructor
+typedef typename Parent::Key argument_type;
-SimpleMap(const M &_m) : m(_m) {};
+typedef typename Parent::Value result_type;
-///\e
-Value operator[](Key k) const {return m[k];}
+/// Constructor
-};
+MapToFunctor(const M &m) : _m(m) {}
+/// \e
-///Returns a \c SimpleMap class
+Value operator()(const Key &k) const { return _m[k]; }
+/// \e
-///This function just returns a \c SimpleMap class.
+Value operator[](const Key &k) const { return _m[k]; }
-///\relates SimpleMap
+};
+/// Returns a \ref MapToFunctor class
+/// This function just returns a \ref MapToFunctor class.
+/// \relates MapToFunctor
 template<typename M>
-inline SimpleMap<M> simpleMap(const M &m) {
+inline MapToFunctor<M> mapToFunctor(const M &m) {
-return SimpleMap<M>(m);
+return MapToFunctor<M>(m);
 }
-///Simple writable wrapping of a map
+/// \brief Map adaptor to convert the \c Value type of a map to
-///This \ref concepts::ReadWriteMap "read-write map" returns the simple
+/// another type using the default conversion.
-///wrapping of the given map. Sometimes the reference maps cannot be
-///combined with simple read-write maps. This map adaptor wraps the
+/// Map adaptor to convert the \c Value type of a \ref concepts::ReadMap
-///given map to simple read-write map.
+/// "readable map" to another type using the default conversion.
-///
+/// The \c Key type of it is inherited from \c M and the \c Value
-///\sa SimpleMap
+/// type is \c V.
-///
+/// This type conforms the \ref concepts::ReadMap "ReadMap" concept.
-/// \todo Revise the misleading name
+///
-template<typename M>
+/// The simplest way of using this map is through the convertMap()
-class SimpleWriteMap : public MapBase<typename M::Key, typename M::Value> {
+/// function.
-M& m;
+template <typename M, typename V>
+class ConvertMap : public MapBase<typename M::Key, V> {
+const M &_m;
+public:
+typedef MapBase<typename M::Key, V> Parent;
+typedef typename Parent::Key Key;
+typedef typename Parent::Value Value;
+/// Constructor
+/// Constructor.
+/// \param m The underlying map.
+ConvertMap(const M &m) : _m(m) {}
+/// \e
+Value operator[](const Key &k) const { return _m[k]; }
+};
+/// Returns a \ref ConvertMap class
+/// This function just returns a \ref ConvertMap class.
+/// \relates ConvertMap
+template<typename V, typename M>
+inline ConvertMap<M, V> convertMap(const M &map) {
+return ConvertMap<M, V>(map);
+}
+/// Applies all map setting operations to two maps
+/// This map has two \ref concepts::WriteMap "writable map" parameters
+/// and each write request will be passed to both of them.
+/// If \c M1 is also \ref concepts::ReadMap "readable", then the read
+/// operations will return the corresponding values of \c M1.
+///
+/// The \c Key and \c Value types are inherited from \c M1.
+/// The \c Key and \c Value of \c M2 must be convertible from those
+/// of \c M1.
+///
+/// The simplest way of using this map is through the forkMap()
+/// function.
+template<typename  M1, typename M2>
+class ForkMap : public MapBase<typename M1::Key, typename M1::Value> {
+M1 &_m1;
+M2 &_m2;
+public:
+typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+typedef typename Parent::Key Key;
+typedef typename Parent::Value Value;
+/// Constructor
+ForkMap(M1 &m1, M2 &m2) : _m1(m1), _m2(m2) {}
+/// Returns the value associated with the given key in the first map.
+Value operator[](const Key &k) const { return _m1[k]; }
+/// Sets the value associated with the given key in both maps.
+void set(const Key &k, const Value &v) { _m1.set(k,v); _m2.set(k,v); }
+};
+/// Returns a \ref ForkMap class
+/// This function just returns a \ref ForkMap class.
+/// \relates ForkMap
+template <typename M1, typename M2>
+inline ForkMap<M1,M2> forkMap(M1 &m1, M2 &m2) {
+return ForkMap<M1,M2>(m1,m2);
+}
+/// Simple wrapping of a map
+/// This \ref concepts::ReadMap "read only map" returns the simple
+/// wrapping of the given map. Sometimes the reference maps cannot be
+/// combined with simple read maps. This map adaptor wraps the given
+/// map to simple read map.
+///
+/// The simplest way of using this map is through the wrapMap()
+/// function.
+///
+/// \sa WrapWriteMap
+template<typename M>
+class WrapMap : public MapBase<typename M::Key, typename M::Value> {
+const M &_m;
 public:
 typedef MapBase<typename M::Key, typename M::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
-///Constructor
+/// Constructor
-SimpleWriteMap(M &_m) : m(_m) {};
+WrapMap(const M &m) : _m(m) {}
-///\e
+/// \e
-Value operator[](Key k) const {return m[k];}
+Value operator[](const Key &k) const { return _m[k]; }
-///\e
+};
-void set(Key k, const Value& c) { m.set(k, c); }
-};
+/// Returns a \ref WrapMap class
-///Returns a \c SimpleWriteMap class
+/// This function just returns a \ref WrapMap class.
+/// \relates WrapMap
-///This function just returns a \c SimpleWriteMap class.
-///\relates SimpleWriteMap
 template<typename M>
-inline SimpleWriteMap<M> simpleWriteMap(M &m) {
+inline WrapMap<M> wrapMap(const M &map) {
-return SimpleWriteMap<M>(m);
+return WrapMap<M>(map);
 }
-///Sum of two maps
+/// Simple writable wrapping of a map
-///This \ref concepts::ReadMap "read only map" returns the sum of the two
-///given maps.
+/// This \ref concepts::ReadWriteMap "read-write map" returns the simple
-///Its \c Key and \c Value are inherited from \c M1.
+/// wrapping of the given map. Sometimes the reference maps cannot be
-///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
+/// combined with simple read-write maps. This map adaptor wraps the
-template<typename M1, typename M2>
+/// given map to simple read-write map.
+///
+/// The simplest way of using this map is through the wrapWriteMap()
+/// function.
+///
+/// \sa WrapMap
+template<typename M>
+class WrapWriteMap : public MapBase<typename M::Key, typename M::Value> {
+M &_m;
+public:
+typedef MapBase<typename M::Key, typename M::Value> Parent;
+typedef typename Parent::Key Key;
+typedef typename Parent::Value Value;
+/// Constructor
+WrapWriteMap(M &m) : _m(m) {}
+/// \e
+Value operator[](const Key &k) const { return _m[k]; }
+/// \e
+void set(const Key &k, const Value &c) { _m.set(k, c); }
+};
+///Returns a \ref WrapWriteMap class
+///This function just returns a \ref WrapWriteMap class.
+///\relates WrapWriteMap
+template<typename M>
+inline WrapWriteMap<M> wrapWriteMap(M &map) {
+return WrapWriteMap<M>(map);
+}
+/// Sum of two maps
+/// This \ref concepts::ReadMap "read only map" returns the sum
+/// of the values of the two given maps.
+/// Its \c Key and \c Value types are inherited from \c M1.
+/// The \c Key and \c Value of \c M2 must be convertible to those of
+/// \c M1.
+///
+/// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for
+/// \code
+///   AddMap<M1,M2> am(m1,m2);
+/// \endcode
+/// <tt>am[x]</tt> will be equal to <tt>m1[x]+m2[x]</tt>.
+///
+/// The simplest way of using this map is through the addMap()
+/// function.
+///
+/// \sa SubMap, MulMap, DivMap
+/// \sa ShiftMap, ShiftWriteMap
+template<typename M1, typename M2>
 class AddMap : public MapBase<typename M1::Key, typename M1::Value> {
-const M1& m1;
+const M1 &_m1;
-const M2& m2;
+const M2 &_m2;
 public:
 typedef MapBase<typename M1::Key, typename M1::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
-///Constructor
+/// Constructor
-AddMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
+AddMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-///\e
+/// \e
-Value operator[](Key k) const {return m1[k]+m2[k];}
+Value operator[](const Key &k) const { return _m1[k]+_m2[k]; }
 };
-///Returns an \c AddMap class
+/// Returns an \ref AddMap class
-///This function just returns an \c AddMap class.
+/// This function just returns an \ref AddMap class.
-///\todo Extend the documentation: how to call these type of functions?
+///
-///
+/// For example, if \c m1 and \c m2 are both maps with \c double
-///\relates AddMap
+/// values, then <tt>addMap(m1,m2)[x]</tt> will be equal to
-template<typename M1, typename M2>
+/// <tt>m1[x]+m2[x]</tt>.
-inline AddMap<M1, M2> addMap(const M1 &m1,const M2 &m2) {
+///
+/// \relates AddMap
+template<typename M1, typename M2>
+inline AddMap<M1, M2> addMap(const M1 &m1, const M2 &m2) {
 return AddMap<M1, M2>(m1,m2);
 }
-///Shift a map with a constant.
+/// Difference of two maps
-///This \ref concepts::ReadMap "read only map" returns the sum of the
-///given map and a constant value.
+/// This \ref concepts::ReadMap "read only map" returns the difference
-///Its \c Key and \c Value are inherited from \c M.
+/// of the values of the two given maps.
-///
+/// Its \c Key and \c Value types are inherited from \c M1.
-///Actually,
+/// The \c Key and \c Value of \c M2 must be convertible to those of
-///\code
+/// \c M1.
-///  ShiftMap<X> sh(x,v);
+///
-///\endcode
+/// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for
-///is equivalent to
+/// \code
-///\code
+///   SubMap<M1,M2> sm(m1,m2);
-///  ConstMap<X::Key, X::Value> c_tmp(v);
+/// \endcode
-///  AddMap<X, ConstMap<X::Key, X::Value> > sh(x,v);
+/// <tt>sm[x]</tt> will be equal to <tt>m1[x]-m2[x]</tt>.
-///\endcode
+///
-///
+/// The simplest way of using this map is through the subMap()
-///\sa ShiftWriteMap
+/// function.
-template<typename M, typename C = typename M::Value>
+///
-class ShiftMap : public MapBase<typename M::Key, typename M::Value> {
+/// \sa AddMap, MulMap, DivMap
-const M& m;
+template<typename M1, typename M2>
-C v;
-public:
-typedef MapBase<typename M::Key, typename M::Value> Parent;
-typedef typename Parent::Key Key;
-typedef typename Parent::Value Value;
-///Constructor
-///Constructor.
-///\param _m is the undelying map.
-///\param _v is the shift value.
-ShiftMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
-///\e
-Value operator[](Key k) const {return m[k] + v;}
-};
-///Shift a map with a constant (ReadWrite version).
-///This \ref concepts::ReadWriteMap "read-write map" returns the sum of the
-///given map and a constant value. It makes also possible to write the map.
-///Its \c Key and \c Value are inherited from \c M.
-///
-///\sa ShiftMap
-template<typename M, typename C = typename M::Value>
-class ShiftWriteMap : public MapBase<typename M::Key, typename M::Value> {
-M& m;
-C v;
-public:
-typedef MapBase<typename M::Key, typename M::Value> Parent;
-typedef typename Parent::Key Key;
-typedef typename Parent::Value Value;
-///Constructor
-///Constructor.
-///\param _m is the undelying map.
-///\param _v is the shift value.
-ShiftWriteMap(M &_m, const C &_v ) : m(_m), v(_v) {};
-/// \e
-Value operator[](Key k) const {return m[k] + v;}
-/// \e
-void set(Key k, const Value& c) { m.set(k, c - v); }
-};
-///Returns a \c ShiftMap class
-///This function just returns a \c ShiftMap class.
-///\relates ShiftMap
-template<typename M, typename C>
-inline ShiftMap<M, C> shiftMap(const M &m,const C &v) {
-return ShiftMap<M, C>(m,v);
-}
-///Returns a \c ShiftWriteMap class
-///This function just returns a \c ShiftWriteMap class.
-///\relates ShiftWriteMap
-template<typename M, typename C>
-inline ShiftWriteMap<M, C> shiftMap(M &m,const C &v) {
-return ShiftWriteMap<M, C>(m,v);
-}
-///Difference of two maps
-///This \ref concepts::ReadMap "read only map" returns the difference
-///of the values of the two given maps.
-///Its \c Key and \c Value are inherited from \c M1.
-///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
-///
-/// \todo Revise the misleading name
-template<typename M1, typename M2>
 class SubMap : public MapBase<typename M1::Key, typename M1::Value> {
-const M1& m1;
+const M1 &_m1;
-const M2& m2;
+const M2 &_m2;
 public:
 typedef MapBase<typename M1::Key, typename M1::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
-///Constructor
+/// Constructor
-SubMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
+SubMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 /// \e
-Value operator[](Key k) const {return m1[k]-m2[k];}
+Value operator[](const Key &k) const { return _m1[k]-_m2[k]; }
 };
-///Returns a \c SubMap class
+/// Returns a \ref SubMap class
-///This function just returns a \c SubMap class.
+/// This function just returns a \ref SubMap class.
 ///
-///\relates SubMap
+/// For example, if \c m1 and \c m2 are both maps with \c double
-template<typename M1, typename M2>
+/// values, then <tt>subMap(m1,m2)[x]</tt> will be equal to
+/// <tt>m1[x]-m2[x]</tt>.
+///
+/// \relates SubMap
+template<typename M1, typename M2>
 inline SubMap<M1, M2> subMap(const M1 &m1, const M2 &m2) {
-return SubMap<M1, M2>(m1, m2);
+return SubMap<M1, M2>(m1,m2);
 }
-///Product of two maps
+/// Product of two maps
-///This \ref concepts::ReadMap "read only map" returns the product of the
-///values of the two given maps.
+/// This \ref concepts::ReadMap "read only map" returns the product
-///Its \c Key and \c Value are inherited from \c M1.
+/// of the values of the two given maps.
-///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
+/// Its \c Key and \c Value types are inherited from \c M1.
-template<typename M1, typename M2>
+/// The \c Key and \c Value of \c M2 must be convertible to those of
+/// \c M1.
+///
+/// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for
+/// \code
+///   MulMap<M1,M2> mm(m1,m2);
+/// \endcode
+/// <tt>mm[x]</tt> will be equal to <tt>m1[x]*m2[x]</tt>.
+///
+/// The simplest way of using this map is through the mulMap()
+/// function.
+///
+/// \sa AddMap, SubMap, DivMap
+/// \sa ScaleMap, ScaleWriteMap
+template<typename M1, typename M2>
 class MulMap : public MapBase<typename M1::Key, typename M1::Value> {
-const M1& m1;
+const M1 &_m1;
-const M2& m2;
+const M2 &_m2;
 public:
 typedef MapBase<typename M1::Key, typename M1::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
-///Constructor
+/// Constructor
-MulMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
+MulMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
 /// \e
-Value operator[](Key k) const {return m1[k]*m2[k];}
+Value operator[](const Key &k) const { return _m1[k]*_m2[k]; }
 };
-///Returns a \c MulMap class
+/// Returns a \ref MulMap class
-///This function just returns a \c MulMap class.
+/// This function just returns a \ref MulMap class.
-///\relates MulMap
+///
-template<typename M1, typename M2>
+/// For example, if \c m1 and \c m2 are both maps with \c double
+/// values, then <tt>mulMap(m1,m2)[x]</tt> will be equal to
+/// <tt>m1[x]*m2[x]</tt>.
+///
+/// \relates MulMap
+template<typename M1, typename M2>
 inline MulMap<M1, M2> mulMap(const M1 &m1,const M2 &m2) {
 return MulMap<M1, M2>(m1,m2);
 }
-///Scales a map with a constant.
+/// Quotient of two maps
-///This \ref concepts::ReadMap "read only map" returns the value of the
-///given map multiplied from the left side with a constant value.
+/// This \ref concepts::ReadMap "read only map" returns the quotient
-///Its \c Key and \c Value are inherited from \c M.
+/// of the values of the two given maps.
-///
+/// Its \c Key and \c Value types are inherited from \c M1.
-///Actually,
+/// The \c Key and \c Value of \c M2 must be convertible to those of
-///\code
+/// \c M1.
-///  ScaleMap<X> sc(x,v);
+///
-///\endcode
+/// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for
-///is equivalent to
+/// \code
-///\code
+///   DivMap<M1,M2> dm(m1,m2);
-///  ConstMap<X::Key, X::Value> c_tmp(v);
+/// \endcode
-///  MulMap<X, ConstMap<X::Key, X::Value> > sc(x,v);
+/// <tt>dm[x]</tt> will be equal to <tt>m1[x]/m2[x]</tt>.
-///\endcode
+///
-///
+/// The simplest way of using this map is through the divMap()
-///\sa ScaleWriteMap
+/// function.
-template<typename M, typename C = typename M::Value>
+///
-class ScaleMap : public MapBase<typename M::Key, typename M::Value> {
+/// \sa AddMap, SubMap, MulMap
-const M& m;
+template<typename M1, typename M2>
-C v;
-public:
-typedef MapBase<typename M::Key, typename M::Value> Parent;
-typedef typename Parent::Key Key;
-typedef typename Parent::Value Value;
-///Constructor
-///Constructor.
-///\param _m is the undelying map.
-///\param _v is the scaling value.
-ScaleMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
-/// \e
-Value operator[](Key k) const {return v * m[k];}
-};
-///Scales a map with a constant (ReadWrite version).
-///This \ref concepts::ReadWriteMap "read-write map" returns the value of the
-///given map multiplied from the left side with a constant value. It can
-///also be used as write map if the \c / operator is defined between
-///\c Value and \c C and the given multiplier is not zero.
-///Its \c Key and \c Value are inherited from \c M.
-///
-///\sa ScaleMap
-template<typename M, typename C = typename M::Value>
-class ScaleWriteMap : public MapBase<typename M::Key, typename M::Value> {
-M& m;
-C v;
-public:
-typedef MapBase<typename M::Key, typename M::Value> Parent;
-typedef typename Parent::Key Key;
-typedef typename Parent::Value Value;
-///Constructor
-///Constructor.
-///\param _m is the undelying map.
-///\param _v is the scaling value.
-ScaleWriteMap(M &_m, const C &_v ) : m(_m), v(_v) {};
-/// \e
-Value operator[](Key k) const {return v * m[k];}
-/// \e
-void set(Key k, const Value& c) { m.set(k, c / v);}
-};
-///Returns a \c ScaleMap class
-///This function just returns a \c ScaleMap class.
-///\relates ScaleMap
-template<typename M, typename C>
-inline ScaleMap<M, C> scaleMap(const M &m,const C &v) {
-return ScaleMap<M, C>(m,v);
-}
-///Returns a \c ScaleWriteMap class
-///This function just returns a \c ScaleWriteMap class.
-///\relates ScaleWriteMap
-template<typename M, typename C>
-inline ScaleWriteMap<M, C> scaleMap(M &m,const C &v) {
-return ScaleWriteMap<M, C>(m,v);
-}
-///Quotient of two maps
-///This \ref concepts::ReadMap "read only map" returns the quotient of the
-///values of the two given maps.
-///Its \c Key and \c Value are inherited from \c M1.
-///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
-template<typename M1, typename M2>
 class DivMap : public MapBase<typename M1::Key, typename M1::Value> {
-const M1& m1;
+const M1 &_m1;
-const M2& m2;
+const M2 &_m2;
 public:
 typedef MapBase<typename M1::Key, typename M1::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
-///Constructor
+/// Constructor
-DivMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
+DivMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
 /// \e
-Value operator[](Key k) const {return m1[k]/m2[k];}
+Value operator[](const Key &k) const { return _m1[k]/_m2[k]; }
 };
-///Returns a \c DivMap class
+/// Returns a \ref DivMap class
-///This function just returns a \c DivMap class.
+/// This function just returns a \ref DivMap class.
-///\relates DivMap
+///
-template<typename M1, typename M2>
+/// For example, if \c m1 and \c m2 are both maps with \c double
+/// values, then <tt>divMap(m1,m2)[x]</tt> will be equal to
+/// <tt>m1[x]/m2[x]</tt>.
+///
+/// \relates DivMap
+template<typename M1, typename M2>
 inline DivMap<M1, M2> divMap(const M1 &m1,const M2 &m2) {
 return DivMap<M1, M2>(m1,m2);
 }
-///Composition of two maps
+/// Shifts a map with a constant.
-///This \ref concepts::ReadMap "read only map" returns the composition of
-///two given maps.
+/// This \ref concepts::ReadMap "read only map" returns the sum of
-///That is to say, if \c m1 is of type \c M1 and \c m2 is of \c M2,
+/// the given map and a constant value (i.e. it shifts the map with
-///then for
+/// the constant). Its \c Key and \c Value are inherited from \c M.
-///\code
+///
-///  ComposeMap<M1, M2> cm(m1,m2);
+/// Actually,
-///\endcode
+/// \code
-/// <tt>cm[x]</tt> will be equal to <tt>m1[m2[x]]</tt>.
+///   ShiftMap<M> sh(m,v);
-///
+/// \endcode
-///Its \c Key is inherited from \c M2 and its \c Value is from \c M1.
+/// is equivalent to
-///\c M2::Value must be convertible to \c M1::Key.
+/// \code
-///
+///   ConstMap<M::Key, M::Value> cm(v);
-///\sa CombineMap
+///   AddMap<M, ConstMap<M::Key, M::Value> > sh(m,cm);
-///
+/// \endcode
-///\todo Check the requirements.
+///
-template <typename M1, typename M2>
+/// The simplest way of using this map is through the shiftMap()
-class ComposeMap : public MapBase<typename M2::Key, typename M1::Value> {
+/// function.
-const M1& m1;
+///
-const M2& m2;
+/// \sa ShiftWriteMap
-public:
+template<typename M, typename C = typename M::Value>
-typedef MapBase<typename M2::Key, typename M1::Value> Parent;
+class ShiftMap : public MapBase<typename M::Key, typename M::Value> {
-typedef typename Parent::Key Key;
+const M &_m;
-typedef typename Parent::Value Value;
+C _v;
+public:
-///Constructor
+typedef MapBase<typename M::Key, typename M::Value> Parent;
-ComposeMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
+typedef typename Parent::Key Key;
+typedef typename Parent::Value Value;
-/// \e
+/// Constructor
-/// \todo Use the  MapTraits once it is ported.
+/// Constructor.
-///
+/// \param m The undelying map.
+/// \param v The constant value.
-//typename MapTraits<M1>::ConstReturnValue
+ShiftMap(const M &m, const C &v) : _m(m), _v(v) {}
-typename M1::Value
+/// \e
-operator[](Key k) const {return m1[m2[k]];}
+Value operator[](const Key &k) const { return _m[k]+_v; }
 };
-///Returns a \c ComposeMap class
+/// Shifts a map with a constant (read-write version).
-///This function just returns a \c ComposeMap class.
+/// This \ref concepts::ReadWriteMap "read-write map" returns the sum
-///\relates ComposeMap
+/// of the given map and a constant value (i.e. it shifts the map with
-template <typename M1, typename M2>
+/// the constant). Its \c Key and \c Value are inherited from \c M.
-inline ComposeMap<M1, M2> composeMap(const M1 &m1,const M2 &m2) {
+/// It makes also possible to write the map.
-return ComposeMap<M1, M2>(m1,m2);
+///
-}
+/// The simplest way of using this map is through the shiftWriteMap()
+/// function.
-///Combine of two maps using an STL (binary) functor.
+///
+/// \sa ShiftMap
-///Combine of two maps using an STL (binary) functor.
+template<typename M, typename C = typename M::Value>
-///
+class ShiftWriteMap : public MapBase<typename M::Key, typename M::Value> {
-///This \ref concepts::ReadMap "read only map" takes two maps and a
+M &_m;
-///binary functor and returns the composition of the two
+C _v;
-///given maps unsing the functor.
+public:
-///That is to say, if \c m1 and \c m2 is of type \c M1 and \c M2
+typedef MapBase<typename M::Key, typename M::Value> Parent;
-///and \c f is of \c F, then for
+typedef typename Parent::Key Key;
-///\code
+typedef typename Parent::Value Value;
-///  CombineMap<M1,M2,F,V> cm(m1,m2,f);
-///\endcode
+/// Constructor
-/// <tt>cm[x]</tt> will be equal to <tt>f(m1[x],m2[x])</tt>
-///
+/// Constructor.
-///Its \c Key is inherited from \c M1 and its \c Value is \c V.
+/// \param m The undelying map.
-///\c M2::Value and \c M1::Value must be convertible to the corresponding
+/// \param v The constant value.
-///input parameter of \c F and the return type of \c F must be convertible
+ShiftWriteMap(M &m, const C &v) : _m(m), _v(v) {}
-///to \c V.
+/// \e
-///
+Value operator[](const Key &k) const { return _m[k]+_v; }
-///\sa ComposeMap
+/// \e
-///
+void set(const Key &k, const Value &v) { _m.set(k, v-_v); }
-///\todo Check the requirements.
+};
-template<typename M1, typename M2, typename F,
-	   typename V = typename F::result_type>
+/// Returns a \ref ShiftMap class
-class CombineMap : public MapBase<typename M1::Key, V> {
-const M1& m1;
+/// This function just returns a \ref ShiftMap class.
-const M2& m2;
+///
-F f;
+/// For example, if \c m is a map with \c double values and \c v is
-public:
+/// \c double, then <tt>shiftMap(m,v)[x]</tt> will be equal to
-typedef MapBase<typename M1::Key, V> Parent;
+/// <tt>m[x]+v</tt>.
-typedef typename Parent::Key Key;
+///
-typedef typename Parent::Value Value;
+/// \relates ShiftMap
+template<typename M, typename C>
-///Constructor
+inline ShiftMap<M, C> shiftMap(const M &m, const C &v) {
-CombineMap(const M1 &_m1,const M2 &_m2,const F &_f = F())
+return ShiftMap<M, C>(m,v);
-: m1(_m1), m2(_m2), f(_f) {};
+}
-/// \e
-Value operator[](Key k) const {return f(m1[k],m2[k]);}
+/// Returns a \ref ShiftWriteMap class
-};
+/// This function just returns a \ref ShiftWriteMap class.
-///Returns a \c CombineMap class
+///
+/// For example, if \c m is a map with \c double values and \c v is
-///This function just returns a \c CombineMap class.
+/// \c double, then <tt>shiftWriteMap(m,v)[x]</tt> will be equal to
-///
+/// <tt>m[x]+v</tt>.
-///For example if \c m1 and \c m2 are both \c double valued maps, then
+/// Moreover it makes also possible to write the map.
-///\code
+///
-///combineMap(m1,m2,std::plus<double>())
+/// \relates ShiftWriteMap
-///\endcode
+template<typename M, typename C>
-///is equivalent to
+inline ShiftWriteMap<M, C> shiftWriteMap(M &m, const C &v) {
-///\code
+return ShiftWriteMap<M, C>(m,v);
-///addMap(m1,m2)
+}
-///\endcode
-///
-///This function is specialized for adaptable binary function
+/// Scales a map with a constant.
-///classes and C++ functions.
-///
+/// This \ref concepts::ReadMap "read only map" returns the value of
-///\relates CombineMap
+/// the given map multiplied from the left side with a constant value.
-template<typename M1, typename M2, typename F, typename V>
+/// Its \c Key and \c Value are inherited from \c M.
-inline CombineMap<M1, M2, F, V>
+///
-combineMap(const M1& m1,const M2& m2, const F& f) {
+/// Actually,
-return CombineMap<M1, M2, F, V>(m1,m2,f);
+/// \code
-}
+///   ScaleMap<M> sc(m,v);
+/// \endcode
-template<typename M1, typename M2, typename F>
+/// is equivalent to
-inline CombineMap<M1, M2, F, typename F::result_type>
+/// \code
-combineMap(const M1& m1, const M2& m2, const F& f) {
+///   ConstMap<M::Key, M::Value> cm(v);
-return combineMap<M1, M2, F, typename F::result_type>(m1,m2,f);
+///   MulMap<ConstMap<M::Key, M::Value>, M> sc(cm,m);
-}
+/// \endcode
+///
-template<typename M1, typename M2, typename K1, typename K2, typename V>
+/// The simplest way of using this map is through the scaleMap()
-inline CombineMap<M1, M2, V (*)(K1, K2), V>
+/// function.
-combineMap(const M1 &m1, const M2 &m2, V (*f)(K1, K2)) {
+///
-return combineMap<M1, M2, V (*)(K1, K2), V>(m1,m2,f);
+/// \sa ScaleWriteMap
-}
+template<typename M, typename C = typename M::Value>
+class ScaleMap : public MapBase<typename M::Key, typename M::Value> {
-///Negative value of a map
+const M &_m;
+C _v;
-///This \ref concepts::ReadMap "read only map" returns the negative
+public:
-///value of the value returned by the given map.
+typedef MapBase<typename M::Key, typename M::Value> Parent;
-///Its \c Key and \c Value are inherited from \c M.
+typedef typename Parent::Key Key;
-///The unary \c - operator must be defined for \c Value, of course.
+typedef typename Parent::Value Value;
-///
-///\sa NegWriteMap
+/// Constructor
-template<typename M>
+/// Constructor.
+/// \param m The undelying map.
+/// \param v The constant value.
+ScaleMap(const M &m, const C &v) : _m(m), _v(v) {}
+/// \e
+Value operator[](const Key &k) const { return _v*_m[k]; }
+};
+/// Scales a map with a constant (read-write version).
+/// This \ref concepts::ReadWriteMap "read-write map" returns the value of
+/// the given map multiplied from the left side with a constant value.
+/// Its \c Key and \c Value are inherited from \c M.
+/// It can also be used as write map if the \c / operator is defined
+/// between \c Value and \c C and the given multiplier is not zero.
+///
+/// The simplest way of using this map is through the scaleWriteMap()
+/// function.
+///
+/// \sa ScaleMap
+template<typename M, typename C = typename M::Value>
+class ScaleWriteMap : public MapBase<typename M::Key, typename M::Value> {
+M &_m;
+C _v;
+public:
+typedef MapBase<typename M::Key, typename M::Value> Parent;
+typedef typename Parent::Key Key;
+typedef typename Parent::Value Value;
+/// Constructor
+/// Constructor.
+/// \param m The undelying map.
+/// \param v The constant value.
+ScaleWriteMap(M &m, const C &v) : _m(m), _v(v) {}
+/// \e
+Value operator[](const Key &k) const { return _v*_m[k]; }
+/// \e
+void set(const Key &k, const Value &v) { _m.set(k, v/_v); }
+};
+/// Returns a \ref ScaleMap class
+/// This function just returns a \ref ScaleMap class.
+///
+/// For example, if \c m is a map with \c double values and \c v is
+/// \c double, then <tt>scaleMap(m,v)[x]</tt> will be equal to
+/// <tt>v*m[x]</tt>.
+///
+/// \relates ScaleMap
+template<typename M, typename C>
+inline ScaleMap<M, C> scaleMap(const M &m, const C &v) {
+return ScaleMap<M, C>(m,v);
+}
+/// Returns a \ref ScaleWriteMap class
+/// This function just returns a \ref ScaleWriteMap class.
+///
+/// For example, if \c m is a map with \c double values and \c v is
+/// \c double, then <tt>scaleWriteMap(m,v)[x]</tt> will be equal to
+/// <tt>v*m[x]</tt>.
+/// Moreover it makes also possible to write the map.
+///
+/// \relates ScaleWriteMap
+template<typename M, typename C>
+inline ScaleWriteMap<M, C> scaleWriteMap(M &m, const C &v) {
+return ScaleWriteMap<M, C>(m,v);
+}
+/// Negative of a map
+/// This \ref concepts::ReadMap "read only map" returns the negative
+/// of the values of the given map (using the unary \c - operator).
+/// Its \c Key and \c Value are inherited from \c M.
+///
+/// If M::Value is \c int, \c double etc., then
+/// \code
+///   NegMap<M> neg(m);
+/// \endcode
+/// is equivalent to
+/// \code
+///   ScaleMap<M> neg(m,-1);
+/// \endcode
+///
+/// The simplest way of using this map is through the negMap()
+/// function.
+///
+/// \sa NegWriteMap
+template<typename M>
 class NegMap : public MapBase<typename M::Key, typename M::Value> {
-const M& m;
+const M& _m;
 public:
 typedef MapBase<typename M::Key, typename M::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
-///Constructor
+/// Constructor
-NegMap(const M &_m) : m(_m) {};
+NegMap(const M &m) : _m(m) {}
 /// \e
-Value operator[](Key k) const {return -m[k];}
+Value operator[](const Key &k) const { return -_m[k]; }
 };
-///Negative value of a map (ReadWrite version)
+/// Negative of a map (read-write version)
-///This \ref concepts::ReadWriteMap "read-write map" returns the negative
+/// This \ref concepts::ReadWriteMap "read-write map" returns the
-///value of the value returned by the given map.
+/// negative of the values of the given map (using the unary \c -
-///Its \c Key and \c Value are inherited from \c M.
+/// operator).
-///The unary \c - operator must be defined for \c Value, of course.
+/// Its \c Key and \c Value are inherited from \c M.
+/// It makes also possible to write the map.
+///
+/// If M::Value is \c int, \c double etc., then
+/// \code
+///   NegWriteMap<M> neg(m);
+/// \endcode
+/// is equivalent to
+/// \code
+///   ScaleWriteMap<M> neg(m,-1);
+/// \endcode
+///
+/// The simplest way of using this map is through the negWriteMap()
+/// function.
 ///
 /// \sa NegMap
 template<typename M>
 class NegWriteMap : public MapBase<typename M::Key, typename M::Value> {
-M& m;
+M &_m;
 public:
 typedef MapBase<typename M::Key, typename M::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
-///Constructor
+/// Constructor
-NegWriteMap(M &_m) : m(_m) {};
+NegWriteMap(M &m) : _m(m) {}
 /// \e
-Value operator[](Key k) const {return -m[k];}
+Value operator[](const Key &k) const { return -_m[k]; }
 /// \e
-void set(Key k, const Value& v) { m.set(k, -v); }
+void set(const Key &k, const Value &v) { _m.set(k, -v); }
 };
-///Returns a \c NegMap class
+/// Returns a \ref NegMap class
-///This function just returns a \c NegMap class.
+/// This function just returns a \ref NegMap class.
-///\relates NegMap
+///
-template <typename M>
+/// For example, if \c m is a map with \c double values, then
+/// <tt>negMap(m)[x]</tt> will be equal to <tt>-m[x]</tt>.
+///
+/// \relates NegMap
+template <typename M>
 inline NegMap<M> negMap(const M &m) {
 return NegMap<M>(m);
 }
-///Returns a \c NegWriteMap class
+/// Returns a \ref NegWriteMap class
-///This function just returns a \c NegWriteMap class.
+/// This function just returns a \ref NegWriteMap class.
-///\relates NegWriteMap
+///
-template <typename M>
+/// For example, if \c m is a map with \c double values, then
-inline NegWriteMap<M> negMap(M &m) {
+/// <tt>negWriteMap(m)[x]</tt> will be equal to <tt>-m[x]</tt>.
+/// Moreover it makes also possible to write the map.
+///
+/// \relates NegWriteMap
+template <typename M>
+inline NegWriteMap<M> negWriteMap(M &m) {
 return NegWriteMap<M>(m);
 }
-///Absolute value of a map
+/// Absolute value of a map
-///This \ref concepts::ReadMap "read only map" returns the absolute value
-///of the value returned by the given map.
+/// This \ref concepts::ReadMap "read only map" returns the absolute
-///Its \c Key and \c Value are inherited from \c M.
+/// value of the values of the given map.
-///\c Value must be comparable to \c 0 and the unary \c -
+/// Its \c Key and \c Value are inherited from \c M.
-///operator must be defined for it, of course.
+/// \c Value must be comparable to \c 0 and the unary \c -
-template<typename M>
+/// operator must be defined for it, of course.
+///
+/// The simplest way of using this map is through the absMap()
+/// function.
+template<typename M>
 class AbsMap : public MapBase<typename M::Key, typename M::Value> {
-const M& m;
+const M &_m;
 public:
 typedef MapBase<typename M::Key, typename M::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
-///Constructor
+/// Constructor
-AbsMap(const M &_m) : m(_m) {};
+AbsMap(const M &m) : _m(m) {}
 /// \e
-Value operator[](Key k) const {
+Value operator[](const Key &k) const {
-Value tmp = m[k];
+Value tmp = _m[k];
 return tmp >= 0 ? tmp : -tmp;
 }
 };
-///Returns an \c AbsMap class
+/// Returns an \ref AbsMap class
-///This function just returns an \c AbsMap class.
+/// This function just returns an \ref AbsMap class.
-///\relates AbsMap
+///
-template<typename M>
+/// For example, if \c m is a map with \c double values, then
+/// <tt>absMap(m)[x]</tt> will be equal to <tt>m[x]</tt> if
+/// it is positive or zero and <tt>-m[x]</tt> if <tt>m[x]</tt> is
+/// negative.
+///
+/// \relates AbsMap
+template<typename M>
 inline AbsMap<M> absMap(const M &m) {
 return AbsMap<M>(m);
 }
-///Converts an STL style functor to a map
+/// Logical 'not' of a map
-///This \ref concepts::ReadMap "read only map" returns the value
-///of a given functor.
+/// This \ref concepts::ReadMap "read only map" returns the logical
-///
+/// negation of the values of the given map.
-///Template parameters \c K and \c V will become its
+/// Its \c Key is inherited from \c M and its \c Value is \c bool.
-///\c Key and \c Value.
+///
-///In most cases they have to be given explicitly because a
+/// The simplest way of using this map is through the notMap()
-///functor typically does not provide \c argument_type and
+/// function.
-///\c result_type typedefs.
+///
-///
+/// \sa NotWriteMap
-///Parameter \c F is the type of the used functor.
+template <typename M>
-///
-///\sa MapFunctor
-template<typename F,
-	   typename K = typename F::argument_type,
-	   typename V = typename F::result_type>
-class FunctorMap : public MapBase<K, V> {
-F f;
-public:
-typedef MapBase<K, V> Parent;
-typedef typename Parent::Key Key;
-typedef typename Parent::Value Value;
-///Constructor
-FunctorMap(const F &_f = F()) : f(_f) {}
-/// \e
-Value operator[](Key k) const { return f(k);}
-};
-///Returns a \c FunctorMap class
-///This function just returns a \c FunctorMap class.
-///
-///This function is specialized for adaptable binary function
-///classes and C++ functions.
-///
-///\relates FunctorMap
-template<typename K, typename V, typename F> inline
-FunctorMap<F, K, V> functorMap(const F &f) {
-return FunctorMap<F, K, V>(f);
-}
-template <typename F> inline
-FunctorMap<F, typename F::argument_type, typename F::result_type>
-functorMap(const F &f) {
-return FunctorMap<F, typename F::argument_type,
-typename F::result_type>(f);
-}
-template <typename K, typename V> inline
-FunctorMap<V (*)(K), K, V> functorMap(V (*f)(K)) {
-return FunctorMap<V (*)(K), K, V>(f);
-}
-///Converts a map to an STL style (unary) functor
-///This class Converts a map to an STL style (unary) functor.
-///That is it provides an <tt>operator()</tt> to read its values.
-///
-///For the sake of convenience it also works as
-///a ususal \ref concepts::ReadMap "readable map",
-///i.e. <tt>operator[]</tt> and the \c Key and \c Value typedefs also exist.
-///
-///\sa FunctorMap
-template <typename M>
-class MapFunctor : public MapBase<typename M::Key, typename M::Value> {
-const M& m;
-public:
-typedef MapBase<typename M::Key, typename M::Value> Parent;
-typedef typename Parent::Key Key;
-typedef typename Parent::Value Value;
-typedef typename M::Key argument_type;
-typedef typename M::Value result_type;
-///Constructor
-MapFunctor(const M &_m) : m(_m) {};
-///\e
-Value operator()(Key k) const {return m[k];}
-///\e
-Value operator[](Key k) const {return m[k];}
-};
-///Returns a \c MapFunctor class
-///This function just returns a \c MapFunctor class.
-///\relates MapFunctor
-template<typename M>
-inline MapFunctor<M> mapFunctor(const M &m) {
-return MapFunctor<M>(m);
-}
-///Just readable version of \ref ForkWriteMap
-///This map has two \ref concepts::ReadMap "readable map"
-///parameters and each read request will be passed just to the
-///first map. This class is the just readable map type of \c ForkWriteMap.
-///
-///The \c Key and \c Value are inherited from \c M1.
-///The \c Key and \c Value of \c M2 must be convertible from those of \c M1.
-///
-///\sa ForkWriteMap
-///
-/// \todo Why is it needed?
-template<typename  M1, typename M2>
-class ForkMap : public MapBase<typename M1::Key, typename M1::Value> {
-const M1& m1;
-const M2& m2;
-public:
-typedef MapBase<typename M1::Key, typename M1::Value> Parent;
-typedef typename Parent::Key Key;
-typedef typename Parent::Value Value;
-///Constructor
-ForkMap(const M1 &_m1, const M2 &_m2) : m1(_m1), m2(_m2) {};
-/// \e
-Value operator[](Key k) const {return m1[k];}
-};
-///Applies all map setting operations to two maps
-///This map has two \ref concepts::WriteMap "writable map"
-///parameters and each write request will be passed to both of them.
-///If \c M1 is also \ref concepts::ReadMap "readable",
-///then the read operations will return the
-///corresponding values of \c M1.
-///
-///The \c Key and \c Value are inherited from \c M1.
-///The \c Key and \c Value of \c M2 must be convertible from those of \c M1.
-///
-///\sa ForkMap
-template<typename  M1, typename M2>
-class ForkWriteMap : public MapBase<typename M1::Key, typename M1::Value> {
-M1& m1;
-M2& m2;
-public:
-typedef MapBase<typename M1::Key, typename M1::Value> Parent;
-typedef typename Parent::Key Key;
-typedef typename Parent::Value Value;
-///Constructor
-ForkWriteMap(M1 &_m1, M2 &_m2) : m1(_m1), m2(_m2) {};
-///\e
-Value operator[](Key k) const {return m1[k];}
-///\e
-void set(Key k, const Value &v) {m1.set(k,v); m2.set(k,v);}
-};
-///Returns a \c ForkMap class
-///This function just returns a \c ForkMap class.
-///\relates ForkMap
-template <typename M1, typename M2>
-inline ForkMap<M1, M2> forkMap(const M1 &m1, const M2 &m2) {
-return ForkMap<M1, M2>(m1,m2);
-}
-///Returns a \c ForkWriteMap class
-///This function just returns a \c ForkWriteMap class.
-///\relates ForkWriteMap
-template <typename M1, typename M2>
-inline ForkWriteMap<M1, M2> forkMap(M1 &m1, M2 &m2) {
-return ForkWriteMap<M1, M2>(m1,m2);
-}
-/* ************* BOOL MAPS ******************* */
-///Logical 'not' of a map
-///This bool \ref concepts::ReadMap "read only map" returns the
-///logical negation of the value returned by the given map.
-///Its \c Key is inherited from \c M, its \c Value is \c bool.
-///
-///\sa NotWriteMap
-template <typename M>
 class NotMap : public MapBase<typename M::Key, bool> {
-const M& m;
+const M &_m;
 public:
 typedef MapBase<typename M::Key, bool> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 /// Constructor
-NotMap(const M &_m) : m(_m) {};
+NotMap(const M &m) : _m(m) {}
-///\e
+/// \e
-Value operator[](Key k) const {return !m[k];}
+Value operator[](const Key &k) const { return !_m[k]; }
 };
-///Logical 'not' of a map (ReadWrie version)
+/// Logical 'not' of a map (read-write version)
-///This bool \ref concepts::ReadWriteMap "read-write map" returns the
+/// This \ref concepts::ReadWriteMap "read-write map" returns the
-///logical negation of the value returned by the given map. When it is set,
+/// logical negation of the values of the given map.
-///the opposite value is set to the original map.
+/// Its \c Key is inherited from \c M and its \c Value is \c bool.
-///Its \c Key is inherited from \c M, its \c Value is \c bool.
+/// It makes also possible to write the map. When a value is set,
-///
+/// the opposite value is set to the original map.
-///\sa NotMap
+///
-template <typename M>
+/// The simplest way of using this map is through the notWriteMap()
+/// function.
+///
+/// \sa NotMap
+template <typename M>
 class NotWriteMap : public MapBase<typename M::Key, bool> {
-M& m;
+M &_m;
 public:
 typedef MapBase<typename M::Key, bool> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 /// Constructor
-NotWriteMap(M &_m) : m(_m) {};
+NotWriteMap(M &m) : _m(m) {}
-///\e
+/// \e
-Value operator[](Key k) const {return !m[k];}
+Value operator[](const Key &k) const { return !_m[k]; }
-///\e
+/// \e
-void set(Key k, bool v) { m.set(k, !v); }
+void set(const Key &k, bool v) { _m.set(k, !v); }
 };
-///Returns a \c NotMap class
+/// Returns a \ref NotMap class
-///This function just returns a \c NotMap class.
+/// This function just returns a \ref NotMap class.
-///\relates NotMap
+///
-template <typename M>
+/// For example, if \c m is a map with \c bool values, then
+/// <tt>notMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
+///
+/// \relates NotMap
+template <typename M>
 inline NotMap<M> notMap(const M &m) {
 return NotMap<M>(m);
 }
-///Returns a \c NotWriteMap class
+/// Returns a \ref NotWriteMap class
-///This function just returns a \c NotWriteMap class.
+/// This function just returns a \ref NotWriteMap class.
-///\relates NotWriteMap
+///
-template <typename M>
+/// For example, if \c m is a map with \c bool values, then
-inline NotWriteMap<M> notMap(M &m) {
+/// <tt>notWriteMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
+/// Moreover it makes also possible to write the map.
+///
+/// \relates NotWriteMap
+template <typename M>
+inline NotWriteMap<M> notWriteMap(M &m) {
 return NotWriteMap<M>(m);
 }
 namespace _maps_bits {
 template <typename Value>
 struct Identity {
 typedef typename std::iterator_traits<_Iterator>::value_type Value;
 };
 template <typename _Iterator>
 struct IteratorTraits<_Iterator,
 typename exists<typename _Iterator::container_type>::type>
 {
 typedef typename _Iterator::container_type::value_type Value;
 };
 }
 /// \brief Writable bool map for logging each \c true assigned element
 ///
 /// A \ref concepts::ReadWriteMap "read-write" bool map for logging
 /// each \c true assigned element, i.e it copies all the keys set
 /// to \c true to the given iterator.
 ///
 /// \note The container of the iterator should contain space
 /// for each element.
 ///
 /// The following example shows how you can write the edges found by
 /// the \ref Prim algorithm directly to the standard output.
-///\code
+/// \code
-/// typedef IdMap<Graph, Edge> EdgeIdMap;
+///   typedef IdMap<Graph, Edge> EdgeIdMap;
-/// EdgeIdMap edgeId(graph);
+///   EdgeIdMap edgeId(graph);
 ///
-/// typedef MapFunctor<EdgeIdMap> EdgeIdFunctor;
+///   typedef MapToFunctor<EdgeIdMap> EdgeIdFunctor;
-/// EdgeIdFunctor edgeIdFunctor(edgeId);
+///   EdgeIdFunctor edgeIdFunctor(edgeId);
 ///
-/// StoreBoolMap<ostream_iterator<int>, EdgeIdFunctor>
+///   StoreBoolMap<ostream_iterator<int>, EdgeIdFunctor>
-///   writerMap(ostream_iterator<int>(cout, " "), edgeIdFunctor);
+///     writerMap(ostream_iterator<int>(cout, " "), edgeIdFunctor);
 ///
-/// prim(graph, cost, writerMap);
+///   prim(graph, cost, writerMap);
-///\endcode
+/// \endcode
 ///
-///\sa BackInserterBoolMap
+/// \sa BackInserterBoolMap
-///\sa FrontInserterBoolMap
+/// \sa FrontInserterBoolMap
-///\sa InserterBoolMap
+/// \sa InserterBoolMap
 ///
-///\todo Revise the name of this class and the related ones.
+/// \todo Revise the name of this class and the related ones.
 template <typename _Iterator,
 typename _Functor =
 _maps_bits::Identity<typename _maps_bits::
 IteratorTraits<_Iterator>::Value> >
 class StoreBoolMap {
 public:
 typedef bool Value;
 typedef _Functor Functor;
 /// Constructor
 StoreBoolMap(Iterator it, const Functor& functor = Functor())
 : _begin(it), _end(it), _functor(functor) {}
 /// Gives back the given iterator set for the first key
 Iterator begin() const {
 return _begin;
 }
 /// Gives back the the 'after the last' iterator
 Iterator end() const {
 return _end;
 }
-/// The \c set function of the map
+/// The set function of the map
 void set(const Key& key, Value value) const {
 if (value) {
 	*_end++ = _functor(key);
 }
 }
 private:
 Iterator _begin;
 mutable Iterator _end;
 Functor _functor;
 };
 /// \brief Writable bool map for logging each \c true assigned element in
 /// a back insertable container.
 ///
 /// Writable bool map for logging each \c true assigned element by pushing
 /// them into a back insertable container.
 /// It can be used to retrieve the items into a standard
 /// container. The next example shows how you can store the
 /// edges found by the Prim algorithm in a vector.
 ///
-///\code
+/// \code
-/// vector<Edge> span_tree_edges;
+///   vector<Edge> span_tree_edges;
-/// BackInserterBoolMap<vector<Edge> > inserter_map(span_tree_edges);
+///   BackInserterBoolMap<vector<Edge> > inserter_map(span_tree_edges);
-/// prim(graph, cost, inserter_map);
+///   prim(graph, cost, inserter_map);
-///\endcode
+/// \endcode
 ///
-///\sa StoreBoolMap
+/// \sa StoreBoolMap
-///\sa FrontInserterBoolMap
+/// \sa FrontInserterBoolMap
-///\sa InserterBoolMap
+/// \sa InserterBoolMap
 template <typename Container,
 typename Functor =
 _maps_bits::Identity<typename Container::value_type> >
 class BackInserterBoolMap {
 public:
 typedef typename Functor::argument_type Key;
 typedef bool Value;
 /// Constructor
 BackInserterBoolMap(Container& _container,
 const Functor& _functor = Functor())
 : container(_container), functor(_functor) {}
-/// The \c set function of the map
+/// The set function of the map
 void set(const Key& key, Value value) {
 if (value) {
 	container.push_back(functor(key));
 }
 }
 private:
 Container& container;
 Functor functor;
 };
 /// \brief Writable bool map for logging each \c true assigned element in
 /// a front insertable container.
 ///
 /// Writable bool map for logging each \c true assigned element by pushing
 /// them into a front insertable container.
 /// It can be used to retrieve the items into a standard
 /// container. For example see \ref BackInserterBoolMap.
 ///
-///\sa BackInserterBoolMap
+/// \sa BackInserterBoolMap
-///\sa InserterBoolMap
+/// \sa InserterBoolMap
 template <typename Container,
 typename Functor =
 _maps_bits::Identity<typename Container::value_type> >
 class FrontInserterBoolMap {
 public:
 typedef typename Functor::argument_type Key;
 typedef bool Value;
 /// Constructor
 FrontInserterBoolMap(Container& _container,
 const Functor& _functor = Functor())
 : container(_container), functor(_functor) {}
-/// The \c set function of the map
+/// The set function of the map
 void set(const Key& key, Value value) {
 if (value) {
 	container.push_front(functor(key));
 }
 }
 private:
 Container& container;
 Functor functor;
 };
 /// \brief Writable bool map for storing each \c true assigned element in
 /// an insertable container.
 ///
 /// Writable bool map for storing each \c true assigned element in an
 /// insertable container. It will insert all the keys set to \c true into
 /// the container.
 ///
 /// For example, if you want to store the cut arcs of the strongly
 /// connected components in a set you can use the next code:
 ///
-///\code
+/// \code
-/// set<Arc> cut_arcs;
+///   set<Arc> cut_arcs;
-/// InserterBoolMap<set<Arc> > inserter_map(cut_arcs);
+///   InserterBoolMap<set<Arc> > inserter_map(cut_arcs);
-/// stronglyConnectedCutArcs(digraph, cost, inserter_map);
+///   stronglyConnectedCutArcs(digraph, cost, inserter_map);
-///\endcode
+/// \endcode
 ///
-///\sa BackInserterBoolMap
+/// \sa BackInserterBoolMap
-///\sa FrontInserterBoolMap
+/// \sa FrontInserterBoolMap
 template <typename Container,
 typename Functor =
 _maps_bits::Identity<typename Container::value_type> >
 class InserterBoolMap {
 public:
 typedef typename Container::value_type Key;
 typedef bool Value;
 /// Constructor with specified iterator
 /// Constructor with specified iterator.
 /// \param _container The container for storing the elements.
 /// \param _it The elements will be inserted before this iterator.
 /// \param _functor The functor that is used when an element is stored.
 InserterBoolMap(Container& _container, typename Container::iterator _it,
 const Functor& _functor = Functor())
 : container(_container), it(_it), functor(_functor) {}
 /// Constructor
 /// Constructor without specified iterator.
 /// \param _container The container for storing the elements.
 /// \param _functor The functor that is used when an element is stored.
 InserterBoolMap(Container& _container, const Functor& _functor = Functor())
 : container(_container), it(_container.end()), functor(_functor) {}
-/// The \c set function of the map
+/// The set function of the map
 void set(const Key& key, Value value) {
 if (value) {
 	it = container.insert(it, functor(key));
 ++it;
 }
 }
 private:
 Container& container;
 typename Container::iterator it;
 Functor functor;
 };
 /// \brief Writable bool map for filling each \c true assigned element with a
 /// given value.
 ///
 /// Writable bool map for filling each \c true assigned element with a
 /// given value. The value can set the container.
 ///
 /// The following code finds the connected components of a graph
 /// and stores it in the \c comp map:
-///\code
+/// \code
-/// typedef Graph::NodeMap<int> ComponentMap;
+///   typedef Graph::NodeMap<int> ComponentMap;
-/// ComponentMap comp(graph);
+///   ComponentMap comp(graph);
-/// typedef FillBoolMap<Graph::NodeMap<int> > ComponentFillerMap;
+///   typedef FillBoolMap<Graph::NodeMap<int> > ComponentFillerMap;
-/// ComponentFillerMap filler(comp, 0);
+///   ComponentFillerMap filler(comp, 0);
 ///
-/// Dfs<Graph>::DefProcessedMap<ComponentFillerMap>::Create dfs(graph);
+///   Dfs<Graph>::DefProcessedMap<ComponentFillerMap>::Create dfs(graph);
-/// dfs.processedMap(filler);
+///   dfs.processedMap(filler);
-/// dfs.init();
+///   dfs.init();
-/// for (NodeIt it(graph); it != INVALID; ++it) {
+///   for (NodeIt it(graph); it != INVALID; ++it) {
-///   if (!dfs.reached(it)) {
+///     if (!dfs.reached(it)) {
-///     dfs.addSource(it);
+///       dfs.addSource(it);
-///     dfs.start();
+///       dfs.start();
-///     ++filler.fillValue();
+///       ++filler.fillValue();
+///     }
 ///   }
-/// }
+/// \endcode
-///\endcode
 template <typename Map>
 class FillBoolMap {
 public:
 typedef typename Map::Key Key;
 typedef bool Value;
 /// Constructor
 FillBoolMap(Map& _map, const typename Map::Value& _fill)
 : map(_map), fill(_fill) {}
 /// Constructor
 FillBoolMap(Map& _map)
 : map(_map), fill() {}
 /// Gives back the current fill value
 const typename Map::Value& fillValue() const {
 return fill;
 }
 /// Gives back the current fill value
 typename Map::Value& fillValue() {
 return fill;
 }
 /// Sets the current fill value
 void fillValue(const typename Map::Value& _fill) {
 fill = _fill;
 }
-/// The \c set function of the map
+/// The set function of the map
 void set(const Key& key, Value value) {
 if (value) {
 	map.set(key, fill);
 }
 }
 private:
 Map& map;
 typename Map::Value fill;
 };
 /// \brief Writable bool map for storing the sequence number of
 /// \c true assignments.
 ///
 /// Writable bool map that stores for each \c true assigned elements
 /// the sequence number of this setting.
 /// It makes it easy to calculate the leaving
-/// order of the nodes in the \c Dfs algorithm.
+/// order of the nodes in the \ref Dfs algorithm.
 ///
-///\code
+/// \code
-/// typedef Digraph::NodeMap<int> OrderMap;
+///   typedef Digraph::NodeMap<int> OrderMap;
-/// OrderMap order(digraph);
+///   OrderMap order(digraph);
-/// typedef SettingOrderBoolMap<OrderMap> OrderSetterMap;
+///   typedef SettingOrderBoolMap<OrderMap> OrderSetterMap;
-/// OrderSetterMap setter(order);
+///   OrderSetterMap setter(order);
-/// Dfs<Digraph>::DefProcessedMap<OrderSetterMap>::Create dfs(digraph);
+///   Dfs<Digraph>::DefProcessedMap<OrderSetterMap>::Create dfs(digraph);
-/// dfs.processedMap(setter);
+///   dfs.processedMap(setter);
-/// dfs.init();
+///   dfs.init();
-/// for (NodeIt it(digraph); it != INVALID; ++it) {
+///   for (NodeIt it(digraph); it != INVALID; ++it) {
-///   if (!dfs.reached(it)) {
+///     if (!dfs.reached(it)) {
-///     dfs.addSource(it);
+///       dfs.addSource(it);
-///     dfs.start();
+///       dfs.start();
+///     }
 ///   }
-/// }
+/// \endcode
-///\endcode
 ///
 /// The storing of the discovering order is more difficult because the
 /// ReachedMap should be readable in the dfs algorithm but the setting
 /// order map is not readable. Thus we must use the fork map:
 ///
-///\code
+/// \code
-/// typedef Digraph::NodeMap<int> OrderMap;
+///   typedef Digraph::NodeMap<int> OrderMap;
-/// OrderMap order(digraph);
+///   OrderMap order(digraph);
-/// typedef SettingOrderBoolMap<OrderMap> OrderSetterMap;
+///   typedef SettingOrderBoolMap<OrderMap> OrderSetterMap;
-/// OrderSetterMap setter(order);
+///   OrderSetterMap setter(order);
-/// typedef Digraph::NodeMap<bool> StoreMap;
+///   typedef Digraph::NodeMap<bool> StoreMap;
-/// StoreMap store(digraph);
+///   StoreMap store(digraph);
 ///
-/// typedef ForkWriteMap<StoreMap, OrderSetterMap> ReachedMap;
+///   typedef ForkMap<StoreMap, OrderSetterMap> ReachedMap;
-/// ReachedMap reached(store, setter);
+///   ReachedMap reached(store, setter);
 ///
-/// Dfs<Digraph>::DefReachedMap<ReachedMap>::Create dfs(digraph);
+///   Dfs<Digraph>::DefReachedMap<ReachedMap>::Create dfs(digraph);
-/// dfs.reachedMap(reached);
+///   dfs.reachedMap(reached);
-/// dfs.init();
+///   dfs.init();
-/// for (NodeIt it(digraph); it != INVALID; ++it) {
+///   for (NodeIt it(digraph); it != INVALID; ++it) {
-///   if (!dfs.reached(it)) {
+///     if (!dfs.reached(it)) {
-///     dfs.addSource(it);
+///       dfs.addSource(it);
-///     dfs.start();
+///       dfs.start();
+///     }
 ///   }
-/// }
+/// \endcode
-///\endcode
 template <typename Map>
 class SettingOrderBoolMap {
 public:
 typedef typename Map::Key Key;
 typedef bool Value;
 /// Constructor
 SettingOrderBoolMap(Map& _map)
 : map(_map), counter(0) {}
 /// Number of set operations.
 int num() const {
 return counter;
 }
-/// The \c set function of the map
+/// The set function of the map
 void set(const Key& key, Value value) {
 if (value) {
 	map.set(key, counter++);
 }
 }
 private:
 Map& map;
 int counter;
 };

changeset 80	15968e25ca08
parent 54	ff9bac2351bf
child 81	7ff1c348ae0c