/*
   Copyright (C) 2001-2006, William Joseph.
   All Rights Reserved.

   This file is part of GtkRadiant.

   GtkRadiant is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GtkRadiant is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "callback.h"

#if defined( _DEBUG ) || defined( DOXYGEN )

namespace ExampleMemberCaller
{
// MemberCaller example
class Integer
{
public:
int value;

void printValue() const {
	// print this->value here;
}

void setValue(){
	value = 3;
}
// a typedef to make things more readable
typedef MemberCaller<Integer, &Integer::setValue> SetValueCaller;
};

void example(){
	Integer foo = { 0 };

	{
		Callback bar = ConstMemberCaller<Integer, &Integer::printValue>( foo );

		// invoke the callback
		bar(); // foo.printValue()
	}


	{
		// use the typedef to improve readability
		Callback bar = Integer::SetValueCaller( foo );

		// invoke the callback
		bar(); // foo.setValue()
	}
}
// end example
}

namespace ExampleReferenceCaller
{
// ReferenceCaller example
void Int_printValue( const int& value ){
	// print value here;
}

void Int_setValue( int& value ){
	value = 3;
}

// a typedef to make things more readable
typedef ReferenceCaller<int, Int_setValue> IntSetValueCaller;

void example(){
	int foo = 0;

	{
		Callback bar = ConstReferenceCaller<int, Int_printValue>( foo );

		// invoke the callback
		bar(); // Int_printValue(foo)
	}


	{
		// use the typedef to improve readability
		Callback bar = IntSetValueCaller( foo );

		// invoke the callback
		bar(); // Int_setValue(foo)
	}
}
// end example
}

#endif

namespace
{
class A1
{
};
class A2
{
};
class A3
{
};
class A4
{
};

class Test
{
public:
void test0(){
}
typedef Member<Test, void, &Test::test0> Test0;
typedef MemberCaller<Test, &Test::test0> Test0Caller;
void test0const() const {
}
typedef ConstMember<Test, void, &Test::test0const> Test0Const;
typedef ConstMemberCaller<Test, &Test::test0const> Test0ConstCaller;
void test1( A1 ){
}
typedef Member1<Test, A1, void, &Test::test1> Test1;
typedef MemberCaller1<Test, A1, &Test::test1> Test1Caller;
void test1const( A1 ) const {
}
typedef ConstMember1<Test, A1, void, &Test::test1const> Test1Const;
typedef ConstMemberCaller1<Test, A1, &Test::test1const> Test1ConstCaller;
void test2( A1, A2 ){
}
typedef Member2<Test, A1, A2, void, &Test::test2> Test2;
void test2const( A1, A2 ) const {
}
typedef ConstMember2<Test, A1, A2, void, &Test::test2const> Test2Const;
void test3( A1, A2, A3 ){
}
typedef Member3<Test, A1, A2, A3, void, &Test::test3> Test3;
void test3const( A1, A2, A3 ) const {
}
typedef ConstMember3<Test, A1, A2, A3, void, &Test::test3const> Test3Const;
};

void test0free(){
}
typedef FreeCaller<&test0free> Test0FreeCaller;
void test1free( A1 ){
}
typedef FreeCaller1<A1, &test1free> Test1FreeCaller;
void test2free( A1, A2 ){
}
typedef Function2<A1, A2, void, &test2free> Test2Free;
void test3free( A1, A2, A3 ){
}
typedef Function3<A1, A2, A3, void, &test3free> Test3Free;


void test0( Test& test ){
}
typedef ReferenceCaller<Test, &test0> Test0Caller;

void test0const( const Test& test ){
}
typedef ConstReferenceCaller<Test, &test0const> Test0ConstCaller;

void test0p( Test* test ){
}
typedef PointerCaller<Test, &test0p> Test0PCaller;

void test0constp( const Test* test ){
}
typedef ConstPointerCaller<Test, &test0constp> Test0ConstPCaller;

void test1( Test& test, A1 ){
}
typedef ReferenceCaller1<Test, A1, &test1> Test1Caller;

void test1const( const Test& test, A1 ){
}
typedef ConstReferenceCaller1<Test, A1, &test1const> Test1ConstCaller;

void test1p( Test* test, A1 ){
}
typedef PointerCaller1<Test, A1, &test1p> Test1PCaller;

void test1constp( const Test* test, A1 ){
}
typedef ConstPointerCaller1<Test, A1, &test1constp> Test1ConstPCaller;

void test2( Test& test, A1, A2 ){
}
typedef Function3<Test&, A1, A2, void, &test2> Test2;

void test3( Test& test, A1, A2, A3 ){
}
typedef Function4<Test&, A1, A2, A3, void, &test3> Test3;

void instantiate(){
	Test test;
	const Test& testconst = test;
	{
		Callback a = Test0FreeCaller();
		Callback b = Test::Test0Caller( test );
		b = makeCallback0( Test::Test0(), test );
		Callback c = Test::Test0ConstCaller( testconst );
		c = makeCallback0( Test::Test0Const(), test );
		Callback d = Test0Caller( test );
		Callback e = Test0ConstCaller( testconst );
		Callback f = Test0PCaller( &test );
		Callback g = Test0ConstPCaller( &testconst );
		a();
		bool u = a != b;
	}
	{
		typedef Callback1<A1> TestCallback1;
		TestCallback1 a = Test1FreeCaller();
		TestCallback1 b = Test::Test1Caller( test );
		b = makeCallback1( Test::Test1(), test );
		TestCallback1 c = Test::Test1ConstCaller( testconst );
		c = makeCallback1( Test::Test1Const(), test );
		TestCallback1 d = Test1Caller( test );
		TestCallback1 e = Test1ConstCaller( testconst );
		TestCallback1 f = Test1PCaller( &test );
		TestCallback1 g = Test1ConstPCaller( &testconst );
		a( A1() );
		bool u = a != b;
	}
	{
		typedef Callback2<A1, A2> TestCallback2;
		TestCallback2 a = makeStatelessCallback2( Test2Free() );
		TestCallback2 b = makeCallback2( Test2(), test );
		TestCallback2 c = makeCallback2( Test::Test2(), test );
		TestCallback2 d = makeCallback2( Test::Test2Const(), test );
		a( A1(), A2() );
		bool u = a != b;
	}
	{
		typedef Callback3<A1, A2, A3> TestCallback3;
		TestCallback3 a = makeStatelessCallback3( Test3Free() );
		TestCallback3 b = makeCallback3( Test3(), test );
		TestCallback3 c = makeCallback3( Test::Test3(), test );
		TestCallback3 d = makeCallback3( Test::Test3Const(), test );
		a( A1(), A2(), A3() );
		bool u = a != b;
	}
}
}