// -*- c++ -*-

 #ifndef MAP_ITERATOR_H

 #define MAP_ITERATOR_H

 #include <hugo/extended_pair.h>

 ///\ingroup graphmaps

 ///\file

 ///\brief Iterators on the maps.

 namespace hugo {

   /// \addtogroup graphmaps

   /// @{

   /** The base class all of the map iterators.

    *  The class defines the typedefs of the iterators,

    *  simple step functions and equality operators.

    */ 

   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;

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

   protected:

     KeyIt it;

     /// Default constructor.

     MapIteratorBase() {}

     /// KeyIt initialized MapIteratorBase constructor.

     MapIteratorBase(const KeyIt pit) : it(pit) {}

   public:

     /// Stepping forward in the map.   

     void increment() { 

       ++it; 

     }

     /// The equality operator of the map.

     bool operator==(const MapIteratorBase& pit) const {

       return pit.it == it;

     }

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

     bool operator!=(const MapIteratorBase& pit) const {

       return !(*this == pit);

     }

   };

   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 : public MapIteratorBase<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:

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

       : MapIteratorBase<Map>(pit), map(&pmap) {}

     /// Dereference operator for the iterator.

     PairReferenceType operator*() {

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

     }

     /// The pointer type of the iterator.

     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 the iterator.

     PairPointerType operator->() {

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

     }

     /// The pre increment operator of the iterator.

     MapIterator& operator++() { 

       increment(); 

       return *this; 

     }

     /// The post increment operator of the iterator.

     MapIterator operator++(int) { 

       MapIterator tmp(it); 

       increment(); 

       return tmp; 

     }

   private:

     Map* map;

   };

   /** 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 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:    

     /// Default constructor. 

     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) {}

     /// Constructor to create const iterator from a non const.

     MapConstIterator(const MapIterator<Map>& pit) {

       it = pit.it;

       map = pit.map;

     }

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

     }

     /// The pointer type of the iterator.

     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 the iterator.

     PairPointerType operator->() {

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

     }

     /// The pre increment operator of the iterator.

     MapConstIterator& operator++() { 

       increment(); 

       return *this; 

     }

     /// The post increment operator of the iterator.

     MapConstIterator operator++(int) { 

       MapConstIterator<Map> tmp(it); 

       increment(); 

       return tmp; 

     }

   private:

     const Map* map;

   };

   /** The class makes the KeyIt to an stl compatible iterator

    *  with dereferencing operator.

    */

   template <typename Map>

   class MapKeyIterator : public MapIteratorBase<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;

   public:

     /// Default constructor.

     MapKeyIterator() {}

     /// KeyIt initialized iterator.

     MapKeyIterator(const KeyIt& pit) : MapIteratorBase<Map>(pit) {}

     /// The pre increment operator of the iterator.

     MapKeyIterator& operator++() {

       increment(); 

       return *this; 

     }

     /// The post increment operator of the iterator.

     MapKeyIterator operator++(int) {

       MapKeyIterator tmp(*this);

       increment();

       return tmp;

     }

     /// The dereferencing operator of the iterator.

     KeyType operator*() const {

       return static_cast<KeyType>(it);

     }

   };

   template <typename Map> class MapConstValueIterator;

   template <typename Map>

   class MapValueIterator : public MapIteratorBase<Map> {

     friend class MapConstValueIterator<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;

   private:

     Map* map;

   public:

     /// Default constructor.

     MapValueIterator() {}

     /// Map and KeyIt initialized iterator.

     MapValueIterator(Map& pmap, const KeyIt& pit) 

       : MapIteratorBase<Map>(pit), map(&pmap) {}

     /// The pre increment operator of the iterator.

     MapValueIterator& operator++() {

       increment(); 

       return *this; 

     }

     /// The post increment operator of the iterator.

     MapValueIterator operator++(int) {

       MapValueIterator tmp(*this);

       increment();

       return tmp;

     }

     /// The dereferencing operator of the iterator.

     ReferenceType operator*() const {

       return (*map)[it];

     }

     /// The arrow operator of the iterator.

     PointerType operator->() const {

       return &(operator*());

     }

   };

   template <typename Map>

   class MapConstValueIterator : public MapIteratorBase<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;

   private:

     const Map* map;

   public:

     /// Default constructor.

     MapConstValueIterator() {}

     /// Constructor to create const iterator from a non const.

     MapConstValueIterator(const MapValueIterator<Map>& pit) {

       it = pit.it;

       map = pit.map;

     }

     /// Map and KeyIt initialized iterator.

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

       : MapIteratorBase<Map>(pit), map(&pmap) {}

     /// The pre increment operator of the iterator.

     MapConstValueIterator& operator++() {

       increment(); 

       return *this; 

     }

     /// The post increment operator of the iterator.

     MapConstValueIterator operator++(int) {

       MapConstValueIterator tmp(*this);

       increment();

       return tmp;

     }

     /// The dereferencing operator of the iterator.

     ConstReferenceType operator*() const {

       return (*map)[it];

     }

     /// The arrow operator of the iterator.

     ConstPointerType operator->() const {

       return &(operator*());

     }

   };

   /** This class makes from a map an iteratable set

    *  which contains all the keys of the map.

    */

   template <typename Map>

   class MapConstKeySet {

     const Map* 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 map initialized const key set.

     MapConstKeySet(const Map& pmap) : map(&pmap) {}

     /// The const iterator of the set.

     typedef MapKeyIterator<Map> ConstIterator;

     /// It gives back the const iterator pointed to the first element.

     ConstIterator begin() const {

       return ConstIterator(KeyIt(*map->getGraph()));

     }

     /// It gives back the const iterator pointed to the first ivalid element.

     ConstIterator end() const {

       return ConstIterator(KeyIt(INVALID));

     }

   };

   /** This class makes from a map an iteratable set

    *  which contains all the values of the map.

    *  The values cannot be modified.

    */

   template <typename Map>

   class MapConstValueSet {

     const Map* 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 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 element.

     ConstIterator begin() const {

       return ConstIterator(*map, KeyIt(*map->getGraph()));

     }

     /// It gives back the const iterator pointed to the first invalid element.

     ConstIterator end() const {

       return ConstIterator(*map, KeyIt(INVALID));

     }

   };

   /** This class makes from a map an iteratable set

    *  which contains all the values of the map.

    *  The values can be modified.

    */

   template <typename Map>

   class MapValueSet {

     Map* 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 map initialized value set.

     MapValueSet(Map& pmap) : map(&pmap) {}

     /// The const iterator of the set.

     typedef MapConstValueIterator<Map> ConstIterator;

     /// It gives back the const iterator pointed to the first element.

     ConstIterator begin() const {

       return ConstIterator(*map, KeyIt(*map->getGraph()));

     }

     /// It gives back the const iterator pointed to the first invalid element.

     ConstIterator end() const {

       return ConstIterator(*map, KeyIt(INVALID));

     }

     /// The iterator of the set.

     typedef MapValueIterator<Map> Iterator;

     /// It gives back the iterator pointed to the first element.

     Iterator begin() {

       return Iterator(*map, KeyIt(*map->getGraph()));

     }

     /// It gives back the iterator pointed to the first invalid element.

     Iterator end() {

       return Iterator(*map, KeyIt(INVALID));

     }

   };

   /// @}

 }

 #endif