// -*- c++ -*-

#ifndef SYM_MAP_H

#define SYM_MAP_H

///\ingroup graphmaps

///\file

///\brief Graph maps that construates and destruates

///their elements dynamically.

namespace hugo {

/// \addtogroup graphmaps

/// @{

  /** The SymEdgeIt is wrapper class for the EdgeIt. It can be used to

   *  iterate on the symmetric maps when all of the edge - reverse edge pair

   *  has different parity.

   */

  template <typename Graph, typename Edge, typename EdgeIt>

  class SymEdgeIt : public EdgeIt {

  public:

    /** Default constructor.

     */

    SymEdgeIt() 

      : EdgeIt() {}

    /** Graph initialized constructor.

     */

    SymEdgeIt(const Graph& graph) 

      : EdgeIt(graph) {

      while ( (n & 1) && n != -1) {

	EdgeIt::operator++();

      }

    }

    /** Creating invelid SymEdgeIt.

     */

    SymEdgeIt(Invalid invalid) 

      : EdgeIt(invalid) {}

    /** SymEdgeIt from the given Edge.

     */

    SymEdgeIt(const Graph& graph, const Edge& edge)

      : EdgeIt(graph, edge) {

      while ( (n & 1) && n != -1) {

	EdgeIt::operator++();

      }

    }

    /** Increase operator.

     */

    SymEdgeIt& operator++() {

      EdgeIt::operator++();

      while ( (n & 1) && n != -1) {

	EdgeIt::operator++();

      }

      return *this;

    }

  };

  /** The SymMap template class is graph map structure what

   *  wraps an other map structure to use as symmetric map structure.

   *

   *  The template parameter is the MapRegistry that the maps

   *  will belong to and the ValueType.

   */

  template <template <typename, typename> class DynMap, 

	    typename MapRegistry, typename Value>

  class SymMap : public DynMap<MapRegistry, Value>{

  private:

    typedef DynMap<MapRegistry, Value> MapImpl;

  public:

    /// The graph type of the maps. 

    typedef typename MapRegistry::Graph Graph;

    typedef typename MapImpl::KeyType KeyType;

  public:

    /** Default constructor for the map.

     */

    SymMap() : MapImpl() {}

    /** Graph and Registry initialized map constructor.

     */

    SymMap(const Graph& g, MapRegistry& r) : MapImpl(g, r) {}

    /** Constructor to use default value to initialize the map. 

     */

    SymMap(const Graph& g, MapRegistry& r, const Value& v) 

      : MapImpl(g, r, v) {}

    /** Constructor to copy a map of the same map type.

     */

    SymMap(const SymMap& copy) 

      : MapImpl(static_cast<const MapImpl&>(copy)) {}

    /** Constructor to copy a map of an other map type.

     */

    template <typename CMap> SymMap(const CMap& copy) 

      : MapImpl(copy) {}

    /** Assign operator to copy a map of the same map type.

     */

    SymMap& operator=(const SymMap& copy) {

      MapImpl::operator=(static_cast<const MapImpl&>(copy));

      return *this;

    }

    /** Assign operator to copy a map of an other map type.

     */

    template <typename CMap> SymMap& operator=(const CMap& copy) {

      MapImpl::operator=(copy);

      return *this;

    }

    /**

     * The subscript operator. The map can be subscripted by the

     * actual keys of the graph. 

     */

    typename MapImpl::ReferenceType operator[](const KeyType& key) {

      int id = MapImpl::getGraph()->id(key);	

      return MapImpl::operator[](id >> 1);

    } 

    /**

     * The const subscript operator. The map can be subscripted by the

     * actual keys of the graph. 

     */

    typename MapImpl::ConstReferenceType operator[](const KeyType& key) const {

      int id = MapImpl::getGraph()->id(key);

      return MapImpl::operator[](id >> 1);

    }

    /** Setter function of the map. Equivalent with map[key] = val.

     *  This is a compatibility feature with the not dereferable maps.

     */

    void set(const KeyType& key, const typename MapImpl::ValueType& val) {

      int id = MapImpl::getGraph()->id(key);

      MapImpl::operator[](id >> 1) = val;

    }

    /** Add a new key to the map. It called by the map registry.

     */

    void add(const KeyType& key) {

      int id = MapImpl::getGraph()->id(key);

      if (id & 1) return;

      MapImpl::add(key);

    }

    /** Erase a key from the map. It called by the map registry.

     */

    void erase(const KeyType& key) {

      int id = MapImpl::getGraph()->id(key);

      if (id & 1) return;

      MapImpl::add(key);

    }

  };

  /// @}

}

#endif