#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