Changeset 1810:474d093466a5 in lemon-0.x

Timestamp:

11/16/05 19:58:10 (18 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

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

Message:

Modified iterators on graph maps
Other iterators for not graph maps

Location:

lemon

Files:

• bits/array_map.h (modified) (1 diff)
• bits/map_extender.h (added)
• bits/map_iterator.h (deleted)
• bits/static_map.h (modified) (1 diff)
• bits/vector_map.h (modified) (1 diff)
• iterable_maps.h (modified) (8 diffs)
• lp_base.h (modified) (2 diffs)
• map_iterator.h (added)

lemon/bits/array_map.h

@@ -19 +19 @@
 
 #include <memory>
-#include <lemon/bits/map_iterator.h>
+#include <lemon/bits/map_extender.h>
 #include <lemon/concept_check.h>
 #include <lemon/concept/maps.h>

lemon/bits/static_map.h

@@ -22 +22 @@
 
 #include <lemon/utility.h>
-#include <lemon/bits/map_iterator.h>
+#include <lemon/bits/map_extender.h>
 #include <lemon/bits/alteration_notifier.h>
 #include <lemon/error.h>

lemon/bits/vector_map.h

@@ -22 +22 @@
 
 #include <lemon/utility.h>
-#include <lemon/bits/map_iterator.h>
+#include <lemon/bits/map_extender.h>
 #include <lemon/bits/alteration_notifier.h>
 #include <lemon/concept_check.h>

lemon/iterable_maps.h

@@ -137 +137 @@
     {
       sep=0;
-      for(typename BaseMap::MapSet::iterator i=cref.mapSet().begin();
-          i!=cref.mapSet().end();
-          ++i) {
-        i->second=sep;
-        vals.push_back(i->first);
+      for(typename BaseMap::MapIt i(cref);i!=INVALID; ++i) {
+        i.set(sep);
+        vals.push_back(i);
         sep++;
       }
@@ -304 +302 @@
     template <typename Item>
     struct IterableIntMapNode {
-      IterableIntMapNode() : value(-1) {}
+      IterableIntMapNode() {}
+      IterableIntMapNode(int _value) : value(_value) {}
       Item prev, next;
       int value;
@@ -314 +313 @@
   /// \brief Dynamic iterable integer map.
   ///
-  /// \todo Document please
+  /// This class provides a special graph map type which can store
+  /// for each graph item(node, edge, etc.) an integer value. For each
+  /// non negative value it is possible to iterate on the keys which
+  /// mapped to the given value.
+  /// 
+  /// \param _Graph The graph type.
+  /// \param _Item One of the graph's item type, the key of the map.
   template <typename _Graph, typename _Item>
   class IterableIntMap : protected ItemSetTraits<_Graph, _Item> 
@@ -323 +328 @@
     ::Parent Parent;
 
+    /// The key type
     typedef _Item Key;
+    /// The value type
     typedef int Value;
+    /// The graph type
     typedef _Graph Graph;
 
-    explicit IterableIntMap(const Graph& graph) : Parent(graph) {}
+    /// \brief Constructor of the Map.
+    ///
+    /// Constructor of the Map. It set all values -1.
+    explicit IterableIntMap(const Graph& graph) 
+      : Parent(graph, _iterable_maps_bits::IterableIntMapNode<_Item>(-1)) {}
+
+    /// \brief Constructor of the Map with a given value.
+    ///
+    /// Constructor of the Map with a given value.
+    explicit IterableIntMap(const Graph& graph, int value) 
+      : Parent(graph, _iterable_maps_bits::IterableIntMapNode<_Item>(value)) {
+      if (value >= 0) {
+        for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
+          lace(it);
+        }
+      }
+    }
 
   private:
@@ -363 +387 @@
   public:
 
+    /// Indicates that the map if reference map.
     typedef True ReferenceMapTag;
 
+    /// \brief Refernce to the value of the map.
+    ///
+    /// This class is near to similar to the int type. It can
+    /// be converted to int and it has the same operators.
     class Reference {
       friend class IterableIntMap;
@@ -448 +477 @@
       IterableIntMap& _map; 
     };
-    
+
+    /// The const reference type.    
     typedef const Value& ConstReference;
 
+    /// \brief Gives back the maximal value plus one.
+    ///
+    /// Gives back the maximal value plus one.
     int size() const {
       return (int)first.size();
     }
     
+    /// \brief Set operation of the map.
+    ///
+    /// Set operation of the map.
     void set(const Key& key, const Value& value) {
       unlace(key);
@@ -461 +497 @@
     }
 
+    /// \brief Const subscript operator of the map.
+    ///
+    /// Const subscript operator of the map.
     const Value& operator[](const Key& key) const {
       return Parent::operator[](key).value;
     }
 
+    /// \brief Subscript operator of the map.
+    ///
+    /// Subscript operator of the map.
     Reference operator[](const Key& key) {
       return Reference(*this, key);
     }
 
+    /// \brief Iterator for the keys with the same value.
+    ///
+    /// Iterator for the keys with the same value. It works
+    /// like a graph item iterator in the map, it can be converted
+    /// the item type of the map, incremented with \c ++ operator, and
+    /// if the iterator leave the last valid item it will be equal to 
+    /// \c INVALID.
     class ItemIt : public _Item {
     public:
       typedef _Item Parent;
 
+      /// \brief Invalid constructor \& conversion.
+      ///
+      /// This constructor initializes the item to be invalid.
+      /// \sa Invalid for more details.
       ItemIt(Invalid) : Parent(INVALID), _map(0) {}
 
+      /// \brief Creates an iterator with a value.
+      ///
+      /// Creates an iterator with a value. It iterates on the 
+      /// keys which have the given value.
+      /// \param map The IterableIntMap
+      /// \param value The value
       ItemIt(const IterableIntMap& map, int value) : _map(&map) {
         if (value < 0 || value >= (int)_map->first.size()) {      
@@ -483 +542 @@
       } 
 
+      /// \brief Increment operator.
+      ///
+      /// Increment Operator.
       ItemIt& operator++() {
         Parent::operator=(_map->IterableIntMap::Parent::

lemon/lp_base.h

@@ -682 +682 @@
     }
     template<class T>
-    typename enable_if<typename T::ValueSet::value_type::LpSolverCol,
+    typename enable_if<typename T::MapIt::Value::LpSolverCol,
                        int>::type
     addColSet(T &t,dummy<2> = 2) { 
-      ///\bug <tt>return addColSet(t.valueSet());</tt> should also work.
       int s=0;
-      for(typename T::ValueSet::iterator i=t.valueSet().begin();
-          i!=t.valueSet().end();
-          ++i)
+      for(typename T::MapIt i(t); i!=INVALID; ++i)
         {
-          *i=addCol();
+          i.set(addCol());
           s++;
         }
@@ -788 +785 @@
     }
     template<class T>
-    typename enable_if<typename T::ValueSet::value_type::LpSolverRow,
+    typename enable_if<typename T::MapIt::Value::LpSolverRow,
                        int>::type
     addRowSet(T &t,dummy<2> = 2) { 
-      ///\bug <tt>return addRowSet(t.valueSet());</tt> should also work.
       int s=0;
-      for(typename T::ValueSet::iterator i=t.valueSet().begin();
-          i!=t.valueSet().end();
-          ++i)
+      for(typename T::MapIt i(t); i!=INVALID; ++i)
         {
-          *i=addRow();
+          i.set(addRow());
           s++;
         }