00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00031
00032 #pragma once
00033
00034 #include "slot.h"
00035 #include "signals_impl.h"
00036
00039 template <class Param1, class Param2, class Param3>
00040 class CL_SlotCallback_v3 : public CL_SlotCallback
00041 {
00042 public:
00043 virtual void invoke(Param1 param1, Param2 param2, Param3 param3) = 0;
00044 };
00045
00048 template <class Param1, class Param2, class Param3>
00049 class CL_SlotCallback_v3_static : public CL_SlotCallback_v3<Param1, Param2, Param3>
00050 {
00051 public:
00052 CL_SlotCallback_v3_static(void (*static_func)(Param1, Param2, Param3))
00053 : static_func(static_func) { return; }
00054 void invoke(Param1 param1, Param2 param2, Param3 param3) { static_func(param1, param2, param3); }
00055 void (*static_func)(Param1, Param2, Param3);
00056 };
00057
00060 template <class Param1, class Param2, class Param3, class UserData>
00061 class CL_SlotCallback_v3_static_user : public CL_SlotCallback_v3<Param1, Param2, Param3>
00062 {
00063 public:
00064 CL_SlotCallback_v3_static_user(void (*static_func)(Param1, Param2, Param3, UserData), const UserData &user_data)
00065 : static_func(static_func), user_data(user_data) { return; }
00066 void invoke(Param1 param1, Param2 param2, Param3 param3) { static_func(param1, param2, param3, user_data); }
00067 void (*static_func)(Param1, Param2, Param3, UserData);
00068 UserData user_data;
00069 };
00070
00073 template <class Param1, class Param2, class Param3, class InstanceClass>
00074 class CL_SlotCallback_v3_member : public CL_SlotCallback_v3<Param1, Param2, Param3>
00075 {
00076 public:
00077 CL_SlotCallback_v3_member(InstanceClass *instance, void (InstanceClass::*member_func)(Param1, Param2, Param3))
00078 : instance(instance), member_func(member_func) { return; }
00079 void invoke(Param1 param1, Param2 param2, Param3 param3) { (instance->*member_func)(param1, param2, param3); }
00080 InstanceClass *instance;
00081 void (InstanceClass::*member_func)(Param1, Param2, Param3);
00082 };
00083
00086 template <class Param1, class Param2, class Param3, class InstanceClass, class UserData>
00087 class CL_SlotCallback_v3_member_user : public CL_SlotCallback_v3<Param1, Param2, Param3>
00088 {
00089 public:
00090 CL_SlotCallback_v3_member_user(InstanceClass *instance, void (InstanceClass::*member_func)(Param1, Param2, Param3, UserData), const UserData &user_data)
00091 : instance(instance), member_func(member_func), user_data(user_data) { return; }
00092 void invoke(Param1 param1, Param2 param2, Param3 param3) { (instance->*member_func)(param1, param2, param3, user_data); }
00093 InstanceClass *instance;
00094 void (InstanceClass::*member_func)(Param1, Param2, Param3, UserData);
00095 UserData user_data;
00096 };
00097
00100 template <class Param1, class Param2, class Param3, class Functor>
00101 class CL_SlotCallback_v3_functor : public CL_SlotCallback_v3<Param1, Param2, Param3>
00102 {
00103 public:
00104 CL_SlotCallback_v3_functor(const Functor &functor)
00105 : functor(functor) { return; }
00106 void invoke(Param1 param1, Param2 param2, Param3 param3) { functor(param1, param2, param3); }
00107 Functor functor;
00108 };
00109
00113 template <class Param1, class Param2, class Param3>
00114 class CL_Signal_v3
00115 {
00118
00119 public:
00120 CL_Signal_v3()
00121 : impl(new CL_Signal_Impl) { return; }
00122
00123 CL_Signal_v3(const CL_Signal_v3<Param1, Param2, Param3> ©)
00124 : impl(copy.impl) { return; }
00125
00126
00130
00131 public:
00132 CL_Slot connect(void (*function)(Param1, Param2, Param3))
00133 {
00134 clean_up();
00135 CL_SharedPtr<CL_SlotCallback> callback(
00136 new CL_SlotCallback_v3_static<Param1, Param2, Param3>(function));
00137 impl->connected_slots.push_back(callback);
00138 return CL_Slot(callback);
00139 }
00140
00141 template<class UserData>
00142 CL_Slot connect(void (*function)(Param1, Param2, Param3, UserData), const UserData &user_data)
00143 {
00144 clean_up();
00145 CL_SharedPtr<CL_SlotCallback> callback(
00146 new CL_SlotCallback_v3_static_user<Param1, Param2, Param3, UserData>(function, user_data));
00147 impl->connected_slots.push_back(callback);
00148 return CL_Slot(callback);
00149 }
00150
00151 template<class InstanceClass>
00152 CL_Slot connect(InstanceClass *instance, void (InstanceClass::*function)(Param1, Param2, Param3))
00153 {
00154 clean_up();
00155 CL_SharedPtr<CL_SlotCallback> callback(
00156 new CL_SlotCallback_v3_member<Param1, Param2, Param3, InstanceClass>(instance, function));
00157 impl->connected_slots.push_back(callback);
00158 return CL_Slot(callback);
00159 }
00160
00161 template<class InstanceClass, class UserData>
00162 CL_Slot connect(InstanceClass *instance, void (InstanceClass::*function)(Param1, Param2, Param3, UserData), const UserData &user_data)
00163 {
00164 clean_up();
00165 CL_SharedPtr<CL_SlotCallback> callback(
00166 new CL_SlotCallback_v3_member_user<Param1, Param2, Param3, InstanceClass, UserData>(instance, function, user_data));
00167 impl->connected_slots.push_back(callback);
00168 return CL_Slot(callback);
00169 }
00170
00171 template<class Functor>
00172 CL_Slot connect_functor(const Functor &functor)
00173 {
00174 clean_up();
00175 CL_SharedPtr<CL_SlotCallback> callback(
00176 new CL_SlotCallback_v3_functor<Param1, Param2, Param3, Functor>(functor));
00177 impl->connected_slots.push_back(callback);
00178 return CL_Slot(callback);
00179 }
00180
00181 void invoke(Param1 param1, Param2 param2, Param3 param3) const
00182 {
00183 std::vector< CL_SharedPtr<CL_SlotCallback> > callbacks = impl->connected_slots;
00184 std::vector< CL_SharedPtr<CL_SlotCallback> >::size_type i, size;
00185 size = callbacks.size();
00186 for (i = 0; i < size; i++)
00187 if (callbacks[i]->valid && callbacks[i]->enabled)
00188 ((CL_SlotCallback_v3<Param1, Param2, Param3> *) callbacks[i].get())->invoke(param1, param2, param3);
00189 }
00190
00191
00195
00196 private:
00197 void clean_up()
00198 {
00199 std::vector< CL_SharedPtr<CL_SlotCallback> >::size_type i, size;
00200 size = impl->connected_slots.size();
00201 for (i = 0; i < size; i++)
00202 {
00203 if (!impl->connected_slots[i]->valid)
00204 {
00205 impl->connected_slots.erase(impl->connected_slots.begin()+i);
00206 i--;
00207 size--;
00208 }
00209 }
00210 }
00211
00212 CL_SharedPtr<CL_Signal_Impl> impl;
00214 };
00215
00216