SPAR/AIModule/SparAIModule/Utils/EventHandler.h

Go to the documentation of this file.

#pragma once
#include "../../Utils/Utils.h"
#include <utility>
#include <boost/tuple/tuple.hpp>

class Component;

struct EventHandlerBase
{
  EventHandlerBase(const Component& owner)
#ifdef _DEBUG_COMPONENT
    : m_owner(owner)
#endif
  {
    unused(owner);
  }

  virtual ~EventHandlerBase() {}

#ifdef _DEBUG_COMPONENT

  const Component& m_owner;
#endif
};

template <class Arguments>
struct EventHandlerT : public EventHandlerBase
{
  EventHandlerT(const Component& owner)
    : EventHandlerBase(owner)
  {}

  typedef Arguments arguments;

  virtual void onEvent(void* data, arguments& args) = 0;
};

struct EventHandler : EventHandlerT<boost::tuple<>>
{
  EventHandler(const Component& owner)
    : EventHandlerT(owner)
  {}
};

template<class T1>
struct EventHandler1 : EventHandlerT<boost::tuple<T1>>
{
  EventHandler1(const Component& owner)
    : EventHandlerT(owner)
  {}
};

template<class T1, class T2>
struct EventHandler2 : EventHandlerT<boost::tuple<T1,T2>>
{
  EventHandler2(const Component& owner)
    : EventHandlerT(owner)
  {}
};

template<class T1, class T2, class T3>
struct EventHandler3 : EventHandlerT<boost::tuple<T1,T2,T3>>
{
  EventHandler3(const Component& owner)
    : EventHandlerT(owner)
  {}
};

template<class T1, class T2, class T3, class T4>
struct EventHandler4 : EventHandlerT<boost::tuple<T1,T2,T3,T4>>
{
  EventHandler4(const Component& owner)
    : EventHandlerT(owner)
  {}
};

template<class T1, class T2, class T3, class T4, class T5>
struct EventHandler5 : EventHandlerT<boost::tuple<T1,T2,T3,T4,T5>>
{
  EventHandler5(const Component& owner)
    : EventHandlerT(owner)
  {}
};

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

#define EVENT_HANDLER_NAME(Type, Function) \
  EventHandler_##Type##_##Function

#define EVENT_HANDLER(Type, Function) \
  struct EVENT_HANDLER_NAME(Type, Function) : EventHandler \
  { \
    EVENT_HANDLER_NAME(Type, Function)(Type& object) \
      : EventHandler(object) \
      , m_object(object) {} \
    virtual ~EVENT_HANDLER_NAME(Type, Function)() {} \
    virtual void onEvent(void* data, arguments&) \
    { \
      m_object.Function(data); \
    } \
  private: \
    Type& m_object; \
  }

#define EVENT_HANDLER1(Type, Function, T1) \
  struct EVENT_HANDLER_NAME(Type, Function) : EventHandler1<T1> \
  { \
    EVENT_HANDLER_NAME(Type, Function)(Type& object) \
      : EventHandler1(object) \
      , m_object(object) {} \
    virtual ~EVENT_HANDLER_NAME(Type, Function)() {} \
    virtual void onEvent(void* data, arguments& args) \
    { \
      m_object.Function(data, args.get<0>()); \
    } \
  private: \
    Type& m_object; \
  }

#define EVENT_HANDLER2(Type, Function, T1, T2) \
  struct EVENT_HANDLER_NAME(Type, Function) : EventHandler2<T1,T2> \
  { \
    EVENT_HANDLER_NAME(Type, Function)(Type& object) \
      : EventHandler2(object) \
      , m_object(object) {} \
    virtual ~EVENT_HANDLER_NAME(Type, Function)() {} \
    virtual void onEvent(void* data, arguments& args) \
    { \
      m_object.Function(data, args.get<0>(), args.get<1>()); \
    } \
  private: \
    Type& m_object; \
  }

#define EVENT_HANDLER3(Type, Function, T1, T2, T3) \
  struct EVENT_HANDLER_NAME(Type, Function) : EventHandler3<T1,T2,T3> \
  { \
    EVENT_HANDLER_NAME(Type, Function)(Type& object) \
      : EventHandler3(object) \
      , m_object(object) {} \
    virtual ~EVENT_HANDLER_NAME(Type, Function)() {} \
    virtual void onEvent(void* data, arguments& args) \
    { \
      m_object.Function(data, args.get<0>(), args.get<1>(), args.get<2>()); \
    } \
  private: \
    Type& m_object; \
  }

#define EVENT_HANDLER4(Type, Function, T1, T2, T3, T4) \
  struct EVENT_HANDLER_NAME(Type, Function) : EventHandler4<T1,T2,T3,T4> \
  { \
    EVENT_HANDLER_NAME(Type, Function)(Type& object) \
      : EventHandler4(object) \
      , m_object(object) {} \
    virtual ~EVENT_HANDLER_NAME(Type, Function)() {} \
    virtual void onEvent(void* data, arguments& args) \
    { \
      m_object.Function(data, args.get<0>(), args.get<1>(), args.get<2>(), args.get<3>()); \
    } \
  private: \
    Type& m_object; \
  }

#define EVENT_HANDLER5(Type, Function, T1, T2, T3, T4, T5) \
  struct EVENT_HANDLER_NAME(Type, Function) : EventHandler5<T1,T2,T3,T4,T5> \
  { \
    EVENT_HANDLER_NAME(Type, Function)(Type& object) \
      : EventHandler5(object) \
      , m_object(object) {} \
    virtual ~EVENT_HANDLER_NAME(Type, Function)() {} \
    virtual void onEvent(void* data, arguments& args) \
    { \
      m_object.Function(data, args.get<0>(), args.get<1>(), args.get<2>(), args.get<3>(), args.get<4>()); \
    } \
  private: \
    Type& m_object; \
  }