ptsigslot signals/slots library for C++

#include "ptsigslot/signals.hpp"
#include <iostream>
#define COUT std::cout << __FILE__ << ":" << std::dec<<__LINE__ << ": "

int function()
{
	COUT << "function() called." << std::endl;
	return 0;
}

int function1i(int i)
{
	COUT << "function(int) called: "<<i<<"" << std::endl;
	return 0;
}

struct Object : public ptsigslot::Connectable
{
	bool method()
	{
		COUT << "Object::method called." << std::endl;
		return true;
	}

	bool method1( std::string const & m )
	{
		COUT << "Object::method(string) called: " << m << std::endl;
		return true;
	}

	char constMethod() const
	{
		COUT << "Object::constMethod called." << std::endl;
		return 'r';
	}

	void constMethod2(int,int) const
	{
		return;
	}

	static std::string staticMethod()
	{
		COUT << "Object::staticMethod called." << std::endl;
		return "test";
	}
};

/**
   If you have a class which you can edit but you do not want to
   subclass ptsigslot::Connectable, a partial workaround is to define
   an inner class which subclasses Connectable, then use it to proxy
   signals through to the non-virtual containing type. That approach
   is demonstrated below...
*/
class NonSlotted
{
public:
	struct SlotProxy : public ptsigslot::Connectable
	{
		NonSlotted & self;
		SlotProxy( NonSlotted & n ) : self(n)
		{
		}
		double proxy( double d )
		{
			COUT << "NonSlotted::SlotProxy::proxy("<<d<<")"<<std::endl;
			return self.proxied(d);
		}
		int slotish()
		{
			COUT << "NonSlotted::SlotProxy::slotish()"<<std::endl;
			return self.slotish();
		}
	};
	NonSlotted() : m_proxy(*this)
	{
	}


	double proxied(double d)
	{
		COUT << "NonSlotted::proxied("<<d<<")"<<std::endl;
		return 2*d;
	}

	SlotProxy & proxy()
	{
		return this->m_proxy;
	}

	int slotish()
	{
		COUT << "NonSlotted::slotish())"<<std::endl;
		return 42;
	}

private:
	SlotProxy m_proxy;

};

#include <ptsigslot/delegate.hpp>
void delegate_tests()
{
	COUT << "Delegates...\n";
	namespace ps = ptsigslot;
	if( 1 )
	{
		ps::Delegate<int> d1;
		ps::connect( d1, function );
		d1();
		NonSlotted obj;
		ps::connect( d1, obj.proxy(), &NonSlotted::SlotProxy::slotish );
		d1();
	}

	if( 1 )
	{
		Object obj;
		ps::Delegate<bool> db;
		ps::connect( db, obj,&Object::method );
		std::cout << "db() == " << db() << std::endl;
	}

	if( 1 )
	{
		bool thrown = false;
		try
		{
			Object * obj = new Object;
			ps::Delegate<bool> db;
			ps::connect( db, *obj, &Object::method );
			db();
			delete obj;
			COUT << "db() should throw here:\n"; 
			db();
		}
		catch( std::exception const & ex )
		{
			thrown = true;
			COUT << "EXPECTED exception: " << ex.what() << std::endl;
		}
		if( ! thrown )
		{
			throw std::runtime_error("delegate_tests() expected an exception and got none.");
		}
	}
	COUT << "Delegate tests done.\n";
}

int main(int argc, char* argv[])
{
	namespace ps = ptsigslot;
	try
	{
		Object obj;
		ps::Signal<> signal;
		signal.connect( ps::slot(obj, &Object::method) );
		signal.connect( ps::slot(obj, &Object::constMethod) );
		signal.connect( ps::slot(&Object::staticMethod) );
		signal.connect( ps::slot(function) );
		signal.send();

		Object * o2 = new Object;
		ps::connect( signal, *o2, &Object::method );
		COUT << "before (delete o2): signal():\n";
		signal();
		delete o2;
		COUT << "after (delete o2): signal():" << std::endl;
		signal();

		ps::Signal<int> intsig;
		intsig.connect( ps::slot(function1i) );
		intsig( 42 );
    
		ps::Signal<std::string const &> strsig;
		strsig.connect( ps::slot(obj, &Object::method1) );
		strsig( "Hi, world" );

		ps::Signal<std::string const &> strcp(strsig);
		strcp("Bye, world");

		ps::Signal<int,int> sigi2;
		sigi2.connect( ps::slot( obj, &Object::constMethod2 ) );
		sigi2(34,43);

		NonSlotted nonslotted;
		ps::Signal<double> proxiedsig;
		proxiedsig.connect( ps::slot( nonslotted.proxy(), &NonSlotted::SlotProxy::proxy ) );
		proxiedsig(42.42);

		delegate_tests();

	}
	catch (const std::exception& e)
	{
		std::cerr << "EXCEPTION: " << e.what() << std::endl;
		return 1;
	}
}

test.cpp:21: Object::method called.
test.cpp:33: Object::constMethod called.
test.cpp:44: Object::staticMethod called.
test.cpp:7: function() called.
test.cpp:167: before (delete o2): signal():
test.cpp:21: Object::method called.
test.cpp:33: Object::constMethod called.
test.cpp:44: Object::staticMethod called.
test.cpp:7: function() called.
test.cpp:21: Object::method called.
test.cpp:170: after (delete o2): signal():
test.cpp:21: Object::method called.
test.cpp:33: Object::constMethod called.
test.cpp:44: Object::staticMethod called.
test.cpp:7: function() called.
test.cpp:13: function(int) called: 42
test.cpp:27: Object::method(string) called: Hi, world
test.cpp:27: Object::method(string) called: Bye, world
test.cpp:67: NonSlotted::SlotProxy::proxy(42.42)
test.cpp:83: NonSlotted::proxied(42.42)
test.cpp:106: Delegates...
test.cpp:7: function() called.
test.cpp:72: NonSlotted::SlotProxy::slotish()
test.cpp:94: NonSlotted::slotish())
test.cpp:21: Object::method called.
db() == 1
test.cpp:21: Object::method called.
test.cpp:136: db() should throw here:
test.cpp:142: EXPECTED exception: Delegate not connected
test.cpp:149: Delegate tests done.