RhodeCode

    typedef typename Parent::Value Value;

    /// Default constructor

    /// Default constructor.

    /// The value of the map will be uninitialized. 

    /// (More exactly it will be default constructed.)

    ConstMap() {}

    /// Constructor with specified initial value

    /// Constructor with specified initial value.

    /// \param _v is the initial value of the map.

    ConstMap(const T &_v) : v(_v) {}

    ///\e

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

    ///\e

    void setAll(const T &t) {

      v = t;

    }    

    template<typename T1>

    ConstMap(const ConstMap<K, T1> &, const T &_v) : v(_v) {}

  };

  ///Returns a \c ConstMap class

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

  ///\relates ConstMap

  template<typename K, typename V> 

  inline ConstMap<K, V> constMap(const V &v) {

    return ConstMap<K, V>(v);

  }

  template<typename T, T v>

  struct Const { };

  /// Constant map with inlined constant value.

  /// This is a readable map which assigns a specified value to each key.

  /// In other aspects it is equivalent to the \c NullMap.

  template<typename K, typename V, V v>

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

  public:

    typedef MapBase<K, V> Parent;

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

    }    

  };

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

  class IntegerMap {

    template <typename T1>

    friend class IntegerMap;

  public:

    typedef True ReferenceMapTag;

    ///\e

    typedef int Key;

    ///\e

    typedef T Value;

    ///\e

    ///Constructor

    ///Constructor.

    ///\param _m is the underlying map.

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

    /// \brief The subscript operator.

    ///

    /// The subscript operator.

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

  };

  ///Returns a \c ConvertMap class

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

  ///\relates ConvertMap

  template<typename T, typename M>

  inline ConvertMap<M, T> convertMap(const M &m) {

    return ConvertMap<M, T>(m);

  }

  ///Simple wrapping of a map

  ///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];}

  };

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

  };

  /// dfs.reachedMap(reached);

  /// dfs.init();

  /// for (NodeIt it(digraph); it != INVALID; ++it) {

  ///   if (!dfs.reached(it)) {

  ///     dfs.addSource(it);

  ///     dfs.start();

  ///   }

  /// }

  ///\endcode

  template <typename Map>

  class SettingOrderBoolMap {

  public:

    typedef typename Map::Key Key;

    typedef bool Value;

    /// Constructor

    SettingOrderBoolMap(Map& _map) 

      : map(_map), counter(0) {}

    /// Number of set operations.

    int num() const {

      return counter;

    }

    void set(const Key& key, Value value) {

      if (value) {

	map.set(key, counter++);

      }

    }

  private:

    Map& map;

    int counter;

  };

  /// @}

}

#endif // LEMON_MAPS_H