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

///\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, 

    template <typename, typename> class _InvMap = std::Map

  >

  class InversableMap : protected _Map {

  public:

    typename _Map Map;

    typename _InvMap<Map::Value, Map::Key> InverseMap;

    typename _Map::Key Key;

    typename _Map::Value Value;

    typename _Map::ConstReference ConstReference;

    /// Constructor.

    /// Construct a new InversableMap for the graph.

    ///

    InversableMap(const Graph& graph) : Map(graph) {} 

    /// The setter function of the map.

    /// It sets the map and the inverse map 

    void set(const Key& key, const Value& val) {

      Value oldval = Map::operator[](key);

      InverseMap::iterator it = invMap.find(oldval);

      if (it != invMap.end() && it->second == key) {

	invMap.erase(it);

      }      

      invMap.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);

      InverseMap::iterator it = invMap.find(val);

      if (it != invMap.end() && it->second == key) {

	invMap.erase(it);

      }

      Map::erase(key);

    }

    const InverseMap& inverse() const {

      return invMap;

    } 

  private:

    InverseMap invMap;    

  };

}