RhodeCode

      : _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>