source: lemon-0.x/src/work/deba/map_base.h @ 591:eb532eef6170

#ifndef MAP_BASE_H
#define MAP_BASE_H

/**
        Template base class for implementing mapping on nodes.
        \param The first template parameter is the Graph class. The Graph
                must have an \emp node_maps member with \emp MapRegistry class.
        \param The second template parameter is the  type of the class.
        
*/


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

#include "map_registry.h"

namespace hugo {

        template <typename G, typename K, typename KIt>
        class MapBase {
        public:
                typedef G Graph;
                typedef MapRegistry<G, K, KIt> Registry;
                typedef K KeyType;
                typedef KIt KeyIt;
        
                friend class Registry;
                
                /** 
                        Default constructor.
                */      
                
                MapBase() : registry(0) {}

                /** 
                        Simple constructor to register into a graph registry.
                */
        
                MapBase(Graph& g, Registry& r) : graph(&g), registry(0) {
                        registry->attach(*this);
                }

                /** 
                        Copy constructor with registering into the map.
                */      
        
                MapBase(const MapBase& copy) : registry(0), graph(copy.graph) {
                        if (copy.registry) {
                                copy.registry->attach(*this);
                        }
                } 
        
                /** 
                        Assign operator.
                */      

                const MapBase& operator=(const MapBase& copy) {
                        if (registry) {
                                registry->detach(*this);
                        }
                        graph = copy.graph;
                        if (copy.registry) {
                                copy.registry->attach(*this);
                        }
                }
        

                /** 
                        Destructor.
                */              

                virtual ~MapBase() {
                        if (registry) {
                                registry->detach(*this);
                        }
                }
        
        protected:
                
                Registry* registry;
                Graph* graph;

                int registry_index;
        
                /**
                        Helper function to implement the default constructor in the subclasses.
                */
        
                virtual void init() {

                        for (KeyIt it(*graph); graph->valid(it); graph->next(it)) {
                                add(it);
                        }
                }
        
                /**
                        Helper function to implement the destructor in the subclasses.
                */
        
                virtual void destroy() {
                        for (KeyIt it(*graph); graph->valid(it); graph->next(it)) {
                                erase(it);
                        }
                }
        
                /** 
                        The add member function should be overloaded in the subclasses.
                        \e Add extends the map with the new node.
                */
        
                virtual void add(const KeyType&) = 0;
        
                /** 
                        The erase member function should be overloaded in the subclasses.
                        \e Erase removes the node from the map.
                */
        
                virtual void erase(const KeyType&) = 0;
        
                /**
                        Exception class to throw at unsupported operation.
                */
        
                class NotSupportedOperationException {};

        };
        
}

#endif