lemon-0.x: src/hugo/map_iterator.h@88226d9fe821

     1 // -*- c++ -*-

     2 #ifndef MAP_ITERATOR_H

     3 #define MAP_ITERATOR_H

     5 #include <hugo/extended_pair.h>

     7 namespace hugo {

    10   template <typename Map>

    11   class MapIterator;

    13   template <typename Map>

    14   class MapConstIterator;

    16   /** Compatible iterator with the stl maps' iterators.

    17    *  It iterates on pairs of a key and a value.

    18    */

    19   template <typename Map>

    20   class MapIterator {

    21     //    friend class Map;

    22     friend class MapConstIterator<Map>;

    24   public:

    26     /// The key type of the iterator.

    27     typedef typename Map::KeyType KeyType;

    28     /// The iterator to iterate on the keys.

    29     typedef typename Map::KeyIt KeyIt;

    31     /// The value type of the iterator.

    32     typedef typename Map::ValueType ValueType;

    33     /// The reference type of the iterator.

    34     typedef typename Map::ReferenceType ReferenceType;

    35     /// The pointer type of the iterator.

    36     typedef typename Map::PointerType PointerType;

    38     /// The const value type of the iterator.

    39     typedef typename Map::ConstValueType ConstValueType;

    40     /// The const reference type of the iterator.

    41     typedef typename Map::ConstReferenceType ConstReferenceType;

    42     /// The pointer type of the iterator.

    43     typedef typename Map::ConstPointerType ConstPointerType;

    45   public:

    47     /** Constructor to initalize the the iterators returned

    48      *  by the begin() and end().

    49      */

    50     MapIterator (Map& pmap, const KeyIt& pit)

    51       : map(&pmap), it(pit) {}

    53   public:

    55     /** Default constructor.

    56      */

    57     MapIterator() {}

    59     typedef extended_pair<const KeyType&, const KeyType&,

    60       ReferenceType, ReferenceType> PairReferenceType;

    62     /** Dereference operator for map.

    63      */

    64     PairReferenceType operator*() {

    65       return PairReferenceType(it, (*map)[it]);

    66     }

    68     class PairPointerType {

    69       friend class MapIterator;

    70     private:

    71       PairReferenceType data;

    72       PairPointerType(const KeyType& key, ReferenceType val)

    73 	: data(key, val) {}

    74     public:

    75       PairReferenceType* operator->() {return &data;}

    76     };

    78     /** Arrow operator for map.

    79      */

    80     PairPointerType operator->() {

    81       return PairPointerType(it, ((*map)[it]));

    82     }

    84     /** The pre increment operator of the map.

    85      */

    86     MapIterator& operator++() {

    87       ++it;

    88       return *this;

    89     }

    91     /** The post increment operator of the map.

    92      */

    93     MapIterator operator++(int) {

    94       MapIterator tmp(it);

    95       ++it;

    96       return tmp;

    97     }

    99     /** The equality operator of the map.

   100      */

   101     bool operator==(const MapIterator& p_it) const {

   102       return p_it.it == it;

   103     }

   105     /** The not-equality operator of the map.

   106      */

   107     bool operator!=(const MapIterator& p_it) const {

   108       return !(*this == p_it);

   109     }

   111     /** The equality operator of the map.

   112      */

   113     bool operator==(const MapConstIterator<Map>& p_it) const {

   114       return p_it.it == it;

   115     }

   117     /** The not-equality operator of the map.

   118      */

   119     bool operator!=(const MapConstIterator<Map>& p_it) const {

   120       return !(*this == p_it);

   121     }

   123   private:

   124     Map* map;

   125     KeyIt it;

   126   };

   128   /** Compatible iterator with the stl maps' iterators.

   129    *  It iterates on pairs of a key and a value.

   130    */

   131   template <typename Map>

   132   class MapConstIterator {

   133     // friend class Map;

   134     friend class MapIterator<Map>;

   136   public:

   138     /// The key type of the iterator.

   139     typedef typename Map::KeyType KeyType;

   140     /// The iterator to iterate on the keys.

   141     typedef typename Map::KeyIt KeyIt;

   143     /// The value type of the iterator.

   144     typedef typename Map::ValueType ValueType;

   145     /// The reference type of the iterator.

   146     typedef typename Map::ReferenceType ReferenceType;

   147     /// The pointer type of the iterator.

   148     typedef typename Map::PointerType PointerType;

   150     /// The const value type of the iterator.

   151     typedef typename Map::ConstValueType ConstValueType;

   152     /// The const reference type of the iterator.

   153     typedef typename Map::ConstReferenceType ConstReferenceType;

   154     /// The pointer type of the iterator.

   155     typedef typename Map::ConstPointerType ConstPointerType;

   157   public:

   159     /** Constructor to initalize the the iterators returned

   160      *  by the begin() and end().

   161      */

   163     MapConstIterator (const Map& pmap, const KeyIt& pit)

   164       : map(&pmap), it(pit) {}

   166   public:

   168     /** Default constructor.

   169      */

   170     MapConstIterator() {}

   172     typedef extended_pair<const KeyType&, const KeyType&,

   173       ConstReferenceType, ConstReferenceType> PairReferenceType;

   175     /** Dereference operator for map.

   176      */

   177     PairReferenceType operator*() {

   178       return PairReferenceType(it, (*map)[it]);

   179     }

   181     class PairPointerType {

   182       friend class MapConstIterator;

   183     private:

   184       PairReferenceType data;

   185       PairPointerType(const KeyType& key, ConstReferenceType val)

   186 	: data(key, val) {}

   187     public:

   188       PairReferenceType* operator->() {return &data;}

   189     };

   191     /** Arrow operator for map.

   192      */

   193     PairPointerType operator->() {

   194       return PairPointerType(it, ((*map)[it]));

   195     }

   197     /** The pre increment operator of the map.

   198      */

   199     MapConstIterator& operator++() {

   200       ++it;

   201       return *this;

   202     }

   204     /** The post increment operator of the map.

   205      */

   206     MapConstIterator operator++(int) {

   207       MapConstIterator<Map> tmp(it);

   208       ++it;

   209       return tmp;

   210     }

   212     /** The equality operator of the map.

   213      */

   214     bool operator==(const MapIterator<Map>& p_it) const {

   215       return p_it.it == it;

   216     }

   218     /** The not-equality operator of the map.

   219      */

   220     bool operator!=(const MapIterator<Map>& p_it) const {

   221       return !(*this == p_it);

   222     }

   224     /** The equality operator of the map.

   225      */

   226     bool operator==(const MapConstIterator& p_it) const {

   227       return p_it.it == it;

   228     }

   230     /** The not-equality operator of the map.

   231      */

   232     bool operator!=(const MapConstIterator& p_it) const {

   233       return !(*this == p_it);

   234     }

   236   private:

   237     const Map* map;

   238     KeyIt it;

   239   };

   241 }

   243 #endif

author	deba
	Wed, 08 Sep 2004 12:06:45 +0000
changeset 822	88226d9fe821
child 830	89dfa3bece81
permissions	-rw-r--r--