// -*- c++ -*-

 #ifndef MAP_ITERATOR_H

 #define MAP_ITERATOR_H

 #include <hugo/extended_pair.h>

 namespace hugo {

   template <typename Map>

   class MapIterator;

   template <typename Map>

   class MapConstIterator;

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

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

    */

   template <typename Map>  

   class MapIterator {

     //    friend class Map;

     friend class MapConstIterator<Map>;

   public:

     /// 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;

   public:

     /** Constructor to initalize the the iterators returned

      *  by the begin() and end().

      */

     MapIterator (Map& pmap, const KeyIt& pit) 

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

   public:

     /** Default constructor. 

      */

     MapIterator() {}

     typedef extended_pair<const KeyType&, const KeyType&, 

       ReferenceType, ReferenceType> PairReferenceType;

     /** Dereference operator for map.

      */	 

     PairReferenceType operator*() {

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

     }

     class PairPointerType {

       friend class MapIterator;

     private:

       PairReferenceType data;

       PairPointerType(const KeyType& key, ReferenceType val) 

 	: data(key, val) {}

     public:

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

     };

     /** Arrow operator for map.

      */	 

     PairPointerType operator->() {

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

     }

     /** The pre increment operator of the map.

      */

     MapIterator& operator++() { 

       ++it; 

       return *this; 

     }

     /** The post increment operator of the map.

      */

     MapIterator operator++(int) { 

       MapIterator tmp(it); 

       ++it; 

       return tmp; 

     }

     /** The equality operator of the map.

      */

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

       return p_it.it == it;

     }

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

      */

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

       return !(*this == p_it);

     }

     /** The equality operator of the map.

      */

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

       return p_it.it == it;

     }

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

      */

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

       return !(*this == p_it);

     }

   private:

     Map* map;

     KeyIt it;

   };

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

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

    */

   template <typename Map>

   class MapConstIterator {

     // friend class Map;

     friend class MapIterator<Map>;

   public:

     /// 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;

   public:    

     /** Constructor to initalize the the iterators returned

      *  by the begin() and end().

      */

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

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

   public:

     /** Default constructor. 

      */

     MapConstIterator() {}

     typedef extended_pair<const KeyType&, const KeyType&, 

       ConstReferenceType, ConstReferenceType> PairReferenceType;

     /** Dereference operator for map.

      */	 

     PairReferenceType operator*() {

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

     }

     class PairPointerType {

       friend class MapConstIterator;

     private:

       PairReferenceType data;

       PairPointerType(const KeyType& key, ConstReferenceType val) 

 	: data(key, val) {}

     public:

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

     };

     /** Arrow operator for map.

      */	 

     PairPointerType operator->() {

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

     }

     /** The pre increment operator of the map.

      */

     MapConstIterator& operator++() { 

       ++it; 

       return *this; 

     }

     /** The post increment operator of the map.

      */

     MapConstIterator operator++(int) { 

       MapConstIterator<Map> tmp(it); 

       ++it; 

       return tmp; 

     }

     /** The equality operator of the map.

      */

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

       return p_it.it == it;

     }

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

      */

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

       return !(*this == p_it);

     }

     /** The equality operator of the map.

      */

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

       return p_it.it == it;

     }

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

      */

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

       return !(*this == p_it);

     }

   private:

     const Map* map;

     KeyIt it;

   };

 }

 #endif