SPAR/AIModule/SparAIModule/Utils/Event.h

Go to the documentation of this file.

#pragma once
#include "SafeList.h"
#include "EventHandler.h"

struct EventBase
{
  virtual ~EventBase() {}

#ifdef _DEBUG_COMPONENT
  virtual void onOwnerDeleted(Component* owner) = 0;
#endif
};

template <class Arguments = boost::tuple<>>
class Event : public EventBase
{
public:
  typedef EventHandlerT<Arguments> EventHandlerType;
  class SubscriberID
  {
  public:
    SubscriberID()
      : m_isValid(false)
    {}
    SubscriberID(typename SafeList<std::pair<EventHandlerType*, void*>>::iterator id)
      : m_id(id)
      , m_isValid(true)
    {}
    bool isValid() const
    {
      return m_isValid;
    }
  protected:
    friend class Event;
    bool m_isValid;
    typename SafeList<std::pair<EventHandlerType*, void*>>::iterator m_id;
  };

#ifndef _DEBUG_COMPONENT
  virtual ~Event() {}
#else
  virtual void onOwnerDeleted(Component* owner)
  {
    struct DeleteIfInvalidOwner
    {
      DeleteIfInvalidOwner(const Component* owner)
        : m_owner(owner)
      {
      }
      SafeListBase::FunctionReturn operator()(const std::pair<EventHandlerType*, void*>& p) const
      {
        bool shouldDelete = (&p.first->m_owner == m_owner);
        return SafeListBase::FunctionReturn(shouldDelete, false);
      }
    private:
      const Component* const m_owner;
    };

    m_subscribers.for_each(DeleteIfInvalidOwner(owner));
  }
 
  virtual ~Event()
  {
    struct Notify
    {
      Notify(Event* ev)
        : m_event(ev)
      {}
      SafeListBase::ConstFunctionReturn operator()(const std::pair<EventHandlerType*, void*>& p) const
      {
        p.first->m_owner.onEventDeleted(p.first, m_event);
        return SafeListBase::ConstFunctionReturn();
      }
    private:
      Event* const m_event;
    };

    m_subscribers.for_each(Notify(this));
  }
#endif

  SubscriberID subscribe(EventHandlerType* eventHandler, void* data)
  {
#ifdef _DEBUG_COMPONENT
    eventHandler->m_owner.onEventSubscribe(eventHandler, this);
#endif
    return SubscriberID(m_subscribers.add(std::make_pair(eventHandler, data)));
  }

  void unsubscribe(SubscriberID& id)
  {
    if (id.m_isValid)
    {
#ifdef _DEBUG_COMPONENT
      std::pair<EventHandlerType*, void*>& pair = *id.m_id;
      pair.first->m_owner.onEventUnsubscribe(pair.first, this);
#endif
      m_subscribers.erase(id.m_id);
      id.m_isValid = false;
    }
  }

  void internalRaise(Arguments& arguments)
  {
    struct RaiseOnEvent
    {
      RaiseOnEvent(Arguments& args) : m_args(args) { }
      typename SafeList<std::pair<EventHandlerType*, void*>>::FunctionReturn 
        operator()(std::pair<EventHandlerType*, void*>& pair)
      {
        pair.first->onEvent(pair.second, m_args);
        return typename SafeList<std::pair<EventHandlerType*, void*>>::FunctionReturn();
      }
    private:
      Arguments& m_args;
    };

    m_subscribers.for_each(RaiseOnEvent(arguments));
  }

protected:
  SafeList<std::pair<EventHandlerType*, void*>> m_subscribers;
};

class Event0 : public Event<boost::tuple<>>
{
public:
  void raise()
  {
    internalRaise(boost::make_tuple());
  }
};

template <class T1>
class Event1 : public Event<boost::tuple<T1>>
{
public:
  void raise(T1 t1)
  {
    internalRaise(boost::make_tuple(t1));
  }
};

template <class T1, class T2>
class Event2 : public Event<boost::tuple<T1,T2>>
{
public:
  void raise(T1 t1, T2 t2)
  {
    internalRaise(boost::make_tuple(t1,t2));
  }
};

template <class T1, class T2, class T3>
class Event3 : public Event<boost::tuple<T1,T2,T3>>
{
public:
  void raise(T1 t1, T2 t2, T3 t3)
  {
    internalRaise(boost::make_tuple(t1,t2,t3));
  }
};

template <class T1, class T2, class T3, class T4>
class Event4 : public Event<boost::tuple<T1,T2,T3,T4>>
{
public:
  void raise(T1 t1, T2 t2, T3 t3, T4 t4)
  {
    internalRaise(boost::make_tuple(t1,t2,t3,t4));
  }
};

template <class T1, class T2, class T3, class T4, class T5>
class Event5 : public Event<boost::tuple<T1,T2,T3,T4,T5>>
{
public:
  void raise(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
  {
    internalRaise(boost::make_tuple(t1,t2,t3,t4,t5));
  }
};

#define DECLARE_EVENT(Name) \
  class Name : public Event0 \
  { \
  public: \
    virtual ~Name() {} \
  };

#define DECLARE_EVENT1(Name, T1) \
  class Name : public Event1<T1> \
  { \
  public: \
    virtual ~Name() {} \
  };

#define DECLARE_EVENT2(Name, T1, T2) \
  class Name : public Event2<T1,T2> \
  { \
  public: \
    virtual ~Name() {} \
  };

#define DECLARE_EVENT3(Name, T1, T2, T3) \
  class Name : public Event3<T1,T2,T3> \
  { \
  public: \
    virtual ~Name() {} \
  };

#define DECLARE_EVENT4(Name, T1, T2, T3, T4) \
  class Name : public Event4<T1,T2,T3,T4> \
  { \
  public: \
    virtual ~Name() {} \
  };

#define DECLARE_EVENT5(Name, T1, T2, T3, T4, T5) \
  class Name : public Event5<T1,T2,T3,T4,T5> \
  { \
  public: \
    virtual ~Name() {} \
  };

#define EVENT(Name) \
  mutable Name