#ifndef MAPPEDGRAPH_H
#define MAPPEDGRAPH_H

#include <vector>

template <typename GB, typename K>
class MapBase;

template <typename GB>
class MappedGraph : public GB {
public:
	typedef GB GraphBase;
	
	typedef MapBase<GB, typename GB::Edge> EdgeMapBase;
	typedef MapBase<GB, typename GB::Node> NodeMapBase;

protected:
	typedef std::vector<EdgeMapBase*> EdgeMaps; 
	typedef std::vector<NodeMapBase*> NodeMaps;
	
	EdgeMaps edge_maps;
	NodeMaps node_maps;
	
	void add(EdgeMapBase& map_base) {
		if (map_base.graph) {
			map_base.graph->erase(map_base);
		}
		edge_maps.push_back(&map_base);
		map_base.graph_index = map_base.size()-1;
	} 
	
	void erase(EdgeMapBase& map_base) {
		if (map_base.graph != this) return;
		edge_maps.back()->graph_index = map_base.graph_index; 
		edge_maps[map_base.graph_index] = edge_maps.back();
		edge_maps.pop_back();
		map_base.graph = 0;
	}
	
	void addEdge(typename GB::Edge& edge) {
		typename EdgeMaps::iterator it;
		for (it = edge_maps.begin(); it != edge_maps.end(); ++it) {
			(*it)->add(edge);
		}
	}
	
	void eraseEdge(typename GB::Edge& edge) {
		typename EdgeMaps::iterator it;
		for (it = edge_maps.begin(); it != edge_maps.end(); ++it) {
			(*it)->erase(edge);
		}
	}

	void add(NodeMapBase& map_base) {
		if (map_base.graph) {
			map_base.graph->erase(map_base);
		}
		node_maps.push_back(&map_base);
		map_base.graph_index = node_maps.size()-1;
	} 
	
	void erase(NodeMapBase& map_base) {
		if (map_base.graph != this) return;
		node_maps.back()->graph_index = map_base.graph_index; 
		node_maps[map_base.graph_index] = node_maps.back();
		node_maps.pop_back();
		map_base.graph = 0;
	}

	void addNode(typename GB::Node& node) {
		typename NodeMaps::iterator it;
		for (it = node_maps.begin(); it != node_maps.end(); ++it) {
			(*it)->add(node);
		}
	}
	
	void eraseNode(typename GB::Node& node) {
		typename NodeMaps::iterator it;
		for (it = node_maps.begin(); it != node_maps.end(); ++it) {
			(*it)->erase(node);
		}
	}
	
	friend class EdgeMapBase;
	friend class NodeMapBase;
};

#endif