// -*- c++ -*-

#ifndef SYM_MAP_FACTORY_H

#define SYM_MAP_FACTORY_H

namespace hugo {

  template <typename Graph, typename Edge, typename EdgeIt>

  class SymEdgeIt : public EdgeIt {

  public:

    SymEdgeIt() 

      : EdgeIt() {}

    SymEdgeIt(const Graph& graph) 

      : EdgeIt(graph) {

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

	EdgeIt::operator++();

      }

    }

    SymEdgeIt(Invalid invalid) 

      : EdgeIt(invalid) {}

    SymEdgeIt(const Graph& graph, Edge edge)

      : EdgeIt(graph, edge) {}

    SymEdgeIt& operator++() {

      EdgeIt::operator++();

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

	EdgeIt::operator++();

      }

      return *this;

    }

  };

  template <typename MapRegistry, template <typename> class MapFactory>

  class SymMapFactory {

  public:

    typedef typename MapRegistry::Graph Graph;

    typedef typename MapRegistry::KeyType KeyType;

    typedef typename MapRegistry::KeyIt KeyIt;

    typedef typename MapRegistry::MapBase MapBase;

    template <typename V>

    class Map : public MapFactory<MapRegistry>::template Map<V> {

      typedef typename MapFactory<MapRegistry>::template Map<V> MapImpl;

    public:

      typedef V Value;

      Map() : MapImpl() {}

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

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

	: MapImpl(g, r, v) {}

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

      template <typename CMap> Map(const CMap& copy) : MapImpl(copy) {}

      Map& operator=(const Map& copy) {

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

	return *this;

      }

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

	MapImpl::operator=(copy);

	return *this;

      }

      Value& operator[](const KeyType& key) {

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

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

      } 

      const Value& operator[](const KeyType& key) const {

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

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

      }

      const Value& get(const KeyType& key) const {

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

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

      } 

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

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

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

      }

      void add(const KeyType& key) {

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

	if (id & 1) return;

	MapImpl::add(key);

      }

      void erase(const KeyType& key) {

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

	if (id & 1) return;

	MapImpl::add(key);

      }

    };  

  };

}

#endif