RhodeCode

namespace lemon {

  /// \addtogroup maps

  /// @{

  /// Base class of maps.

  /// Base class of maps.

  /// It provides the necessary <tt>typedef</tt>s required by the map concept.

  template<typename K, typename T>

  class MapBase {

  public:

    typedef K Key;

    typedef T Value;

  };

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

  /// This map can be used if you have to provide a map only for

  /// its type definitions, or if you have to provide a writable map, 

  /// but data written to it is not required (i.e. it will be sent to 

  /// <tt>/dev/null</tt>).

  template<typename K, typename T>

  class NullMap : public MapBase<K, T> {

  public:

    /// \e

    void setAll(const T &t) {

      _value = t;

      _map.clear();

    }    

    template <typename T1, typename C1 = std::less<T1> >

    struct rebind {

      typedef StdMap<Key, T1, C1> other;

    };

  };

  ///

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

    CombineMap(const M1 &_m1,const M2 &_m2,const F &_f = F())

      : m1(_m1), m2(_m2), f(_f) {};

    /// \e

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

  };

  ///Returns a \c CombineMap class

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

  ///

  ///For example if \c m1 and \c m2 are both \c double valued maps, then 

  ///\code

  ///\endcode

  ///is equivalent to

  ///\code

  ///addMap(m1,m2)

  ///\endcode

  ///

  ///This function is specialized for adaptable binary function

  ///classes and C++ functions.

  ///

  ///\relates CombineMap

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

  inline CombineMap<M1, M2, F, V> 

  ///\relates AbsMap

  template<typename M> 

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

    return AbsMap<M>(m);

  }

  ///Converts an STL style functor to a map

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

  ///of a given functor.

  ///

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

  ///

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

  ///

  ///\sa MapFunctor

  template<typename F, 

	   typename K = typename F::argument_type, 

	   typename V = typename F::result_type> 

  class FunctorMap : public MapBase<K, V> {

    F f;

  public:

    typedef MapBase<K, V> Parent;

    typedef typename Parent::Key Key;

  /// EdgeIdMap edgeId(graph);

  ///

  /// typedef MapFunctor<EdgeIdMap> EdgeIdFunctor;

  /// EdgeIdFunctor edgeIdFunctor(edgeId);

  ///

  /// StoreBoolMap<ostream_iterator<int>, EdgeIdFunctor> 

  ///   writerMap(ostream_iterator<int>(cout, " "), edgeIdFunctor);

  ///

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

  ///\endcode

  ///

  ///\sa BackInserterBoolMap 

  ///

  ///\todo Revise the name of this class and the related ones.

  template <typename _Iterator, 

            typename _Functor =

            _maps_bits::Identity<typename _maps_bits::

                                 IteratorTraits<_Iterator>::Value> >

  class StoreBoolMap {

  public:

    typedef _Iterator Iterator;

    typedef typename _Functor::argument_type Key;

    typedef bool Value;