source: lemon-0.x/src/work/deba/mappedgraph.h @ 266:4cec4981dfd1

#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