signals 2.0

deprec/source/main.cpp

@@ -0,0 +1,199 @@
+#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;
+}
+
+