RhodeCode

  ///

  /// 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 typename Container::value_type Key;

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

      }

    }

  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

  ///

    typedef bool Value;

    /// Constructor with specified iterator

    /// Constructor with specified iterator.

    /// \param _container The container for storing the elements.

    /// \param _it The elements will be inserted before this iterator.

    /// \param _functor The functor that is used when an element is stored.

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

                    const Functor& _functor = Functor()) 

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

    /// Constructor

    /// Constructor without specified iterator.

    /// The elements will be inserted before <tt>_container.end()</tt>.

    /// \param _container The container for storing the elements.

    /// \param _functor The functor that is used when an element is stored.

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

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

    /// The \c set function of the map

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

      if (value) {

        ++it;

      }

    }

  private:

    Container& container;

    typename Container::iterator it;

    Functor functor;

  };

  /// \brief Writable bool map for filling each \c true assigned element with a 

  /// given value.

  ///

  /// Writable bool map for filling each \c true assigned element with a 

  /// given value. The value can set the container.

  ///

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

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

  ///\code

  /// typedef Graph::NodeMap<int> ComponentMap;

  /// ComponentMap comp(graph);

  /// typedef FillBoolMap<Graph::NodeMap<int> > ComponentFillerMap;

  /// ComponentFillerMap filler(comp, 0);

  ///