args_event_listener.h

//-*- C++ -*-
//
#ifndef __LISTENER__args_event_listener_h__
#define __LISTENER__args_event_listener_h__

#include "common.h"
#include "event.h"
#include "listener.h"
#include "utils/functions.h"

namespace listener {
  template <typename E >
  class GenArgListener: public ListenerForEvent<E > {
  public:
    typedef typename E::function_type function_type ;
    GenArgListener(Publisher* p, const function_type& f) ;
  protected:
    inline bool process_event(E* e) ;
  private:
    function_type f_ ;
  } ;
}

#define CREATE_EVENT_LISTENER(EXP,NAME)                                       \
  class EXP NAME##Listener: public listener::GenArgListener< NAME##Event > {  \
  public:                                                                     \
    NAME##Listener(listener::Publisher* p, const function_type& f):                     \
      listener::GenArgListener< NAME##Event >(p,f) {}                         \
  } ;



// ==================================================================
// ----------- no arg
// ==================================================================
namespace listener { 
  class IGSLISTENER NoArgEvent: public Event {
  public:
    typedef basic::function0<void> function_type ;
    NoArgEvent() ;
    virtual ~NoArgEvent() ;
    bool process(const function_type&) ;
  } ;
}
#define CREATE_0_ARG_EVENT_LISTENER(EXP,NAME)                                 \
  class EXP NAME##Event: public listener::NoArgEvent {                        \
  public:                                                                     \
    NAME##Event(): listener::NoArgEvent() {}                                  \
  } ;                                                                         \
  CREATE_EVENT_LISTENER(EXP,NAME)

// ==================================================================
// ----------- 1 arg
// ==================================================================
namespace listener {
  template <typename T1>
  class OneArgEvent: public Event {
  public:
    typedef basic::function1<void, T1> function_type ;
    OneArgEvent(T1) ;
    virtual ~OneArgEvent() ;
    T1 arg1() const ;
    bool process(const function_type& f) ;
  private:
    T1 arg1_ ;
  } ;
}
#define CREATE_1_ARG_EVENT_LISTENER(EXP,NAME,T1)                              \
  class EXP NAME##Event: public listener::OneArgEvent<T1 > {                  \
  public:                                                                     \
    NAME##Event(T1 t1): listener::OneArgEvent<T1 >(t1) {}                     \
  } ;                                                                         \
  CREATE_EVENT_LISTENER(EXP,NAME)

// ==================================================================
// ----------- 2 args
// ==================================================================
namespace listener { 
  template <typename T1, typename T2>
  class TwoArgsEvent: public OneArgEvent< T1 > {
  public:
    typedef basic::function2<void,T1,T2 > function_type ;
    TwoArgsEvent(T1, T2) ;
    virtual ~TwoArgsEvent() ;
    T2 arg2() const ;
    bool process(const function_type& f) ;
  private:
    T2 arg2_ ;
  } ;
}
#define CREATE_2_ARGS_EVENT_LISTENER(EXP,NAME,T1,T2)                          \
  class EXP NAME##Event: public listener::TwoArgsEvent<T1,T2 > {              \
  public:                                                                     \
    NAME##Event(T1 t1,T2 t2): listener::TwoArgsEvent<T1,T2 >(t1,t2) {}        \
  } ;                                                                         \
  CREATE_EVENT_LISTENER(EXP,NAME)

// ==================================================================
// ----------- 3 args
// ==================================================================
namespace listener { 
  template <typename T1, typename T2, typename T3>
  class ThreeArgsEvent: public TwoArgsEvent<T1,T2 > {
  public:
    typedef basic::function3<void,T1,T2,T3 > function_type ;
    ThreeArgsEvent(T1, T2, T3) ;
    virtual ~ThreeArgsEvent() ;
    T3 arg3() const ;
    bool process(const function_type& f) ;
  private:
    T3 arg3_ ;
  } ;
}
#define CREATE_3_ARGS_EVENT_LISTENER(EXP,NAME,T1,T2,T3)                       \
  class EXP NAME##Event: public listener::ThreeArgsEvent<T1,T2,T3 > {         \
  public:                                                                     \
    NAME##Event(T1 t1,T2 t2,T3 t3):                                           \
      listener::ThreeArgsEvent<T1,T2,T3 >(t1,t2,t3) {}                        \
  } ;                                                                         \
  CREATE_EVENT_LISTENER(EXP,NAME)

// ==================================================================
// ----------- 4 args
// ==================================================================
namespace listener { 
  template <typename T1, typename T2, typename T3, typename T4>
  class FourArgsEvent: public ThreeArgsEvent<T1,T2,T3 > {
  public:
    typedef basic::function4<void,T1,T2,T3,T4 > function_type ;
    FourArgsEvent(T1, T2, T3, T4) ;
    virtual ~FourArgsEvent() ;
    T4 arg4() const ;
    bool process(const function_type& f) ;
  private:
    T4 arg4_ ;
  } ;
}
#define CREATE_4_ARGS_EVENT_LISTENER(EXP,NAME,T1,T2,T3,T4)                    \
  class EXP NAME##Event: public listener::FourArgsEvent<T1,T2,T3,T4 > {       \
  public:                                                                     \
    NAME##Event(T1 t1,T2 t2,T3 t3,T4 t4):                                     \
      listener::FourArgsEvent<T1,T2,T3,T4 >(t1,t2,t3,t4) {}                   \
  } ;                                                                         \
  CREATE_EVENT_LISTENER(EXP,NAME)

// ==================================================================
// ----------- 5 args
// ==================================================================
namespace listener { 
  template <typename T1, typename T2, typename T3, typename T4, typename T5>
  class FiveArgsEvent: public FourArgsEvent<T1,T2,T3,T4 > {
  public:
    typedef basic::function5<void,T1,T2,T3,T4,T5 > function_type ;
    FiveArgsEvent(T1, T2, T3, T4, T5) ;
    virtual ~FiveArgsEvent() ;
    T5 arg5() const ;
    bool process(const function_type& f) ;
  private:
    T5 arg5_ ;
  } ;
}
#define CREATE_5_ARGS_EVENT_LISTENER(EXP,NAME,T1,T2,T3,T4,T5)                 \
  class EXP NAME##Event: public listener::FiveArgsEvent<T1,T2,T3,T4,T5 > {    \
  public:                                                                     \
    NAME##Event(T1 t1,T2 t2,T3 t3,T4 t4, T5 t5):                              \
     listener::FiveArgsEvent<T1,T2,T3,T4,T5 >(t1,t2,t3,t4,t5) {}              \
  } ;                                                                         \
  CREATE_EVENT_LISTENER(EXP,NAME)




#include "inline_src/args_event_listener.hxx"
#endif

---