RhodeCode

    return ConstMap<K, Const<V, v> >();

  }

  ///This is essentially a wrapper for \c std::map with addition that

  ///you can specify a default value different from \c Value().

  };

  ///default value.

  ///\relates StdMap

  template<typename K, typename V, typename Compare = std::less<K> > 

    return StdMap<K, V, Compare>(value);

  }

  ///appropriate std::map.

  ///\relates StdMap

  template<typename K, typename V, typename Compare = std::less<K> > 

  };

  ///\relates IntegerMap

  template<typename T>

  inline IntegerMap<T> integerMap(int size = 0, const T& value = T()) {

  ///\brief Convert the \c Value of a map to another type using

  ///the default conversion.

  ///

  ///converts the \c Value of a map to type \c T.

  ///Its \c Key is inherited from \c M.

  template <typename M, typename T> 

    Value operator[](Key k) const {return m[k];}

  };

  ///\relates SimpleMap

  template<typename M>

  inline SimpleMap<M> simpleMap(const M &m) {

  ///Simple writable wrapping of a map

  ///wrapping of the given map. Sometimes the reference maps cannot be

  ///combined with simple read-write maps. This map adaptor wraps the

  ///given map to simple read-write map.

    void set(Key k, const Value& c) { m.set(k, c); }

  };

  ///\relates SimpleWriteMap

  template<typename M>

  inline SimpleWriteMap<M> simpleWriteMap(M &m) {

  ///Sum of two maps

  ///given maps.

  ///Its \c Key and \c Value are inherited from \c M1.

  ///The \c Key and \c Value of M2 must be convertible to those of \c M1.

  ///Shift a map with a constant.

  ///given map and a constant value.

  ///Its \c Key and \c Value are inherited from \c M.

  ///

  ///Shift a map with a constant (ReadWrite version).

  ///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.

  ///

  ///Difference of two maps

  ///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.

  ///Product of two maps

  ///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.

  ///Scales a map with a constant.

  ///given map multiplied from the left side with a constant value.

  ///Its \c Key and \c Value are inherited from \c M.

  ///

  ///Scales a map with a constant (ReadWrite version).

  ///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.

  ///Quotient of two maps

  ///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.

  ///Composition of two maps

  ///two given maps.

  ///That is to say, if \c m1 is of type \c M1 and \c m2 is of \c M2,

  ///then for

  ///Combine of two maps using an STL (binary) functor.

  ///

  ///binary functor and returns the composition of the two

  ///given maps unsing the functor. 

  ///That is to say, if \c m1 and \c m2 is of type \c M1 and \c M2

  ///Negative value of a map

  ///value of the value returned by the given map.

  ///Its \c Key and \c Value are inherited from \c M.

  ///The unary \c - operator must be defined for \c Value, of course.

  ///Negative value of a map (ReadWrite version)

  ///value of the value returned by the given map.

  ///Its \c Key and \c Value are inherited from \c M.

  ///The unary \c - operator must be defined for \c Value, of course.

  ///Absolute value of a map

  ///of the value returned by the given map.

  ///Its \c Key and \c Value are inherited from \c M. 

  ///\c Value must be comparable to \c 0 and the unary \c -

  ///Converts an STL style functor to a map

  ///of a given functor.

  ///

  ///Template parameters \c K and \c V will become its

  ///that is it provides an <tt>operator()</tt> to read its values.

  ///

  ///For the sake of convenience it also works as

  ///i.e. <tt>operator[]</tt> and the \c Key and \c Value typedefs also exist.

  ///

  ///\sa FunctorMap

  ///Applies all map setting operations to two maps

  ///parameters and each read request will be passed just to the

  ///

  ///The \c Key and \c Value are inherited from \c M1.

  ///The \c Key and \c Value of M2 must be convertible from those of \c M1.

  ///Applies all map setting operations to two maps

  ///parameters and each write request will be passed to both of them.

  ///then the read operations will return the

  ///corresponding values of \c M1.

  ///

  ///Logical 'not' of a map

  ///logical negation of the value returned by the given map.

  ///Its \c Key is inherited from \c M, its Value is \c bool.

  ///

  ///Logical 'not' of a map (ReadWrie version)

  ///logical negation of the value returned by the given map. When it is set,

  ///the opposite value is set to the original map.

  ///Its \c Key is inherited from \c M, its Value is \c bool.

  /// \brief Writable bool map for logging each \c true assigned element

  ///

  ///

  /// \note The container of the iterator should contain space 

  /// for each element.