/* -*- C++ -*-
 * src/lemon/map_utils.h - Part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Combinatorial Optimization Research Group, 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.
 *
 */

///\ingroup mutils
///\file
///\brief Map utilities.

#include <map>


namespace lemon {

  /// \addtogroup gutils
  /// @{


  /// \brief General inversable map type.

  /// This type provides simple inversable map functions. 
  /// The InversableMap wraps an arbitrary ReadWriteMap 
  /// and if a key is setted to a new value then store it
  /// in the inverse map.
  template <
    typename _Graph, 
    typename _Map
  >
  class InversableMap : protected _Map {

  public:
    typedef _Graph Graph;

    typedef _Map Map;
    typedef typename _Map::Key Key;
    typedef typename _Map::Value Value;
    typedef std::map<Value, Key> InverseMap;
    
    typedef typename _Map::ConstReference ConstReference;

    /// \brief Constructor.
    ///
    /// Construct a new InversableMap for the graph.
    ///
    InversableMap(const Graph& graph) : Map(graph) {} 
    
    /// \brief The setter function of the map.
    ///
    /// It sets the map and the inverse map to given key-value pair.
    void set(const Key& key, const Value& val) {
      Value oldval = Map::operator[](key);
      typename InverseMap::iterator it = inv_map.find(oldval);
      if (it != inv_map.end() && it->second == key) {
	inv_map.erase(it);
      }      
      inv_map.insert(make_pair(val, key));
      Map::set(key, val);
    }

    ConstReference operator[](const Key&) const {
      return Map::operator[](key);
    }

    virtual void add(const Key&) {
      Map::add(key);
    }

    virtual void erase(const Key&) {
      Value val = Map::operator[](key);
      typename InverseMap::iterator it = inv_map.find(val);
      if (it != inv_map.end() && it->second == key) {
	invMap.erase(it);
      }
      Map::erase(key);
    }

    const InverseMap& inverse() const {
      return inv_map;
    } 


  private:
    InverseMap inv_map;    
  };


  
  /// \brief Provides a mutable, continous and unique descriptor for each 
  /// item in the graph.
  ///
  /// The DescriptorMap class provides a mutable, continous and immutable
  /// mapping for each item in the graph.
  ///
  /// \param _Graph The graph class the \c DescriptorMap belongs to.
  /// \param _Item The Item is the Key of the Map. It may be Node, Edge or 
  /// UndirEdge.
  /// \param _Map A ReadWriteMap mapping from the item type to integer.

  template <
    typename _Graph,   
    typename _Item,
    typename _Map
  >
  class DescriptorMap : protected _Map {

    typedef _Item Item;
    typedef _Map Map;

  public:
    /// The graph class of DescriptorMap.
    typedef _Graph Graph;

    /// The key type of DescriptorMap (Node, Edge, UndirEdge).
    typedef typename _Map::Key Key;
    /// The value type of DescriptorMap.
    typedef typename _Map::Value Value;

    typedef std::vector<Item> InverseMap;

    /// \brief Constructor.
    ///
    /// Constructor for creating descriptor map.
    DescriptorMap(const Graph& _graph) : Map(_graph) {
      build();
    }

    virtual void add(const Item& item) {
      Map::add(item);
      Map::set(item, inv_map.size());
      inv_map.push_back(item);
    }

    virtual void erase(const Item& item) {
      Map::set(inv_map.back(), Map::operator[](item));
      inv_map[Map::operator[](item)] = inv_map.back();
      Map::erase(item);
    }

    virtual void build() {
      Map::build();
      Item it;
      for (getGraph()->first(it); it != INVALID; getGraph()->next(it)) {
	Map::set(it, inv_map.size());
	inv_map.push_back(it);	
      }      
    }
    
    virtual void clear() {
      inv_map.clear();
      Map::clear();
    }

    /// \brief Gives back the \e descriptor of the item.
    ///
    /// Gives back the mutable and unique \e descriptor of the map.
    int operator[](const Item& item) const {
      return Map::operator[](item);
    }
    
    /// \brief Gives back the inverse of the map.
    ///
    /// Gives back the inverse of the map.
    const InverseMap inverse() const {
      return inv_map;
    }

  private:
    vector<Item> inv_map;
  };
  
  /// Provides an immutable and unique id for each item in the graph.

  /// The IdMap class provides an unique and immutable mapping for each item
  /// in the graph.
  ///
  template <typename _Graph, typename _Item>
  class IdMap {
  public:
    typedef _Graph Graph;
    typedef int Value;
    typedef _Item Item;

    /// \brief The class represents the inverse of the map.
    ///
    /// The class represents the inverse of the map.
    /// \see inverse()
    class InverseMap {
    protected:
      InverseMap(const Graph& _graph) : graph(_graph) {}
    public:
      /// \brief Gives back the given item by its id.
      ///
      /// Gives back the given item by its id.
      /// 
      Item operator[](int id) const { return graph->fromId(id, Item());}
    private:
      Graph* graph;
    };

    /// \brief Constructor.
    ///
    /// Constructor for creating id map.
    IdMap(const Graph& _graph) : graph(&_graph) {}

    /// \brief Gives back the \e id of the item.
    ///
    /// Gives back the immutable and unique \e id of the map.
    int operator[](const Item& item) const { return graph->id(item);}

    /// \brief Gives back the inverse of the map.
    ///
    /// Gives back the inverse of the map.
    InverseMap inverse() const { return InverseMap(*graph);} 

  private:
    const Graph* graph;

  };



}