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