lemon-0.x: comparison lemon/iterable

equal deleted inserted replaced

-:42dc0c7ee65e
+:c2d9473f5782
 public:
 explicit IterableBoolMap(BaseMap &_m,bool init=false) : cref(_m)
 {
 sep=0;
-for(typename BaseMap::MapSet::iterator i=cref.mapSet().begin();
+for(typename BaseMap::MapIt i(cref);i!=INVALID; ++i) {
-	  i!=cref.mapSet().end();
+	i.set(sep);
-	  ++i) {
+	vals.push_back(i);
-	i->second=sep;
-	vals.push_back(i->first);
 	sep++;
 }
 if(init) sep=0;
 }
 ///\e
 namespace _iterable_maps_bits {
 template <typename Item>
 struct IterableIntMapNode {
-IterableIntMapNode() : value(-1) {}
+IterableIntMapNode() {}
+IterableIntMapNode(int _value) : value(_value) {}
 Item prev, next;
 int value;
 };
 }
 ///\ingroup maps
 ///
 /// \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>
 ::template Map<_iterable_maps_bits::IterableIntMapNode<_Item> >::Parent {
 public:
 typedef typename ItemSetTraits<_Graph, _Item>
 ::template Map<_iterable_maps_bits::IterableIntMapNode<_Item> >
 ::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:
 void unlace(const Key& key) {
 typename Parent::Value& node = Parent::operator[](key);
 first[node.value] = key;
 }
 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;
 private:
 Reference(IterableIntMap& map, const Key& key)
 	: _key(key), _map(map) {}
 private:
 Key _key;
 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);
 Parent::operator[](key).value = value;
 lace(key);
 }
+/// \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()) {
 	  Parent::operator=(INVALID);
 	} else {
 	  Parent::operator=(_map->first[value]);
 	}
 }
+/// \brief Increment operator.
+///
+/// Increment Operator.
 ItemIt& operator++() {
 	Parent::operator=(_map->IterableIntMap::Parent::
 			  operator[](static_cast<Parent&>(*this)).next);
 	return *this;
 }

changeset 1849	a4d1362397fe
parent 1805	d284f81f02a5
child 1873	d73c7f115f53