/* -*- 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