RhodeCode

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

  }

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

    /// \e

    void setAll(const T &t) {

      _value = t;

      _map.clear();

    }    

  };

  ///default value.

  ///\relates StdMap

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

  inline StdMap<K, V, Compare> stdMap(const V& value = V()) {

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

  }

  ///appropriate std::map.

  ///\relates StdMap

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

  inline StdMap<K, V, Compare> stdMap( const std::map<K, V, Compare> &map, 

                                       const V& value = V() ) {

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

  }

    /// \e 

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

      _vector[k] = t;

    }

  };

  ///\relates IntegerMap

  template<typename T>

  inline IntegerMap<T> integerMap(int size = 0, const T& value = T()) {

    return IntegerMap<T>(size, value);

  }

  /// @}

  inline IdentityMap<T> identityMap() {

    return IdentityMap<T>();

  }

  ///\brief Convert the \c Value of a map to another type using

  ///the default conversion.

  ///

  ///converts the \c Value of a map to type \c T.

  ///Its \c Key is inherited from \c M.

  template <typename M, typename T> 

  class ConvertMap : public MapBase<typename M::Key, T> {

    const M& m;

  public:

    typedef MapBase<typename M::Key, T> 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];}

  };

  ///\relates SimpleMap

  template<typename M>

  inline SimpleMap<M> simpleMap(const M &m) {

    return SimpleMap<M>(m);

  }

  ///Simple writable wrapping of a map

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

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

  };

  ///\relates SimpleWriteMap

  template<typename M>

  inline SimpleWriteMap<M> simpleWriteMap(M &m) {

    return SimpleWriteMap<M>(m);

  }

  ///Sum of two maps

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

  ///\relates AddMap

  template<typename M1, typename M2> 

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

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

  }

  ///Shift a map with a constant.

  ///given map and a constant value.

  ///Its \c Key and \c Value are inherited from \c M.

  ///

  ///Actually,

  ///\code

  ///  ShiftMap<X> sh(x,v);

  ///\endcode

  ///is equivalent to

    ///\param _v is the shift value.

    ShiftMap(const M &_m, const C &_v ) : m(_m), v(_v) {};

    ///\e

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

  };

  ///Shift a map with a constant (ReadWrite version).

  ///given map and a constant value. It makes also possible to write the map.

  ///Its \c Key and \c Value are inherited from \c M.

  ///

  ///\sa ShiftMap

  template<typename M, typename C = typename M::Value> 

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

    M& m;

    C v;

  ///\relates ShiftWriteMap

  template<typename M, typename C> 

  inline ShiftWriteMap<M, C> shiftMap(M &m,const C &v) {

    return ShiftWriteMap<M, C>(m,v);

  }

  ///Difference of two maps

  ///of the values of the two given maps.

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

  ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.

  ///

  /// \todo Revise the misleading name

  template<typename M1, typename M2> 

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

    const M1& m1;

  ///\relates SubMap

  template<typename M1, typename M2> 

  inline SubMap<M1, M2> subMap(const M1 &m1, const M2 &m2) {

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

  }

  ///Product of two maps

  ///values of the two given maps.

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

  ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.

  template<typename M1, typename M2> 

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

    const M1& m1;

    const M2& m2;

  public:

  ///\relates MulMap

  template<typename M1, typename M2> 

  inline MulMap<M1, M2> mulMap(const M1 &m1,const M2 &m2) {

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

  }

  ///Scales a map with a constant.

  ///given map multiplied from the left side with a constant value.

  ///Its \c Key and \c Value are inherited from \c M.

  ///

  ///Actually,

  ///\code

  ///  ScaleMap<X> sc(x,v);

  ///\endcode

  ///is equivalent to

    ///\param _v is the scaling value.

    ScaleMap(const M &_m, const C &_v ) : m(_m), v(_v) {};

    /// \e

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

  };

  ///Scales a map with a constant (ReadWrite version).

  ///given map multiplied from the left side with a constant value. It can

  ///also be used as write map if the \c / operator is defined between

  ///\c Value and \c C and the given multiplier is not zero.

  ///Its \c Key and \c Value are inherited from \c M.

  ///

  ///\sa ScaleMap

  template<typename M, typename C = typename M::Value> 

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

  ///\relates ScaleWriteMap

  template<typename M, typename C> 

  inline ScaleWriteMap<M, C> scaleMap(M &m,const C &v) {

    return ScaleWriteMap<M, C>(m,v);

  }

  ///Quotient of two maps

  ///values of the two given maps.

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

  ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.

  template<typename M1, typename M2> 

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

    const M1& m1;

    const M2& m2;

  public:

  ///\relates DivMap

  template<typename M1, typename M2> 

  inline DivMap<M1, M2> divMap(const M1 &m1,const M2 &m2) {

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

  }

  ///Composition of two maps

  ///two given maps.

  ///That is to say, if \c m1 is of type \c M1 and \c m2 is of \c M2,

  ///then for

  ///\code

  ///  ComposeMap<M1, M2> cm(m1,m2);

  ///\endcode

  /// <tt>cm[x]</tt> will be equal to <tt>m1[m2[x]]</tt>.

  ///

  inline ComposeMap<M1, M2> composeMap(const M1 &m1,const M2 &m2) {

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

  }

  ///Combine of two maps using an STL (binary) functor.

  ///Combine of two maps using an STL (binary) functor.

  ///

  ///binary functor and returns the composition of the two

  ///given maps unsing the functor. 

  ///That is to say, if \c m1 and \c m2 is of type \c M1 and \c M2

  ///and \c f is of \c F, then for

  ///\code

  ///  CombineMap<M1,M2,F,V> cm(m1,m2,f);

  ///\endcode

  /// <tt>cm[x]</tt> will be equal to <tt>f(m1[x],m2[x])</tt>

  template<typename M1, typename M2, typename K1, typename K2, typename V> 

  inline CombineMap<M1, M2, V (*)(K1, K2), V> 

  combineMap(const M1 &m1, const M2 &m2, V (*f)(K1, K2)) {

    return combineMap<M1, M2, V (*)(K1, K2), V>(m1,m2,f);

  }

  ///Negative value of a map

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

  ///Its \c Key and \c Value are inherited from \c M.

  ///The unary \c - operator must be defined for \c Value, of course.

  ///

  ///\sa NegWriteMap

  template<typename M> 

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

    const M& m;

    ///Constructor

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

    /// \e

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

  };

  ///Negative value of a map (ReadWrite version)

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

  ///Its \c Key and \c Value are inherited from \c M.

  ///The unary \c - operator must be defined for \c Value, of course.

  ///

  /// \sa NegMap

  template<typename M> 

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

    M& m;

  ///\relates NegWriteMap

  template <typename M> 

  inline NegWriteMap<M> negMap(M &m) {

    return NegWriteMap<M>(m);

  }

  ///Absolute value of a map

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

  ///Its \c Key and \c Value are inherited from \c M. 

  ///\c Value must be comparable to \c 0 and the unary \c -

  ///operator must be defined for it, of course.

  template<typename M> 

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

    const M& m;

  public:

  ///\relates AbsMap

  template<typename M> 

  inline AbsMap<M> absMap(const M &m) {

    return AbsMap<M>(m);

  }

  ///Converts an STL style functor to a map

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

  ///functor typically does not provide such typedefs.

  ///

  ///Parameter \c F is the type of the used functor.

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

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

  ///that is it provides an <tt>operator()</tt> to read its values.

  ///

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

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

  ///

  ///\sa FunctorMap

  template <typename M> 

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

    const M& m;

  public:

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

  ///\relates MapFunctor

  template<typename M> 

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

    return MapFunctor<M>(m);

  }

  ///Applies all map setting operations to two maps

  ///parameters and each read request will be passed just to the

  ///

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

  ///The \c Key and \c Value of M2 must be convertible from those of \c M1.

  ///

  ///\sa ForkWriteMap

  ///

  /// \todo Why is it needed?

  template<typename  M1, typename M2> 

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

    /// \e

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

  };

  ///Applies all map setting operations to two maps

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

  ///then the read operations will return the

  ///corresponding values of \c M1.

  ///

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

  ///The \c Key and \c Value of M2 must be convertible from those of \c M1.

  ///

  ///\sa ForkMap

  template<typename  M1, typename M2> 

  }

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

  ///Logical 'not' of a map

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

  ///Its \c Key is inherited from \c M, its Value is \c bool.

  ///

  ///\sa NotWriteMap

  template <typename M> 

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

    const M& m;

  public:

    /// Constructor

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

    ///\e

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

  };

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

  ///logical negation of the value returned by the given map. When it is set,

  ///the opposite value is set to the original map.

  ///Its \c Key is inherited from \c M, its Value is \c bool.

  ///

  ///\sa NotMap

  template <typename M> 

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

    M& m;

      typedef typename _Iterator::container_type::value_type Value;

    };

  }

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

  ///

  ///

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

  /// for each element.

  ///

  /// The following example shows how you can write the edges found by the Prim

  /// algorithm directly

  /// to the standard output.

  ///\code