Changeset 1778:4ba7965386fb in lemon-0.x for lemon/maps.h

Timestamp:

11/04/05 20:19:52 (18 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2310

Message:

Some just writeable bool maps.

File:

• lemon/maps.h (modified) (3 diffs)

lemon/maps.h

@@ -18 +18 @@
 #define LEMON_MAPS_H
 
+#include <iterator>
+
 #include <lemon/utility.h>
 #include <lemon/traits.h>
@@ -843 +845 @@
     typedef typename Parent::Value Value;
 
-    ///Constructor
+    /// Constructor
     NotMap(const M &_m) : m(_m) {};
     Value operator[](Key k) const {return !m[k];}
@@ -857 +859 @@
   }
 
+  /// \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;
+  };
+
   /// @}
 }