swaits/cpp-signal
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

now compiles and is back to a functional state!

Browse Source
This commit is contained in:
swaits committed 2010-10-04 15:59:09 -07:00
1 parent 9043e38ef2
commit 0b396aede9
21 files changed
+109 -114
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

signal0.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 0 parameter(s). // Abstract base class for slots with 0 parameter(s).
// //
template<typename T_return> template<typename T_return>
class slot0 : public slot_base class slot0: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal0: public signal_base
typedef T_return (*FUNCTION_POINTER)(); typedef T_return (*FUNCTION_POINTER)();
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot0<T_return>* sNewFunc = new slot0_function<T_return>( func ); slot0<T_return>* sNewFunc = new slot0_function<T_return>( func );
@@ -175,7 +175,7 @@ class signal0: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot0<T_return>* sNewMethod = new slot0_method<T_object,T_member,T_return>( p_object, p_member ); slot0<T_return>* sNewMethod = new slot0_method<T_object,T_member,T_return>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal0: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot0_function<T_return> sTest( func ); slot0_function<T_return> sTest( func );
@@ -201,7 +201,7 @@ class signal0: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot0_method<T_object,T_member,T_return> sTemp(p_object,p_member); slot0_method<T_object,T_member,T_return> sTemp(p_object,p_member);
signal1.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 1 parameter(s). // Abstract base class for slots with 1 parameter(s).
// //
template<typename T_return, typename T_arg0> template<typename T_return, typename T_arg0>
class slot1 : public slot_base class slot1: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal1: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot1<T_return, T_arg0>* sNewFunc = new slot1_function<T_return, T_arg0>( func ); slot1<T_return, T_arg0>* sNewFunc = new slot1_function<T_return, T_arg0>( func );
@@ -175,7 +175,7 @@ class signal1: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot1<T_return, T_arg0>* sNewMethod = new slot1_method<T_object,T_member,T_return, T_arg0>( p_object, p_member ); slot1<T_return, T_arg0>* sNewMethod = new slot1_method<T_object,T_member,T_return, T_arg0>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal1: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot1_function<T_return, T_arg0> sTest( func ); slot1_function<T_return, T_arg0> sTest( func );
@@ -201,7 +201,7 @@ class signal1: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot1_method<T_object,T_member,T_return, T_arg0> sTemp(p_object,p_member); slot1_method<T_object,T_member,T_return, T_arg0> sTemp(p_object,p_member);
signal10.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 10 parameter(s). // Abstract base class for slots with 10 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8, typename T_arg9> template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8, typename T_arg9>
class slot10 : public slot_base class slot10: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal10: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8, T_arg9 a9); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8, T_arg9 a9);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot10<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>* sNewFunc = new slot10_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>( func ); slot10<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>* sNewFunc = new slot10_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>( func );
@@ -175,7 +175,7 @@ class signal10: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot10<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>* sNewMethod = new slot10_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>( p_object, p_member ); slot10<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>* sNewMethod = new slot10_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal10: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot10_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9> sTest( func ); slot10_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9> sTest( func );
@@ -201,7 +201,7 @@ class signal10: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot10_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9> sTemp(p_object,p_member); slot10_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9> sTemp(p_object,p_member);
signal11.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 11 parameter(s). // Abstract base class for slots with 11 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8, typename T_arg9, typename T_arg10> template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8, typename T_arg9, typename T_arg10>
class slot11 : public slot_base class slot11: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal11: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8, T_arg9 a9, T_arg10 a10); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8, T_arg9 a9, T_arg10 a10);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot11<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10>* sNewFunc = new slot11_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10>( func ); slot11<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10>* sNewFunc = new slot11_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10>( func );
@@ -175,7 +175,7 @@ class signal11: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot11<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10>* sNewMethod = new slot11_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10>( p_object, p_member ); slot11<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10>* sNewMethod = new slot11_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal11: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot11_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10> sTest( func ); slot11_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10> sTest( func );
@@ -201,7 +201,7 @@ class signal11: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot11_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10> sTemp(p_object,p_member); slot11_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10> sTemp(p_object,p_member);
signal12.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 12 parameter(s). // Abstract base class for slots with 12 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8, typename T_arg9, typename T_arg10, typename T_arg11> template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8, typename T_arg9, typename T_arg10, typename T_arg11>
class slot12 : public slot_base class slot12: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal12: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8, T_arg9 a9, T_arg10 a10, T_arg11 a11); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8, T_arg9 a9, T_arg10 a10, T_arg11 a11);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot12<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11>* sNewFunc = new slot12_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11>( func ); slot12<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11>* sNewFunc = new slot12_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11>( func );
@@ -175,7 +175,7 @@ class signal12: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot12<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11>* sNewMethod = new slot12_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11>( p_object, p_member ); slot12<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11>* sNewMethod = new slot12_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal12: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot12_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11> sTest( func ); slot12_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11> sTest( func );
@@ -201,7 +201,7 @@ class signal12: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot12_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11> sTemp(p_object,p_member); slot12_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11> sTemp(p_object,p_member);
signal13.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 13 parameter(s). // Abstract base class for slots with 13 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8, typename T_arg9, typename T_arg10, typename T_arg11, typename T_arg12> template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8, typename T_arg9, typename T_arg10, typename T_arg11, typename T_arg12>
class slot13 : public slot_base class slot13: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal13: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8, T_arg9 a9, T_arg10 a10, T_arg11 a11, T_arg12 a12); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8, T_arg9 a9, T_arg10 a10, T_arg11 a11, T_arg12 a12);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot13<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12>* sNewFunc = new slot13_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12>( func ); slot13<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12>* sNewFunc = new slot13_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12>( func );
@@ -175,7 +175,7 @@ class signal13: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot13<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12>* sNewMethod = new slot13_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12>( p_object, p_member ); slot13<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12>* sNewMethod = new slot13_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal13: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot13_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12> sTest( func ); slot13_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12> sTest( func );
@@ -201,7 +201,7 @@ class signal13: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot13_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12> sTemp(p_object,p_member); slot13_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12> sTemp(p_object,p_member);
signal14.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 14 parameter(s). // Abstract base class for slots with 14 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8, typename T_arg9, typename T_arg10, typename T_arg11, typename T_arg12, typename T_arg13> template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8, typename T_arg9, typename T_arg10, typename T_arg11, typename T_arg12, typename T_arg13>
class slot14 : public slot_base class slot14: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal14: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8, T_arg9 a9, T_arg10 a10, T_arg11 a11, T_arg12 a12, T_arg13 a13); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8, T_arg9 a9, T_arg10 a10, T_arg11 a11, T_arg12 a12, T_arg13 a13);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot14<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13>* sNewFunc = new slot14_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13>( func ); slot14<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13>* sNewFunc = new slot14_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13>( func );
@@ -175,7 +175,7 @@ class signal14: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot14<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13>* sNewMethod = new slot14_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13>( p_object, p_member ); slot14<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13>* sNewMethod = new slot14_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal14: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot14_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13> sTest( func ); slot14_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13> sTest( func );
@@ -201,7 +201,7 @@ class signal14: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot14_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13> sTemp(p_object,p_member); slot14_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13> sTemp(p_object,p_member);
signal15.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 15 parameter(s). // Abstract base class for slots with 15 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8, typename T_arg9, typename T_arg10, typename T_arg11, typename T_arg12, typename T_arg13, typename T_arg14> template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8, typename T_arg9, typename T_arg10, typename T_arg11, typename T_arg12, typename T_arg13, typename T_arg14>
class slot15 : public slot_base class slot15: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal15: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8, T_arg9 a9, T_arg10 a10, T_arg11 a11, T_arg12 a12, T_arg13 a13, T_arg14 a14); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8, T_arg9 a9, T_arg10 a10, T_arg11 a11, T_arg12 a12, T_arg13 a13, T_arg14 a14);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot15<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14>* sNewFunc = new slot15_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14>( func ); slot15<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14>* sNewFunc = new slot15_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14>( func );
@@ -175,7 +175,7 @@ class signal15: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot15<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14>* sNewMethod = new slot15_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14>( p_object, p_member ); slot15<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14>* sNewMethod = new slot15_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal15: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot15_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14> sTest( func ); slot15_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14> sTest( func );
@@ -201,7 +201,7 @@ class signal15: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot15_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14> sTemp(p_object,p_member); slot15_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14> sTemp(p_object,p_member);
signal16.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 16 parameter(s). // Abstract base class for slots with 16 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8, typename T_arg9, typename T_arg10, typename T_arg11, typename T_arg12, typename T_arg13, typename T_arg14, typename T_arg15> template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8, typename T_arg9, typename T_arg10, typename T_arg11, typename T_arg12, typename T_arg13, typename T_arg14, typename T_arg15>
class slot16 : public slot_base class slot16: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal16: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8, T_arg9 a9, T_arg10 a10, T_arg11 a11, T_arg12 a12, T_arg13 a13, T_arg14 a14, T_arg15 a15); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8, T_arg9 a9, T_arg10 a10, T_arg11 a11, T_arg12 a12, T_arg13 a13, T_arg14 a14, T_arg15 a15);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot16<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14, T_arg15>* sNewFunc = new slot16_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14, T_arg15>( func ); slot16<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14, T_arg15>* sNewFunc = new slot16_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14, T_arg15>( func );
@@ -175,7 +175,7 @@ class signal16: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot16<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14, T_arg15>* sNewMethod = new slot16_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14, T_arg15>( p_object, p_member ); slot16<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14, T_arg15>* sNewMethod = new slot16_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14, T_arg15>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal16: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot16_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14, T_arg15> sTest( func ); slot16_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14, T_arg15> sTest( func );
@@ -201,7 +201,7 @@ class signal16: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot16_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14, T_arg15> sTemp(p_object,p_member); slot16_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10, T_arg11, T_arg12, T_arg13, T_arg14, T_arg15> sTemp(p_object,p_member);
signal2.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 2 parameter(s). // Abstract base class for slots with 2 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1> template<typename T_return, typename T_arg0, typename T_arg1>
class slot2 : public slot_base class slot2: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal2: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot2<T_return, T_arg0, T_arg1>* sNewFunc = new slot2_function<T_return, T_arg0, T_arg1>( func ); slot2<T_return, T_arg0, T_arg1>* sNewFunc = new slot2_function<T_return, T_arg0, T_arg1>( func );
@@ -175,7 +175,7 @@ class signal2: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot2<T_return, T_arg0, T_arg1>* sNewMethod = new slot2_method<T_object,T_member,T_return, T_arg0, T_arg1>( p_object, p_member ); slot2<T_return, T_arg0, T_arg1>* sNewMethod = new slot2_method<T_object,T_member,T_return, T_arg0, T_arg1>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal2: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot2_function<T_return, T_arg0, T_arg1> sTest( func ); slot2_function<T_return, T_arg0, T_arg1> sTest( func );
@@ -201,7 +201,7 @@ class signal2: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot2_method<T_object,T_member,T_return, T_arg0, T_arg1> sTemp(p_object,p_member); slot2_method<T_object,T_member,T_return, T_arg0, T_arg1> sTemp(p_object,p_member);
signal3.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 3 parameter(s). // Abstract base class for slots with 3 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2> template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2>
class slot3 : public slot_base class slot3: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal3: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot3<T_return, T_arg0, T_arg1, T_arg2>* sNewFunc = new slot3_function<T_return, T_arg0, T_arg1, T_arg2>( func ); slot3<T_return, T_arg0, T_arg1, T_arg2>* sNewFunc = new slot3_function<T_return, T_arg0, T_arg1, T_arg2>( func );
@@ -175,7 +175,7 @@ class signal3: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot3<T_return, T_arg0, T_arg1, T_arg2>* sNewMethod = new slot3_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2>( p_object, p_member ); slot3<T_return, T_arg0, T_arg1, T_arg2>* sNewMethod = new slot3_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal3: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot3_function<T_return, T_arg0, T_arg1, T_arg2> sTest( func ); slot3_function<T_return, T_arg0, T_arg1, T_arg2> sTest( func );
@@ -201,7 +201,7 @@ class signal3: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot3_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2> sTemp(p_object,p_member); slot3_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2> sTemp(p_object,p_member);
signal4.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 4 parameter(s). // Abstract base class for slots with 4 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3> template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3>
class slot4 : public slot_base class slot4: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal4: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot4<T_return, T_arg0, T_arg1, T_arg2, T_arg3>* sNewFunc = new slot4_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3>( func ); slot4<T_return, T_arg0, T_arg1, T_arg2, T_arg3>* sNewFunc = new slot4_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3>( func );
@@ -175,7 +175,7 @@ class signal4: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot4<T_return, T_arg0, T_arg1, T_arg2, T_arg3>* sNewMethod = new slot4_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3>( p_object, p_member ); slot4<T_return, T_arg0, T_arg1, T_arg2, T_arg3>* sNewMethod = new slot4_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal4: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot4_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3> sTest( func ); slot4_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3> sTest( func );
@@ -201,7 +201,7 @@ class signal4: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot4_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3> sTemp(p_object,p_member); slot4_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3> sTemp(p_object,p_member);
signal5.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 5 parameter(s). // Abstract base class for slots with 5 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4> template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
class slot5 : public slot_base class slot5: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal5: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot5<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>* sNewFunc = new slot5_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>( func ); slot5<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>* sNewFunc = new slot5_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>( func );
@@ -175,7 +175,7 @@ class signal5: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot5<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>* sNewMethod = new slot5_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>( p_object, p_member ); slot5<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>* sNewMethod = new slot5_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal5: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot5_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4> sTest( func ); slot5_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4> sTest( func );
@@ -201,7 +201,7 @@ class signal5: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot5_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4> sTemp(p_object,p_member); slot5_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4> sTemp(p_object,p_member);
signal6.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 6 parameter(s). // Abstract base class for slots with 6 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5> template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
class slot6 : public slot_base class slot6: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal6: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot6<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* sNewFunc = new slot6_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>( func ); slot6<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* sNewFunc = new slot6_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>( func );
@@ -175,7 +175,7 @@ class signal6: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot6<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* sNewMethod = new slot6_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>( p_object, p_member ); slot6<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* sNewMethod = new slot6_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal6: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot6_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sTest( func ); slot6_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sTest( func );
@@ -201,7 +201,7 @@ class signal6: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot6_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sTemp(p_object,p_member); slot6_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sTemp(p_object,p_member);
signal7.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 7 parameter(s). // Abstract base class for slots with 7 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6> template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
class slot7 : public slot_base class slot7: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal7: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot7<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* sNewFunc = new slot7_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>( func ); slot7<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* sNewFunc = new slot7_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>( func );
@@ -175,7 +175,7 @@ class signal7: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot7<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* sNewMethod = new slot7_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>( p_object, p_member ); slot7<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* sNewMethod = new slot7_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal7: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot7_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sTest( func ); slot7_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sTest( func );
@@ -201,7 +201,7 @@ class signal7: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot7_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sTemp(p_object,p_member); slot7_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sTemp(p_object,p_member);
signal8.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 8 parameter(s). // Abstract base class for slots with 8 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7> template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
class slot8 : public slot_base class slot8: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal8: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot8<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* sNewFunc = new slot8_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>( func ); slot8<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* sNewFunc = new slot8_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>( func );
@@ -175,7 +175,7 @@ class signal8: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot8<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* sNewMethod = new slot8_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>( p_object, p_member ); slot8<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* sNewMethod = new slot8_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal8: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot8_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sTest( func ); slot8_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sTest( func );
@@ -201,7 +201,7 @@ class signal8: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot8_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sTemp(p_object,p_member); slot8_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sTemp(p_object,p_member);
signal9.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with 9 parameter(s). // Abstract base class for slots with 9 parameter(s).
// //
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8> template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7, typename T_arg8>
class slot9 : public slot_base class slot9: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal9: public signal_base
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8); typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7, T_arg8 a8);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot9<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>* sNewFunc = new slot9_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>( func ); slot9<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>* sNewFunc = new slot9_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>( func );
@@ -175,7 +175,7 @@ class signal9: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot9<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>* sNewMethod = new slot9_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>( p_object, p_member ); slot9<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>* sNewMethod = new slot9_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal9: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot9_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8> sTest( func ); slot9_function<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8> sTest( func );
@@ -201,7 +201,7 @@ class signal9: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot9_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8> sTemp(p_object,p_member); slot9_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8> sTemp(p_object,p_member);
signal_base.cpp
+2 -2
View File
@@ -2,7 +2,7 @@
#include "signal_base.h" #include "signal_base.h"
signal_base::signal_base() : head(0), tail(0), bEmitting(false) signal_base::signal_base() : head(0), tail(0), emitting(false)
{ {
// empty // empty
} }
@@ -13,7 +13,7 @@ signal_base::~signal_base()
clear_list(); clear_list();
} }
signal_base::signal_base( const signal_base& rSource ) : head(0), tail(0), bEmitting(false) signal_base::signal_base( const signal_base& rSource ) : head(0), tail(0), emitting(false)
{ {
// Set an assert to let the user know that we don't support signal copying. // Set an assert to let the user know that we don't support signal copying.
// There are too many places where the signals are directly connected to objects, // There are too many places where the signals are directly connected to objects,
signal_base.h
+5 -1
View File
@@ -32,7 +32,7 @@ class signal_base
/** /**
* Determines the number of slots that are connected to the signal. * Determines the number of slots that are connected to the signal.
*/ */
int Count( void ); int count( void );
protected: protected:
// linked list data structure // linked list data structure
@@ -97,12 +97,16 @@ class signal_base
*/ */
void remove_from_list(list_node* n); void remove_from_list(list_node* n);
protected:
/** /**
* Removes any nodes that were tagged for deletion during the signal emit sequence * Removes any nodes that were tagged for deletion during the signal emit sequence
*/ */
void remove_pending_nodes( void ); void remove_pending_nodes( void );
//----------------------------------------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------------------------------------
protected:
list_node* head; list_node* head;
list_node* tail; list_node* tail;
signal_template.h
+5 -5
View File
@@ -15,7 +15,7 @@
// Abstract base class for slots with ===NARG=== parameter(s). // Abstract base class for slots with ===NARG=== parameter(s).
// //
template<typename T_return===TEMPLATE_ARG_DECL===> template<typename T_return===TEMPLATE_ARG_DECL===>
class slot===NARG=== : public slot_base class slot===NARG===: public slot_base
{ {
public: public:
/** /**
@@ -164,7 +164,7 @@ class signal===NARG===: public signal_base
typedef T_return (*FUNCTION_POINTER)(===FORMAL_ARG_DECL===); typedef T_return (*FUNCTION_POINTER)(===FORMAL_ARG_DECL===);
// connect to normal functions // connect to normal functions
bool Connect( FUNCTION_POINTER func ) bool connect( FUNCTION_POINTER func )
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot===NARG===<T_return===TEMPLATE_ARG===>* sNewFunc = new slot===NARG===_function<T_return===TEMPLATE_ARG===>( func ); slot===NARG===<T_return===TEMPLATE_ARG===>* sNewFunc = new slot===NARG===_function<T_return===TEMPLATE_ARG===>( func );
@@ -175,7 +175,7 @@ class signal===NARG===: public signal_base
// connect to an object's method // connect to an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Connect(T_object* p_object, T_member p_member) bool connect(T_object* p_object, T_member p_member)
{ {
// make a copy of the slot to store in our list // make a copy of the slot to store in our list
slot===NARG===<T_return===TEMPLATE_ARG===>* sNewMethod = new slot===NARG===_method<T_object,T_member,T_return===TEMPLATE_ARG===>( p_object, p_member ); slot===NARG===<T_return===TEMPLATE_ARG===>* sNewMethod = new slot===NARG===_method<T_object,T_member,T_return===TEMPLATE_ARG===>( p_object, p_member );
@@ -190,7 +190,7 @@ class signal===NARG===: public signal_base
// //
// disconnect from a normal function // disconnect from a normal function
bool Disconnect( FUNCTION_POINTER func ) bool disconnect( FUNCTION_POINTER func )
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot===NARG===_function<T_return===TEMPLATE_ARG===> sTest( func ); slot===NARG===_function<T_return===TEMPLATE_ARG===> sTest( func );
@@ -201,7 +201,7 @@ class signal===NARG===: public signal_base
// disconnect from an object's method // disconnect from an object's method
template <class T_object, typename T_member> template <class T_object, typename T_member>
bool Disconnect(T_object* p_object, T_member p_member) bool disconnect(T_object* p_object, T_member p_member)
{ {
// make a temporary slot we can use to find a match in the list // make a temporary slot we can use to find a match in the list
slot===NARG===_method<T_object,T_member,T_return===TEMPLATE_ARG===> sTemp(p_object,p_member); slot===NARG===_method<T_object,T_member,T_return===TEMPLATE_ARG===> sTemp(p_object,p_member);
test.cpp
+12 -21
View File
@@ -2,8 +2,7 @@
#include <cstring> #include <cstring>
#include "slot.h" #include "signal.h"
#include "signal0.h"
class ParentFoo class ParentFoo
{ {
@@ -35,37 +34,29 @@ public:
} }
}; };
Foo f;
bool somefunc() bool somefunc()
{ {
printf("some func\n"); printf("some func\n");
return true; return true;
} }
template <class T_class, typename T_method> void anotherfunc(int x)
slot0_method<T_class,T_method>* make_slot(T_class* c, T_method m)
{ {
return new slot0_method<T_class,T_method>(c,m); printf("got %d\n",x);
} }
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
slot0* s = make_slot(&f,&Foo::Bar); Foo f;
slot0* t = make_slot(&f,&ParentFoo::Bar);
slot0_function<bool> x( somefunc ); signal<bool> sig;
slot0* u = &x;
if ( *s == *t )
(*s)();
(*u)();
signal0 sig;
sig.connect(&f,&Foo::Bar); sig.connect(&f,&Foo::Bar);
sig.connect(&f,&ParentFoo::Bar);
sig.connect(&somefunc);
sig(); sig();
}
signal<void,int> sigx;
sigx.connect(&anotherfunc);
sigx(12);
sigx(999);
}