RhodeCode

#define LEMON_MAPS_H

#include <iterator>

#include <functional>

#include <vector>

#include <lemon/bits/utility.h>

// #include <lemon/bits/traits.h>

///\file

///\ingroup maps

///\brief Miscellaneous property maps

///

#include <map>

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:

    /// The key type of the map.

    typedef K Key;

    /// The value type of the map. (The type of objects associated with the keys).

    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:

    typedef MapBase<K, T> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    /// Gives back a default constructed element.

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

    /// Absorbs the value.

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

  };

  ///Returns a \c NullMap class

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

  ///\relates NullMap

  template <typename K, typename V> 

  NullMap<K, V> nullMap() {

    return NullMap<K, V>();

  }

  /// Constant map.

  template<typename K, typename T>

  class ConstMap : public MapBase<K, T> {

  private:

    T v;

  public:

    typedef MapBase<K, T> Parent;

    typedef typename Parent::Key Key;

    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.

  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;

    ConstMap() { }

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

    typedef MapBase<K, T> Parent;

    ///\e

    typedef typename Parent::Key Key;

    ///\e

    typedef typename Parent::Value Value;

    ///\e

    typedef T& Reference;

    ///\e

    typedef const T& ConstReference;

    typedef True ReferenceMapTag;

  private:

    typedef std::map<K, T, Compare> Map;

    Value _value;

    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:

    StdMap& operator=(const StdMap&);

  public:

    ///\e

    Reference operator[](const Key &k) {

      typename Map::iterator it = _map.lower_bound(k);

      if (it != _map.end() && !_map.key_comp()(k, it->first))

	return it->second;

      else

	return _map.insert(it, std::make_pair(k, _value))->second;

    }

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

    }    

  };

  ///Returns a \c StdMap class

  ///This function just returns a \c StdMap class with specified 

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

  }

  ///Returns a \c StdMap class created from an appropriate std::map

  ///This function just returns a \c StdMap class created from an 

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

  }

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

    friend class IntegerMap;

  public:

    typedef MapBase<int, T> Parent;

    ///\e

    typedef typename Parent::Key Key;

    ///\e

    typedef typename Parent::Value Value;

    ///\e

    typedef T& Reference;

    ///\e

    typedef const T& ConstReference;

    typedef True ReferenceMapTag;

  private:

    typedef std::vector<T> Vector;

    Vector _vector;

  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()) {

      _vector.resize(size, value);

    }

  private:

    IntegerMap& operator=(const IntegerMap&);

  public:

    ///\e

    Reference operator[](Key k) {

      return _vector[k];

    }

    /// \e 

    ConstReference operator[](Key k) const {

      return _vector[k];

    }

    /// \e 

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

      _vector[k] = t;

    }

  };

  ///Returns an \c IntegerMap class

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

  ///\relates IntegerMap

  template<typename T>

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

    return IntegerMap<T>(size, value);

  }

  /// @}

  /// \addtogroup map_adaptors

  /// @{

  /// \brief Identity map.

  ///

  /// This map gives back the given key as value without any

  /// modification. 

  template <typename T>

  class IdentityMap : public MapBase<T, T> {

  public:

    typedef MapBase<T, T> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    /// \e

    const T& operator[](const T& t) const {

      return t;

    }

  };

  ///Returns an \c IdentityMap class

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

  ///\relates IdentityMap

  template<typename T>

  inline IdentityMap<T> identityMap() {

    return IdentityMap<T>();

  }

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

  ///the default conversion.

  ///

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

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

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

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

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

  ///

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

  };

  ///Returns a \c SimpleMap class

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

  ///\relates SimpleMap

  template<typename M>

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

    return SimpleMap<M>(m);

  }

  ///Simple writable wrapping of a map

  ///This \ref concepts::ReadWriteMap "read-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.

  ///

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

  };

  ///Returns a \c SimpleWriteMap class

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

  ///\relates SimpleWriteMap

  template<typename M>

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

    return SimpleWriteMap<M>(m);

  }

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

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

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

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

    ///\e

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

  }

  ///Shift a map with a constant.

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

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

  ///\code

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

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

  ///\endcode

  ///

  ///\sa ShiftWriteMap

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

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

    const M& m;

    C v;

  public:

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

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

    ///Constructor.

    ///\param _m is the undelying map.

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

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

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

  public:

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

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

    ///Constructor.

    ///\param _m is the undelying map.

    ///\param _v is the shift value.

    /// \e

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

  };

  ///Returns a \c NegMap class

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

  ///\relates NegMap

  template <typename M> 

  inline NegMap<M> negMap(const M &m) {

    return NegMap<M>(m);

  }

  ///Returns a \c NegWriteMap class

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

  ///\relates NegWriteMap

  template <typename M> 

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

    return NegWriteMap<M>(m);

  }

  ///Absolute value of a map

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

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

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

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

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

    /// \e

    Value operator[](Key k) const {

      Value tmp = m[k]; 

      return tmp >= 0 ? tmp : -tmp;

    }

  };

  ///Returns an \c AbsMap class

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

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

	   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;

    typedef typename Parent::Value Value;

    ///Constructor

    FunctorMap(const F &_f = F()) : f(_f) {}

    /// \e

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

  };

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

  }

  template <typename F> inline 

  FunctorMap<F, typename F::argument_type, typename F::result_type> 

  functorMap(const F &f) {

    return FunctorMap<F, typename F::argument_type, 

      typename F::result_type>(f);

  }

  template <typename K, typename V> inline 

  FunctorMap<V (*)(K), K, V> functorMap(V (*f)(K)) {

    return FunctorMap<V (*)(K), 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

  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;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    typedef typename M::Key argument_type;

    typedef typename M::Value result_type;

    ///Constructor

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

    ///\e

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

    ///\e

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

  };

  ///Returns a \c MapFunctor class

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

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

    const M1& m1;

    const M2& m2;

  public:

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

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

    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

  ///This map has two \ref concepts::WriteMap "writable map"

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

  public:

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

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

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

    ///\e

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

    ///\e

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

  };

  ///Returns a \c ForkMap class

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

  ///\relates ForkMap

  template <typename M1, typename M2> 

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

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

  }

  ///Returns a \c ForkWriteMap class

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

  ///\relates ForkWriteMap

  template <typename M1, typename M2> 

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

    return ForkWriteMap<M1, M2>(m1,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:

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

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    /// Constructor

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

    ///\e

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

  };

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

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

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    /// Constructor

    NotWriteMap(M &_m) : m(_m) {};

    ///\e

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

    ///\e

    void set(Key k, bool v) { m.set(k, !v); }

  };

  ///Returns a \c NotMap class

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

  ///\relates NotMap

  template <typename M> 

  inline NotMap<M> notMap(const M &m) {

    return NotMap<M>(m);

  }

  ///Returns a \c NotWriteMap class

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

  ///\relates NotWriteMap

  template <typename M> 

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

    return NotWriteMap<M>(m);

  }

  namespace _maps_bits {

    template <typename Value>

    struct Identity {

      typedef Value argument_type;

      typedef Value result_type;

      Value operator()(const Value& val) const {

	return val;

      }

    };

    template <typename _Iterator, typename Enable = void>

    struct IteratorTraits {

      typedef typename std::iterator_traits<_Iterator>::value_type Value;

    };

    template <typename _Iterator>

    struct IteratorTraits<_Iterator,

      typename exists<typename _Iterator::container_type>::type> 

    {

      typedef typename _Iterator::container_type::value_type Value;

    };

  }

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

  ///

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

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

  ///

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

  ///\endcode

  ///

  ///\sa BackInserterBoolMap 

  ///\sa FrontInserterBoolMap 

  ///\sa InserterBoolMap 

  ///

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

    typedef _Functor Functor;

    /// Constructor

    StoreBoolMap(Iterator it, const Functor& functor = Functor()) 

      : _begin(it), _end(it), _functor(functor) {}

    /// Gives back the given iterator set for the first key

    Iterator begin() const {

      return _begin;

    }

    /// Gives back the the 'after the last' iterator

    Iterator end() const {

      return _end;

    }

    /// The \c set function of the map

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

      if (value) {

	*_end++ = _functor(key);

      }

    }

  private:

    Iterator _begin;

    mutable Iterator _end;

    Functor _functor;

  };

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

  /// a back insertable container.

  ///

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

  /// them into a back insertable container.

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