RhodeCode

    return NullMap<K, V>();

  }

  /// Constant map.

  template<typename K, typename T>

  class ConstMap : public MapBase<K, T> {

  private:

    T v;

  public:

  template<typename T, T v>

  struct Const { };

  /// Constant map with inlined constant value.

  template<typename K, typename V, V v>

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

  public:

    typedef MapBase<K, V> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///\e

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

    ///\e

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

  };

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

  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:

    Map _map;

  public:

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

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

  private:

                                       const V& value = V() ) {

    return StdMap<K, V, Compare>(map, value);

  }

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

  template <typename T>

  class IntegerMap : public MapBase<int, T> {

    template <typename T1>

  public:

    /// Constructor with specified default value

    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) 

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

    /// \brief Resize the container

    void resize(int size, const T& value = T()) {

    ///Constructor

    ///Constructor.

    ///\param _m is the underlying map.

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

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

  };

  ///Returns a \c ConvertMap class

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

  ///Sum of two maps

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

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

    const M1& m1;

    const M2& m2;

  public:

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

  };

  ///Returns an \c AddMap class

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

  ///

  ///\relates AddMap

  template<typename M1, typename M2> 

  inline AddMap<M1, M2> addMap(const M1 &m1,const M2 &m2) {

    return AddMap<M1, M2>(m1,m2);

  }

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

  ///of a given functor.

  ///

  ///Template parameters \c K and \c V will become its

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

  ///

  ///\sa MapFunctor

  template<typename F, 

	   typename K = typename F::argument_type, 

  };

  ///Returns a \c FunctorMap class

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

  ///

  ///\relates FunctorMap

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

  FunctorMap<F, K, V> functorMap(const F &f) {

    return FunctorMap<F, K, V>(f);

  }

  }

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

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

  ///

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

  ///a ususal \ref concepts::ReadMap "readable map",

  ///i.e. <tt>operator[]</tt> and the \c Key and \c Value typedefs also exist.

  ///

  ///\sa FunctorMap

  ///\relates MapFunctor

  template<typename M> 

  inline MapFunctor<M> mapFunctor(const M &m) {

    return MapFunctor<M>(m);

  }

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

  ///

  /// \todo Why is it needed?

  template<typename  M1, typename M2> 

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

  ///parameters and each write request will be passed to both of them.

  ///If \c M1 is also \ref concepts::ReadMap "readable",

  ///then the read operations will return the

  ///corresponding values of \c M1.

  ///

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

  ///

  ///\sa ForkMap

  template<typename  M1, typename M2> 

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

    M1& m1;

    M2& m2;

  /* ************* BOOL MAPS ******************* */

  ///Logical 'not' of a map

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

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

  ///

  ///\sa NotWriteMap

  template <typename M> 

  class NotMap : public MapBase<typename M::Key, bool> {

    const M& m;

  public:

  ///Logical 'not' of a map (ReadWrie version)

  ///This bool \ref concepts::ReadWriteMap "read-write map" returns the 

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

  template <typename M> 

  class NotWriteMap : public MapBase<typename M::Key, bool> {

    M& m;

  public:

  }

  /// \brief Writable bool map for logging each \c true assigned element

  ///

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

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

  ///

  /// \note The container of the iterator should contain space 

  /// for each element.

  ///

  ///\code

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

  /// EdgeIdMap edgeId(graph);

  ///

  /// typedef MapFunctor<EdgeIdMap> EdgeIdFunctor;

  /// EdgeIdFunctor edgeIdFunctor(edgeId);