updated to latest signals. some cleanup & refactoring begun.
This commit is contained in:
swaits committed
1 parent
ef1b465179
commit
c7d43807e3
28 files changed
+3892
-235
No files matched your search
+1
-1
@@ -2,7 +2,7 @@
|
||||
#define __horrible_cast_h__
|
||||
|
||||
|
||||
// horrible_union is used by {safe|dangerous}_horrible_cast to copy one arbitrary type to another
|
||||
//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
|
||||
{
|
||||
|
||||
Whitespace-only changes.
@@ -0,0 +1,134 @@
|
||||
#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>
|
||||
{
|
||||
};
|
||||
|
||||
|
||||
#include "signal/FixedArgSlot.h"
|
||||
|
||||
|
||||
#endif // __Signal_h__
|
||||
@@ -0,0 +1,103 @@
|
||||
#!/usr/bin/perl
|
||||
|
||||
##############################################################
|
||||
# script to generate signal*.h files from signal_template.h
|
||||
##############################################################
|
||||
|
||||
|
||||
##############################################
|
||||
#
|
||||
# globals
|
||||
#
|
||||
##############################################
|
||||
|
||||
# a variable to store our template text in
|
||||
my $template = "";
|
||||
|
||||
|
||||
##############################################
|
||||
#
|
||||
# main()
|
||||
#
|
||||
##############################################
|
||||
|
||||
# load template text (see bottom of script)
|
||||
open(INFILE,"<signal_template.h") || die "Couldn't open signal_template.h";
|
||||
my $isheader = 0;
|
||||
while(<INFILE>)
|
||||
{
|
||||
$template .= $_;
|
||||
}
|
||||
close(INFILE);
|
||||
|
||||
# generate [signal0.h,signal16.h]
|
||||
for (my $i=0;$i<=16;$i++)
|
||||
{
|
||||
GenerateSignalXHeader($i);
|
||||
}
|
||||
|
||||
|
||||
##############################################
|
||||
#
|
||||
# Subroutines
|
||||
#
|
||||
##############################################
|
||||
|
||||
# subroutine to generate one signal header file
|
||||
sub GenerateSignalXHeader
|
||||
{
|
||||
# only argument is number of template arguments to allow for this signal
|
||||
my($nargs) = @_;
|
||||
|
||||
# create a local copy of template text
|
||||
my $file = $template;
|
||||
|
||||
# create other substitution strings
|
||||
my $narg_str = "";
|
||||
my $template_arg_decl_str = "";
|
||||
my $template_arg_str = "";
|
||||
my $formal_arg_decl_str = "";
|
||||
my $formal_arg_str = "";
|
||||
|
||||
# create subst string for # of args
|
||||
$narg_str = sprintf("%d",$nargs);
|
||||
|
||||
# create subst strings for template and function arguments
|
||||
if ( $nargs > 0 )
|
||||
{
|
||||
# template args follow T_return, so start with a comma
|
||||
$template_arg_decl_str = ", ";
|
||||
$template_arg_str = ", ";
|
||||
|
||||
for (my $i=0;$i<($nargs-1);$i++)
|
||||
{
|
||||
# args with trailing comma
|
||||
$template_arg_decl_str .= sprintf("typename T_arg%d, ",$i);
|
||||
$template_arg_str .= sprintf("T_arg%d, ",$i);
|
||||
$formal_arg_decl_str .= sprintf("T_arg%d a%d, ",$i,$i);
|
||||
$formal_arg_str .= sprintf("a%d, ",$i);
|
||||
}
|
||||
|
||||
# args without trailing comma
|
||||
$template_arg_decl_str .= sprintf("typename T_arg%d",$nargs-1);
|
||||
$template_arg_str .= sprintf("T_arg%d",$nargs-1);
|
||||
$formal_arg_decl_str .= sprintf("T_arg%d a%d",$nargs-1,$nargs-1);
|
||||
$formal_arg_str .= sprintf("a%d",$nargs-1);
|
||||
}
|
||||
|
||||
# do substitution
|
||||
$file =~ s/===NARG===/$narg_str/g;
|
||||
$file =~ s/===TEMPLATE_ARG_DECL===/$template_arg_decl_str/g;
|
||||
$file =~ s/===TEMPLATE_ARG===/$template_arg_str/g;
|
||||
$file =~ s/===FORMAL_ARG_DECL===/$formal_arg_decl_str/g;
|
||||
$file =~ s/===FORMAL_ARG===/$formal_arg_str/g;
|
||||
|
||||
# create filename
|
||||
my $filename = sprintf("signal%d.h",$nargs);
|
||||
|
||||
# write file
|
||||
open(OUTFILE,">$filename") || die;
|
||||
print OUTFILE $file;
|
||||
close(OUTFILE);
|
||||
}
|
||||
|
||||
@@ -1,36 +1,181 @@
|
||||
#ifndef __signal0_h__
|
||||
#define __signal0_h__
|
||||
|
||||
#include "signal_base.h"
|
||||
#include "slot.h"
|
||||
|
||||
class signal0: public signal_base
|
||||
{
|
||||
public:
|
||||
/*
|
||||
signal0();
|
||||
virtual ~signal0();
|
||||
*/
|
||||
|
||||
void operator() () const
|
||||
{
|
||||
// TODO: need a way to iterate the bound signal_base list ...
|
||||
list_node* cur = head;
|
||||
while(cur)
|
||||
{
|
||||
(cur->slot)();
|
||||
cur = cur->next;
|
||||
}
|
||||
}
|
||||
|
||||
template <class T_object, typename T_member>
|
||||
void connect(T_object* p_object, T_member p_member)
|
||||
{
|
||||
bind( slot0_method<T_object,T_member>(p_object,p_member) );
|
||||
}
|
||||
};
|
||||
|
||||
#include "signal0.inl"
|
||||
|
||||
#endif // __signal0_h__
|
||||
|
||||
|
||||
#ifndef __Signal0_h__
|
||||
#define __Signal0_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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)();
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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)();
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
template< typename T_return >
|
||||
class Signal0: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
void operator() ()
|
||||
{
|
||||
if( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal0<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot0 pointer
|
||||
Slot0<T_return>* s = static_cast<Slot0<T_return>*>(cur->slot);
|
||||
|
||||
// call the Signal
|
||||
(*s)();
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
typedef T_return (*FUNCTION_POINTER)();
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal0_h__
|
||||
Whitespace-only changes.
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal1_h__
|
||||
#define __Signal1_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
template< typename T_return, typename T_arg0 >
|
||||
class Signal1: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
void operator() (T_arg0 a0)
|
||||
{
|
||||
if( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal1<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot1 pointer
|
||||
Slot1<T_return, T_arg0>* s = static_cast<Slot1<T_return, T_arg0>*>(cur->slot);
|
||||
|
||||
// call the Signal
|
||||
(*s)(a0);
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal1_h__
|
||||
+181
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal10_h__
|
||||
#define __Signal10_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
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:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal10<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot10 pointer
|
||||
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
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
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);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal10_h__
|
||||
+181
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal11_h__
|
||||
#define __Signal11_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
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:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal11<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot11 pointer
|
||||
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
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
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);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal11_h__
|
||||
+181
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal12_h__
|
||||
#define __Signal12_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
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:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal12<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot12 pointer
|
||||
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
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
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);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal12_h__
|
||||
+181
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal13_h__
|
||||
#define __Signal13_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
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:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal13<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot13 pointer
|
||||
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
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
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);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal13_h__
|
||||
+181
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal14_h__
|
||||
#define __Signal14_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
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:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal14<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot14 pointer
|
||||
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
|
||||
(*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;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
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);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal14_h__
|
||||
+181
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal15_h__
|
||||
#define __Signal15_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
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:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal15<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot15 pointer
|
||||
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
|
||||
(*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;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
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);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal15_h__
|
||||
+181
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal16_h__
|
||||
#define __Signal16_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
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:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal16<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot16 pointer
|
||||
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
|
||||
(*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;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
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);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal16_h__
|
||||
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal2_h__
|
||||
#define __Signal2_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
template< typename T_return, typename T_arg0, typename T_arg1 >
|
||||
class Signal2: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
void operator() (T_arg0 a0, T_arg1 a1)
|
||||
{
|
||||
if( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal2<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot2 pointer
|
||||
Slot2<T_return, T_arg0, T_arg1>* s = static_cast<Slot2<T_return, T_arg0, T_arg1>*>(cur->slot);
|
||||
|
||||
// call the Signal
|
||||
(*s)(a0, a1);
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal2_h__
|
||||
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal3_h__
|
||||
#define __Signal3_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
template< typename T_return, typename T_arg0, typename T_arg1, typename T_arg2 >
|
||||
class Signal3: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2)
|
||||
{
|
||||
if( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal3<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot3 pointer
|
||||
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
|
||||
(*s)(a0, a1, a2);
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal3_h__
|
||||
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal4_h__
|
||||
#define __Signal4_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
template< typename T_return, typename T_arg0, typename T_arg1, typename T_arg2, typename T_arg3 >
|
||||
class Signal4: public signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3)
|
||||
{
|
||||
if( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal4<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot4 pointer
|
||||
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
|
||||
(*s)(a0, a1, a2, a3);
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal4_h__
|
||||
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal5_h__
|
||||
#define __Signal5_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
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:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4)
|
||||
{
|
||||
if( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal5<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot5 pointer
|
||||
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
|
||||
(*s)(a0, a1, a2, a3, a4);
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal5_h__
|
||||
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal6_h__
|
||||
#define __Signal6_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
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:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5)
|
||||
{
|
||||
if( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal6<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot6 pointer
|
||||
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
|
||||
(*s)(a0, a1, a2, a3, a4, a5);
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
typedef T_return (*FUNCTION_POINTER)(T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal6_h__
|
||||
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal7_h__
|
||||
#define __Signal7_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
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:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
void operator() (T_arg0 a0, T_arg1 a1, T_arg2 a2, T_arg3 a3, T_arg4 a4, T_arg5 a5, T_arg6 a6)
|
||||
{
|
||||
if( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal7<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot7 pointer
|
||||
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
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6);
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
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);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal7_h__
|
||||
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal8_h__
|
||||
#define __Signal8_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
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:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal8<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot8 pointer
|
||||
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
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7);
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
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);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal8_h__
|
||||
@@ -0,0 +1,181 @@
|
||||
|
||||
#ifndef __Signal9_h__
|
||||
#define __Signal9_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Slot tempplate.
|
||||
//=========================================================================================================================================
|
||||
/**
|
||||
* 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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal tempplate.
|
||||
//=========================================================================================================================================
|
||||
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:
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
// Execute the Signal:
|
||||
// - Walk the list of Slot nodes.
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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( IsSignalEmitting( ) )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal9<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
BeginEmit( );
|
||||
|
||||
list_node* cur = GetFirstNode( );
|
||||
|
||||
// iterate through the list
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot9 pointer
|
||||
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
|
||||
(*s)(a0, a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal connections
|
||||
//=========================================================================================================================================
|
||||
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);
|
||||
|
||||
// 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 bind(sNewFunc);
|
||||
}
|
||||
|
||||
// Object methods
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//=========================================================================================================================================
|
||||
// Signal Disconnections
|
||||
//=========================================================================================================================================
|
||||
// Functions
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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 unbind(&sTest);
|
||||
}
|
||||
|
||||
|
||||
// Object 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __Signal9_h__
|
||||
+271
-151
@@ -1,151 +1,271 @@
|
||||
#include <cassert>
|
||||
#include "signal_base.h"
|
||||
|
||||
signal_base::signal_base() : head(0), tail(0)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
signal_base::~signal_base()
|
||||
{
|
||||
// clear the list
|
||||
clear_list();
|
||||
}
|
||||
|
||||
bool signal_base::bind(const slot_base& slot)
|
||||
{
|
||||
// add it to our signal list
|
||||
return add_to_list(slot);
|
||||
}
|
||||
|
||||
bool signal_base::unbind(const 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 )
|
||||
{
|
||||
return false; // no match found
|
||||
}
|
||||
|
||||
// take it out of the linked list
|
||||
remove_from_list(n);
|
||||
|
||||
// free it
|
||||
delete n;
|
||||
|
||||
// found a match, success
|
||||
return true;
|
||||
}
|
||||
|
||||
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(const 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 )
|
||||
{
|
||||
// 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(const slot_base& slot)
|
||||
{
|
||||
// a sanity check
|
||||
assert((head && tail) || (!head && !tail));
|
||||
|
||||
// make a new list_node to hold this slot in the list
|
||||
list_node* n = new list_node;
|
||||
if ( !n )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// initialize new list_node
|
||||
n->slot = slot; // copy slot into list_node
|
||||
n->prev = tail; // prev is tail because we'll put this list_node behind it (i.e. the new tail)
|
||||
n->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 = n; // insert item after current tail
|
||||
tail = n; // now have a new tail
|
||||
}
|
||||
else
|
||||
{
|
||||
// list is currently empty, add this new list_node
|
||||
head = tail = n; // 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;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
#include <cassert>
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
signal_base::signal_base() : head(0), tail(0), bEmitting(false)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
signal_base::~signal_base()
|
||||
{
|
||||
// clear the list
|
||||
clear_list();
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
signal_base::signal_base( const signal_base& rSource ) : head(0), tail(0), bEmitting(false)
|
||||
{
|
||||
// Set an assert to let the user know that we don't support construction of a signal by copying another one.
|
||||
// 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* pIndex;
|
||||
pIndex = head;
|
||||
|
||||
while( pIndex )
|
||||
{
|
||||
pIndex = pIndex->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( !IsSignalEmitting( ) )
|
||||
{
|
||||
// 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->bDeleteRequested = true;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// no match
|
||||
return false;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
signal_base::list_node::list_node(slot_base* s) : slot(s),
|
||||
prev(0),
|
||||
next(0),
|
||||
bDeleteRequested(false)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
signal_base::list_node::~list_node()
|
||||
{
|
||||
// release the slot
|
||||
delete slot;
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
signal_base::list_node* signal_base::GetFirstNode( void ) const
|
||||
{
|
||||
return head;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
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* pIndex;
|
||||
list_node* pNext;
|
||||
|
||||
pIndex = head;
|
||||
|
||||
while( pIndex )
|
||||
{
|
||||
// Prepare the next link in the list the removal stage.
|
||||
pNext = pIndex->next;
|
||||
|
||||
// Do we need to remove this link.
|
||||
if( pIndex->bDeleteRequested )
|
||||
remove_from_list( pIndex );
|
||||
|
||||
// Go to the next item.
|
||||
pIndex = pNext;
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
void signal_base::BeginEmit( void )
|
||||
{
|
||||
bEmitting = true;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
void signal_base::EndEmit( void )
|
||||
{
|
||||
bEmitting = false;
|
||||
|
||||
remove_pending_nodes( );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
bool signal_base::IsSignalEmitting( void ) const
|
||||
{
|
||||
return bEmitting;
|
||||
}
|
||||
+121
-38
@@ -1,38 +1,121 @@
|
||||
#ifndef __signal_base_h__
|
||||
#define __signal_base_h__
|
||||
|
||||
#include "slot_base.h"
|
||||
|
||||
class signal_base
|
||||
{
|
||||
public:
|
||||
|
||||
signal_base();
|
||||
virtual ~signal_base();
|
||||
|
||||
protected:
|
||||
|
||||
bool bind(const slot_base& slot);
|
||||
bool unbind(const slot_base& slot);
|
||||
|
||||
// TEMP HACK private:
|
||||
|
||||
// linked list data structure
|
||||
struct list_node
|
||||
{
|
||||
slot_base slot;
|
||||
list_node* prev;
|
||||
list_node* next;
|
||||
};
|
||||
list_node* head;
|
||||
list_node* tail;
|
||||
|
||||
// linked list manipulation
|
||||
void clear_list();
|
||||
list_node* find_in_list(const slot_base& slot) const;
|
||||
bool add_to_list(const slot_base& slot);
|
||||
void remove_from_list(list_node* n);
|
||||
};
|
||||
|
||||
#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 bDeleteRequested;
|
||||
};
|
||||
|
||||
/**
|
||||
* 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);
|
||||
|
||||
/**
|
||||
* Used to obtain the first slot that is connected to this signal. Used for walking the list of slots when a signal is executed.
|
||||
*/
|
||||
list_node* GetFirstNode( void ) const;
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
void BeginEmit( void );
|
||||
void EndEmit( void );
|
||||
bool IsSignalEmitting( void ) const;
|
||||
|
||||
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);
|
||||
|
||||
/**
|
||||
* Removes any nodes that were tagged for deletion during the signal emit sequence
|
||||
*/
|
||||
void remove_pending_nodes( void );
|
||||
|
||||
//-----------------------------------------------------------------------------------------------------------------------------------------
|
||||
list_node* head;
|
||||
list_node* tail;
|
||||
|
||||
bool bEmitting;
|
||||
};
|
||||
|
||||
#endif // __signal_base_h__
|
||||
|
||||
@@ -0,0 +1,179 @@
|
||||
#ifndef __signal===NARG===_h__
|
||||
#define __signal===NARG===_h__
|
||||
|
||||
#include "horrible_cast.h"
|
||||
#include "slot_base.h"
|
||||
#include "signal_base.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Slot ===NARG===
|
||||
//
|
||||
|
||||
//
|
||||
// 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===);
|
||||
|
||||
Slot===NARG===_function( const FUNCTION_POINTER func )
|
||||
{
|
||||
// convert and store function pointer in slot_base
|
||||
this->data[0] = safe_horrible_cast<data_container>(func);
|
||||
}
|
||||
|
||||
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:
|
||||
|
||||
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<data_container>(p_object);
|
||||
this->data[1] = safe_horrible_cast<data_container>(p_member);
|
||||
}
|
||||
|
||||
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===);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// 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)
|
||||
if( IsSignalEmitting() )
|
||||
{
|
||||
#if defined( _DEBUG )
|
||||
printf("WARNING: Signal===NARG===<...> @ 0x%p recursive Emit attempt\n", this);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
// set emitting flag
|
||||
BeginEmit();
|
||||
|
||||
// iterate through the list
|
||||
list_node* cur = GetFirstNode();
|
||||
while( cur )
|
||||
{
|
||||
// make the slot_base pointer a Slot===NARG=== pointer
|
||||
Slot===NARG===<T_return===TEMPLATE_ARG===>* s = static_cast<Slot===NARG===<T_return===TEMPLATE_ARG===>*>(cur->slot);
|
||||
|
||||
// call the Signal
|
||||
(*s)(===FORMAL_ARG===);
|
||||
|
||||
// move to next Slot in the list.
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
// clear emitting flag
|
||||
EndEmit( );
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Signal connections
|
||||
//
|
||||
|
||||
// connect to normal functions
|
||||
typedef T_return (*FUNCTION_POINTER)(===FORMAL_ARG_DECL===); // helper typedef
|
||||
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 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 bind(sNewMethod);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// signal disconnections
|
||||
//
|
||||
|
||||
// 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 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 unbind(&sTemp);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __signal===NARG===_h__
|
||||
+1
-4
@@ -3,9 +3,7 @@
|
||||
|
||||
bool slot_base::data_container::operator== (const slot_base::data_container& other) const
|
||||
{
|
||||
// TODO: should use memcmp or equivalent
|
||||
|
||||
// do a bytewise comparison
|
||||
// do a wordwise comparison
|
||||
for (int i=0;i<SIZE_IN_WORDS;++i)
|
||||
{
|
||||
if ( this->data[i] != other.data[i] )
|
||||
@@ -27,7 +25,6 @@ void slot_base::data_container::zero()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
slot_base::slot_base ()
|
||||
{
|
||||
for (int i=0;i<NUM_DATA_ITEMS;++i)
|
||||
|
||||
+5
-5
@@ -5,21 +5,21 @@ class slot_base
|
||||
{
|
||||
public:
|
||||
|
||||
slot_base (); // constructor
|
||||
slot_base (); // constructor
|
||||
virtual ~slot_base (); // destructor
|
||||
|
||||
/* Use compiler-generated copy constructor, assignment operator */
|
||||
|
||||
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 pointer, virtual method function pointer, etc.
|
||||
// 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 = 4 };
|
||||
enum { SIZE_IN_WORDS = 8 };
|
||||
enum { SIZE_IN_BYTES = SIZE_IN_WORDS*sizeof(unsigned int) };
|
||||
|
||||
// the actual storage space
|
||||
|
||||
File renamed without changes.
Reference in new issue
Block a user