include/Signal.hpp

   1 #ifndef SCX_SIGNAL_HPP
   2 #define SCX_SIGNAL_HPP
   3
   4 #include <vector>
   5 #include "Function.hpp"
   6
   7 namespace scx {
   8
   9 /* Signal class, not support copy now!! */
  10 template<typename signature>
  11 class Signal;
  12
  13 #define SCX_SIGNAL_COPY_SIGNAL_COMMON                   \
  14 public:                                                 \
  15     ~Signal()                                           \
  16     {                                                   \
  17         for (size_t i = 0; i < m_Slots.size(); ++i) {   \
  18             delete m_Slots[i];                          \
  19         }                                               \
  20     }                                                   \
  21     \
  22     template<typename fn_t, typename pv_t>          \
  23     const Function_t* Connect(fn_t fn, pv_t pv)     \
  24     {                                               \
  25         Function_t* pslot = new Function_t(fn, pv); \
  26         m_Slots.push_back(pslot);                   \
  27         return pslot;                               \
  28     }                                               \
  29     \
  30     template<typename fn_t>                         \
  31     const Function_t* Connect(fn_t fn)              \
  32     {                                               \
  33         Function_t* pslot = new Function_t(fn);     \
  34         m_Slots.push_back(pslot);                   \
  35         return pslot;                               \
  36     }                                               \
  37     \
  38     void Connect(Signal* sig)                       \
  39     {                                               \
  40         m_Signals.push_back(sig);                   \
  41     }                                               \
  42     \
  43     void Disconnect(const Function_t* fn)               \
  44     {                                                   \
  45         for (size_t i = 0; i < m_Slots.size(); ++i) {   \
  46             if (m_Slots[i] == fn) {                     \
  47                 delete fn;                              \
  48                 m_Slots.erase(m_Slots.begin() + i);     \
  49                 break;                                  \
  50             }                                           \
  51         }                                               \
  52     }                                                   \
  53     \
  54     void Disconnect(const Signal* sig)                  \
  55     {                                                   \
  56         for (size_t i = 0; i < m_Signals.size(); ++i) { \
  57             if (m_Signals[i] == sig) {                  \
  58                 m_Signals.erase(m_Signals.begin() + i); \
  59                 break;                                  \
  60             }                                           \
  61         }                                               \
  62     }                                                   \
  63     \
  64     template<typename recv_t>                           \
  65     void DisconnectReceiver(recv_t* recv)               \
  66     {                                                   \
  67         for (int i = m_Slots.size()-1; i >= 0; --i) {   \
  68             if ((m_Slots[i]->GetReceiver()) == recv) {  \
  69                 delete m_Slots[i];                      \
  70                 m_Slots.erase(m_Slots.begin() + i);     \
  71             }                                           \
  72         }                                               \
  73     }                                                   \
  74     \
  75     void Reserve(const size_t size)     \
  76     {                                   \
  77         m_Slots.Reserve(size);          \
  78         m_Signals.Reserve(size);        \
  79     }                                   \
  80     \
  81 private:                                \
  82     std::vector<Function_t*> m_Slots;   \
  83     std::vector<Signal*> m_Signals
  84
  85 template<typename ret_t, typename arg_t>
  86 class Signal<ret_t (arg_t)>
  87 {
  88 typedef Function<ret_t (arg_t)> Function_t;
  89
  90 SCX_SIGNAL_COPY_SIGNAL_COMMON;
  91
  92 public:
  93     void operator()(arg_t arg) const
  94     {
  95         for (size_t i = 0; i < m_Slots.size(); ++i) {
  96             (*m_Slots[i])(arg);
  97         }
  98
  99         for (size_t i = 0; i < m_Signals.size(); ++i) {
 100             (*m_Signals[i])(arg);
 101         }
 102     }
 103 };
 104
 105 template<typename ret_t>
 106 class Signal<ret_t (void)>
 107 {
 108 typedef Function<ret_t (void)> Function_t;
 109
 110 SCX_SIGNAL_COPY_SIGNAL_COMMON;
 111
 112 public:
 113     void operator()(void) const
 114     {
 115         for (size_t i = 0; i < m_Slots.size(); ++i) {
 116             (*m_Slots[i])();
 117         }
 118
 119         for (size_t i = 0; i < m_Signals.size(); ++i) {
 120             (*m_Signals[i])();
 121         }
 122     }
 123 };
 124
 125 template<typename ret_t,
 126 typename arg1_t,
 127 typename arg2_t>
 128 class Signal<ret_t (arg1_t, arg2_t)>
 129 {
 130 typedef Function<ret_t (arg1_t, arg2_t)> Function_t;
 131
 132 SCX_SIGNAL_COPY_SIGNAL_COMMON;
 133
 134 public:
 135     void operator()(arg1_t arg1, arg2_t arg2) const
 136     {
 137         for (size_t i = 0; i < m_Slots.size(); ++i) {
 138             (*m_Slots[i])(arg1, arg2);
 139         }
 140
 141         for (size_t i = 0; i < m_Signals.size(); ++i) {
 142             (*m_Signals[i])(arg1, arg2);
 143         }
 144     }
 145 };
 146
 147 template<typename ret_t,
 148 typename arg1_t,
 149 typename arg2_t,
 150 typename arg3_t>
 151 class Signal<ret_t (arg1_t, arg2_t, arg3_t)>
 152 {
 153 typedef Function<ret_t (arg1_t, arg2_t, arg3_t)> Function_t;
 154
 155 SCX_SIGNAL_COPY_SIGNAL_COMMON;
 156
 157 public:
 158     void operator()(arg1_t arg1, arg2_t arg2, arg3_t arg3) const
 159     {
 160         for (size_t i = 0; i < m_Slots.size(); ++i) {
 161             (*m_Slots[i])(arg1, arg2, arg3);
 162         }
 163
 164         for (size_t i = 0; i < m_Signals.size(); ++i) {
 165             (*m_Signals[i])(arg1, arg2, arg3);
 166         }
 167     }
 168 };
 169
 170 template<typename ret_t,
 171 typename arg1_t,
 172 typename arg2_t,
 173 typename arg3_t,
 174 typename arg4_t>
 175 class Signal<ret_t (arg1_t, arg2_t, arg3_t, arg4_t)>
 176 {
 177 typedef Function<ret_t (arg1_t, arg2_t, arg3_t, arg4_t)> Function_t;
 178
 179 SCX_SIGNAL_COPY_SIGNAL_COMMON;
 180
 181 public:
 182     void operator()(arg1_t arg1, arg2_t arg2, arg3_t arg3, arg4_t arg4) const
 183     {
 184         for (size_t i = 0; i < m_Slots.size(); ++i) {
 185             (*m_Slots[i])(arg1, arg2, arg3, arg4);
 186         }
 187
 188         for (size_t i = 0; i < m_Signals.size(); ++i) {
 189             (*m_Signals[i])(arg1, arg2, arg3, arg4);
 190         }
 191     }
 192 };
 193
 194 template<typename ret_t,
 195 typename arg1_t,
 196 typename arg2_t,
 197 typename arg3_t,
 198 typename arg4_t,
 199 typename arg5_t>
 200 class Signal<ret_t (arg1_t, arg2_t, arg3_t, arg4_t, arg5_t)>
 201 {
 202 typedef Function<ret_t (arg1_t, arg2_t, arg3_t, arg4_t, arg5_t)> Function_t;
 203
 204 SCX_SIGNAL_COPY_SIGNAL_COMMON;
 205
 206 public:
 207     void operator()(arg1_t arg1, arg2_t arg2, arg3_t arg3, arg4_t arg4, arg5_t arg5) const
 208     {
 209         for (size_t i = 0; i < m_Slots.size(); ++i) {
 210             (*m_Slots[i])(arg1, arg2, arg3, arg4, arg5);
 211         }
 212
 213         for (size_t i = 0; i < m_Signals.size(); ++i) {
 214             (*m_Signals[i])(arg1, arg2, arg3, arg4, arg5);
 215         }
 216     }
 217 };
 218
 219 #undef SCX_SIGNAL_COPY_SIGNAL_COMMON
 220
 221 }
 222
 223 #endif