/* -*- C++ -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2003-2006

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, 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_ALTERATION_NOTIFIER_H

#define LEMON_ALTERATION_NOTIFIER_H

#include <vector>

#include <algorithm>

///\ingroup graphmapfactory

///\file

///\brief Observer registry for graph alteration observers.

namespace lemon {

  /// \addtogroup graphmapfactory

  /// @{

  /// \brief Registry class to register objects observes alterations in 

  /// the graph.

  ///

  /// This class is a registry for the objects which observe the

  /// alterations in a container. The alteration observers can be attached

  /// to and detached from the registry. The observers have to inherit

  /// from the \ref AlterationNotifier::ObserverBase and override

  /// the virtual functions in that.

  ///

  /// The most important application of the alteration observing is the

  /// dynamic map implementation.

  ///

  /// \param _Item The item type what the observers are observing, usually

  /// edge or node.

  ///

  /// \author Balazs Dezso

  template <typename _Item>

  class AlterationNotifier {

  public:

    typedef True Notifier;

    typedef _Item Item;

    /// ObserverBase is the base class for the observers.

    /// ObserverBase is the abstract base class for the observers.

    /// It will be notified about an item was inserted into or

    /// erased from the graph.

    ///

    /// The observer interface contains some pure virtual functions

    /// to override. The add() and erase() functions are

    /// to notify the oberver when one item is added or

    /// erased.

    ///

    /// The build() and clear() members are to notify the observer

    /// about the container is built from an empty container or

    /// is cleared to an empty container. 

    /// 

    /// \author Balazs Dezso

    class ObserverBase {

    protected:

      typedef AlterationNotifier Registry;

      friend class AlterationNotifier;

      /// \brief Default constructor.

      ///

      /// Default constructor for ObserverBase.

      /// 

      ObserverBase() : registry(0) {}

      ObserverBase(const ObserverBase& copy) {

	if (copy.attached()) {

	  copy.getRegistry()->attach(*this);

	}

      }

      virtual ~ObserverBase() {}

      /// \brief Attaches the observer into an AlterationNotifier.

      ///

      /// This member attaches the observer into an AlterationNotifier.

      ///

      void attach(AlterationNotifier& r) {

	registry = &r;

	registry->attach(*this);

      }

      /// \brief Detaches the observer into an AlterationNotifier.

      ///

      /// This member detaches the observer from an AlterationNotifier.

      ///

      void detach() {

	if (registry) {

	  registry->detach(*this);

	}

      }

      /// Gives back a pointer to the registry what the map attached into.

      /// This function gives back a pointer to the registry what the map

      /// attached into.

      ///

      Registry* getRegistry() const { return const_cast<Registry*>(registry); }

      /// Gives back true when the observer is attached into a registry.

      bool attached() const { return registry != 0; }

    private:

      ObserverBase& operator=(const ObserverBase& copy);

    protected:

      Registry* registry;

      int registry_index;

      /// \brief The member function to notificate the observer about an

      /// item is added to the container.

      ///

      /// The add() member function notificates the observer about an item

      /// is added to the container. It have to be overrided in the

      /// subclasses.

      virtual void add(const Item&) = 0;

      /// \brief The member function to notificate the observer about 

      /// more item is added to the container.

      ///

      /// The add() member function notificates the observer about more item

      /// is added to the container. It have to be overrided in the

      /// subclasses.

      virtual void add(const std::vector<Item>& items) {

	for (int i = 0; i < (int)items.size(); ++i) {

	  add(items[i]);

	}

      }

      /// \brief The member function to notificate the observer about an

      /// item is erased from the container.

      ///

      /// The erase() member function notificates the observer about an

      /// item is erased from the container. It have to be overrided in

      /// the subclasses.

      virtual void erase(const Item&) = 0;

      /// \brief The member function to notificate the observer about 

      /// more item is erased from the container.

      ///

      /// The erase() member function notificates the observer about more item

      /// is erased from the container. It have to be overrided in the

      /// subclasses.

      virtual void erase(const std::vector<Item>& items) {

	for (int i = 0; i < (int)items.size(); ++i) {

	  erase(items[i]);

	}

      }

      /// \brief The member function to notificate the observer about the

      /// container is built.

      ///

      /// The build() member function notificates the observer about the

      /// container is built from an empty container. It have to be

      /// overrided in the subclasses.

      virtual void build() = 0;

      /// \brief The member function to notificate the observer about all

      /// items are erased from the container.

      ///

      /// The clear() member function notificates the observer about all

      /// items are erased from the container. It have to be overrided in

      /// the subclasses.

      virtual void clear() = 0;

    };

  protected:

    typedef std::vector<ObserverBase*> Container; 

    Container container;

  public:

    /// Default constructor.

    ///

    /// The default constructor of the AlterationNotifier. 

    /// It creates an empty registry.

    AlterationNotifier() {}

    /// Copy Constructor of the AlterationNotifier. 

    /// Copy constructor of the AlterationNotifier. 

    /// It creates only an empty registry because the copiable

    /// registry's observers have to be registered still into that registry.

    AlterationNotifier(const AlterationNotifier&) {}

    /// Assign operator.

    /// Assign operator for the AlterationNotifier. 

    /// It makes the notifier only empty because the copiable

    /// notifier's observers have to be registered still into that registry.

    AlterationNotifier& operator=(const AlterationNotifier&) {

      typename Container::iterator it;

      for (it = container.begin(); it != container.end(); ++it) {

	(*it)->registry = 0;

      }

    }

    /// Destructor.

    /// Destructor of the AlterationNotifier.

    ///

    ~AlterationNotifier() {

      typename Container::iterator it;

      for (it = container.begin(); it != container.end(); ++it) {

	(*it)->registry = 0;

      }

    }

  protected:

    void attach(ObserverBase& observer) {

      container.push_back(&observer);

      observer.registry = this;

      observer.registry_index = container.size()-1;

    } 

    void detach(ObserverBase& base) {

      container.back()->registry_index = base.registry_index; 

      container[base.registry_index] = container.back();

      container.pop_back();

      base.registry = 0;

    }

  public:

    /// \brief Notifies all the registered observers about an Item added to 

    /// the container.

    ///

    /// It notifies all the registered observers about an Item added to 

    /// the container.

    /// 

    void add(const Item& item) {

      typename Container::iterator it;

      try {

        for (it = container.begin(); it != container.end(); ++it) {

          (*it)->add(item);

        }

      } catch (...) {

        typename Container::iterator jt;

        for (jt = container.begin(); jt != it; ++it) {

          (*it)->erase(item);

        }

        throw;

      }

    }	

    /// \brief Notifies all the registered observers about more Item added to 

    /// the container.

    ///

    /// It notifies all the registered observers about more Item added to 

    /// the container.

    /// 

    void add(const std::vector<Item>& items) {

      typename Container::iterator it;

      try {

        for (it = container.begin(); it != container.end(); ++it) {

          (*it)->add(items);

        }

      } catch (...) {

        typename Container::iterator jt;

        for (jt = container.begin(); jt != it; ++it) {

          (*it)->erase(items);

        }

        throw;

      }

    }	

    /// \brief Notifies all the registered observers about an Item erased from 

    /// the container.

    ///	

    /// It notifies all the registered observers about an Item erased from 

    /// the container.

    /// 

    void erase(const Item& key) {

      typename Container::iterator it;

      for (it = container.begin(); it != container.end(); ++it) {

	(*it)->erase(key);

      }

    }

    /// \brief Notifies all the registered observers about more Item erased  

    /// from the container.

    ///	

    /// It notifies all the registered observers about more Item erased from 

    /// the container.

    /// 

    void erase(const std::vector<Item>& items) {

      typename Container::iterator it;

      for (it = container.begin(); it != container.end(); ++it) {

	(*it)->erase(items);

      }

    }

    /// \brief Notifies all the registered observers about the container is 

    /// built.

    ///		

    /// Notifies all the registered observers about the container is built

    /// from an empty container.

    void build() {

      typename Container::iterator it;

      try {

        for (it = container.begin(); it != container.end(); ++it) {

          (*it)->build();

        }

      } catch (...) {

        typename Container::iterator jt;

        for (jt = container.begin(); jt != it; ++it) {

          (*it)->clear();

        }

        throw;

      }

    }

    /// \brief Notifies all the registered observers about all Items are 

    /// erased.

    ///

    /// Notifies all the registered observers about all Items are erased

    /// from the container.

    void clear() {

      typename Container::iterator it;

      for (it = container.begin(); it != container.end(); ++it) {

	(*it)->clear();

      }

    }

  };

/// @}

}

#endif