#include <iterator>

   /// \brief Writeable bool map for store each true assigned elements.

   ///

   /// Writeable bool map for store each true assigned elements. It will

   /// copies all the true setted keys to the given iterator.

   ///

   /// \note The container of the iterator should contain for each element.

   template <typename _Iterator>

   class StoreBoolMap {

   public:

     typedef _Iterator Iterator;

     typedef typename std::iterator_traits<Iterator>::value_type Key;

     typedef bool Value;

     /// Constructor

     StoreBoolMap(Iterator it) : _begin(it), _end(it) {}

     /// Gives back the given first setted iterator.

     Iterator begin() const {

       return _begin;

     }

     /// Gives back the iterator after the last setted.

     Iterator end() const {

       return _end;

     }

     /// Setter function of the map

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

       if (value) {

 	*_end++ = key;

       }

     }

   private:

     Iterator _begin, _end;

   };

   /// \brief Writeable bool map for store each true assigned elements in 

   /// a back insertable container.

   ///

   /// Writeable bool map for store each true assigned elements in a back 

   /// insertable container. It will push back all the true setted keys into

   /// the container.

   template <typename Container>

   class BackInserterBoolMap {

   public:

     typedef typename Container::value_type Key;

     typedef bool Value;

     /// Constructor

     BackInserterBoolMap(Container& _container) : container(_container) {}

     /// Setter function of the map

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

       if (value) {

 	container.push_back(key);

       }

     }

   private:

     Container& container;    

   };

   /// \brief Writeable bool map for store each true assigned elements in 

   /// a front insertable container.

   ///

   /// Writeable bool map for store each true assigned elements in a front 

   /// insertable container. It will push front all the true setted keys into

   /// the container.

   template <typename Container>

   class FrontInserterBoolMap {

   public:

     typedef typename Container::value_type Key;

     typedef bool Value;

     /// Constructor

     FrontInserterBoolMap(Container& _container) : container(_container) {}

     /// Setter function of the map

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

       if (value) {

 	container.push_front(key);

       }

     }

   private:

     Container& container;    

   };

   /// \brief Writeable bool map for store each true assigned elements in 

   /// an insertable container.

   ///

   /// Writeable bool map for store each true assigned elements in an 

   /// insertable container. It will insert all the true setted keys into

   /// the container.

   template <typename Container>

   class InserterBoolMap {

   public:

     typedef typename Container::value_type Key;

     typedef bool Value;

     /// Constructor

     InserterBoolMap(Container& _container) : container(_container) {}

     /// Setter function of the map

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

       if (value) {

 	container.insert(key);

       }

     }

   private:

     Container& container;    

   };

   /// \brief Fill the true setted elements with a given value.

   ///

   /// Writeable bool map for fill the true setted elements with a given value.

   /// The value can be setted 

   /// the container.

   template <typename Map>

   class FillBoolMap {

   public:

     typedef typename Map::Key Key;

     typedef bool Value;

     /// Constructor

     FillBoolMap(Map& _map, const typename Map::Value& _fill) 

       : map(_map), fill(_fill) {}

     /// Constructor

     FillBoolMap(Map& _map) 

       : map(_map), fill() {}

     /// Gives back the current fill value

     typename Map::Value fillValue() const {

       return fill;

     } 

     /// Sets the current fill value

     void fillValue(const typename Map::Value& _fill) {

       fill = _fill;

     } 

     /// Setter function of the map

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

       if (value) {

 	map.set(key, fill);

       }

     }

   private:

     Map& map;

     typename Map::Value fill;

   };

   /// \brief Writeable bool map which stores for each true assigned elements  

   /// the setting order number.

   ///

   /// Writeable bool map which stores for each true assigned elements  

   /// the setting order number.

   template <typename Map>

   class SettingOrderBoolMap {

   public:

     typedef typename Map::Key Key;

     typedef bool Value;

     /// Constructor

     SettingOrderBoolMap(Map& _map) 

       : map(_map), counter(0) {}

     /// Number of setted keys.

     int num() const {

       return counter;

     }

     /// Setter function of the map

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

       if (value) {

 	map.set(key, counter++);

       }

     }

   private:

     Map& map;

     int counter;

   };