source: lemon-0.x/src/lemon/map_registry.h @ 943:cb0ac054ea92

/* -*- C++ -*-
 * src/lemon/map_registry.h - Part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Combinatorial Optimization Research Group, EGRES).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
 * express or implied, and with no claim as to its suitability for any
 * purpose.
 *
 */

#ifndef LEMON_MAP_REGISTRY_H
#define LEMON_MAP_REGISTRY_H

#include <vector>

///\ingroup graphmapfactory
///\file
///\brief Map registry for graph maps.

namespace lemon {

  /// \addtogroup graphmapfactory
  /// @{

  /// Map registry for graph maps.

  /** 
   * Registry class to register edge or node maps into the graph. The
   * registry helps you to implement an observer pattern. If you add
   * or erase an edge or node you must notify all the maps about the
   * event.
   *
   * \param G The graph type to register maps.
   * \param K The key type of the maps registered into the registry.
   * \param KIt The key iterator type iterates on the keys.
   *
   * \author Balazs Dezso
   */

  template <typename G, typename K, typename KIt>
  class MapRegistry {
  public:
    typedef G Graph;
    typedef K KeyType;
    typedef KIt KeyIt;

    /// MapBase is the base class of the dynamic maps.
        
    /**
     * MapBase is the base class of the dynamic maps.
     * It defines the core modification operations on the maps and
     * implements some helper functions. 
     */
    class MapBase {
    public:
      typedef G Graph;
      typedef K KeyType;
      typedef KIt KeyIt;

      typedef MapRegistry<G, K, KIt> Registry;
        
      friend class MapRegistry<G, K, KIt>;

      /// Default constructor.

      /**
       * Default constructor for MapBase.
       */

      MapBase() : graph(0), registry(0) {}

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

      /// Copy constructor.

      /** 
       * Copy constructor to register into the registry.
       * If the copiable map is registered into a registry
       * the construated map will be registered to the same registry.
      */        
        
      MapBase(const MapBase& copy) : graph(copy.graph), registry(0) {
        if (copy.registry) {
          copy.registry->attach(*this);
        }
      } 

      /// Assign operator.
        
      /** 
       * Assign operator. This member detach first the map
       * from the current registry and then it attach to the
       * copiable map's registry if it exists.
      */        
      const MapBase& operator=(const MapBase& copy) {
        if (registry) {
          registry->detach(*this);
        }
        graph = copy.graph;
        if (copy.registry) {
          copy.registry->attach(*this);
        }
        return *this;
      }
        
      /// Destructor

      /** 
       * This member detach the map from the its registry if the
       * registry exists.
      */                

      virtual ~MapBase() {
        if (registry) {
          registry->detach(*this);
        }
      }

      /// The graph of the map.

      /*
       * Returns the graph that the map belongs to.
      */

      const Graph* getGraph() const { return graph; }
        
    protected:
                
      const Graph* graph;     
      Registry* registry;

      int registry_index;

    protected:

      /// Helper function to implement constructors in the subclasses.
        
      /**
       * Helper function to implement constructors in the subclasses.
       * It adds all of the nodes or edges to the map via the 
       * \ref MapRegistry::MapBase::add add
       * member function.
      */
        
      virtual void init() {
        for (KeyIt it(*graph); it != INVALID; ++it) {
          add(it);
        }
      }
        

      /// Helper function to implement destructors in the subclasses.
        
      /**
       * Helper function to implement destructors in the subclasses.
       * It erases all of the nodes or edges of the map via the 
       * \ref MapRegistry::MapBase::erase erase
       * member function. It can be used by the clear function also.
      */
        
      virtual void destroy() {
        for (KeyIt it(*getGraph()); it != INVALID; ++it) {
          erase(it);
        }
      }

      /// The member function to add new node or edge to the map.
        
      /** 
          The add member function should be overloaded in the subclasses.
          \e Add extends the map with the new node or edge.
      */
        
      virtual void add(const KeyType&) = 0;     


      /// The member function to erase a node or edge from the map.

      /** 
          The erase member function should be overloaded in the subclasses.
          \e Erase removes the node or edge from the map.
      */
        
      virtual void erase(const KeyType&) = 0;

      /**
       *  The clear member function should be overloaded in the subclasses.
       *  \e Clear makes empty the data structure.
       */

      virtual void clear() = 0;

      /// Exception class to throw at unsupported operation.
        
      /**
       * Exception class to throw at unsupported operation.
       * If the map does not support erasing or adding new
       * node or key it must be throwed.
      */
        
      class NotSupportedOperationException {};

    };
        
  protected:
        

    typedef std::vector<MapBase*> Container; 

    Container container;

                
  public:

    /// Default constructor.
        
    /**
     * Default constructor of the \e MapRegistry. 
     * It creates an empty registry.
     */
    MapRegistry() {}

    /// Copy Constructor of the MapRegistry. 
        
    /**
     * Copy constructor of the \e MapRegistry. 
     * The new registry does not steal
     * the maps from the copiable registry. 
     * The new registry will be empty.
     */
    MapRegistry(const MapRegistry&) {}

    /// Assign operator.
                
    /**
     * Assign operator. This registry does not steal the maps 
     * from the copiable registry. This registry will be an empty registry.
     * This operator will be called when a graph is assigned.
     */
    MapRegistry& operator=(const MapRegistry&) {
      typename Container::iterator it;
      for (it = container.begin(); it != container.end(); ++it) {
        (*it)->clear();
        (*it)->graph = 0;
        (*it)->registry = 0;
      }
    }

    /// Destructor.
                                
    /**
     * Destructor of the MapRegistry. It makes empty the attached map
     * first then detachs them.
     */
    ~MapRegistry() {
      typename Container::iterator it;
      for (it = container.begin(); it != container.end(); ++it) {
        (*it)->clear();
        (*it)->registry = 0;
        (*it)->graph = 0;
      }
    }
        
        
    public:

    /// Attachs a map to the \e MapRegistry.
        
    /**
     * Attachs a map into thr registry. If the map has been attached
     * into an other registry it is detached from that automaticly.
     */
    void attach(MapBase& map) {
      if (map.registry) {
        map.registry->detach(map);
      }
      container.push_back(&map);
      map.registry = this;
      map.registry_index = container.size()-1;
    } 

    /// Detachs a map from the \e MapRegistry.
        
    /**
     * Detachs a map from the \e MapRegistry.
     */
    void detach(MapBase& map) {
      container.back()->registry_index = map.registry_index; 
      container[map.registry_index] = container.back();
      container.pop_back();
      map.registry = 0;
      map.graph = 0;
    }
        
    /// Notify all the registered maps about a Key added.
                
    /**
     * Notify all the registered maps about a Key added.
     * This member should be called whenever a node or edge
     * is added to the graph.
     */
    void add(const KeyType& key) {
      typename Container::iterator it;
      for (it = container.begin(); it != container.end(); ++it) {
        (*it)->add(key);
      }
    }   

    /// Notify all the registered maps about a Key erased.
                
    /**
     * Notify all the registered maps about a Key erased.
     * This member should be called whenever a node or edge
     * is erased from the graph.
     */ 
    void erase(const KeyType& key) {
      typename Container::iterator it;
      for (it = container.begin(); it != container.end(); ++it) {
        (*it)->erase(key);
      }
    }


    /// Notify all the registered maps about all the Keys are erased.

    /**
     * Notify all the registered maps about the map should be cleared.
     * This member should be called whenever all of the nodes or edges
     * are erased from the graph.
     */ 
    void clear() {
      typename Container::iterator it;
      for (it = container.begin(); it != container.end(); ++it) {
        (*it)->clear();
      }
    }
  };

  
/// @}
  

}

#endif