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

  };

}