#pragma once

#ifndef TCG_OBSERVER_NOTIFIER_H

#define TCG_OBSERVER_NOTIFIER_H

// tcg includes

#include "base.h"

// STD includes

#include <set></set>

/*!

  \file     tcg_observer_notifier.h

  \brief    This file contains the barebone of an elementary, classical

            implementation of the Observer pattern requiring derivation.

  \details  This is intended as a convenient and lightweight predefined

            implementation when hardwiring the Observer pattern in a

            known class using derivation.

            Observe that this implementation does not deal with the

            actual notifications forwarding - it just manages the

            set of observers/notifiers in a notifier/observer instance.

            No multithreading is taken into consideration.

  \remark   See elsewhere for more advanced implementations.

*/

namespace tcg {

//************************************************************************

//    Observer/notifier  base polymorphic classes

//************************************************************************

class observer_base;

class notifier_base;

//------------------------------------------------------------

class observer_base {

public:

  virtual ~observer_base() {}

  virtual void attach(notifier_base *notifier) = 0;  //!< Adds the specified

  //! notifier to the internal

  //! set of notifiers.

  virtual void detach(notifier_base *notifier) = 0;  //!< Removes the specified

                                                     //! notifier from the

  //! internal set of

  //! notifiers.

};

//------------------------------------------------------------

class notifier_base {

public:

  virtual ~notifier_base() {}

  virtual void attach(observer_base *observer) = 0;  //!< Adds the specified

  //! observer to the internal

  //! set of observers.

  virtual void detach(observer_base *observer) = 0;  //!< Removes the specified

                                                     //! observer from the

  //! internal set of

  //! observers.

};

//************************************************************************

//    Observer/notifier  with a single interacting object

//************************************************************************

template <typename base="observer_base" notifier="notifier_base," typename=""></typename>

class observer_single : public noncopyable<base> {

  Notifier *m_notifier;  // Not owned

public:

  typedef Notifier notifier_type;

public:

  observer_single() : m_notifier() {}

  ~observer_single() {

    if (m_notifier)

      static_cast<notifier_base *="">(m_notifier)</notifier_base>

          ->detach(

              this);  // The detaching function is most probably \a private in

  }                   // reimplemented notifier classes (like in this observer).

                      // Besides, it would be a virtual function call anyway.

  notifier_type *notifier() const { return m_notifier; }

private:

  void attach(notifier_base *notifier) {

    assert(notifier && !m_notifier);

    m_notifier = static_cast<notifier *="">(notifier);</notifier>

  }

  void detach(notifier_base *notifier) {

    assert(m_notifier && m_notifier == static_cast<notifier *="">(notifier));</notifier>

    m_notifier = 0;

  }

};

//------------------------------------------------------------

template <typename base="notifier_base" observer="observer_base," typename=""></typename>

class notifier_single : public noncopyable<base> {

  Observer *m_observer;  // Not owned

public:

  typedef Observer observer_type;

public:

  notifier_single() : m_observer() {}

  ~notifier_single() {

    if (m_observer) static_cast<observer_base *="">(m_observer)->detach(this);</observer_base>

  }

  observer_type *observer() const { return m_observer; }

  void addObserver(observer_type *observer) {

    notifier_single::attach(

        observer);  // No reason to go polymorphic here - it's this very class.

    static_cast<observer_base *="">(observer)->attach(</observer_base>

        this);  // However, here it's necessary - like above, downcast to

  }             // the very base.

  void removeObserver(observer_type *observer) {

    static_cast<observer_base *="">(observer)->detach(this);</observer_base>

    notifier_single::detach(observer);

  }

private:

  void attach(observer_base *observer) {

    assert(observer && !m_observer);

    m_observer = static_cast<observer *="">(observer);</observer>

  }

  void detach(observer_base *observer) {

    assert(m_observer && m_observer == static_cast<observer *="">(observer));</observer>

    m_observer = 0;

  }

};

//************************************************************************

//    Observer/notifier  with multiple interacting objects

//************************************************************************

template 

          typename Set = std::set<notifier *="">></notifier>

class observer : public noncopyable<base> {

  Set m_notifiers;  // Not owned

public:

  typedef Notifier notifier_type;

  typedef Set notifiers_container;

public:

  ~observer() {

    typename Set::iterator nt, nEnd = m_notifiers.end();

    for (nt = m_notifiers.begin(); nt != nEnd; ++nt)

      static_cast<notifier_base *="">(*nt)->detach(this);</notifier_base>

  }

  const notifiers_container ¬ifiers() const { return m_notifiers; }

private:

  void attach(notifier_base *notifier) {

    assert(notifier);

    m_notifiers.insert(static_cast<notifier *="">(notifier));</notifier>

  }

  void detach(notifier_base *notifier) {

    assert(!m_notifiers.empty());

    m_notifiers.erase(static_cast<notifier *="">(notifier));</notifier>

  }

};

//------------------------------------------------------------

template 

          typename Set = std::set<observer *="">></observer>

class notifier : public noncopyable<base> {

  Set m_observers;  // Not owned

public:

  typedef Observer observer_type;

  typedef Set observers_container;

public:

  ~notifier() {

    typename Set::iterator ot, oEnd = m_observers.end();

    for (ot = m_observers.begin(); ot != oEnd; ++ot)

      static_cast<observer_base *="">(*ot)->detach(this);</observer_base>

  }

  const observers_container &observers() const { return m_observers; }

  void addObserver(observer_type *observer) {

    notifier::attach(observer);

    static_cast<observer_base *="">(observer)->attach(this);</observer_base>

  }

  void removeObserver(observer_type *observer) {

    static_cast<observer_base *="">(observer)->detach(this);</observer_base>

    notifier::detach(observer);

  }

private:

  void attach(observer_base *observer) {

    assert(observer);

    m_observers.insert(static_cast<observer *="">(observer));</observer>

  }

  void detach(observer_base *observer) {

    assert(!m_observers.empty());

    m_observers.erase(static_cast<observer *="">(observer));</observer>

  }

};

}  // namespace tcg

#endif  // TCG_OBSERVER_NOTIFIER_H