/* -*- C++ -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2003-2006
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
 * express or implied, and with no claim as to its suitability for any
 * purpose.
 *
 */

#ifndef LEMON_BITS_MAP_EXTENDER_H
#define LEMON_BITS_MAP_EXTENDER_H

#include <iterator>

#include <lemon/bits/traits.h>

///\file
///\brief Extenders for iterable maps.

namespace lemon {

  /// \ingroup graphbits
  /// 
  /// \brief Extender for maps
  template <typename _Map>
  class MapExtender : public _Map {
  public:

    typedef _Map Parent;
    typedef MapExtender Map;


    typedef typename Parent::Graph Graph;
    typedef typename Parent::Key Item;

    typedef typename Parent::Key Key;
    typedef typename Parent::Value Value;

    class MapIt;
    class ConstMapIt;

    friend class MapIt;
    friend class ConstMapIt;

  public:

    MapExtender(const Graph& graph) 
      : Parent(graph) {}

    MapExtender(const Graph& graph, const Value& value) 
      : Parent(graph, value) {}


    class MapIt : public Item {
    public:
      
      typedef Item Parent;
      typedef typename Map::Value Value;
      
      MapIt() {}

      MapIt(Invalid i) : Parent(i) { }

      explicit MapIt(Map& _map) : map(_map) {
        map.getNotifier()->first(*this);
      }

      MapIt(const Map& _map, const Item& item) 
	: Parent(item), map(_map) {}

      MapIt& operator++() { 
	map.getNotifier()->next(*this);
	return *this; 
      }
      
      typename MapTraits<Map>::ConstReturnValue operator*() const {
	return map[*this];
      }

      typename MapTraits<Map>::ReturnValue operator*() {
	return map[*this];
      }
      
      void set(const Value& value) {
	map.set(*this, value);
      }
      
    protected:
      Map& map;
      
    };

    class ConstMapIt : public Item {
    public:

      typedef Item Parent;

      typedef typename Map::Value Value;
      
      ConstMapIt() {}

      ConstMapIt(Invalid i) : Parent(i) { }

      explicit ConstMapIt(Map& _map) : map(_map) {
        map.getNotifier()->first(*this);
      }

      ConstMapIt(const Map& _map, const Item& item) 
	: Parent(item), map(_map) {}

      ConstMapIt& operator++() { 
	map.getNotifier()->next(*this);
	return *this; 
      }

      typename MapTraits<Map>::ConstReturnValue operator*() const {
	return map[*this];
      }

    protected:
      const Map& map;
    };

    class ItemIt : Item {
    public:
      
      typedef Item Parent;
      
      ItemIt() {}

      ItemIt(Invalid i) : Parent(i) { }

      explicit ItemIt(Map& _map) : map(_map) {
        map->getNotifier()->first(*this);
      }

      ItemIt(const Map& _map, const Item& item) 
	: Parent(item), map(_map) {}

      ItemIt& operator++() { 
	map.getNotifier()->next(*this);
	return *this; 
      }

    protected:
      const Map& map;
      
    };
  };

}

#endif