RhodeCode

  /// Constant map.

  template<typename K, typename T>

  class ConstMap : public MapBase<K, T> {

  /// Constant map with inlined constant value.

  template<typename K, typename V, V v>

  class ConstMap<K, Const<V, v> > : public MapBase<K, V> {

  };

  ///This function just returns a \c ConstMap class with inlined value.

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

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

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

  class StdMap : public MapBase<K, T> {

    /// Constructor with specified default value

    StdMap(const T& value = T()) : _value(value) {}

    template <typename T1, typename Comp1>

    StdMap(const std::map<Key, T1, Comp1> &map, const T& value = T()) 

      : _map(map.begin(), map.end()), _value(value) {}

    template<typename T1, typename Comp1>

    StdMap(const StdMap<Key, T1, Comp1> &c) 

  /// \brief Map for storing values for keys from the range <tt>[0..size-1]</tt>

  ///

  /// are stored in a \c std::vector<T>  container. It can be used with

  /// some data structures, for example \c UnionFind, \c BinHeap, when 

  ///

  /// \todo Revise its name

    IntegerMap(int size = 0, const T& value = T()) : _vector(size, value) {}

    template <typename T1>

    IntegerMap(const std::vector<T1>& vector) 

      : _vector(vector.begin(), vector.end()) {}

    template <typename T1>

    IntegerMap(const IntegerMap<T1> &c) 

    ConvertMap(const M &_m) : m(_m) {};

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

  };

  ///given maps.

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

  template<typename M1, typename M2> 

  class AddMap : public MapBase<typename M1::Key, typename M1::Value> {

  ///This function just returns an \c AddMap class.

  ///

  ///\relates AddMap

  ///\c Key and \c Value. 

  ///In most cases they have to be given explicitly because a 

  ///

  ///Parameter \c F is the type of the used functor.

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

  ///

  ///\relates FunctorMap

  template<typename K, typename V, typename F> inline 

  ///This class Converts a map to an STL style (unary) functor.

  ///

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

  }

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

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

  ///

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

  ///

  ///\sa ForkWriteMap

  ///

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

  ///

  ///\sa ForkMap

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

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

  ///

  ///\sa NotWriteMap

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

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

  ///

  ///\sa NotMap

  ///

  /// A \ref concepts::ReadWriteMap "read-write" bool map for logging 

  /// to \c true to the given iterator.

  ///

  /// for each element.

  ///

  ///\code

  /// typedef IdMap<Graph, Edge> EdgeIdMap;