Demo.cpp

#include <stdio.h>
#include "FastDelegate.h"
// Demonstrate the syntax for FastDelegates.
//				-Don Clugston, May 2004.
// It's a really boring example, but it shows the most important cases.

// Declare some functions of varying complexity...
void SimpleStaticFunction(int num, char *str) {
	printf("In SimpleStaticFunction. Num=%d, str = %s\n", num, str);
}

void SimpleVoidFunction() {
	printf("In SimpleVoidFunction with no parameters.\n");
}

class CBaseClass {
protected:
	char *m_name;
public:
	CBaseClass(char *name) : m_name(name) {};
	void SimpleMemberFunction(int num, char *str) {
		printf("In SimpleMemberFunction in %s. Num=%d, str = %s\n", m_name, num, str);	}
	int SimpleMemberFunctionReturnsInt(int num, char *str) {
		printf("In SimpleMemberFunction in %s. Num=%d, str = %s\n", m_name, num, str); return -1;	}
	void ConstMemberFunction(int num, char *str) const {
		printf("In ConstMemberFunction in %s. Num=%d, str = %s\n", m_name, num, str);	}
	virtual void SimpleVirtualFunction(int num, char *str) {
		printf("In SimpleVirtualFunction in %s. Num=%d, str = %s\n", m_name, num, str);	}
	static void StaticMemberFunction(int num, char *str) {
		printf("In StaticMemberFunction. Num=%d, str =%s\n", num, str);	}
};

class COtherClass {
	double rubbish; // to ensure this class has non-zero size.
public:
	virtual void UnusedVirtualFunction(void) { }
	virtual void TrickyVirtualFunction(int num, char *str)=0;
};

class VeryBigClass {
	int letsMakeThingsComplicated[400];
};

// This declaration ensures that we get a convoluted class heirarchy.
class CDerivedClass : public VeryBigClass, virtual public COtherClass, virtual public CBaseClass
{
	double m_somemember[8];
public:
	CDerivedClass() : CBaseClass("Base of Derived") { m_somemember[0]=1.2345; }
	void SimpleDerivedFunction(int num, char *str) { printf("In SimpleDerived. num=%d\n", num); }
	virtual void AnotherUnusedVirtualFunction(int num, char *str) {}
	virtual void TrickyVirtualFunction(int num, char *str) {
		printf("In Derived TrickyMemberFunction. Num=%d, str = %s\n", num, str);
	}
};

using namespace fastdelegate;

int main(void)
{
	// Delegates with up to 8 parameters are supported.
	// Here's the case for a void function.
	// We declare a delegate and attach it to SimpleVoidFunction()
	printf("-- FastDelegate demo --\nA no-parameter delegate is declared using FastDelegate0\n\n");

	FastDelegate0<> noparameterdelegate(&SimpleVoidFunction);

	noparameterdelegate(); // invoke the delegate - this calls SimpleVoidFunction()

	printf("\n-- Examples using two-parameter delegates (int, char *) --\n\n");

    // By default, the return value is void.
    typedef FastDelegate2<int, char *> MyDelegate;

	// If you want to have a non-void return value, put it at the end.
    typedef FastDelegate2<int, char *, int> IntMyDelegate;


	MyDelegate funclist[12]; // delegates are initialized to empty
	CBaseClass a("Base A");
	CBaseClass b("Base B");
	CDerivedClass d;
	CDerivedClass c;

	IntMyDelegate newdeleg;
    newdeleg = MakeDelegate(&a, &CBaseClass::SimpleMemberFunctionReturnsInt);
    
	// Binding a simple member function
        funclist[0].bind(&a, &CBaseClass::SimpleMemberFunction);
		
	// You can also bind static (free) functions
        funclist[1].bind(&SimpleStaticFunction);
	// and static member functions
        funclist[2].bind(&CBaseClass::StaticMemberFunction);
	// and const member functions (these only need a const class pointer).		 
        funclist[11].bind( (const CBaseClass *)&a, &CBaseClass::ConstMemberFunction);
        funclist[3].bind( &a, &CBaseClass::ConstMemberFunction);
	// and virtual member functions
        funclist[4].bind(&b, &CBaseClass::SimpleVirtualFunction);

	// You can also use the = operator. For static functions, a fastdelegate
	// looks identical to a simple function pointer.
        funclist[5] = &CBaseClass::StaticMemberFunction;

	// The weird rule about the class of derived member function pointers is avoided.
	// For MSVC, you can use &CDerivedClass::SimpleVirtualFunction here, but DMC will complain.
	// Note that as well as .bind(), you can also use the MakeDelegate()
	// global function.
        funclist[6] = MakeDelegate(&d, &CBaseClass::SimpleVirtualFunction);

	// The worst case is an abstract virtual function of a virtually-derived class
	// with at least one non-virtual base class. This is a VERY obscure situation,
	// which you're unlikely to encounter in the real world.
	// FastDelegate versions prior to 1.3 had problems with this case on VC6.
	// Now, it works without problems on all compilers.
       funclist[7].bind(&c, &CDerivedClass::TrickyVirtualFunction);
	// BUT... in such cases you should be using the base class as an 
	// interface, anyway.
       funclist[8].bind(&c, &COtherClass::TrickyVirtualFunction);
	// Calling a function that was first declared in the derived class is straightforward
        funclist[9] = MakeDelegate(&c, &CDerivedClass::SimpleDerivedFunction);

	// You can also bind directly using the constructor
        MyDelegate dg(&b, &CBaseClass::SimpleVirtualFunction);

	char *msg = "Looking for equal delegate";
	for (int i=0; i<12; i++) {
		printf("%d :", i);
		// The == and != operators are provided
		// Note that they work even for inline functions.
		if (funclist[i]==dg) { msg = "Found equal delegate"; };
		// operator ! can be used to test for an empty delegate
		// You can also use the .empty() member function.
		if (!funclist[i]) {
			printf("Delegate is empty\n");
		} else {
			// Invocation generates optimal assembly code.
			funclist[i](i, msg);
		};
	}
	return 0;
}