lemon-0.x: comparison src/hugo/map

equal deleted inserted replaced

-:e2a2eb53657f
+:f9012b139d76
 // -*- c++ -*-
 #ifndef MAP_ITERATOR_H
 #define MAP_ITERATOR_H
+#include <iterator>
 #include <hugo/extended_pair.h>
 ///\ingroup graphmaps
 ///\file
 template <typename Map>
 class MapIteratorBase {
 public:
 /// The key type of the iterator.
 typedef typename Map::KeyType KeyType;
 /// The iterator to iterate on the keys.
 typedef typename Map::KeyIt KeyIt;
 template <typename Map>
 class MapIterator : public MapIteratorBase<Map> {
 friend class MapConstIterator<Map>;
-public:
+public:
+/// The iterator base class.
+typedef MapIteratorBase<Map> Base;
 /// The key type of the iterator.
 typedef typename Map::KeyType KeyType;
 /// The iterator to iterate on the keys.
 typedef typename Map::KeyIt KeyIt;
 typedef typename Map::ConstReferenceType ConstReferenceType;
 /// The pointer type of the iterator.
 typedef typename Map::ConstPointerType ConstPointerType;
 public:
+/// The value type of the iterator.
+typedef extended_pair<KeyType, const KeyType&,
+ValueType, const ValueType&> PairValueType;
 /// The reference type of the iterator.
 typedef extended_pair<const KeyType&, const KeyType&,
 ReferenceType, ReferenceType> PairReferenceType;
 /// Default constructor.
 MapIterator() {}
 /// Constructor to initalize the iterators returned
 /// by the begin() and end().
-MapIterator(Map& pmap, const KeyIt& pit)
+MapIterator(Map& pmap, const KeyIt& pit) : Base(pit), map(&pmap) {}
-: MapIteratorBase<Map>(pit), map(&pmap) {}
 /// Dereference operator for the iterator.
 PairReferenceType operator*() {
-return PairReferenceType(it, (*map)[it]);
+return PairReferenceType(Base::it, (*map)[Base::it]);
 }
 /// The pointer type of the iterator.
 class PairPointerType {
 friend class MapIterator;
 PairReferenceType* operator->() {return &data;}
 };
 /// Arrow operator for the iterator.
 PairPointerType operator->() {
-return PairPointerType(it, ((*map)[it]));
+return PairPointerType(Base::it, ((*map)[Base::it]));
 }
 /// The pre increment operator of the iterator.
 MapIterator& operator++() {
-increment();
+Base::increment();
 return *this;
 }
 /// The post increment operator of the iterator.
 MapIterator operator++(int) {
-MapIterator tmp(it);
+MapIterator tmp(*this);
-increment();
+Base::increment();
 return tmp;
 }
 private:
 Map* map;
+public:
+// STL  compatibility typedefs.
+typedef std::forward_iterator_tag iterator_category;
+typedef int difference_type;
+typedef PairValueType value_type;
+typedef PairReferenceType reference;
+typedef PairPointerType pointer;
 };
 /** Compatible iterator with the stl maps' iterators.
 *  It iterates on pairs of a key and a value.
 */
 template <typename Map>
 class MapConstIterator : public MapIteratorBase<Map> {
 public:
+/// The iterator base class.
+typedef MapIteratorBase<Map> Base;
 /// The key type of the iterator.
 typedef typename Map::KeyType KeyType;
 /// The iterator to iterate on the keys.
 typedef typename Map::KeyIt KeyIt;
 MapConstIterator() {}
 /// Constructor to initalize the the iterators returned
 ///  by the begin() and end().
 MapConstIterator(const Map& pmap, const KeyIt& pit)
-: MapIteratorBase<Map>(pit), map(&pmap) {}
+: Base(pit), map(&pmap) {}
 /// Constructor to create const iterator from a non const.
 MapConstIterator(const MapIterator<Map>& pit) {
-it = pit.it;
+Base::it = pit.Base::it;
 map = pit.map;
 }
+/// The value type of the iterator.
+typedef extended_pair<KeyType, const KeyType&,
+ValueType, const ValueType&> PairValueType;
 /// The reference type of map.
 typedef extended_pair<const KeyType&, const KeyType&,
 ConstReferenceType, ConstReferenceType> PairReferenceType;
 /// Dereference operator for the iterator.
 PairReferenceType operator*() {
-return PairReferenceType(it, (*map)[it]);
+return PairReferenceType(Base::it, (*map)[Base::it]);
 }
 /// The pointer type of the iterator.
 class PairPointerType {
 friend class MapConstIterator;
 PairReferenceType* operator->() {return &data;}
 };
 /// Arrow operator for the iterator.
 PairPointerType operator->() {
-return PairPointerType(it, ((*map)[it]));
+return PairPointerType(Base::it, (*map)[Base::it]);
 }
 /// The pre increment operator of the iterator.
 MapConstIterator& operator++() {
-increment();
+Base::increment();
 return *this;
 }
 /// The post increment operator of the iterator.
 MapConstIterator operator++(int) {
-MapConstIterator<Map> tmp(it);
+MapConstIterator tmp(*this);
-increment();
+Base::increment();
 return tmp;
 }
 private:
 const Map* map;
+public:
+// STL  compatibility typedefs.
+typedef std::input_iterator_tag iterator_category;
+typedef int difference_type;
+typedef PairValueType value_type;
+typedef PairReferenceType reference;
+typedef PairPointerType pointer;
 };
 /** The class makes the KeyIt to an stl compatible iterator
 *  with dereferencing operator.
 */
 template <typename Map>
 class MapKeyIterator : public MapIteratorBase<Map> {
 public:
+/// The iterator base class.
+typedef MapIteratorBase<Map> Base;
 /// The key type of the iterator.
 typedef typename Map::KeyType KeyType;
 /// The iterator to iterate on the keys.
 typedef typename Map::KeyIt KeyIt;
 /// Default constructor.
 MapKeyIterator() {}
 /// KeyIt initialized iterator.
-MapKeyIterator(const KeyIt& pit) : MapIteratorBase<Map>(pit) {}
+MapKeyIterator(const KeyIt& pit) : Base(pit) {}
 /// The pre increment operator of the iterator.
 MapKeyIterator& operator++() {
-increment();
+Base::increment();
 return *this;
 }
 /// The post increment operator of the iterator.
 MapKeyIterator operator++(int) {
 MapKeyIterator tmp(*this);
-increment();
+Base::increment();
 return tmp;
 }
 /// The dereferencing operator of the iterator.
 KeyType operator*() const {
-return static_cast<KeyType>(it);
+return static_cast<KeyType>(Base::it);
 }
+public:
+// STL  compatibility typedefs.
+typedef std::input_iterator_tag iterator_category;
+typedef int difference_type;
+typedef KeyType value_type;
+typedef const KeyType& reference;
+typedef const KeyType* pointer;
 };
 template <typename Map> class MapConstValueIterator;
+/** MapValueIterator creates an stl compatible iterator
+*  for the values.
+*/
 template <typename Map>
 class MapValueIterator : public MapIteratorBase<Map> {
 friend class MapConstValueIterator<Map>;
 public:
+/// The iterator base class.
+typedef MapIteratorBase<Map> Base;
 /// The key type of the iterator.
 typedef typename Map::KeyType KeyType;
 /// The iterator to iterate on the keys.
 typedef typename Map::KeyIt KeyIt;
 /// Default constructor.
 MapValueIterator() {}
 /// Map and KeyIt initialized iterator.
 MapValueIterator(Map& pmap, const KeyIt& pit)
-: MapIteratorBase<Map>(pit), map(&pmap) {}
+: Base(pit), map(&pmap) {}
 /// The pre increment operator of the iterator.
 MapValueIterator& operator++() {
-increment();
+Base::increment();
 return *this;
 }
 /// The post increment operator of the iterator.
 MapValueIterator operator++(int) {
 MapValueIterator tmp(*this);
-increment();
+Base::increment();
 return tmp;
 }
 /// The dereferencing operator of the iterator.
 ReferenceType operator*() const {
-return (*map)[it];
+return (*map)[Base::it];
 }
 /// The arrow operator of the iterator.
 PointerType operator->() const {
 return &(operator*());
 }
-};
+public:
+// STL  compatibility typedefs.
+typedef std::forward_iterator_tag iterator_category;
+typedef int difference_type;
+typedef ValueType value_type;
+typedef ReferenceType reference;
+typedef PointerType pointer;
+};
+/** MapValueIterator creates an stl compatible iterator
+*  for the const values.
+*/
 template <typename Map>
 class MapConstValueIterator : public MapIteratorBase<Map> {
 public:
-/// The key type of the iterator.
+/// The iterator base class.
-typedef typename Map::KeyType KeyType;
+typedef MapIteratorBase<Map> Base;
-/// The iterator to iterate on the keys.
-typedef typename Map::KeyIt KeyIt;
+/// The key type of the iterator.
+typedef typename Map::KeyType KeyType;
+/// The iterator to iterate on the keys.
+typedef typename Map::KeyIt KeyIt;
 /// The value type of the iterator.
 typedef typename Map::ValueType ValueType;
 /// The reference type of the iterator.
 typedef typename Map::ReferenceType ReferenceType;
 /// Default constructor.
 MapConstValueIterator() {}
 /// Constructor to create const iterator from a non const.
 MapConstValueIterator(const MapValueIterator<Map>& pit) {
-it = pit.it;
+Base::it = pit.Base::it;
 map = pit.map;
 }
 /// Map and KeyIt initialized iterator.
 MapConstValueIterator(const Map& pmap, const KeyIt& pit)
-: MapIteratorBase<Map>(pit), map(&pmap) {}
+: Base(pit), map(&pmap) {}
 /// The pre increment operator of the iterator.
 MapConstValueIterator& operator++() {
-increment();
+Base::increment();
 return *this;
 }
 /// The post increment operator of the iterator.
 MapConstValueIterator operator++(int) {
 MapConstValueIterator tmp(*this);
-increment();
+Base::increment();
 return tmp;
 }
 /// The dereferencing operator of the iterator.
 ConstReferenceType operator*() const {
-return (*map)[it];
+return (*map)[Base::it];
 }
 /// The arrow operator of the iterator.
 ConstPointerType operator->() const {
 return &(operator*());
 }
+public:
+// STL  compatibility typedefs.
+typedef std::input_iterator_tag iterator_category;
+typedef int difference_type;
+typedef ValueType value_type;
+typedef ConstReferenceType reference;
+typedef ConstPointerType pointer;
 };
 /** This class makes from a map an iteratable set
 *  which contains all the keys of the map.
 /// The key type of the iterator.
 typedef typename Map::KeyType KeyType;
 /// The iterator to iterate on the keys.
 typedef typename Map::KeyIt KeyIt;
+/// The value type of the iterator.
+typedef typename Map::ValueType ValueType;
+/// The reference type of the iterator.
+typedef typename Map::ReferenceType ReferenceType;
+/// The pointer type of the iterator.
+typedef typename Map::PointerType PointerType;
+/// The const value type of the iterator.
+typedef typename Map::ConstValueType ConstValueType;
+/// The const reference type of the iterator.
+typedef typename Map::ConstReferenceType ConstReferenceType;
+/// The pointer type of the iterator.
+typedef typename Map::ConstPointerType ConstPointerType;
 /// The map initialized const key set.
 MapConstKeySet(const Map& pmap) : map(&pmap) {}
 /// The const iterator of the set.
 /// It gives back the const iterator pointed to the first ivalid element.
 ConstIterator end() const {
 return ConstIterator(KeyIt(INVALID));
 }
+public:
+// STL  compatibility typedefs.
+typedef ValueType value_type;
+typedef ConstIterator const_iterator;
+typedef ConstReferenceType const_reference;
+typedef ConstPointerType const_pointer;
+typedef int difference_type;
 };
 /** This class makes from a map an iteratable set
 *  which contains all the values of the map.
 *  The values cannot be modified.
 /// The key type of the iterator.
 typedef typename Map::KeyType KeyType;
 /// The iterator to iterate on the keys.
 typedef typename Map::KeyIt KeyIt;
+/// The value type of the iterator.
+typedef typename Map::ValueType ValueType;
+/// The reference type of the iterator.
+typedef typename Map::ReferenceType ReferenceType;
+/// The pointer type of the iterator.
+typedef typename Map::PointerType PointerType;
+/// The const value type of the iterator.
+typedef typename Map::ConstValueType ConstValueType;
+/// The const reference type of the iterator.
+typedef typename Map::ConstReferenceType ConstReferenceType;
+/// The pointer type of the iterator.
+typedef typename Map::ConstPointerType ConstPointerType;
 /// The map initialized const value set.
 MapConstValueSet(const Map& pmap) : map(&pmap) {}
 /// The const iterator of the set.
 typedef MapConstValueIterator<Map> ConstIterator;
 /// It gives back the const iterator pointed to the first invalid element.
 ConstIterator end() const {
 return ConstIterator(*map, KeyIt(INVALID));
 }
+public:
+// STL  compatibility typedefs.
+typedef ValueType value_type;
+typedef ConstIterator const_iterator;
+typedef ConstReferenceType const_reference;
+typedef ConstPointerType const_pointer;
+typedef int difference_type;
 };
 /** This class makes from a map an iteratable set
 *  which contains all the values of the map.
 /// The key type of the iterator.
 typedef typename Map::KeyType KeyType;
 /// The iterator to iterate on the keys.
 typedef typename Map::KeyIt KeyIt;
+/// The value type of the iterator.
+typedef typename Map::ValueType ValueType;
+/// The reference type of the iterator.
+typedef typename Map::ReferenceType ReferenceType;
+/// The pointer type of the iterator.
+typedef typename Map::PointerType PointerType;
+/// The const value type of the iterator.
+typedef typename Map::ConstValueType ConstValueType;
+/// The const reference type of the iterator.
+typedef typename Map::ConstReferenceType ConstReferenceType;
+/// The pointer type of the iterator.
+typedef typename Map::ConstPointerType ConstPointerType;
 /// The map initialized value set.
 MapValueSet(Map& pmap) : map(&pmap) {}
 /// The const iterator of the set.
 typedef MapConstValueIterator<Map> ConstIterator;
 /// It gives back the iterator pointed to the first invalid element.
 Iterator end() {
 return Iterator(*map, KeyIt(INVALID));
 }
+public:
+// STL  compatibility typedefs.
+typedef ValueType value_type;
+typedef Iterator iterator;
+typedef ConstIterator const_iterator;
+typedef ReferenceType reference;
+typedef ConstReferenceType const_reference;
+typedef PointerType pointer;
+typedef ConstPointerType const_pointer;
+typedef int difference_type;
 };
 /// @}
 }

changeset 890	3a48bc350e0f
parent 830	89dfa3bece81
child 901	69a8e672acb1