RhodeCode

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

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

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

  ///

  ///\code

  /// vector<Edge> span_tree_edges;

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

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

  ///\endcode

  ///

  ///\sa StoreBoolMap

  ///\sa FrontInserterBoolMap

  ///\sa InserterBoolMap

  template <typename Container,

            typename Functor =

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

  class BackInserterBoolMap {

  public:

    typedef bool Value;

    /// Constructor

    BackInserterBoolMap(Container& _container, 

                        const Functor& _functor = Functor()) 

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

    /// The \c set function of the map

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

      if (value) {

	container.push_back(functor(key));

      }

    }

  private:

    Container& container;

    Functor functor;

  };

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

  /// a front insertable container.

  ///

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

  /// them into a front insertable container.

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

  /// container. For example see \ref BackInserterBoolMap.

  ///

  ///\sa BackInserterBoolMap

  ///\sa InserterBoolMap

  template <typename Container,

            typename Functor =

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

  class FrontInserterBoolMap {

  public:

    typedef bool Value;

    /// Constructor

    FrontInserterBoolMap(Container& _container,

                         const Functor& _functor = Functor()) 

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

    /// The \c set function of the map

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

      if (value) {

	container.push_front(functor(key));

      }

    }

  private:

    Container& container;    

    Functor functor;

  };

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

  /// an insertable container.

  ///

  /// Writable bool map for storing each \c true assigned element in an 

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

  /// the container.

  ///

  /// For example, if you want to store the cut arcs of the strongly

  /// connected components in a set you can use the next code:

  ///

  ///\code

  /// set<Arc> cut_arcs;

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

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

  ///\endcode

  ///

  ///\sa BackInserterBoolMap

  ///\sa FrontInserterBoolMap

  template <typename Container,

            typename Functor =

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

  class InserterBoolMap {

  public:

    typedef typename Container::value_type Key;

    typedef bool Value;

    /// Constructor with specified iterator

    /// Constructor with specified iterator.