RhodeCode

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

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

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

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

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

  class StdMap : public MapBase<K, T> {

    template <typename K1, typename T1, typename C1>

    friend class StdMap;

  public:

    typedef MapBase<K, T> Parent;

    ///Key type

    typedef typename Parent::Key Key;

    ///Value type

    typedef typename Parent::Value Value;

    ///Reference Type

    typedef T& Reference;

    ///Const reference type

    typedef const T& ConstReference;

    typedef True ReferenceMapTag;

  private:

    typedef std::map<K, T, Compare> Map;

    Value _value;

    Map _map;

  public:

    /// Constructor with specified default value

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

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

    /// explicitly specifies a default 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) {}

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

    template<typename T1, typename Comp1>

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

      : _map(c._map.begin(), c._map.end()), _value(c._value) {}

  private:

    StdMap& operator=(const StdMap&);

  public:

    ///\e

    Reference operator[](const Key &k) {

      typename Map::iterator it = _map.lower_bound(k);

      if (it != _map.end() && !_map.key_comp()(k, it->first))

	return it->second;

      else

	return _map.insert(it, std::make_pair(k, _value))->second;

    }

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

    void set(const Key &k, const T &t) {

      typename Map::iterator it = _map.lower_bound(k);

      if (it != _map.end() && !_map.key_comp()(k, it->first))

	it->second = t;

      else

	_map.insert(it, std::make_pair(k, t));

    }

    /// \e

    void setAll(const T &t) {

      _value = t;

      _map.clear();

    }    

  };

  ///Returns a \c StdMap class

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

  ///default value.

  ///\relates StdMap

  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

  }

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

  ///

  /// This map gives back the given key as value without any