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