RhodeCode

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ConstMap() { }

    ///\e

    V operator[](const K&) const { return v; }

    ///\e

    void set(const K&, const V&) { }

  };

  ///Returns a \c ConstMap class

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

  ///\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 std::map

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

    template <typename K1, typename T1, typename C1>

    friend class StdMap;

  public:

    ///\e

    ///\e

    ///\e

    typedef T& Reference;

    ///\e

    typedef const T& ConstReference;

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

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

    }    

  };

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

  ///

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

  ///

  /// \todo Revise its name

  template <typename T>

    template <typename T1>

    friend class IntegerMap;

  public:

    ///\e

    ///\e

    ///\e

    typedef T& Reference;

    ///\e

    typedef const T& ConstReference;

  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 std::vector.

    template <typename T1>

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

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

    /// \brief Constructs a map from an other 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;

    }

  };

  /// @}

  /// \addtogroup map_adaptors

  /// @{

  /// \brief Identity map.

  ///

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

  /// modification. 

  template <typename T>

  class IdentityMap : public MapBase<T, T> {

  public:

    typedef MapBase<T, T> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    /// \e

    const T& operator[](const T& t) const {

      return t;

    }

  };

  ///Returns an \c IdentityMap class

  ///Simple wrapping of a map

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

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

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

  ///map to simple read map.

  ///

  ///\sa SimpleWriteMap

  ///

  /// \todo Revise the misleading name 

  template<typename M> 

  class SimpleMap : public MapBase<typename M::Key, typename M::Value> {

    const M& m;

  public:

    typedef MapBase<typename M::Key, typename M::Value> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

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

    ///\e

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

  };

  ///Simple writable wrapping of a map

  ///This \ref concepts::WriteMap "write map" returns the simple

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

  ///

  ///\sa SimpleMap

  ///

  /// \todo Revise the misleading name

  template<typename M> 

  class SimpleWriteMap : public MapBase<typename M::Key, typename M::Value> {

    M& m;

  public:

    typedef MapBase<typename M::Key, typename M::Value> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

    SimpleWriteMap(M &_m) : m(_m) {};

    ///\e

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

    ///\e

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

  };

  ///Sum of two maps

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

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

  template<typename M1, typename M2> 

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

    const M1& m1;

    const M2& m2;

  public:

    typedef MapBase<typename M1::Key, typename M1::Value> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

    AddMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};

    ///\e

    Value operator[](Key k) const {return m1[k]+m2[k];}

  };

  ///Returns an \c AddMap class