#ifndef VECTOR_MAP_H

#define VECTOR_MAP_H

#include <vector>

namespace hugo {

  template <typename MapRegistry>

    class VectorMapFactory {

    public:

    typedef typename MapRegistry::Graph Graph;

    typedef typename MapRegistry::Key Key;

    typedef typename MapRegistry::KeyIt KeyIt;

    typedef typename MapRegistry::MapBase MapBase;

    template <typename V> 

      class Map : public MapBase {

      public:

      typedef V Value;

      typedef std::vector<Value> Container;

      Map() {}

      Map(Graph& g, MapRegistry& r) : MapBase(g, r) {

	init();

      }

      virtual ~Map() {

	destroy();

      }

      typename Container::reference operator[](const Key& key) {

	int id = graph->id(key);

	return container[id];

      } 

      typename Container::const_reference operator[](const Key& key) const {

	int id = graph->id(key);

	return container[id];

      }

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

	int id = graph->id(key);

	container[id] = val;

      }

      void add(const Key& key) {

	int id = graph->id(key);

	if (id >= container.size()) {

	  container.resize(id + 1);

	}

      }

      void erase(const Key& key) {}

      class const_iterator {

      private:

      };

      class iterator {

      public:

	iterator() {}

	std::pair<const Key&, Value&> operator*() {

	  return std::pair<const Key&, Value&>(static_cast<Key&>(it), map[it]);

	}

	iterator& operator++() { ++it; return *this; }

	iterator operator++(int) { iterator tmp(it); ++it; return tmp; }

      private:

	Map& map;

	KeyIt it;

      };

      private:

      typedef std::vector<Value> Container;

      Container container;

    };

  };

}

#endif