convert all line-endings to unix. remove slot.h.
This commit is contained in:
swaits committed
1 parent
8ba8303868
commit
1ee19a654d
26 files changed
+4541
-4627
No files matched your search
+61
-61
@@ -1,62 +1,62 @@
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
|
||||
|
||||
#include "signal.h"
|
||||
|
||||
class ParentFoo
|
||||
{
|
||||
public:
|
||||
virtual bool Bar()
|
||||
{
|
||||
printf("ParentFoo::Bar!\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
virtual ~ParentFoo()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
};
|
||||
|
||||
class Foo: public ParentFoo
|
||||
{
|
||||
public:
|
||||
bool Bar()
|
||||
{
|
||||
printf("Foo::Bar!\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
virtual ~Foo()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
};
|
||||
|
||||
bool somefunc()
|
||||
{
|
||||
printf("some func\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
void anotherfunc(int x)
|
||||
{
|
||||
printf("got %d\n",x);
|
||||
}
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
Foo f;
|
||||
|
||||
signal<bool> sig;
|
||||
sig.connect(&f,&Foo::Bar);
|
||||
sig.connect(&f,&ParentFoo::Bar);
|
||||
sig.connect(&somefunc);
|
||||
sig();
|
||||
|
||||
signal<void,int> sigx;
|
||||
sigx.connect(&anotherfunc);
|
||||
sigx(12);
|
||||
sigx(999);
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
|
||||
|
||||
#include "signal.h"
|
||||
|
||||
class ParentFoo
|
||||
{
|
||||
public:
|
||||
virtual bool Bar()
|
||||
{
|
||||
printf("ParentFoo::Bar!\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
virtual ~ParentFoo()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
};
|
||||
|
||||
class Foo: public ParentFoo
|
||||
{
|
||||
public:
|
||||
bool Bar()
|
||||
{
|
||||
printf("Foo::Bar!\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
virtual ~Foo()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
};
|
||||
|
||||
bool somefunc()
|
||||
{
|
||||
printf("some func\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
void anotherfunc(int x)
|
||||
{
|
||||
printf("got %d\n",x);
|
||||
}
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
Foo f;
|
||||
|
||||
signal<bool> sig;
|
||||
sig.connect(&f,&Foo::Bar);
|
||||
sig.connect(&f,&ParentFoo::Bar);
|
||||
sig.connect(&somefunc);
|
||||
sig();
|
||||
|
||||
signal<void,int> sigx;
|
||||
sigx.connect(&anotherfunc);
|
||||
sigx(12);
|
||||
sigx(999);
|
||||
}
|
||||
+56
-56
@@ -1,56 +1,56 @@
|
||||
#ifndef __horrible_cast_h__
|
||||
#define __horrible_cast_h__
|
||||
|
||||
|
||||
//horrible_union is used by {safe|dangerous}_horrible_cast to copy one arbitrary type to another
|
||||
template <typename t_out, typename t_in>
|
||||
union horrible_union
|
||||
{
|
||||
t_in in;
|
||||
t_out out;
|
||||
};
|
||||
|
||||
|
||||
// dangerous_horrible_cast uses horrible_union to blindly copy one arbitrary type to another
|
||||
//
|
||||
// the data is zeroed out (via memset) before copying, in the case that he input type is smaller
|
||||
// than the output type
|
||||
template <typename t_out, typename t_in>
|
||||
inline t_out dangerous_horrible_cast(t_in in)
|
||||
{
|
||||
// instance the union
|
||||
horrible_union<t_out,t_in> data;
|
||||
|
||||
// zero out the output part of the union (only if the input is actually smaller than the output)
|
||||
if ( sizeof(t_in) < sizeof(t_out) )
|
||||
{
|
||||
memset(&data.out,0,sizeof(data.out));
|
||||
}
|
||||
|
||||
// copy the input into the union
|
||||
data.in = in;
|
||||
|
||||
// return the output part out of the union
|
||||
return data.out;
|
||||
}
|
||||
|
||||
|
||||
// safe_horrible_cast is exactly like dangerous_horrible_cast, except it statically checks to make
|
||||
// certain that the output type (t_out) is at least large enough (in size) to store an instance of
|
||||
// the input type (t_in)
|
||||
//
|
||||
// note: if you use safe_horrible_cast to copy an instance of A to B, then you may safely use
|
||||
// dangerous_horrible_cast to copy an instance of B back to A.
|
||||
template <typename t_out, typename t_in>
|
||||
inline t_out safe_horrible_cast(t_in in)
|
||||
{
|
||||
// statically (compile-time) test if t_out is at least as big as t_in
|
||||
typedef int ERROR___horrible_union_is_too_small_to_store_input_type[(sizeof(t_in) <= sizeof(t_out)) ? 1 : -1];
|
||||
|
||||
// now just do the regular horrible_cast
|
||||
return dangerous_horrible_cast<t_out,t_in>(in);
|
||||
}
|
||||
|
||||
|
||||
#endif // __horrible_cast_h__
|
||||
|
||||
#ifndef __horrible_cast_h__
|
||||
#define __horrible_cast_h__
|
||||
|
||||
|
||||
//horrible_union is used by {safe|dangerous}_horrible_cast to copy one arbitrary type to another
|
||||
template <typename t_out, typename t_in>
|
||||
union horrible_union
|
||||
{
|
||||
t_in in;
|
||||
t_out out;
|
||||
};
|
||||
|
||||
|
||||
// dangerous_horrible_cast uses horrible_union to blindly copy one arbitrary type to another
|
||||
//
|
||||
// the data is zeroed out (via memset) before copying, in the case that he input type is smaller
|
||||
// than the output type
|
||||
template <typename t_out, typename t_in>
|
||||
inline t_out dangerous_horrible_cast(t_in in)
|
||||
{
|
||||
// instance the union
|
||||
horrible_union<t_out,t_in> data;
|
||||
|
||||
// zero out the output part of the union (only if the input is actually smaller than the output)
|
||||
if ( sizeof(t_in) < sizeof(t_out) )
|
||||
{
|
||||
memset(&data.out,0,sizeof(data.out));
|
||||
}
|
||||
|
||||
// copy the input into the union
|
||||
data.in = in;
|
||||
|
||||
// return the output part out of the union
|
||||
return data.out;
|
||||
}
|
||||
|
||||
|
||||
// safe_horrible_cast is exactly like dangerous_horrible_cast, except it statically checks to make
|
||||
// certain that the output type (t_out) is at least large enough (in size) to store an instance of
|
||||
// the input type (t_in)
|
||||
//
|
||||
// note: if you use safe_horrible_cast to copy an instance of A to B, then you may safely use
|
||||
// dangerous_horrible_cast to copy an instance of B back to A.
|
||||
template <typename t_out, typename t_in>
|
||||
inline t_out safe_horrible_cast(t_in in)
|
||||
{
|
||||
// statically (compile-time) test if t_out is at least as big as t_in
|
||||
typedef int ERROR___horrible_union_is_too_small_to_store_input_type[(sizeof(t_in) <= sizeof(t_out)) ? 1 : -1];
|
||||
|
||||
// now just do the regular horrible_cast
|
||||
return dangerous_horrible_cast<t_out,t_in>(in);
|
||||
}
|
||||
|
||||
|
||||
#endif // __horrible_cast_h__
|
||||
|
||||
@@ -1,131 +1,131 @@
|
||||
#ifndef __signal_h__
|
||||
#define __signal_h__
|
||||
|
||||
|
||||
|
||||
#include "signal0.h"
|
||||
#include "signal1.h"
|
||||
#include "signal2.h"
|
||||
#include "signal3.h"
|
||||
#include "signal4.h"
|
||||
#include "signal5.h"
|
||||
#include "signal6.h"
|
||||
#include "signal7.h"
|
||||
#include "signal8.h"
|
||||
#include "signal9.h"
|
||||
#include "signal10.h"
|
||||
#include "signal11.h"
|
||||
#include "signal12.h"
|
||||
#include "signal13.h"
|
||||
#include "signal14.h"
|
||||
#include "signal15.h"
|
||||
#include "signal16.h"
|
||||
|
||||
|
||||
|
||||
struct nilarg;
|
||||
|
||||
template <typename T_return, typename T_arg0=nilarg, typename T_arg1=nilarg, typename T_arg2=nilarg, typename T_arg3=nilarg, typename T_arg4=nilarg, typename T_arg5=nilarg, typename T_arg6=nilarg, typename T_arg7=nilarg, typename T_arg8=nilarg, typename T_arg9=nilarg, typename T_arg10=nilarg, typename T_arg11=nilarg, typename T_arg12=nilarg, typename T_arg13=nilarg, typename T_arg14=nilarg, typename T_arg15=nilarg>
|
||||
class signal :
|
||||
public signal16<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>
|
||||
{
|
||||
};
|
||||
|
||||
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 signal<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> :
|
||||
public signal15<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>
|
||||
{
|
||||
};
|
||||
|
||||
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 signal<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> :
|
||||
public signal14<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>
|
||||
{
|
||||
};
|
||||
|
||||
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 signal<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> :
|
||||
public signal13<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>
|
||||
{
|
||||
};
|
||||
|
||||
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 signal<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> :
|
||||
public signal12<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>
|
||||
{
|
||||
};
|
||||
|
||||
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 signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10> :
|
||||
public signal11<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, 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>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9> :
|
||||
public signal10<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, 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>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8> :
|
||||
public signal9<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, 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>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> :
|
||||
public signal8<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, 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>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> :
|
||||
public signal7<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> :
|
||||
public signal6<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4> :
|
||||
public signal5<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3> :
|
||||
public signal4<T_return, T_arg0, T_arg1, T_arg2, T_arg3>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2> :
|
||||
public signal3<T_return, T_arg0, T_arg1, T_arg2>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T_return, typename T_arg0, typename T_arg1>
|
||||
class signal<T_return, T_arg0, T_arg1> :
|
||||
public signal2<T_return, T_arg0, T_arg1>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T_return, typename T_arg0>
|
||||
class signal<T_return, T_arg0> :
|
||||
public signal1<T_return, T_arg0>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T_return>
|
||||
class signal<T_return> :
|
||||
public signal0<T_return>
|
||||
{
|
||||
};
|
||||
|
||||
|
||||
#endif // __signal_h__
|
||||
#ifndef __signal_h__
|
||||
#define __signal_h__
|
||||
|
||||
|
||||
|
||||
#include "signal0.h"
|
||||
#include "signal1.h"
|
||||
#include "signal2.h"
|
||||
#include "signal3.h"
|
||||
#include "signal4.h"
|
||||
#include "signal5.h"
|
||||
#include "signal6.h"
|
||||
#include "signal7.h"
|
||||
#include "signal8.h"
|
||||
#include "signal9.h"
|
||||
#include "signal10.h"
|
||||
#include "signal11.h"
|
||||
#include "signal12.h"
|
||||
#include "signal13.h"
|
||||
#include "signal14.h"
|
||||
#include "signal15.h"
|
||||
#include "signal16.h"
|
||||
|
||||
|
||||
|
||||
struct nilarg;
|
||||
|
||||
template <typename T_return, typename T_arg0=nilarg, typename T_arg1=nilarg, typename T_arg2=nilarg, typename T_arg3=nilarg, typename T_arg4=nilarg, typename T_arg5=nilarg, typename T_arg6=nilarg, typename T_arg7=nilarg, typename T_arg8=nilarg, typename T_arg9=nilarg, typename T_arg10=nilarg, typename T_arg11=nilarg, typename T_arg12=nilarg, typename T_arg13=nilarg, typename T_arg14=nilarg, typename T_arg15=nilarg>
|
||||
class signal :
|
||||
public signal16<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>
|
||||
{
|
||||
};
|
||||
|
||||
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 signal<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> :
|
||||
public signal15<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>
|
||||
{
|
||||
};
|
||||
|
||||
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 signal<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> :
|
||||
public signal14<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>
|
||||
{
|
||||
};
|
||||
|
||||
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 signal<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> :
|
||||
public signal13<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>
|
||||
{
|
||||
};
|
||||
|
||||
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 signal<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> :
|
||||
public signal12<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>
|
||||
{
|
||||
};
|
||||
|
||||
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 signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, T_arg10> :
|
||||
public signal11<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9, 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>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9> :
|
||||
public signal10<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, 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>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8> :
|
||||
public signal9<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, 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>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> :
|
||||
public signal8<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, 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>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> :
|
||||
public signal7<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> :
|
||||
public signal6<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4> :
|
||||
public signal5<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2, T_arg3> :
|
||||
public signal4<T_return, T_arg0, T_arg1, T_arg2, T_arg3>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2>
|
||||
class signal<T_return, T_arg0, T_arg1, T_arg2> :
|
||||
public signal3<T_return, T_arg0, T_arg1, T_arg2>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T_return, typename T_arg0, typename T_arg1>
|
||||
class signal<T_return, T_arg0, T_arg1> :
|
||||
public signal2<T_return, T_arg0, T_arg1>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T_return, typename T_arg0>
|
||||
class signal<T_return, T_arg0> :
|
||||
public signal1<T_return, T_arg0>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename T_return>
|
||||
class signal<T_return> :
|
||||
public signal0<T_return>
|
||||
{
|
||||
};
|
||||
|
||||
|
||||
#endif // __signal_h__
|
||||
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal0_h__
|
||||
#define __signal0_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot0, slot0_function, and slot0_method
|
||||
//
|
||||
|
||||
//
|
||||
// Abstract base class for slots with 0 parameter(s).
|
||||
//
|
||||
template<typename T_return>
|
||||
class slot0: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() () const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return>
|
||||
class slot0_function: public slot0<T_return>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot0_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() () const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func();
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return>
|
||||
class slot0_method: public slot0<T_return>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot0_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() () const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal0
|
||||
//
|
||||
template< typename T_return >
|
||||
class signal0: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() ()
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal0<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot0 pointer (converts from raw memory to pointer again)
|
||||
slot0<T_return>* s = static_cast<slot0<T_return>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)();
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
typedef T_return (*FUNCTION_POINTER)();
|
||||
|
||||
// connect to normal functions
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// make a copy of the slot to store in our list
|
||||
slot0<T_return>* sNewFunc = new slot0_function<T_return>( func );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// make a temporary slot we can use to find a match in the list
|
||||
slot0_function<T_return> sTest( func );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
slot0_method<T_object,T_member,T_return> sTemp(p_object,p_member);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal0_h__
|
||||
#ifndef __signal0_h__
|
||||
#define __signal0_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot0, slot0_function, and slot0_method
|
||||
//
|
||||
|
||||
//
|
||||
// Abstract base class for slots with 0 parameter(s).
|
||||
//
|
||||
template<typename T_return>
|
||||
class slot0: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() () const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return>
|
||||
class slot0_function: public slot0<T_return>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot0_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() () const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func();
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return>
|
||||
class slot0_method: public slot0<T_return>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot0_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() () const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal0
|
||||
//
|
||||
template< typename T_return >
|
||||
class signal0: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() ()
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal0<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot0 pointer (converts from raw memory to pointer again)
|
||||
slot0<T_return>* s = static_cast<slot0<T_return>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)();
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
typedef T_return (*FUNCTION_POINTER)();
|
||||
|
||||
// connect to normal functions
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// make a copy of the slot to store in our list
|
||||
slot0<T_return>* sNewFunc = new slot0_function<T_return>( func );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// make a temporary slot we can use to find a match in the list
|
||||
slot0_function<T_return> sTest( func );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
slot0_method<T_object,T_member,T_return> sTemp(p_object,p_member);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal0_h__
|
||||
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal1_h__
|
||||
#define __signal1_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot1, slot1_function, and slot1_method
|
||||
//
|
||||
|
||||
//
|
||||
// Abstract base class for slots with 1 parameter(s).
|
||||
//
|
||||
template<typename T_return, typename T_arg0>
|
||||
class slot1: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return, typename T_arg0>
|
||||
class slot1_function: public slot1<T_return, T_arg0>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot1_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return, typename T_arg0>
|
||||
class slot1_method: public slot1<T_return, T_arg0>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot1_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal1
|
||||
//
|
||||
template< typename T_return, typename T_arg0 >
|
||||
class signal1: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal1<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot1 pointer (converts from raw memory to pointer again)
|
||||
slot1<T_return, T_arg0>* s = static_cast<slot1<T_return, T_arg0>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0);
|
||||
|
||||
// connect to normal functions
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// make a temporary slot we can use to find a match in the list
|
||||
slot1_function<T_return, T_arg0> sTest( func );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
slot1_method<T_object,T_member,T_return, T_arg0> sTemp(p_object,p_member);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal1_h__
|
||||
#ifndef __signal1_h__
|
||||
#define __signal1_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot1, slot1_function, and slot1_method
|
||||
//
|
||||
|
||||
//
|
||||
// Abstract base class for slots with 1 parameter(s).
|
||||
//
|
||||
template<typename T_return, typename T_arg0>
|
||||
class slot1: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return, typename T_arg0>
|
||||
class slot1_function: public slot1<T_return, T_arg0>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot1_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return, typename T_arg0>
|
||||
class slot1_method: public slot1<T_return, T_arg0>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot1_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal1
|
||||
//
|
||||
template< typename T_return, typename T_arg0 >
|
||||
class signal1: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal1<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot1 pointer (converts from raw memory to pointer again)
|
||||
slot1<T_return, T_arg0>* s = static_cast<slot1<T_return, T_arg0>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0);
|
||||
|
||||
// connect to normal functions
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// make a temporary slot we can use to find a match in the list
|
||||
slot1_function<T_return, T_arg0> sTest( func );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
slot1_method<T_object,T_member,T_return, T_arg0> sTemp(p_object,p_member);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal1_h__
|
||||
+214
-214
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal10_h__
|
||||
#define __signal10_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot10, slot10_function, and slot10_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot10: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public slot10<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot10_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public slot10<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot10_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal10
|
||||
//
|
||||
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 signal10: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal10<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot10 pointer (converts from raw memory to pointer again)
|
||||
slot10<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>* s = static_cast<slot10<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal10_h__
|
||||
#ifndef __signal10_h__
|
||||
#define __signal10_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot10, slot10_function, and slot10_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot10: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public slot10<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot10_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public slot10<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot10_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal10
|
||||
//
|
||||
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 signal10: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal10<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot10 pointer (converts from raw memory to pointer again)
|
||||
slot10<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>* s = static_cast<slot10<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8, T_arg9>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal10_h__
|
||||
+214
-214
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal11_h__
|
||||
#define __signal11_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot11, slot11_function, and slot11_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot11: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot11_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot11_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal11
|
||||
//
|
||||
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 signal11: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal11<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot11 pointer (converts from raw memory to pointer again)
|
||||
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>* s = static_cast<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>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal11_h__
|
||||
#ifndef __signal11_h__
|
||||
#define __signal11_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot11, slot11_function, and slot11_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot11: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot11_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot11_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal11
|
||||
//
|
||||
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 signal11: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal11<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot11 pointer (converts from raw memory to pointer again)
|
||||
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>* s = static_cast<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>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal11_h__
|
||||
+214
-214
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal12_h__
|
||||
#define __signal12_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot12, slot12_function, and slot12_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot12: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot12_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot12_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal12
|
||||
//
|
||||
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 signal12: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal12<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot12 pointer (converts from raw memory to pointer again)
|
||||
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>* s = static_cast<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>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal12_h__
|
||||
#ifndef __signal12_h__
|
||||
#define __signal12_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot12, slot12_function, and slot12_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot12: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot12_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot12_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal12
|
||||
//
|
||||
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 signal12: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal12<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot12 pointer (converts from raw memory to pointer again)
|
||||
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>* s = static_cast<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>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal12_h__
|
||||
+214
-214
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal13_h__
|
||||
#define __signal13_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot13, slot13_function, and slot13_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot13: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot13_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot13_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal13
|
||||
//
|
||||
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 signal13: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal13<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot13 pointer (converts from raw memory to pointer again)
|
||||
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>* s = static_cast<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>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal13_h__
|
||||
#ifndef __signal13_h__
|
||||
#define __signal13_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot13, slot13_function, and slot13_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot13: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot13_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot13_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal13
|
||||
//
|
||||
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 signal13: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal13<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot13 pointer (converts from raw memory to pointer again)
|
||||
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>* s = static_cast<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>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal13_h__
|
||||
+214
-214
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal14_h__
|
||||
#define __signal14_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot14, slot14_function, and slot14_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot14: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot14_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot14_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal14
|
||||
//
|
||||
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 signal14: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal14<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot14 pointer (converts from raw memory to pointer again)
|
||||
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>* s = static_cast<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>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal14_h__
|
||||
#ifndef __signal14_h__
|
||||
#define __signal14_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot14, slot14_function, and slot14_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot14: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot14_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot14_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal14
|
||||
//
|
||||
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 signal14: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal14<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot14 pointer (converts from raw memory to pointer again)
|
||||
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>* s = static_cast<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>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal14_h__
|
||||
+214
-214
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal15_h__
|
||||
#define __signal15_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot15, slot15_function, and slot15_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot15: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot15_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot15_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal15
|
||||
//
|
||||
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 signal15: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal15<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot15 pointer (converts from raw memory to pointer again)
|
||||
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>* s = static_cast<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>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal15_h__
|
||||
#ifndef __signal15_h__
|
||||
#define __signal15_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot15, slot15_function, and slot15_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot15: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot15_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot15_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal15
|
||||
//
|
||||
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 signal15: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal15<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot15 pointer (converts from raw memory to pointer again)
|
||||
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>* s = static_cast<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>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal15_h__
|
||||
+214
-214
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal16_h__
|
||||
#define __signal16_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot16, slot16_function, and slot16_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot16: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot16_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot16_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal16
|
||||
//
|
||||
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 signal16: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal16<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot16 pointer (converts from raw memory to pointer again)
|
||||
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>* s = static_cast<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>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal16_h__
|
||||
#ifndef __signal16_h__
|
||||
#define __signal16_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot16, slot16_function, and slot16_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot16: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot16_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public 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>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot16_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal16
|
||||
//
|
||||
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 signal16: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal16<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot16 pointer (converts from raw memory to pointer again)
|
||||
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>* s = static_cast<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>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal16_h__
|
||||
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal2_h__
|
||||
#define __signal2_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot2, slot2_function, and slot2_method
|
||||
//
|
||||
|
||||
//
|
||||
// Abstract base class for slots with 2 parameter(s).
|
||||
//
|
||||
template<typename T_return, typename T_arg0, typename T_arg1>
|
||||
class slot2: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0, T_arg1 a1) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return, typename T_arg0, typename T_arg1>
|
||||
class slot2_function: public slot2<T_return, T_arg0, T_arg1>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot2_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return, typename T_arg0, typename T_arg1>
|
||||
class slot2_method: public slot2<T_return, T_arg0, T_arg1>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot2_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal2
|
||||
//
|
||||
template< typename T_return, typename T_arg0, typename T_arg1 >
|
||||
class signal2: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0, T_arg1 a1)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal2<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot2 pointer (converts from raw memory to pointer again)
|
||||
slot2<T_return, T_arg0, T_arg1>* s = static_cast<slot2<T_return, T_arg0, T_arg1>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1);
|
||||
|
||||
// connect to normal functions
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// make a temporary slot we can use to find a match in the list
|
||||
slot2_function<T_return, T_arg0, T_arg1> sTest( func );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
slot2_method<T_object,T_member,T_return, T_arg0, T_arg1> sTemp(p_object,p_member);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal2_h__
|
||||
#ifndef __signal2_h__
|
||||
#define __signal2_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot2, slot2_function, and slot2_method
|
||||
//
|
||||
|
||||
//
|
||||
// Abstract base class for slots with 2 parameter(s).
|
||||
//
|
||||
template<typename T_return, typename T_arg0, typename T_arg1>
|
||||
class slot2: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0, T_arg1 a1) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return, typename T_arg0, typename T_arg1>
|
||||
class slot2_function: public slot2<T_return, T_arg0, T_arg1>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot2_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return, typename T_arg0, typename T_arg1>
|
||||
class slot2_method: public slot2<T_return, T_arg0, T_arg1>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot2_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal2
|
||||
//
|
||||
template< typename T_return, typename T_arg0, typename T_arg1 >
|
||||
class signal2: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0, T_arg1 a1)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal2<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot2 pointer (converts from raw memory to pointer again)
|
||||
slot2<T_return, T_arg0, T_arg1>* s = static_cast<slot2<T_return, T_arg0, T_arg1>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1);
|
||||
|
||||
// connect to normal functions
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// make a temporary slot we can use to find a match in the list
|
||||
slot2_function<T_return, T_arg0, T_arg1> sTest( func );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
slot2_method<T_object,T_member,T_return, T_arg0, T_arg1> sTemp(p_object,p_member);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal2_h__
|
||||
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal3_h__
|
||||
#define __signal3_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot3, slot3_function, and slot3_method
|
||||
//
|
||||
|
||||
//
|
||||
// Abstract base class for slots with 3 parameter(s).
|
||||
//
|
||||
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2>
|
||||
class slot3: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2>
|
||||
class slot3_function: public slot3<T_return, T_arg0, T_arg1, T_arg2>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot3_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return, typename T_arg0, typename T_arg1, typename T_arg2>
|
||||
class slot3_method: public slot3<T_return, T_arg0, T_arg1, T_arg2>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot3_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal3
|
||||
//
|
||||
template< typename T_return, typename T_arg0, typename T_arg1, typename T_arg2 >
|
||||
class signal3: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal3<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot3 pointer (converts from raw memory to pointer again)
|
||||
slot3<T_return, T_arg0, T_arg1, T_arg2>* s = static_cast<slot3<T_return, T_arg0, T_arg1, T_arg2>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2);
|
||||
|
||||
// connect to normal functions
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
slot3_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2> sTemp(p_object,p_member);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal3_h__
|
||||
#ifndef __signal3_h__
|
||||
#define __signal3_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot3, slot3_function, and slot3_method
|
||||
//
|
||||
|
||||
//
|
||||
// Abstract base class for slots with 3 parameter(s).
|
||||
//
|
||||
template<typename T_return, typename T_arg0, typename T_arg1, typename T_arg2>
|
||||
class slot3: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2>
|
||||
class slot3_function: public slot3<T_return, T_arg0, T_arg1, T_arg2>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot3_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return, typename T_arg0, typename T_arg1, typename T_arg2>
|
||||
class slot3_method: public slot3<T_return, T_arg0, T_arg1, T_arg2>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot3_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal3
|
||||
//
|
||||
template< typename T_return, typename T_arg0, typename T_arg1, typename T_arg2 >
|
||||
class signal3: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal3<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot3 pointer (converts from raw memory to pointer again)
|
||||
slot3<T_return, T_arg0, T_arg1, T_arg2>* s = static_cast<slot3<T_return, T_arg0, T_arg1, T_arg2>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2);
|
||||
|
||||
// connect to normal functions
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
slot3_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2> sTemp(p_object,p_member);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal3_h__
|
||||
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal4_h__
|
||||
#define __signal4_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot4, slot4_function, and slot4_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot4: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3>
|
||||
class slot4_function: public slot4<T_return, T_arg0, T_arg1, T_arg2, T_arg3>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot4_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3>
|
||||
class slot4_method: public slot4<T_return, T_arg0, T_arg1, T_arg2, T_arg3>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot4_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal4
|
||||
//
|
||||
template< typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3 >
|
||||
class signal4: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal4<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot4 pointer (converts from raw memory to pointer again)
|
||||
slot4<T_return, T_arg0, T_arg1, T_arg2, T_arg3>* s = static_cast<slot4<T_return, T_arg0, T_arg1, T_arg2, T_arg3>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3);
|
||||
|
||||
// connect to normal functions
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
slot4_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3> sTemp(p_object,p_member);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal4_h__
|
||||
#ifndef __signal4_h__
|
||||
#define __signal4_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot4, slot4_function, and slot4_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot4: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3>
|
||||
class slot4_function: public slot4<T_return, T_arg0, T_arg1, T_arg2, T_arg3>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot4_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3>
|
||||
class slot4_method: public slot4<T_return, T_arg0, T_arg1, T_arg2, T_arg3>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot4_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal4
|
||||
//
|
||||
template< typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3 >
|
||||
class signal4: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal4<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot4 pointer (converts from raw memory to pointer again)
|
||||
slot4<T_return, T_arg0, T_arg1, T_arg2, T_arg3>* s = static_cast<slot4<T_return, T_arg0, T_arg1, T_arg2, T_arg3>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3);
|
||||
|
||||
// connect to normal functions
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
slot4_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3> sTemp(p_object,p_member);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal4_h__
|
||||
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal5_h__
|
||||
#define __signal5_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot5, slot5_function, and slot5_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot5: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
|
||||
class slot5_function: public slot5<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot5_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
|
||||
class slot5_method: public slot5<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot5_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal5
|
||||
//
|
||||
template< typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
|
||||
class signal5: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal5<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot5 pointer (converts from raw memory to pointer again)
|
||||
slot5<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>* s = static_cast<slot5<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4);
|
||||
|
||||
// connect to normal functions
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
slot5_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4> sTemp(p_object,p_member);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal5_h__
|
||||
#ifndef __signal5_h__
|
||||
#define __signal5_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot5, slot5_function, and slot5_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot5: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
|
||||
class slot5_function: public slot5<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot5_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
|
||||
class slot5_method: public slot5<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot5_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal5
|
||||
//
|
||||
template< typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
|
||||
class signal5: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal5<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot5 pointer (converts from raw memory to pointer again)
|
||||
slot5<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>* s = static_cast<slot5<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4);
|
||||
|
||||
// connect to normal functions
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
slot5_method<T_object,T_member,T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4> sTemp(p_object,p_member);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal5_h__
|
||||
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal6_h__
|
||||
#define __signal6_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot6, slot6_function, and slot6_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot6: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
|
||||
class slot6_function: public slot6<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot6_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
|
||||
class slot6_method: public slot6<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot6_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal6
|
||||
//
|
||||
template< typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
|
||||
class signal6: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal6<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot6 pointer (converts from raw memory to pointer again)
|
||||
slot6<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* s = static_cast<slot6<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal6_h__
|
||||
#ifndef __signal6_h__
|
||||
#define __signal6_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot6, slot6_function, and slot6_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot6: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
|
||||
class slot6_function: public slot6<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot6_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
|
||||
class slot6_method: public slot6<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot6_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal6
|
||||
//
|
||||
template< typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
|
||||
class signal6: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal6<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot6 pointer (converts from raw memory to pointer again)
|
||||
slot6<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* s = static_cast<slot6<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal6_h__
|
||||
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal7_h__
|
||||
#define __signal7_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot7, slot7_function, and slot7_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot7: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public slot7<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot7_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public slot7<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot7_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal7
|
||||
//
|
||||
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 signal7: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal7<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot7 pointer (converts from raw memory to pointer again)
|
||||
slot7<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* s = static_cast<slot7<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal7_h__
|
||||
#ifndef __signal7_h__
|
||||
#define __signal7_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot7, slot7_function, and slot7_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot7: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public slot7<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot7_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public slot7<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot7_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal7
|
||||
//
|
||||
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 signal7: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal7<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot7 pointer (converts from raw memory to pointer again)
|
||||
slot7<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* s = static_cast<slot7<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal7_h__
|
||||
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal8_h__
|
||||
#define __signal8_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot8, slot8_function, and slot8_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot8: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public slot8<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot8_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public slot8<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot8_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal8
|
||||
//
|
||||
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 signal8: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal8<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot8 pointer (converts from raw memory to pointer again)
|
||||
slot8<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* s = static_cast<slot8<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal8_h__
|
||||
#ifndef __signal8_h__
|
||||
#define __signal8_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot8, slot8_function, and slot8_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot8: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public slot8<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot8_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public slot8<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot8_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal8
|
||||
//
|
||||
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 signal8: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6, T_arg7 a7)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal8<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot8 pointer (converts from raw memory to pointer again)
|
||||
slot8<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* s = static_cast<slot8<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal8_h__
|
||||
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal9_h__
|
||||
#define __signal9_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot9, slot9_function, and slot9_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot9: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public slot9<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot9_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public slot9<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot9_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal9
|
||||
//
|
||||
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 signal9: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal9<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot9 pointer (converts from raw memory to pointer again)
|
||||
slot9<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>* s = static_cast<slot9<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal9_h__
|
||||
#ifndef __signal9_h__
|
||||
#define __signal9_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot9, slot9_function, and slot9_method
|
||||
//
|
||||
|
||||
//
|
||||
// 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>
|
||||
class slot9: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (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) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
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_function: public slot9<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>
|
||||
{
|
||||
public:
|
||||
|
||||
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); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot9_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(a0, a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, 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_method: public slot9<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot9_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (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) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(a0, a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal9
|
||||
//
|
||||
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 signal9: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (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)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal9<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot9 pointer (converts from raw memory to pointer again)
|
||||
slot9<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>* s = static_cast<slot9<T_return, T_arg0, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_arg8>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
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
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
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);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal9_h__
|
||||
+228
-228
@@ -1,228 +1,228 @@
|
||||
#include <cassert>
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
signal_base::signal_base() : head(0), tail(0), emitting(false)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
signal_base::~signal_base()
|
||||
{
|
||||
// clear the list
|
||||
clear_list();
|
||||
}
|
||||
|
||||
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.
|
||||
// There are too many places where the signals are directly connected to objects,
|
||||
// where copying them would create a disconnect between the signal and the objects
|
||||
// that want to react to the signal execution.
|
||||
assert( 0 );
|
||||
}
|
||||
|
||||
signal_base& signal_base::operator=( const signal_base& rSource )
|
||||
{
|
||||
// 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,
|
||||
// where copying them would create a disconnect between the signal and the objects
|
||||
// that want to react to the signal execution.
|
||||
assert( 0 );
|
||||
return *this;
|
||||
}
|
||||
|
||||
int signal_base::count( void )
|
||||
{
|
||||
int count = 0;
|
||||
list_node* cur = head;
|
||||
|
||||
while( cur )
|
||||
{
|
||||
cur = cur->next;
|
||||
count++;
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
bool signal_base::bind(slot_base* slot)
|
||||
{
|
||||
// add it to our signal list
|
||||
return add_to_list(slot);
|
||||
}
|
||||
|
||||
bool signal_base::unbind(slot_base* slot)
|
||||
{
|
||||
// look for corresponding list_node in list
|
||||
list_node* n = find_in_list(slot);
|
||||
|
||||
// see if we found a match
|
||||
if( n )
|
||||
{
|
||||
// If we are not processing a signal emit sequence, then release the node.
|
||||
if( !emitting )
|
||||
{
|
||||
// take it out of the linked list
|
||||
remove_from_list(n);
|
||||
|
||||
// found a match, return success
|
||||
return true;
|
||||
}
|
||||
// Otherwise mark it for removal.
|
||||
else
|
||||
{
|
||||
n->deleted = true;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// no match
|
||||
return false;
|
||||
}
|
||||
|
||||
signal_base::list_node::list_node(slot_base* s) : slot(s), prev(0), next(0), deleted(false)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
signal_base::list_node::~list_node()
|
||||
{
|
||||
// release the slot
|
||||
delete slot;
|
||||
}
|
||||
|
||||
|
||||
void signal_base::clear_list()
|
||||
{
|
||||
// start at head
|
||||
list_node* cur = head;
|
||||
|
||||
// iterate
|
||||
while ( cur )
|
||||
{
|
||||
// save off next so we can safely delete
|
||||
list_node* next = cur->next;
|
||||
|
||||
// free
|
||||
delete cur;
|
||||
|
||||
// advance
|
||||
cur = next;
|
||||
}
|
||||
|
||||
// reset head & tail
|
||||
head = tail = 0;
|
||||
}
|
||||
|
||||
signal_base::list_node* signal_base::find_in_list(slot_base* slot) const
|
||||
{
|
||||
// start search at head of list
|
||||
list_node* cur = head;
|
||||
|
||||
// search list for slot
|
||||
while ( cur )
|
||||
{
|
||||
// see if this is a match
|
||||
if ( *(cur->slot) == *(slot) ) // note comparing values, not addresses !!!
|
||||
{
|
||||
// we have a match, return it
|
||||
return cur;
|
||||
}
|
||||
|
||||
// advance to next in list
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// no match
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool signal_base::add_to_list(slot_base* slot)
|
||||
{
|
||||
// a sanity check
|
||||
assert((head && tail) || (!head && !tail));
|
||||
|
||||
// make a new list_node to hold this slot in the list
|
||||
// and initialize with this slot pointer
|
||||
list_node* node = new list_node(slot);
|
||||
assert(node);
|
||||
if ( !node )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// setup new list_node
|
||||
node->prev = tail; // prev is tail because we'll put this list_node behind it (i.e. the new tail)
|
||||
node->next = 0; // next is 0 because we'll put this list_node on the tail
|
||||
|
||||
// add to tail
|
||||
if ( tail )
|
||||
{
|
||||
// tail exists, just append
|
||||
tail->next = node; // insert item after current tail
|
||||
tail = node; // now have a new tail
|
||||
}
|
||||
else
|
||||
{
|
||||
// list is currently empty, add this new list_node
|
||||
head = tail = node; // now have a single list_node, which is also both the head and tail
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void signal_base::remove_from_list(list_node* n)
|
||||
{
|
||||
// do a little sanity checking
|
||||
assert((head && tail) || (!head && !tail));
|
||||
assert(n->prev == 0 || n->prev->next == n);
|
||||
assert(n->next == 0 || n->next->prev == n);
|
||||
|
||||
// if this is the head, set the new head
|
||||
if ( n == head )
|
||||
{
|
||||
head = n->next;
|
||||
}
|
||||
|
||||
// if this is the tail, set the new tail
|
||||
if ( n == tail )
|
||||
{
|
||||
tail = n->prev;
|
||||
}
|
||||
|
||||
// set list to skip over this list_node
|
||||
if ( n->prev )
|
||||
{
|
||||
n->prev->next = n->next;
|
||||
}
|
||||
if ( n->next )
|
||||
{
|
||||
n->next->prev = n->prev;
|
||||
}
|
||||
|
||||
// finally, destroy the node
|
||||
delete n;
|
||||
}
|
||||
|
||||
void signal_base::remove_pending_nodes( void )
|
||||
{
|
||||
list_node* cur = head;
|
||||
list_node* next;
|
||||
|
||||
while( cur )
|
||||
{
|
||||
// Prepare the next link in the list the removal stage.
|
||||
next = cur->next;
|
||||
|
||||
// Do we need to remove this link.
|
||||
if( cur->deleted )
|
||||
{
|
||||
remove_from_list( cur );
|
||||
}
|
||||
|
||||
// Go to the next item.
|
||||
cur = next;
|
||||
}
|
||||
}
|
||||
|
||||
#include <cassert>
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
signal_base::signal_base() : head(0), tail(0), emitting(false)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
signal_base::~signal_base()
|
||||
{
|
||||
// clear the list
|
||||
clear_list();
|
||||
}
|
||||
|
||||
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.
|
||||
// There are too many places where the signals are directly connected to objects,
|
||||
// where copying them would create a disconnect between the signal and the objects
|
||||
// that want to react to the signal execution.
|
||||
assert( 0 );
|
||||
}
|
||||
|
||||
signal_base& signal_base::operator=( const signal_base& rSource )
|
||||
{
|
||||
// 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,
|
||||
// where copying them would create a disconnect between the signal and the objects
|
||||
// that want to react to the signal execution.
|
||||
assert( 0 );
|
||||
return *this;
|
||||
}
|
||||
|
||||
int signal_base::count( void )
|
||||
{
|
||||
int count = 0;
|
||||
list_node* cur = head;
|
||||
|
||||
while( cur )
|
||||
{
|
||||
cur = cur->next;
|
||||
count++;
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
bool signal_base::bind(slot_base* slot)
|
||||
{
|
||||
// add it to our signal list
|
||||
return add_to_list(slot);
|
||||
}
|
||||
|
||||
bool signal_base::unbind(slot_base* slot)
|
||||
{
|
||||
// look for corresponding list_node in list
|
||||
list_node* n = find_in_list(slot);
|
||||
|
||||
// see if we found a match
|
||||
if( n )
|
||||
{
|
||||
// If we are not processing a signal emit sequence, then release the node.
|
||||
if( !emitting )
|
||||
{
|
||||
// take it out of the linked list
|
||||
remove_from_list(n);
|
||||
|
||||
// found a match, return success
|
||||
return true;
|
||||
}
|
||||
// Otherwise mark it for removal.
|
||||
else
|
||||
{
|
||||
n->deleted = true;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// no match
|
||||
return false;
|
||||
}
|
||||
|
||||
signal_base::list_node::list_node(slot_base* s) : slot(s), prev(0), next(0), deleted(false)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
signal_base::list_node::~list_node()
|
||||
{
|
||||
// release the slot
|
||||
delete slot;
|
||||
}
|
||||
|
||||
|
||||
void signal_base::clear_list()
|
||||
{
|
||||
// start at head
|
||||
list_node* cur = head;
|
||||
|
||||
// iterate
|
||||
while ( cur )
|
||||
{
|
||||
// save off next so we can safely delete
|
||||
list_node* next = cur->next;
|
||||
|
||||
// free
|
||||
delete cur;
|
||||
|
||||
// advance
|
||||
cur = next;
|
||||
}
|
||||
|
||||
// reset head & tail
|
||||
head = tail = 0;
|
||||
}
|
||||
|
||||
signal_base::list_node* signal_base::find_in_list(slot_base* slot) const
|
||||
{
|
||||
// start search at head of list
|
||||
list_node* cur = head;
|
||||
|
||||
// search list for slot
|
||||
while ( cur )
|
||||
{
|
||||
// see if this is a match
|
||||
if ( *(cur->slot) == *(slot) ) // note comparing values, not addresses !!!
|
||||
{
|
||||
// we have a match, return it
|
||||
return cur;
|
||||
}
|
||||
|
||||
// advance to next in list
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// no match
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool signal_base::add_to_list(slot_base* slot)
|
||||
{
|
||||
// a sanity check
|
||||
assert((head && tail) || (!head && !tail));
|
||||
|
||||
// make a new list_node to hold this slot in the list
|
||||
// and initialize with this slot pointer
|
||||
list_node* node = new list_node(slot);
|
||||
assert(node);
|
||||
if ( !node )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// setup new list_node
|
||||
node->prev = tail; // prev is tail because we'll put this list_node behind it (i.e. the new tail)
|
||||
node->next = 0; // next is 0 because we'll put this list_node on the tail
|
||||
|
||||
// add to tail
|
||||
if ( tail )
|
||||
{
|
||||
// tail exists, just append
|
||||
tail->next = node; // insert item after current tail
|
||||
tail = node; // now have a new tail
|
||||
}
|
||||
else
|
||||
{
|
||||
// list is currently empty, add this new list_node
|
||||
head = tail = node; // now have a single list_node, which is also both the head and tail
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void signal_base::remove_from_list(list_node* n)
|
||||
{
|
||||
// do a little sanity checking
|
||||
assert((head && tail) || (!head && !tail));
|
||||
assert(n->prev == 0 || n->prev->next == n);
|
||||
assert(n->next == 0 || n->next->prev == n);
|
||||
|
||||
// if this is the head, set the new head
|
||||
if ( n == head )
|
||||
{
|
||||
head = n->next;
|
||||
}
|
||||
|
||||
// if this is the tail, set the new tail
|
||||
if ( n == tail )
|
||||
{
|
||||
tail = n->prev;
|
||||
}
|
||||
|
||||
// set list to skip over this list_node
|
||||
if ( n->prev )
|
||||
{
|
||||
n->prev->next = n->next;
|
||||
}
|
||||
if ( n->next )
|
||||
{
|
||||
n->next->prev = n->prev;
|
||||
}
|
||||
|
||||
// finally, destroy the node
|
||||
delete n;
|
||||
}
|
||||
|
||||
void signal_base::remove_pending_nodes( void )
|
||||
{
|
||||
list_node* cur = head;
|
||||
list_node* next;
|
||||
|
||||
while( cur )
|
||||
{
|
||||
// Prepare the next link in the list the removal stage.
|
||||
next = cur->next;
|
||||
|
||||
// Do we need to remove this link.
|
||||
if( cur->deleted )
|
||||
{
|
||||
remove_from_list( cur );
|
||||
}
|
||||
|
||||
// Go to the next item.
|
||||
cur = next;
|
||||
}
|
||||
}
|
||||
|
||||
+117
-117
@@ -1,117 +1,117 @@
|
||||
#ifndef __signal_base_h__
|
||||
#define __signal_base_h__
|
||||
|
||||
#include "slot_base.h"
|
||||
|
||||
|
||||
/**
|
||||
* -----------------------------------------------------------------------------------------------------------------------------------------
|
||||
* Signals - An elegant system of that manages software events and the callbacks that respond to them.
|
||||
* -----------------------------------------------------------------------------------------------------------------------------------------
|
||||
*
|
||||
* Each discrete signal represents a moment within your application that might require some reaction. A signal might represent a
|
||||
* basketball going through the basket, or hitting the ground. Another signal might identify when a bullet was fired out of a gun.
|
||||
* There is no limit to what the signal represents.
|
||||
*
|
||||
* The reactions that need to be processed through the signal system are called "Slots". Slots are nothing more than a common interface
|
||||
* that the Signal can use to call many variations of callbacks with a single interface. Some have labelled slots as "Delegates" as they are
|
||||
* not the actual code that performs the reaction, but instead are used to translate the common reaction request into the actual callback that
|
||||
* is desired. Please see slot_base.h for more information.
|
||||
*
|
||||
*/
|
||||
class signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
signal_base();
|
||||
virtual ~signal_base();
|
||||
|
||||
signal_base( const signal_base& rSource );
|
||||
signal_base& operator=( const signal_base& rSource );
|
||||
|
||||
/**
|
||||
* Determines the number of slots that are connected to the signal.
|
||||
*/
|
||||
int count( void );
|
||||
|
||||
protected:
|
||||
// linked list data structure
|
||||
// used to maintain a list of pointers to slot_base.. no memory management is
|
||||
// performed on the slot_base data - derived class should take care of this.
|
||||
struct list_node
|
||||
{
|
||||
list_node(slot_base* s);
|
||||
~list_node();
|
||||
|
||||
slot_base* slot;
|
||||
list_node* prev;
|
||||
list_node* next;
|
||||
|
||||
bool deleted;
|
||||
};
|
||||
|
||||
/**
|
||||
* Request to add a slot to the signals reaction list that is processed when a signal is executed.
|
||||
*
|
||||
* @param slot A pointer to a slot base class that contains the required callback mechanism.
|
||||
*
|
||||
* @return true if the signal is able to add the slot.
|
||||
* false if the signal could NOT add the slot.
|
||||
*/
|
||||
bool bind(slot_base* slot);
|
||||
|
||||
/**
|
||||
* Request to remove a slot from the signals reaction list.
|
||||
*
|
||||
* @param slot A pointer to a slot base class that contains the required callback mechanism.
|
||||
*
|
||||
* @return true if the signal is able to remove the slot.
|
||||
* false if the signal could NOT remove the slot.
|
||||
*/
|
||||
bool unbind(slot_base* slot);
|
||||
|
||||
/**
|
||||
* Functions used to maintain the status of a signal. When a signal is active it means that it is "Emitting". During the emitting
|
||||
* stage, we are walking the list of slots to allow each slot to react to the signal. There are special considerations that
|
||||
* must be made when walking the list, such as adding or removing slots during the emit stage.
|
||||
*/
|
||||
|
||||
private:
|
||||
/**
|
||||
* Removes all slots that are connected to the signal
|
||||
*/
|
||||
void clear_list( );
|
||||
|
||||
/**
|
||||
* Searches the slot list to find a slot that contains the same components. The location within the list is returned.
|
||||
*/
|
||||
list_node* find_in_list(slot_base* slot) const;
|
||||
|
||||
/**
|
||||
* Performs the actual operation of adding the slot to signal's internal list.
|
||||
*/
|
||||
bool add_to_list(slot_base* slot);
|
||||
|
||||
/**
|
||||
* Performs the actual operation of removing the slot from the signal's internal list.
|
||||
*/
|
||||
void remove_from_list(list_node* n);
|
||||
|
||||
protected:
|
||||
|
||||
/**
|
||||
* Removes any nodes that were tagged for deletion during the signal emit sequence
|
||||
*/
|
||||
void remove_pending_nodes( void );
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
protected:
|
||||
|
||||
list_node* head;
|
||||
list_node* tail;
|
||||
|
||||
bool emitting;
|
||||
};
|
||||
|
||||
#endif // __signal_base_h__
|
||||
|
||||
#ifndef __signal_base_h__
|
||||
#define __signal_base_h__
|
||||
|
||||
#include "slot_base.h"
|
||||
|
||||
|
||||
/**
|
||||
* -----------------------------------------------------------------------------------------------------------------------------------------
|
||||
* Signals - An elegant system of that manages software events and the callbacks that respond to them.
|
||||
* -----------------------------------------------------------------------------------------------------------------------------------------
|
||||
*
|
||||
* Each discrete signal represents a moment within your application that might require some reaction. A signal might represent a
|
||||
* basketball going through the basket, or hitting the ground. Another signal might identify when a bullet was fired out of a gun.
|
||||
* There is no limit to what the signal represents.
|
||||
*
|
||||
* The reactions that need to be processed through the signal system are called "Slots". Slots are nothing more than a common interface
|
||||
* that the Signal can use to call many variations of callbacks with a single interface. Some have labelled slots as "Delegates" as they are
|
||||
* not the actual code that performs the reaction, but instead are used to translate the common reaction request into the actual callback that
|
||||
* is desired. Please see slot_base.h for more information.
|
||||
*
|
||||
*/
|
||||
class signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
signal_base();
|
||||
virtual ~signal_base();
|
||||
|
||||
signal_base( const signal_base& rSource );
|
||||
signal_base& operator=( const signal_base& rSource );
|
||||
|
||||
/**
|
||||
* Determines the number of slots that are connected to the signal.
|
||||
*/
|
||||
int count( void );
|
||||
|
||||
protected:
|
||||
// linked list data structure
|
||||
// used to maintain a list of pointers to slot_base.. no memory management is
|
||||
// performed on the slot_base data - derived class should take care of this.
|
||||
struct list_node
|
||||
{
|
||||
list_node(slot_base* s);
|
||||
~list_node();
|
||||
|
||||
slot_base* slot;
|
||||
list_node* prev;
|
||||
list_node* next;
|
||||
|
||||
bool deleted;
|
||||
};
|
||||
|
||||
/**
|
||||
* Request to add a slot to the signals reaction list that is processed when a signal is executed.
|
||||
*
|
||||
* @param slot A pointer to a slot base class that contains the required callback mechanism.
|
||||
*
|
||||
* @return true if the signal is able to add the slot.
|
||||
* false if the signal could NOT add the slot.
|
||||
*/
|
||||
bool bind(slot_base* slot);
|
||||
|
||||
/**
|
||||
* Request to remove a slot from the signals reaction list.
|
||||
*
|
||||
* @param slot A pointer to a slot base class that contains the required callback mechanism.
|
||||
*
|
||||
* @return true if the signal is able to remove the slot.
|
||||
* false if the signal could NOT remove the slot.
|
||||
*/
|
||||
bool unbind(slot_base* slot);
|
||||
|
||||
/**
|
||||
* Functions used to maintain the status of a signal. When a signal is active it means that it is "Emitting". During the emitting
|
||||
* stage, we are walking the list of slots to allow each slot to react to the signal. There are special considerations that
|
||||
* must be made when walking the list, such as adding or removing slots during the emit stage.
|
||||
*/
|
||||
|
||||
private:
|
||||
/**
|
||||
* Removes all slots that are connected to the signal
|
||||
*/
|
||||
void clear_list( );
|
||||
|
||||
/**
|
||||
* Searches the slot list to find a slot that contains the same components. The location within the list is returned.
|
||||
*/
|
||||
list_node* find_in_list(slot_base* slot) const;
|
||||
|
||||
/**
|
||||
* Performs the actual operation of adding the slot to signal's internal list.
|
||||
*/
|
||||
bool add_to_list(slot_base* slot);
|
||||
|
||||
/**
|
||||
* Performs the actual operation of removing the slot from the signal's internal list.
|
||||
*/
|
||||
void remove_from_list(list_node* n);
|
||||
|
||||
protected:
|
||||
|
||||
/**
|
||||
* Removes any nodes that were tagged for deletion during the signal emit sequence
|
||||
*/
|
||||
void remove_pending_nodes( void );
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
protected:
|
||||
|
||||
list_node* head;
|
||||
list_node* tail;
|
||||
|
||||
bool emitting;
|
||||
};
|
||||
|
||||
#endif // __signal_base_h__
|
||||
|
||||
+214
-214
@@ -1,214 +1,214 @@
|
||||
#ifndef __signal===NARG===_h__
|
||||
#define __signal===NARG===_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot===NARG===, slot===NARG===_function, and slot===NARG===_method
|
||||
//
|
||||
|
||||
//
|
||||
// Abstract base class for slots with ===NARG=== parameter(s).
|
||||
//
|
||||
template<typename T_return===TEMPLATE_ARG_DECL===>
|
||||
class slot===NARG===: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (===FORMAL_ARG_DECL===) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return===TEMPLATE_ARG_DECL===>
|
||||
class slot===NARG===_function: public slot===NARG===<T_return===TEMPLATE_ARG===>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(===FORMAL_ARG_DECL===); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot===NARG===_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (===FORMAL_ARG_DECL===) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(===FORMAL_ARG===);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return===TEMPLATE_ARG_DECL===>
|
||||
class slot===NARG===_method: public slot===NARG===<T_return===TEMPLATE_ARG===>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot===NARG===_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (===FORMAL_ARG_DECL===) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(===FORMAL_ARG===);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal===NARG===
|
||||
//
|
||||
template< typename T_return===TEMPLATE_ARG_DECL=== >
|
||||
class signal===NARG===: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (===FORMAL_ARG_DECL===)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal===NARG===<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot===NARG=== pointer (converts from raw memory to pointer again)
|
||||
slot===NARG===<T_return===TEMPLATE_ARG===>* s = static_cast<slot===NARG===<T_return===TEMPLATE_ARG===>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(===FORMAL_ARG===);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
typedef T_return (*FUNCTION_POINTER)(===FORMAL_ARG_DECL===);
|
||||
|
||||
// connect to normal functions
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// make a temporary slot we can use to find a match in the list
|
||||
slot===NARG===_function<T_return===TEMPLATE_ARG===> sTest( func );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
slot===NARG===_method<T_object,T_member,T_return===TEMPLATE_ARG===> sTemp(p_object,p_member);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal===NARG===_h__
|
||||
#ifndef __signal===NARG===_h__
|
||||
#define __signal===NARG===_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// classes slot===NARG===, slot===NARG===_function, and slot===NARG===_method
|
||||
//
|
||||
|
||||
//
|
||||
// Abstract base class for slots with ===NARG=== parameter(s).
|
||||
//
|
||||
template<typename T_return===TEMPLATE_ARG_DECL===>
|
||||
class slot===NARG===: public slot_base
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Method which performs the actual callback. Must be overridden.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
virtual T_return operator() (===FORMAL_ARG_DECL===) const = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for a normal function.
|
||||
//
|
||||
template <typename T_return===TEMPLATE_ARG_DECL===>
|
||||
class slot===NARG===_function: public slot===NARG===<T_return===TEMPLATE_ARG===>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)(===FORMAL_ARG_DECL===); // convenience typedef
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts a function pointer into raw data.
|
||||
*/
|
||||
slot===NARG===_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(func);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a function pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (===FORMAL_ARG_DECL===) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
return func(===FORMAL_ARG===);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// A concrete slot class for an object pointer and method (usually 'this' and 'Class::Method').
|
||||
//
|
||||
template <class T_object, typename T_member, typename T_return===TEMPLATE_ARG_DECL===>
|
||||
class slot===NARG===_method: public slot===NARG===<T_return===TEMPLATE_ARG===>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* Converts an object and method pointer into raw data.
|
||||
*/
|
||||
slot===NARG===_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<slot_base::data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<slot_base::data_container>(p_member);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform callback.
|
||||
*
|
||||
* Converts raw data back into a method pointer, and calls it.
|
||||
*
|
||||
* @return Returns an object of type T_return; the result of the user callback.
|
||||
*/
|
||||
T_return operator() (===FORMAL_ARG_DECL===) const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
return (p_object->*p_member)(===FORMAL_ARG===);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// class signal===NARG===
|
||||
//
|
||||
template< typename T_return===TEMPLATE_ARG_DECL=== >
|
||||
class signal===NARG===: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Emit the signal.
|
||||
*
|
||||
* Iterate through the list of slots, and call each one.
|
||||
*/
|
||||
void operator() (===FORMAL_ARG_DECL===)
|
||||
{
|
||||
// if we're already emitting, return (i.e. no re-entrancy allowed)
|
||||
if( signal_base::emitting )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: signal===NARG===<...> @ 0x%p recursive emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
signal_base::emitting = true;
|
||||
|
||||
// iterate through the list
|
||||
signal_base::list_node* cur = signal_base::head;
|
||||
while( cur )
|
||||
{
|
||||
// cast the slot_base pointer to a slot===NARG=== pointer (converts from raw memory to pointer again)
|
||||
slot===NARG===<T_return===TEMPLATE_ARG===>* s = static_cast<slot===NARG===<T_return===TEMPLATE_ARG===>*>(cur->slot);
|
||||
|
||||
// call the signal as long as it's still valid
|
||||
if ( !cur->deleted )
|
||||
{
|
||||
(*s)(===FORMAL_ARG===);
|
||||
}
|
||||
|
||||
// move to next slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// delete any pending slot deletions
|
||||
signal_base::remove_pending_nodes( );
|
||||
|
||||
// clear emitting flag
|
||||
signal_base::emitting = false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal connections to slots
|
||||
//
|
||||
|
||||
// convenience typedef
|
||||
typedef T_return (*FUNCTION_POINTER)(===FORMAL_ARG_DECL===);
|
||||
|
||||
// connect to normal functions
|
||||
bool connect( FUNCTION_POINTER func )
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewFunc);
|
||||
}
|
||||
|
||||
// connect to an object's method
|
||||
template <class T_object, typename T_member>
|
||||
bool connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
// 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 );
|
||||
|
||||
// add it to the end of our linked list
|
||||
return signal_base::bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections from slots
|
||||
//
|
||||
|
||||
// disconnect from a normal function
|
||||
bool disconnect( FUNCTION_POINTER func )
|
||||
{
|
||||
// make a temporary slot we can use to find a match in the list
|
||||
slot===NARG===_function<T_return===TEMPLATE_ARG===> sTest( func );
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTest);
|
||||
}
|
||||
|
||||
// disconnect from an object's method
|
||||
template <class T_object, typename T_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
|
||||
slot===NARG===_method<T_object,T_member,T_return===TEMPLATE_ARG===> sTemp(p_object,p_member);
|
||||
|
||||
// search and remove it
|
||||
return signal_base::unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal===NARG===_h__
|
||||
@@ -1,86 +0,0 @@
|
||||
#ifndef __slot_h__
|
||||
#define __slot_h__
|
||||
|
||||
|
||||
#include "slot_base.h"
|
||||
#include "horrible_cast.h"
|
||||
|
||||
|
||||
// TODO: do return types really matter???
|
||||
// if we get rid of them, slot0 untemplates, making signal completely untemplate as well!
|
||||
// maybe signal::Emit() should simply return the number of signals it emits?
|
||||
|
||||
|
||||
//
|
||||
// abstract base class for a slot taking 0 arguments
|
||||
//
|
||||
// this is basically just slot_base with the pure virtual "operator(...)" added
|
||||
//
|
||||
// each derivative of this should have NO storage of its own. Instead it should
|
||||
// store data in the slot_base (parent class) members 'data[]'. Use horrible_cast<>()
|
||||
// to subvert C++'s type system.
|
||||
//
|
||||
class slot0: public slot_base
|
||||
{
|
||||
public:
|
||||
|
||||
virtual void operator() () const = 0;
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
// a concrete slot class for a normal function
|
||||
//
|
||||
template <typename T_return>
|
||||
class slot0_function: public slot0
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T_return (*FUNCTION_POINTER)();
|
||||
|
||||
slot0_function(const FUNCTION_POINTER func)
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<data_container>(func);
|
||||
}
|
||||
|
||||
void operator() () const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to a function pointer
|
||||
FUNCTION_POINTER func = dangerous_horrible_cast<FUNCTION_POINTER>(this->data[0]);
|
||||
|
||||
// call function
|
||||
func();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
// a concrete slot class for an object pointer and method (usually 'this' and 'Class::Method')
|
||||
//
|
||||
template <class T_object, typename T_member>
|
||||
class slot0_method: public slot0
|
||||
{
|
||||
public:
|
||||
|
||||
slot0_method(const T_object* p_object, const T_member p_member)
|
||||
{
|
||||
// convert and store object pointer and member function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<data_container>(p_member);
|
||||
}
|
||||
|
||||
void operator() () const
|
||||
{
|
||||
// retrieve data from slot_base and convert back to an object pointer and member function pointer
|
||||
T_object* p_object = dangerous_horrible_cast<T_object*>(this->data[0]);
|
||||
T_member p_member = dangerous_horrible_cast<T_member> (this->data[1]);
|
||||
|
||||
// call member function
|
||||
(p_object->*p_member)();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
#endif // __slot_h__
|
||||
|
||||
+53
-53
@@ -1,53 +1,53 @@
|
||||
#include "slot_base.h"
|
||||
|
||||
|
||||
bool slot_base::data_container::operator== (const slot_base::data_container& other) const
|
||||
{
|
||||
// do a wordwise comparison
|
||||
for (int i=0;i<SIZE_IN_WORDS;++i)
|
||||
{
|
||||
if ( this->data[i] != other.data[i] )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// must be a perfect match
|
||||
return true;
|
||||
}
|
||||
|
||||
void slot_base::data_container::zero()
|
||||
{
|
||||
// do a bytewise zeroing
|
||||
for (int i=0;i<SIZE_IN_WORDS;++i)
|
||||
{
|
||||
this->data[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
slot_base::slot_base ()
|
||||
{
|
||||
for (int i=0;i<NUM_DATA_ITEMS;++i)
|
||||
{
|
||||
data[i].zero();
|
||||
}
|
||||
}
|
||||
|
||||
slot_base::~slot_base ()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
bool slot_base::operator== (const slot_base& other) const
|
||||
{
|
||||
// check each data item for inequality
|
||||
for (int i=0;i<NUM_DATA_ITEMS;++i)
|
||||
{
|
||||
if ( !(this->data[i] == other.data[i]) )
|
||||
return false;
|
||||
}
|
||||
|
||||
// all data matched
|
||||
return true;
|
||||
}
|
||||
|
||||
#include "slot_base.h"
|
||||
|
||||
|
||||
bool slot_base::data_container::operator== (const slot_base::data_container& other) const
|
||||
{
|
||||
// do a wordwise comparison
|
||||
for (int i=0;i<SIZE_IN_WORDS;++i)
|
||||
{
|
||||
if ( this->data[i] != other.data[i] )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// must be a perfect match
|
||||
return true;
|
||||
}
|
||||
|
||||
void slot_base::data_container::zero()
|
||||
{
|
||||
// do a bytewise zeroing
|
||||
for (int i=0;i<SIZE_IN_WORDS;++i)
|
||||
{
|
||||
this->data[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
slot_base::slot_base ()
|
||||
{
|
||||
for (int i=0;i<NUM_DATA_ITEMS;++i)
|
||||
{
|
||||
data[i].zero();
|
||||
}
|
||||
}
|
||||
|
||||
slot_base::~slot_base ()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
bool slot_base::operator== (const slot_base& other) const
|
||||
{
|
||||
// check each data item for inequality
|
||||
for (int i=0;i<NUM_DATA_ITEMS;++i)
|
||||
{
|
||||
if ( !(this->data[i] == other.data[i]) )
|
||||
return false;
|
||||
}
|
||||
|
||||
// all data matched
|
||||
return true;
|
||||
}
|
||||
|
||||
+43
-43
@@ -1,43 +1,43 @@
|
||||
#ifndef __slot_base_h__
|
||||
#define __slot_base_h__
|
||||
|
||||
class slot_base
|
||||
{
|
||||
public:
|
||||
|
||||
slot_base (); // constructor
|
||||
virtual ~slot_base (); // destructor
|
||||
|
||||
bool operator== (const slot_base& other) const;
|
||||
|
||||
// note: copy constructor, assignment operator not specified. use compiler-generated versions.
|
||||
|
||||
protected:
|
||||
|
||||
// a generic type to hold a chunk of raw data. we use it to store a pointer, virtual method function pointer, etc.
|
||||
struct data_container
|
||||
{
|
||||
// should be at least as large as the largest type you want
|
||||
// to store in one of these
|
||||
enum { SIZE_IN_WORDS = 8 };
|
||||
enum { SIZE_IN_BYTES = SIZE_IN_WORDS*sizeof(unsigned int) };
|
||||
|
||||
// the actual storage space
|
||||
unsigned int data[SIZE_IN_WORDS];
|
||||
|
||||
// an equality operator
|
||||
bool operator== (const data_container& other) const;
|
||||
|
||||
// a method to set to empty (zero)
|
||||
void zero();
|
||||
};
|
||||
|
||||
// number of pointers, etc. we'll track in this class
|
||||
enum { NUM_DATA_ITEMS = 2 };
|
||||
|
||||
// storage for function pointers, etc. hoisted out of derivative slots
|
||||
data_container data[NUM_DATA_ITEMS];
|
||||
};
|
||||
|
||||
#endif // __slot_base_h__
|
||||
|
||||
#ifndef __slot_base_h__
|
||||
#define __slot_base_h__
|
||||
|
||||
class slot_base
|
||||
{
|
||||
public:
|
||||
|
||||
slot_base (); // constructor
|
||||
virtual ~slot_base (); // destructor
|
||||
|
||||
bool operator== (const slot_base& other) const;
|
||||
|
||||
// note: copy constructor, assignment operator not specified. use compiler-generated versions.
|
||||
|
||||
protected:
|
||||
|
||||
// a generic type to hold a chunk of raw data. we use it to store a pointer, virtual method function pointer, etc.
|
||||
struct data_container
|
||||
{
|
||||
// should be at least as large as the largest type you want
|
||||
// to store in one of these
|
||||
enum { SIZE_IN_WORDS = 8 };
|
||||
enum { SIZE_IN_BYTES = SIZE_IN_WORDS*sizeof(unsigned int) };
|
||||
|
||||
// the actual storage space
|
||||
unsigned int data[SIZE_IN_WORDS];
|
||||
|
||||
// an equality operator
|
||||
bool operator== (const data_container& other) const;
|
||||
|
||||
// a method to set to empty (zero)
|
||||
void zero();
|
||||
};
|
||||
|
||||
// number of pointers, etc. we'll track in this class
|
||||
enum { NUM_DATA_ITEMS = 2 };
|
||||
|
||||
// storage for function pointers, etc. hoisted out of derivative slots
|
||||
data_container data[NUM_DATA_ITEMS];
|
||||
};
|
||||
|
||||
#endif // __slot_base_h__
|
||||
|
||||
Reference in new issue
Block a user