Observer.hpp

#pragma once

#include <list>
#include <utility>

#include <amdis/Output.hpp>
#include <amdis/common/ConceptsBase.hpp>
#include <amdis/common/Index.hpp>
#include <amdis/common/TypeTraits.hpp>

namespace AMDiS
{
  namespace event
  {
    struct preAdapt { bool value = true; };

    struct adapt { bool value = true; };

    struct postAdapt {};
  }


  template <class Event>
  class ObserverInterface
  {
  public:
    virtual ~ObserverInterface() = default;
    virtual void update(Event e) = 0;
    virtual void unset() = 0;
  };



  template <class Event, class... Events>
  class Notifier
      : public Notifier<Event>
      , public Notifier<Events...>
  {
  public:
    using Notifier<Event>::notify;
    using Notifier<Events...>::notify;
  };

  template <class Event>
  class Notifier<Event>
  {
  public:
    virtual ~Notifier()
    {
      // Remove remaining pointers to this to avoid segfaults
      for (ObserverInterface<Event>* o : observers_)
        o->unset();
    }

    void notify(Event const& e)
    {
      for (ObserverInterface<Event>* o : observers_)
        o->update(e);
    }

    void attach(ObserverInterface<Event>* o)
    {
      // insert only if not yet in the list
      if (std::find(observers_.begin(), observers_.end(), o) == observers_.end())
        observers_.push_back(o);
    }

    void detach(ObserverInterface<Event>* o)
    {
      observers_.remove(o);
    }

  private:
    std::list<ObserverInterface<Event>*> observers_;
  };


  template <class Event, class... Tags>
  class Observer
      : public ObserverInterface<Event>
  {
  public:
    template <class N,
      REQUIRES(std::is_base_of_v<Notifier<Event>,N>)>
    Observer(N const& notifier)
      : notifier_(const_cast<N*>(&notifier))
    {
      notifier_->attach(this);
    }

    template <class N,
      REQUIRES(not std::is_base_of_v<Notifier<Event>,N>)>
    Observer(N const& notifier)
    {
      warning("Ignoring Notifier. Use AdaptiveGrid wrapper.");
    }


    virtual ~Observer()
    {
      if (notifier_)
        notifier_->detach(this);
    }

    Observer(Observer const& other)
      : notifier_(other.notifier_)
    {
      notifier_->attach(this);
    }

    Observer& operator=(Observer const& other)
    {
      if (&other != this) {
        notifier_->detach(this);
        notifier_ = other.notifier_;
        notifier_->attach(this);
      }
      return *this;
    }

    void unset() final
    {
      notifier_ = nullptr;
    }

    void update(Event e) final
    {
      updateImpl(e, Tags{}...);
    }

  protected:
    // NOTE: The additional `Tags...` arguments can be used to distinguish
    //       between multiple observers of the same event.
    virtual void updateImpl(Event e, Tags...) = 0;

  private:
    Notifier<Event>* notifier_ = nullptr;
  };


  namespace Impl
  {
    template <class Event, class Tags>
    class ObserverSequenceImpl;

    template <class Event, std::size_t... Is>
    class ObserverSequenceImpl<Event, std::index_sequence<Is...>>
        : private Observer<Event,index_t<Is>>...
    {
    public:
      template <class... Notifiers,
        REQUIRES(sizeof...(Notifiers) == sizeof...(Is))>
      ObserverSequenceImpl(Notifiers&&... notifiers)
        : Observer<Event,index_t<Is>>(FWD(notifiers))...
      {}
    };

  } // end namespace Impl

  template <class Event, std::size_t N>
  using ObserverSequence = Impl::ObserverSequenceImpl<Event, std::make_index_sequence<N>>;

} // end namespace AMDiS