#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