RhodeCode

  /// Null map. (a.k.a. DoNothingMap)

  template<typename K, typename T>

  class NullMap : public MapBase<K, T> {

  public:

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

  };

  template <typename K, typename V> 

  NullMap<K, V> nullMap() {

    return NullMap<K, V>();

    /// Default constructor

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

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

    ConstMap() {}

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

    ///\e

  ///Map based on std::map

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

  class StdMap {

    template <typename K1, typename T1, typename C1>

  /// \addtogroup map_adaptors

  /// @{

  ///

  /// modification. 

  template <typename T>

  class IdentityMap : public MapBase<T, T> {

  ///the default conversion.

  ///

  ///This \c concepts::ReadMap "read only map"

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

  template <typename M, typename T> 

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

    ///Constructor

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

    /// \brief The subscript operator.

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

  };

  ///\relates ConvertMap

  template<typename T, typename M>

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

    return ConvertMap<M, T>(m);

  }

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

  ///

  template<typename M> 

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

    const M& m;

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

  };

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

  ///

  /// \todo Revise the misleading name

  template<typename M> 

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

  ///Sum of two maps

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

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

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

  ///given map and a constant value.

  ///

  ///Actually,

  ///\code

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

  ///\endcode

  ///\code

  ///  ConstMap<X::Key, X::Value> c_tmp(v);

  ///  AddMap<X, ConstMap<X::Key, X::Value> > sh(x,v);

  ///\endcode

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

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

    const M& m;

    ///Constructor

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

    ///\e

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

  };

  ///This \c concepts::ReadWriteMap "read-write map" returns the sum of the

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

  ///

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

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

    M& m;

    ///Constructor

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

    /// \e

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

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

  };

  ///\relates ShiftMap

  template<typename M, typename C> 

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

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

  }

  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

  ///This \c concepts::ReadMap "read only map" returns the difference

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

  ///

  /// \todo Revise the misleading name

  ///Product of two maps

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

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

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

  }

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

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

  ///

  ///Actually,

  ///\code

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

  ///\endcode

  ///\code

  ///  ConstMap<X::Key, X::Value> c_tmp(v);

  ///  MulMap<X, ConstMap<X::Key, X::Value> > sc(x,v);

  ///\endcode

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

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

    const M& m;

    ///Constructor

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

    /// \e

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

  };

  ///This \c concepts::ReadWriteMap "read-write map" returns the value of the

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

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

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

    M& m;

    ///Constructor

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

    /// \e

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

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

  };

  ///\relates ScaleMap

  template<typename M, typename C> 

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

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

  }

  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

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

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

  ///Composition of two maps

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

  ///then for

  ///\code

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

  ///\endcode

  ///

  ///\todo Check the requirements.

  template <typename M1, typename M2> 

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

    typename M1::Value

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

  };

  ///Returns a \c ComposeMap class

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

  ///\relates ComposeMap

  template <typename M1, typename M2> 

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

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

  }

  ///

  ///This \c concepts::ReadMap "read only map" takes two maps and a

  ///given maps unsing the functor. 

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

  ///\code

  ///\endcode

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

  ///

  ///Its \c Key is inherited from \c M1 and its \c Value is \c V.

  ///input parameter of \c F and the return type of \c F must be convertible

  ///to \c V.

  ///\todo Check the requirements.

  template<typename M1, typename M2, typename F,

	   typename V = typename F::result_type> 

  ///\code

  ///combineMap<double>(m1,m2,std::plus<double>())

  ///\endcode

  ///\code

  ///addMap(m1,m2)

  ///\endcode

  ///

  ///This function is specialized for adaptable binary function

  ///

  ///\relates CombineMap

  template<typename M1, typename M2, typename F, typename V> 

  ///Negative value of a map

  ///This \c concepts::ReadMap "read only map" returns the negative

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

  template<typename M> 

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

    const M& m;

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

  ///This \c concepts::ReadWriteMap "read-write map" returns the negative

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

  template<typename M> 

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

    M& m;

    return NegMap<M>(m);

  }

  template <typename M> 

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

    return NegWriteMap<M>(m);

  ///Absolute value of a map

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

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

  template<typename M> 

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

    const M& m;

  };

  ///\relates AbsMap

  template<typename M> 

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

  ///Converts an STL style functor to a map

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

  ///

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

  ///because a functor does not provide such typedefs.

  ///

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

  template<typename F, 

	   typename K = typename F::argument_type, 

	   typename V = typename F::result_type> 

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

  ///

  ///It is specialized for adaptable function classes and

  ///\relates FunctorMap

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

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

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

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

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

  template <typename M> 

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

    const M& m;

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

  ///first map. This class is the just readable map type of the ForkWriteMap.

  ///

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

  ///

  /// \todo Why is it needed?

  template<typename  M1, typename M2> 

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

  ///then the read operations will return the

  ///corresponding values of \c M1.

  ///

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

  template<typename  M1, typename M2> 

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

    M1& m1;

    void set(Key k, const Value &v) {m1.set(k,v); m2.set(k,v);}

  };

  ///\relates ForkMap

  template <typename M1, typename M2> 

  inline ForkMap<M1, M2> forkMap(const M1 &m1, const M2 &m2) {

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

  }

  template <typename M1, typename M2> 

  inline ForkWriteMap<M1, M2> forkMap(M1 &m1, M2 &m2) {

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

  ///Logical 'not' of a map

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

  template <typename M> 

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

    const M& m;

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

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

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

  template <typename M> 

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

    M& m;

    return NotMap<M>(m);

  }

  template <typename M> 

  inline NotWriteMap<M> notMap(M &m) {

    return NotWriteMap<M>(m);

  }

  ///

  ///

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

  /// for each element.

  /// prim(graph, cost, writerMap);

  ///\endcode

  ///

  template <typename _Iterator, 

            typename _Functor =

            _maps_bits::Identity<typename _maps_bits::

      return _end;

    }

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

      if (value) {

	*_end++ = _functor(key);

    Functor _functor;

  };

  ///

  /// It can be used to retrieve the items into a standard

  /// container. The next example shows how you can store the

  /// edges found by the Prim algorithm in a vector.

  /// BackInserterBoolMap<vector<Edge> > inserter_map(span_tree_edges);

  /// prim(graph, cost, inserter_map);

  ///\endcode

  template <typename Container,

            typename Functor =

            _maps_bits::Identity<typename Container::value_type> >

                        const Functor& _functor = Functor()) 

      : container(_container), functor(_functor) {}

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

      if (value) {

	container.push_back(functor(key));

    Functor functor;

  };

  /// a front insertable container.

  ///

  template <typename Container,

            typename Functor =

            _maps_bits::Identity<typename Container::value_type> >

                         const Functor& _functor = Functor()) 

      : container(_container), functor(_functor) {}

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

      if (value) {

	container.push_front(key);

    Functor functor;

  };

  /// an insertable container.

  ///

  /// insertable container. It will insert all the keys set to \c true into

  /// the container.

  ///

  /// InserterBoolMap<set<Arc> > inserter_map(cut_arcs);

  /// stronglyConnectedCutArcs(digraph, cost, inserter_map);

  ///\endcode

  template <typename Container,

            typename Functor =

            _maps_bits::Identity<typename Container::value_type> >

    typedef typename Container::value_type Key;

    typedef bool Value;

    InserterBoolMap(Container& _container, typename Container::iterator _it,

                    const Functor& _functor = Functor()) 

      : container(_container), it(_it), functor(_functor) {}

    /// Constructor

    InserterBoolMap(Container& _container, const Functor& _functor = Functor())

      : container(_container), it(_container.end()), functor(_functor) {}

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

      if (value) {

	it = container.insert(it, key);

    Functor functor;

  };

  ///

  ///

  /// The following code finds the connected components of a graph

  /// and stores it in the \c comp map:

      fill = _fill;

    } 

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

      if (value) {

	map.set(key, fill);

  };

  /// 

  /// the sequence number of this setting.

  /// It makes it easy to calculate the leaving

  /// order of the nodes in the \c Dfs algorithm.