200 lines
3.1 KiB
C++
200 lines
3.1 KiB
C++
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <assert.h>
|
|
|
|
|
|
|
|
#include "Signal.h"
|
|
|
|
|
|
|
|
void Function()
|
|
{
|
|
printf("Function()\n");
|
|
}
|
|
|
|
void Function1(int x)
|
|
{
|
|
printf("Function1(%d)\n",x);
|
|
}
|
|
|
|
void Function5(int a,int b, int c, int d, int e)
|
|
{
|
|
printf("Function5(%d,%d,%d,%d,%d)\n",a,b,c,d,e);
|
|
}
|
|
|
|
|
|
|
|
class Dummy
|
|
{
|
|
public:
|
|
|
|
virtual void member()
|
|
{
|
|
printf("Dummy::member()\n");
|
|
}
|
|
|
|
void operator() ()
|
|
{
|
|
printf("Dummy::operator()()\n");
|
|
}
|
|
|
|
void member5(int a,int b, int c, int d, int e) const
|
|
{
|
|
printf("Dummy::member5(%d,%d,%d,%d,%d)\n",a,b,c,d,e);
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class DummyChild: public Dummy
|
|
{
|
|
public:
|
|
|
|
virtual void member()
|
|
{
|
|
printf("DummyChild::member()\n");
|
|
}
|
|
};
|
|
|
|
|
|
|
|
class OverloadedMembers
|
|
{
|
|
public:
|
|
|
|
void member(int x)
|
|
{
|
|
printf("OverloadedMembers::member(%d)\n",x);
|
|
}
|
|
|
|
void member(int x, int y)
|
|
{
|
|
printf("OverloadedMembers::member(%d,%d)\n",x,y);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
class MySlot: public Signal<void>::SlotBase
|
|
{
|
|
public:
|
|
|
|
MySlot(int id)
|
|
{
|
|
this->some_id = id;
|
|
}
|
|
|
|
virtual void operator() () const
|
|
{
|
|
printf("MySlot::operator() [some_id = %d]\n",some_id);
|
|
}
|
|
|
|
virtual bool operator== (const Slot0<void>* other) const
|
|
{
|
|
const MySlot* pother = dynamic_cast<const MySlot*>(other);
|
|
if ( pother )
|
|
{
|
|
return this->some_id == pother->some_id;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
virtual Slot0<void>* clone() const
|
|
{
|
|
return new MySlot(some_id);
|
|
}
|
|
|
|
private:
|
|
|
|
int some_id;
|
|
};
|
|
|
|
|
|
|
|
MySlot Create_MySlot(int x)
|
|
{
|
|
return MySlot(x);
|
|
}
|
|
|
|
|
|
|
|
int main()
|
|
{
|
|
Signal<void> sig;
|
|
Signal<void> sig_copy;
|
|
Signal<void,int> sig1;
|
|
Signal<void,int,int> sig2;
|
|
Signal<void,int,int,int,int,int> sig5;
|
|
Signal<void> count_test;
|
|
|
|
assert( !count_test.IsConnected(Function) );
|
|
count_test.Connect(Function,2);
|
|
assert( count_test.IsConnected(Function) );
|
|
count_test();
|
|
count_test();
|
|
count_test();
|
|
|
|
OverloadedMembers bf;
|
|
|
|
assert( !sig1.IsConnected(&bf,&OverloadedMembers::member) );
|
|
assert( !sig2.IsConnected(&bf,&OverloadedMembers::member) );
|
|
sig1.Connect(&bf,&OverloadedMembers::member);
|
|
sig2.Connect(&bf,&OverloadedMembers::member);
|
|
assert( sig1.IsConnected(&bf,&OverloadedMembers::member) );
|
|
assert( sig2.IsConnected(&bf,&OverloadedMembers::member) );
|
|
sig1(10);
|
|
sig2(1,2);
|
|
|
|
assert( !sig.IsConnected(Create_MySlot(1)) );
|
|
sig.Connect(Create_MySlot(1));
|
|
assert( sig.IsConnected(Create_MySlot(1)) );
|
|
sig.Disconnect(Create_MySlot(1));
|
|
assert( !sig.IsConnected(Create_MySlot(1)) );
|
|
|
|
sig1.Connect(Function1);
|
|
sig1(0);
|
|
sig1(1);
|
|
sig1(2);
|
|
sig1(3);
|
|
|
|
Dummy d;
|
|
Dummy d2;
|
|
DummyChild dc;
|
|
|
|
sig5.Connect(Function5);
|
|
sig5.Connect(&d,&Dummy::member5);
|
|
sig5.Connect(&dc,&Dummy::member5);
|
|
sig5(0,1,2,3,4);
|
|
|
|
printf("\n---\n\n");
|
|
sig.Connect(Function);
|
|
|
|
sig.Connect(&d);
|
|
sig.Connect(&d2);
|
|
sig.Connect(&d,&Dummy::member);
|
|
sig.Connect(&dc,&DummyChild::member);
|
|
sig.Connect(&dc,&Dummy::member);
|
|
sig.Connect(&dc);
|
|
|
|
sig.Emit();
|
|
|
|
printf("\n---\n\n");
|
|
sig.Disconnect(Function);
|
|
sig.Emit();
|
|
|
|
printf("\n---\n\n");
|
|
|
|
sig_copy = sig;
|
|
sig_copy.Emit();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|