RhodeCode

      /// Returns the value associated with a key.

    /// Read/writable map concept

    /// \todo Rethink this concept.

      ///Returns a reference to the value associated with a key.

      ///Returns a const reference to the value associated with a key.

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

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

  ///Returns a \c ConstMap class with inlined value

  ///Map based on \c std::map

  ///It meets the \ref concepts::ReferenceMap "ReferenceMap" concept.

  class StdMap : public MapBase<K, T> {

    typedef MapBase<K, T> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    typedef True ReferenceMapTag;

    /// \brief Constructs the map from an appropriate \c std::map, and 

    /// explicitly specifies a default value.

    /// \brief Constructs a map from an other \ref StdMap.

  ///Returns a \c StdMap class

  ///This function just returns a \c StdMap class with specified 

  ///default value.

  ///\relates StdMap

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

  inline StdMap<K, V, Compare> stdMap(const V& value = V()) {

    return StdMap<K, V, Compare>(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, typename Compare = std::less<K> > 

  inline StdMap<K, V, Compare> stdMap( const std::map<K, V, Compare> &map, 

                                       const V& value = V() ) {

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

  }

  /// This map has the <tt>[0..size-1]</tt> keyset and the values

  /// the used items are small integer numbers.

  /// This map meets the \ref concepts::ReferenceMap "ReferenceMap" concept.

  class IntegerMap : public MapBase<int, T> {

    typedef MapBase<int, T> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    typedef True ReferenceMapTag;

    /// \brief Constructs the map from an appropriate \c std::vector.

    /// \brief Constructs a map from an other \ref IntegerMap.

  ///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);

  }

  ///This \ref concepts::ReadMap "read only map"

    ///\e

  ///Returns a \c SimpleMap class

  ///This function just returns a \c SimpleMap class.

  ///\relates SimpleMap

  template<typename M>

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

    return SimpleMap<M>(m);

  }

  ///This \ref concepts::ReadWriteMap "read-write map" returns the simple

  ///Returns a \c SimpleWriteMap class

  ///This function just returns a \c SimpleWriteMap class.

  ///\relates SimpleWriteMap

  template<typename M>

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

    return SimpleWriteMap<M>(m);

  }

  ///This \ref concepts::ReadMap "read only map" returns the sum of the two

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

  ///\todo Extend the documentation: how to call these type of functions?

  ///This \ref concepts::ReadMap "read only map" returns the sum of the

  ///This \ref concepts::ReadWriteMap "read-write map" returns the sum of the

  ///This \ref concepts::ReadMap "read only map" returns the difference

  ///This \ref concepts::ReadMap "read only map" returns the product of the

  ///This \ref concepts::ReadMap "read only map" returns the value of the

  ///This \ref concepts::ReadWriteMap "read-write map" returns the value of the

  ///This \ref concepts::ReadMap "read only map" returns the quotient of the

  ///This \ref concepts::ReadMap "read only map" returns the composition of

  ///This \ref concepts::ReadMap "read only map" takes two maps and a

  ///This \ref concepts::ReadMap "read only map" returns the negative

  ///This \ref concepts::ReadWriteMap "read-write map" returns the negative

  ///This \ref concepts::ReadMap "read only map" returns the absolute value

  ///This \ref concepts::ReadMap "read only map" returns the value

  ///functor typically does not provide \c argument_type and 

  ///\c result_type typedefs.

  ///This function is specialized for adaptable binary function

  ///classes and C++ functions.

  ///

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

  ///a ususal \ref concepts::ReadMap "readable map",

  ///Just readable version of \ref ForkWriteMap

  ///This map has two \ref concepts::ReadMap "readable map"

  ///first map. This class is the just readable map type of \c ForkWriteMap.

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

  ///This map has two \ref concepts::WriteMap "writable map"

  ///If \c M1 is also \ref concepts::ReadMap "readable",

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

  ///This bool \ref concepts::ReadMap "read only map" returns the 

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

  ///This bool \ref concepts::ReadWriteMap "read-write map" returns the 

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

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

  /// The following example shows how you can write the edges found by 

  /// the \ref Prim algorithm directly to the standard output.