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