#ifndef MAP_REGISTRY_H
#define MAP_REGISTRY_H

#include <vector>


namespace hugo {
	template <typename G, typename K, typename KIt>
	class MapRegistry;
}

#include "map_base.h"

namespace hugo {

	template <typename G, typename K, typename KIt>
	class MapRegistry {
	public:
		typedef G Graph;
		typedef K Key;
		typedef KIt KeyIt;
	
		typedef MapBase<Graph, Key, KIt> Map;
		friend class Base;
	
	protected:
	
		typedef std::vector<Map*> Container; 
	  Container container;

		Graph* graph;		
		
		
	public:
	
		MapRegistry(Graph& g) : container(0), graph(&g) {}
				
		~MapRegistry() {
			typename Container::iterator it;
			for (it = container.begin(); it != container.end(); ++it) {
				(*it)->destroy(*graph);
				(*it)->registry = 0;
			}
		}
	
	private:
		MapRegistry(const MapRegistry& ) {}
		MapRegistry& operator=(const MapRegistry& ) {}
	
	public:
	
		void add(Map& map) {
			if (map.registry) {
				map.registry->erase(map);
			}
			container.push_back(&map);
			map.registry = this;
			map.registry_index = container.size()-1;
			map.init(*graph);
		} 
	
		void erase(Map& map_base) {
			map_base.destroy(*graph);
			container.back()->registry_index = map_base.registry_index; 
			container[map_base.registry_index] = container.back();
			container.pop_back();
			map_base.registry = 0;
		}
	
		
		void add(Key& key) {
			typename Container::iterator it;
			for (it = container.begin(); it != container.end(); ++it) {
				(*it)->add(key);
			}
		}	
		
		void erase(Key& key) {
			typename Container::iterator it;
			for (it = container.begin(); it != container.end(); ++it) {
				(*it)->erase(key);
			}
		}

		Graph& getGraph() {
			return *graph;
		}


	};

}

#endif