core/sourcehook/generate/FastDelegate.hxx
author Scott Ehlert <ds@alliedmods.net>
Thu Dec 10 00:59:50 2009 -0600 (2009-12-10)
changeset 689 4065ba5e9155
parent 539 db914129ae01
permissions -rw-r--r--
Rewrote user message caching code to always use IServerGameDLL::GetUserMessageInfo (bug 4117, r=dvander).

Games where the above function can crash are handled by detouring tier0's Error() function and jumping back to our own code. So in theory this should work on all games now.
pavolmarko@117
     1
//						FastDelegate.h
pavolmarko@1
     2
//	Efficient delegates in C++ that generate only two lines of asm code!
pavolmarko@1
     3
//  Documentation is found at http://www.codeproject.com/cpp/FastDelegate.asp
pavolmarko@1
     4
//
pavolmarko@1
     5
//						- Don Clugston, Mar 2004.
pavolmarko@1
     6
//		Major contributions were made by Jody Hagins.
pavolmarko@1
     7
// History:
pavolmarko@134
     8
// 24-Apr-04 1.0  * Submitted to CodeProject.
pavolmarko@1
     9
// 28-Apr-04 1.1  * Prevent most unsafe uses of evil static function hack.
pavolmarko@1
    10
//				  * Improved syntax for horrible_cast (thanks Paul Bludov).
pavolmarko@1
    11
//				  * Tested on Metrowerks MWCC and Intel ICL (IA32)
pavolmarko@1
    12
//				  * Compiled, but not run, on Comeau C++ and Intel Itanium ICL.
pavolmarko@1
    13
//	27-Jun-04 1.2 * Now works on Borland C++ Builder 5.5
pavolmarko@1
    14
//				  * Now works on /clr "managed C++" code on VC7, VC7.1
pavolmarko@1
    15
//				  * Comeau C++ now compiles without warnings.
pavolmarko@117
    16
//				  * Prevent the virtual inheritance case from being used on
pavolmarko@1
    17
//					  VC6 and earlier, which generate incorrect code.
pavolmarko@1
    18
//				  * Improved warning and error messages. Non-standard hacks
pavolmarko@1
    19
//					 now have compile-time checks to make them safer.
pavolmarko@1
    20
//				  * implicit_cast used instead of static_cast in many cases.
pavolmarko@1
    21
//				  * If calling a const member function, a const class pointer can be used.
pavolmarko@1
    22
//				  * MakeDelegate() global helper function added to simplify pass-by-value.
pavolmarko@1
    23
//				  * Added fastdelegate.clear()
pavolmarko@1
    24
// 16-Jul-04 1.2.1* Workaround for gcc bug (const member function pointers in templates)
pavolmarko@1
    25
// 30-Oct-04 1.3  * Support for (non-void) return values.
pavolmarko@1
    26
//				  * No more workarounds in client code!
pavolmarko@1
    27
//					 MSVC and Intel now use a clever hack invented by John Dlugosz:
pavolmarko@1
    28
//				     - The FASTDELEGATEDECLARE workaround is no longer necessary.
pavolmarko@1
    29
//					 - No more warning messages for VC6
pavolmarko@1
    30
//				  * Less use of macros. Error messages should be more comprehensible.
pavolmarko@1
    31
//				  * Added include guards
pavolmarko@1
    32
//				  * Added FastDelegate::empty() to test if invocation is safe (Thanks Neville Franks).
pavolmarko@134
    33
//				  * Now tested on VS 2005 Express Beta, PGI C++
pavolmarko@1
    34
// 24-Dec-04 1.4  * Added DelegateMemento, to allow collections of disparate delegates.
pavolmarko@1
    35
//                * <,>,<=,>= comparison operators to allow storage in ordered containers.
pavolmarko@1
    36
//				  * Substantial reduction of code size, especially the 'Closure' class.
pavolmarko@1
    37
//				  * Standardised all the compiler-specific workarounds.
pavolmarko@1
    38
//                * MFP conversion now works for CodePlay (but not yet supported in the full code).
pavolmarko@134
    39
//                * Now compiles without warnings on _any_ supported compiler, including BCC 5.5.1
pavolmarko@117
    40
//				  * New syntax: FastDelegate< int (char *, double) >.
pavolmarko@134
    41
// 14-Feb-05 1.4.1* Now treats =0 as equivalent to .clear(), ==0 as equivalent to .empty(). (Thanks elfric).
pavolmarko@134
    42
//				  * Now tested on Intel ICL for AMD64, VS2005 Beta for AMD64 and Itanium.
pavolmarko@134
    43
// 30-Mar-05 1.5  * Safebool idiom: "if (dg)" is now equivalent to "if (!dg.empty())"
pavolmarko@134
    44
//				  * Fully supported by CodePlay VectorC
pavolmarko@134
    45
//                * Bugfix for Metrowerks: empty() was buggy because a valid MFP can be 0 on MWCC!
pavolmarko@134
    46
//                * More optimal assignment,== and != operators for static function pointers.
pavolmarko@1
    47
pavolmarko@1
    48
#ifndef FASTDELEGATE_H
pavolmarko@1
    49
#define FASTDELEGATE_H
pavolmarko@48
    50
pavolmarko@48
    51
#ifdef _MSC_VER
pavolmarko@48
    52
# if _MSC_VER > 1000
pavolmarko@48
    53
#  pragma once
pavolmarko@48
    54
# endif // _MSC_VER > 1000
pavolmarko@48
    55
#endif // #ifdef _MSC_VER
pavolmarko@1
    56
pavolmarko@1
    57
#include <memory.h> // to allow <,> comparisons
pavolmarko@1
    58
pavolmarko@1
    59
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
    60
//						Configuration options
pavolmarko@1
    61
//
pavolmarko@1
    62
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
    63
pavolmarko@1
    64
// Uncomment the following #define for optimally-sized delegates.
pavolmarko@1
    65
// In this case, the generated asm code is almost identical to the code you'd get
pavolmarko@1
    66
// if the compiler had native support for delegates.
pavolmarko@117
    67
// It will not work on systems where sizeof(dataptr) < sizeof(codeptr).
pavolmarko@1
    68
// Thus, it will not work for DOS compilers using the medium model.
pavolmarko@1
    69
// It will also probably fail on some DSP systems.
pavolmarko@1
    70
#define FASTDELEGATE_USESTATICFUNCTIONHACK
pavolmarko@1
    71
pavolmarko@1
    72
// Uncomment the next line to allow function declarator syntax.
pavolmarko@1
    73
// It is automatically enabled for those compilers where it is known to work.
pavolmarko@1
    74
//#define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
pavolmarko@1
    75
pavolmarko@1
    76
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
    77
//						Compiler identification for workarounds
pavolmarko@1
    78
//
pavolmarko@1
    79
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
    80
pavolmarko@1
    81
// Compiler identification. It's not easy to identify Visual C++ because
pavolmarko@1
    82
// many vendors fraudulently define Microsoft's identifiers.
pavolmarko@1
    83
#if defined(_MSC_VER) && !defined(__MWERKS__) && !defined(__VECTOR_C) && !defined(__ICL) && !defined(__BORLANDC__)
pavolmarko@1
    84
#define FASTDLGT_ISMSVC
pavolmarko@1
    85
pavolmarko@1
    86
#if (_MSC_VER <1300) // Many workarounds are required for VC6.
pavolmarko@1
    87
#define FASTDLGT_VC6
pavolmarko@1
    88
#pragma warning(disable:4786) // disable this ridiculous warning
pavolmarko@1
    89
#endif
pavolmarko@1
    90
pavolmarko@1
    91
#endif
pavolmarko@1
    92
pavolmarko@1
    93
// Does the compiler uses Microsoft's member function pointer structure?
pavolmarko@1
    94
// If so, it needs special treatment.
pavolmarko@117
    95
// Metrowerks CodeWarrior, Intel, and CodePlay fraudulently define Microsoft's
pavolmarko@1
    96
// identifier, _MSC_VER. We need to filter Metrowerks out.
pavolmarko@1
    97
#if defined(_MSC_VER) && !defined(__MWERKS__)
pavolmarko@1
    98
#define FASTDLGT_MICROSOFT_MFP
pavolmarko@1
    99
pavolmarko@1
   100
#if !defined(__VECTOR_C)
pavolmarko@1
   101
// CodePlay doesn't have the __single/multi/virtual_inheritance keywords
pavolmarko@1
   102
#define FASTDLGT_HASINHERITANCE_KEYWORDS
pavolmarko@1
   103
#endif
pavolmarko@1
   104
#endif
pavolmarko@1
   105
pavolmarko@1
   106
// Does it allow function declarator syntax? The following compilers are known to work:
pavolmarko@1
   107
#if defined(FASTDLGT_ISMSVC) && (_MSC_VER >=1310) // VC 7.1
pavolmarko@1
   108
#define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
pavolmarko@1
   109
#endif
pavolmarko@1
   110
pavolmarko@1
   111
// Gcc(2.95+), and versions of Digital Mars, Intel and Comeau in common use.
pavolmarko@1
   112
#if defined (__DMC__) || defined(__GNUC__) || defined(__ICL) || defined(__COMO__)
pavolmarko@1
   113
#define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
pavolmarko@1
   114
#endif
pavolmarko@1
   115
pavolmarko@1
   116
// It works on Metrowerks MWCC 3.2.2. From boost.Config it should work on earlier ones too.
pavolmarko@1
   117
#if defined (__MWERKS__)
pavolmarko@1
   118
#define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
pavolmarko@1
   119
#endif
pavolmarko@1
   120
pavolmarko@117
   121
#ifdef __GNUC__ // Workaround GCC bug #8271
pavolmarko@1
   122
	// At present, GCC doesn't recognize constness of MFPs in templates
pavolmarko@1
   123
#define FASTDELEGATE_GCC_BUG_8271
pavolmarko@1
   124
#endif
pavolmarko@1
   125
pavolmarko@1
   126
pavolmarko@1
   127
pavolmarko@1
   128
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   129
//						General tricks used in this code
pavolmarko@1
   130
//
pavolmarko@1
   131
// (a) Error messages are generated by typdefing an array of negative size to
pavolmarko@1
   132
//     generate compile-time errors.
pavolmarko@1
   133
// (b) Warning messages on MSVC are generated by declaring unused variables, and
pavolmarko@1
   134
//	    enabling the "variable XXX is never used" warning.
pavolmarko@1
   135
// (c) Unions are used in a few compiler-specific cases to perform illegal casts.
pavolmarko@1
   136
// (d) For Microsoft and Intel, when adjusting the 'this' pointer, it's cast to
pavolmarko@1
   137
//     (char *) first to ensure that the correct number of *bytes* are added.
pavolmarko@1
   138
//
pavolmarko@1
   139
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   140
//						Helper templates
pavolmarko@1
   141
//
pavolmarko@1
   142
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   143
pavolmarko@1
   144
pavolmarko@1
   145
namespace fastdelegate {
pavolmarko@1
   146
namespace detail {	// we'll hide the implementation details in a nested namespace.
pavolmarko@1
   147
pavolmarko@1
   148
//		implicit_cast< >
pavolmarko@117
   149
// I believe this was originally going to be in the C++ standard but
pavolmarko@1
   150
// was left out by accident. It's even milder than static_cast.
pavolmarko@1
   151
// I use it instead of static_cast<> to emphasize that I'm not doing
pavolmarko@117
   152
// anything nasty.
pavolmarko@1
   153
// Usage is identical to static_cast<>
pavolmarko@1
   154
template <class OutputClass, class InputClass>
pavolmarko@1
   155
inline OutputClass implicit_cast(InputClass input){
pavolmarko@1
   156
	return input;
pavolmarko@1
   157
}
pavolmarko@1
   158
pavolmarko@1
   159
//		horrible_cast< >
pavolmarko@117
   160
// This is truly evil. It completely subverts C++'s type system, allowing you
pavolmarko@117
   161
// to cast from any class to any other class. Technically, using a union
pavolmarko@1
   162
// to perform the cast is undefined behaviour (even in C). But we can see if
pavolmarko@1
   163
// it is OK by checking that the union is the same size as each of its members.
pavolmarko@117
   164
// horrible_cast<> should only be used for compiler-specific workarounds.
pavolmarko@1
   165
// Usage is identical to reinterpret_cast<>.
pavolmarko@1
   166
pavolmarko@1
   167
// This union is declared outside the horrible_cast because BCC 5.5.1
pavolmarko@1
   168
// can't inline a function with a nested class, and gives a warning.
pavolmarko@1
   169
template <class OutputClass, class InputClass>
pavolmarko@1
   170
union horrible_union{
pavolmarko@1
   171
	OutputClass out;
pavolmarko@1
   172
	InputClass in;
pavolmarko@1
   173
};
pavolmarko@1
   174
pavolmarko@1
   175
template <class OutputClass, class InputClass>
pavolmarko@1
   176
inline OutputClass horrible_cast(const InputClass input){
pavolmarko@1
   177
	horrible_union<OutputClass, InputClass> u;
pavolmarko@1
   178
	// Cause a compile-time error if in, out and u are not the same size.
pavolmarko@1
   179
	// If the compile fails here, it means the compiler has peculiar
pavolmarko@1
   180
	// unions which would prevent the cast from working.
pavolmarko@117
   181
	typedef int ERROR_CantUseHorrible_cast[sizeof(InputClass)==sizeof(u)
pavolmarko@1
   182
		&& sizeof(InputClass)==sizeof(OutputClass) ? 1 : -1];
pavolmarko@1
   183
	u.in = input;
pavolmarko@1
   184
	return u.out;
pavolmarko@1
   185
}
pavolmarko@1
   186
pavolmarko@1
   187
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   188
//						Workarounds
pavolmarko@1
   189
//
pavolmarko@1
   190
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   191
pavolmarko@1
   192
// Backwards compatibility: This macro used to be necessary in the virtual inheritance
pavolmarko@1
   193
// case for Intel and Microsoft. Now it just forward-declares the class.
pavolmarko@1
   194
#define FASTDELEGATEDECLARE(CLASSNAME)	class CLASSNAME;
pavolmarko@1
   195
pavolmarko@1
   196
// Prevent use of the static function hack with the DOS medium model.
pavolmarko@1
   197
#ifdef __MEDIUM__
pavolmarko@1
   198
#undef FASTDELEGATE_USESTATICFUNCTIONHACK
pavolmarko@1
   199
#endif
pavolmarko@1
   200
pavolmarko@1
   201
//			DefaultVoid - a workaround for 'void' templates in VC6.
pavolmarko@1
   202
//
pavolmarko@1
   203
//  (1) VC6 and earlier do not allow 'void' as a default template argument.
pavolmarko@1
   204
//  (2) They also doesn't allow you to return 'void' from a function.
pavolmarko@1
   205
//
pavolmarko@1
   206
// Workaround for (1): Declare a dummy type 'DefaultVoid' which we use
pavolmarko@1
   207
//   when we'd like to use 'void'. We convert it into 'void' and back
pavolmarko@1
   208
//   using the templates DefaultVoidToVoid<> and VoidToDefaultVoid<>.
pavolmarko@1
   209
// Workaround for (2): On VC6, the code for calling a void function is
pavolmarko@1
   210
//   identical to the code for calling a non-void function in which the
pavolmarko@1
   211
//   return value is never used, provided the return value is returned
pavolmarko@117
   212
//   in the EAX register, rather than on the stack.
pavolmarko@1
   213
//   This is true for most fundamental types such as int, enum, void *.
pavolmarko@117
   214
//   Const void * is the safest option since it doesn't participate
pavolmarko@1
   215
//   in any automatic conversions. But on a 16-bit compiler it might
pavolmarko@1
   216
//   cause extra code to be generated, so we disable it for all compilers
pavolmarko@1
   217
//   except for VC6 (and VC5).
pavolmarko@1
   218
#ifdef FASTDLGT_VC6
pavolmarko@1
   219
// VC6 workaround
pavolmarko@1
   220
typedef const void * DefaultVoid;
pavolmarko@1
   221
#else
pavolmarko@1
   222
// On any other compiler, just use a normal void.
pavolmarko@1
   223
typedef void DefaultVoid;
pavolmarko@1
   224
#endif
pavolmarko@1
   225
pavolmarko@1
   226
// Translate from 'DefaultVoid' to 'void'.
pavolmarko@1
   227
// Everything else is unchanged
pavolmarko@1
   228
template <class T>
pavolmarko@1
   229
struct DefaultVoidToVoid { typedef T type; };
pavolmarko@1
   230
pavolmarko@1
   231
template <>
pavolmarko@1
   232
struct DefaultVoidToVoid<DefaultVoid> {	typedef void type; };
pavolmarko@1
   233
pavolmarko@1
   234
// Translate from 'void' into 'DefaultVoid'
pavolmarko@1
   235
// Everything else is unchanged
pavolmarko@1
   236
template <class T>
pavolmarko@1
   237
struct VoidToDefaultVoid { typedef T type; };
pavolmarko@1
   238
pavolmarko@1
   239
template <>
pavolmarko@1
   240
struct VoidToDefaultVoid<void> { typedef DefaultVoid type; };
pavolmarko@1
   241
pavolmarko@1
   242
pavolmarko@1
   243
pavolmarko@1
   244
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   245
//						Fast Delegates, part 1:
pavolmarko@1
   246
//
pavolmarko@1
   247
//		Conversion of member function pointer to a standard form
pavolmarko@1
   248
//
pavolmarko@1
   249
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   250
pavolmarko@1
   251
// GenericClass is a fake class, ONLY used to provide a type.
pavolmarko@1
   252
// It is vitally important that it is never defined, so that the compiler doesn't
pavolmarko@1
   253
// think it can optimize the invocation. For example, Borland generates simpler
pavolmarko@1
   254
// code if it knows the class only uses single inheritance.
pavolmarko@1
   255
pavolmarko@1
   256
// Compilers using Microsoft's structure need to be treated as a special case.
pavolmarko@1
   257
#ifdef  FASTDLGT_MICROSOFT_MFP
pavolmarko@1
   258
pavolmarko@1
   259
#ifdef FASTDLGT_HASINHERITANCE_KEYWORDS
pavolmarko@117
   260
	// For Microsoft and Intel, we want to ensure that it's the most efficient type of MFP
pavolmarko@117
   261
	// (4 bytes), even when the /vmg option is used. Declaring an empty class
pavolmarko@1
   262
	// would give 16 byte pointers in this case....
pavolmarko@1
   263
	class __single_inheritance GenericClass;
pavolmarko@1
   264
#endif
pavolmarko@1
   265
	// ...but for Codeplay, an empty class *always* gives 4 byte pointers.
pavolmarko@1
   266
	// If compiled with the /clr option ("managed C++"), the JIT compiler thinks
pavolmarko@1
   267
	// it needs to load GenericClass before it can call any of its functions,
pavolmarko@117
   268
	// (compiles OK but crashes at runtime!), so we need to declare an
pavolmarko@1
   269
	// empty class to make it happy.
pavolmarko@1
   270
	// Codeplay and VC4 can't cope with the unknown_inheritance case either.
pavolmarko@1
   271
	class GenericClass {};
pavolmarko@1
   272
#else
pavolmarko@1
   273
	class GenericClass;
pavolmarko@1
   274
#endif
pavolmarko@1
   275
pavolmarko@1
   276
// The size of a single inheritance member function pointer.
pavolmarko@1
   277
const int SINGLE_MEMFUNCPTR_SIZE = sizeof(void (GenericClass::*)());
pavolmarko@1
   278
pavolmarko@1
   279
//						SimplifyMemFunc< >::Convert()
pavolmarko@1
   280
//
pavolmarko@117
   281
//	A template function that converts an arbitrary member function pointer into the
pavolmarko@1
   282
//	simplest possible form of member function pointer, using a supplied 'this' pointer.
pavolmarko@1
   283
//  According to the standard, this can be done legally with reinterpret_cast<>.
pavolmarko@117
   284
//	For (non-standard) compilers which use member function pointers which vary in size
pavolmarko@117
   285
//  depending on the class, we need to use	knowledge of the internal structure of a
pavolmarko@1
   286
//  member function pointer, as used by the compiler. Template specialization is used
pavolmarko@117
   287
//  to distinguish between the sizes. Because some compilers don't support partial
pavolmarko@1
   288
//	template specialisation, I use full specialisation of a wrapper struct.
pavolmarko@1
   289
pavolmarko@1
   290
// general case -- don't know how to convert it. Force a compile failure
pavolmarko@1
   291
template <int N>
pavolmarko@1
   292
struct SimplifyMemFunc {
pavolmarko@1
   293
	template <class X, class XFuncType, class GenericMemFuncType>
pavolmarko@117
   294
	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
pavolmarko@117
   295
		GenericMemFuncType &bound_func) {
pavolmarko@1
   296
		// Unsupported member function type -- force a compile failure.
pavolmarko@1
   297
	    // (it's illegal to have a array with negative size).
pavolmarko@1
   298
		typedef char ERROR_Unsupported_member_function_pointer_on_this_compiler[N-100];
pavolmarko@117
   299
		return 0;
pavolmarko@1
   300
	}
pavolmarko@1
   301
};
pavolmarko@1
   302
pavolmarko@1
   303
// For compilers where all member func ptrs are the same size, everything goes here.
pavolmarko@1
   304
// For non-standard compilers, only single_inheritance classes go here.
pavolmarko@1
   305
template <>
pavolmarko@117
   306
struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE>  {
pavolmarko@1
   307
	template <class X, class XFuncType, class GenericMemFuncType>
pavolmarko@117
   308
	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
pavolmarko@1
   309
			GenericMemFuncType &bound_func) {
pavolmarko@117
   310
#if defined __DMC__
pavolmarko@117
   311
		// Digital Mars doesn't allow you to cast between abitrary PMF's,
pavolmarko@1
   312
		// even though the standard says you can. The 32-bit compiler lets you
pavolmarko@1
   313
		// static_cast through an int, but the DOS compiler doesn't.
pavolmarko@1
   314
		bound_func = horrible_cast<GenericMemFuncType>(function_to_bind);
pavolmarko@117
   315
#else
pavolmarko@1
   316
        bound_func = reinterpret_cast<GenericMemFuncType>(function_to_bind);
pavolmarko@1
   317
#endif
pavolmarko@1
   318
        return reinterpret_cast<GenericClass *>(pthis);
pavolmarko@1
   319
	}
pavolmarko@1
   320
};
pavolmarko@1
   321
pavolmarko@1
   322
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   323
//						Fast Delegates, part 1b:
pavolmarko@1
   324
//
pavolmarko@1
   325
//					Workarounds for Microsoft and Intel
pavolmarko@1
   326
//
pavolmarko@1
   327
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   328
pavolmarko@1
   329
pavolmarko@1
   330
// Compilers with member function pointers which violate the standard (MSVC, Intel, Codeplay),
pavolmarko@1
   331
// need to be treated as a special case.
pavolmarko@1
   332
#ifdef FASTDLGT_MICROSOFT_MFP
pavolmarko@1
   333
pavolmarko@1
   334
// We use unions to perform horrible_casts. I would like to use #pragma pack(push, 1)
pavolmarko@1
   335
// at the start of each function for extra safety, but VC6 seems to ICE
pavolmarko@1
   336
// intermittently if you do this inside a template.
pavolmarko@1
   337
pavolmarko@1
   338
// __multiple_inheritance classes go here
pavolmarko@1
   339
// Nasty hack for Microsoft and Intel (IA32 and Itanium)
pavolmarko@1
   340
template<>
pavolmarko@1
   341
struct SimplifyMemFunc< SINGLE_MEMFUNCPTR_SIZE + sizeof(int) >  {
pavolmarko@1
   342
	template <class X, class XFuncType, class GenericMemFuncType>
pavolmarko@117
   343
	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
pavolmarko@117
   344
		GenericMemFuncType &bound_func) {
pavolmarko@1
   345
		// We need to use a horrible_cast to do this conversion.
pavolmarko@1
   346
		// In MSVC, a multiple inheritance member pointer is internally defined as:
pavolmarko@1
   347
        union {
pavolmarko@1
   348
			XFuncType func;
pavolmarko@117
   349
			struct {
pavolmarko@1
   350
				GenericMemFuncType funcaddress; // points to the actual member function
pavolmarko@1
   351
				int delta;	     // #BYTES to be added to the 'this' pointer
pavolmarko@1
   352
			}s;
pavolmarko@1
   353
        } u;
pavolmarko@1
   354
		// Check that the horrible_cast will work
pavolmarko@1
   355
		typedef int ERROR_CantUsehorrible_cast[sizeof(function_to_bind)==sizeof(u.s)? 1 : -1];
pavolmarko@1
   356
        u.func = function_to_bind;
pavolmarko@1
   357
		bound_func = u.s.funcaddress;
pavolmarko@117
   358
		return reinterpret_cast<GenericClass *>(reinterpret_cast<char *>(pthis) + u.s.delta);
pavolmarko@1
   359
	}
pavolmarko@1
   360
};
pavolmarko@1
   361
pavolmarko@1
   362
// virtual inheritance is a real nuisance. It's inefficient and complicated.
pavolmarko@1
   363
// On MSVC and Intel, there isn't enough information in the pointer itself to
pavolmarko@1
   364
// enable conversion to a closure pointer. Earlier versions of this code didn't
pavolmarko@1
   365
// work for all cases, and generated a compile-time error instead.
pavolmarko@1
   366
// But a very clever hack invented by John M. Dlugosz solves this problem.
pavolmarko@117
   367
// My code is somewhat different to his: I have no asm code, and I make no
pavolmarko@1
   368
// assumptions about the calling convention that is used.
pavolmarko@1
   369
pavolmarko@117
   370
// In VC++ and ICL, a virtual_inheritance member pointer
pavolmarko@1
   371
// is internally defined as:
pavolmarko@1
   372
struct MicrosoftVirtualMFP {
pavolmarko@1
   373
	void (GenericClass::*codeptr)(); // points to the actual member function
pavolmarko@1
   374
	int delta;		// #bytes to be added to the 'this' pointer
pavolmarko@1
   375
	int vtable_index; // or 0 if no virtual inheritance
pavolmarko@1
   376
};
pavolmarko@1
   377
// The CRUCIAL feature of Microsoft/Intel MFPs which we exploit is that the
pavolmarko@1
   378
// m_codeptr member is *always* called, regardless of the values of the other
pavolmarko@1
   379
// members. (This is *not* true for other compilers, eg GCC, which obtain the
pavolmarko@1
   380
// function address from the vtable if a virtual function is being called).
pavolmarko@1
   381
// Dlugosz's trick is to make the codeptr point to a probe function which
pavolmarko@1
   382
// returns the 'this' pointer that was used.
pavolmarko@1
   383
pavolmarko@1
   384
// Define a generic class that uses virtual inheritance.
pavolmarko@1
   385
// It has a trival member function that returns the value of the 'this' pointer.
pavolmarko@1
   386
struct GenericVirtualClass : virtual public GenericClass
pavolmarko@1
   387
{
pavolmarko@1
   388
	typedef GenericVirtualClass * (GenericVirtualClass::*ProbePtrType)();
pavolmarko@1
   389
	GenericVirtualClass * GetThis() { return this; }
pavolmarko@1
   390
};
pavolmarko@1
   391
pavolmarko@1
   392
// __virtual_inheritance classes go here
pavolmarko@1
   393
template <>
pavolmarko@1
   394
struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE + 2*sizeof(int) >
pavolmarko@1
   395
{
pavolmarko@1
   396
pavolmarko@1
   397
	template <class X, class XFuncType, class GenericMemFuncType>
pavolmarko@117
   398
	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
pavolmarko@1
   399
		GenericMemFuncType &bound_func) {
pavolmarko@1
   400
		union {
pavolmarko@1
   401
			XFuncType func;
pavolmarko@1
   402
			GenericClass* (X::*ProbeFunc)();
pavolmarko@1
   403
			MicrosoftVirtualMFP s;
pavolmarko@1
   404
		} u;
pavolmarko@1
   405
		u.func = function_to_bind;
pavolmarko@1
   406
		bound_func = reinterpret_cast<GenericMemFuncType>(u.s.codeptr);
pavolmarko@1
   407
		union {
pavolmarko@1
   408
			GenericVirtualClass::ProbePtrType virtfunc;
pavolmarko@1
   409
			MicrosoftVirtualMFP s;
pavolmarko@1
   410
		} u2;
pavolmarko@1
   411
		// Check that the horrible_cast<>s will work
pavolmarko@1
   412
		typedef int ERROR_CantUsehorrible_cast[sizeof(function_to_bind)==sizeof(u.s)
pavolmarko@1
   413
			&& sizeof(function_to_bind)==sizeof(u.ProbeFunc)
pavolmarko@1
   414
			&& sizeof(u2.virtfunc)==sizeof(u2.s) ? 1 : -1];
pavolmarko@117
   415
   // Unfortunately, taking the address of a MF prevents it from being inlined, so
pavolmarko@1
   416
   // this next line can't be completely optimised away by the compiler.
pavolmarko@1
   417
		u2.virtfunc = &GenericVirtualClass::GetThis;
pavolmarko@1
   418
		u.s.codeptr = u2.s.codeptr;
pavolmarko@1
   419
		return (pthis->*u.ProbeFunc)();
pavolmarko@1
   420
	}
pavolmarko@1
   421
};
pavolmarko@1
   422
pavolmarko@1
   423
#if (_MSC_VER <1300)
pavolmarko@1
   424
pavolmarko@1
   425
// Nasty hack for Microsoft Visual C++ 6.0
pavolmarko@1
   426
// unknown_inheritance classes go here
pavolmarko@1
   427
// There is a compiler bug in MSVC6 which generates incorrect code in this case!!
pavolmarko@1
   428
template <>
pavolmarko@1
   429
struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE + 3*sizeof(int) >
pavolmarko@1
   430
{
pavolmarko@1
   431
	template <class X, class XFuncType, class GenericMemFuncType>
pavolmarko@117
   432
	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
pavolmarko@1
   433
		GenericMemFuncType &bound_func) {
pavolmarko@1
   434
		// There is an apalling but obscure compiler bug in MSVC6 and earlier:
pavolmarko@117
   435
		// vtable_index and 'vtordisp' are always set to 0 in the
pavolmarko@1
   436
		// unknown_inheritance case!
pavolmarko@1
   437
		// This means that an incorrect function could be called!!!
pavolmarko@1
   438
		// Compiling with the /vmg option leads to potentially incorrect code.
pavolmarko@1
   439
		// This is probably the reason that the IDE has a user interface for specifying
pavolmarko@117
   440
		// the /vmg option, but it is disabled -  you can only specify /vmg on
pavolmarko@1
   441
		// the command line. In VC1.5 and earlier, the compiler would ICE if it ever
pavolmarko@1
   442
		// encountered this situation.
pavolmarko@1
   443
		// It is OK to use the /vmg option if /vmm or /vms is specified.
pavolmarko@1
   444
pavolmarko@1
   445
		// Fortunately, the wrong function is only called in very obscure cases.
pavolmarko@117
   446
		// It only occurs when a derived class overrides a virtual function declared
pavolmarko@117
   447
		// in a virtual base class, and the member function
pavolmarko@1
   448
		// points to the *Derived* version of that function. The problem can be
pavolmarko@117
   449
		// completely averted in 100% of cases by using the *Base class* for the
pavolmarko@1
   450
		// member fpointer. Ie, if you use the base class as an interface, you'll
pavolmarko@1
   451
		// stay out of trouble.
pavolmarko@1
   452
		// Occasionally, you might want to point directly to a derived class function
pavolmarko@117
   453
		// that isn't an override of a base class. In this case, both vtable_index
pavolmarko@1
   454
		// and 'vtordisp' are zero, but a virtual_inheritance pointer will be generated.
pavolmarko@1
   455
		// We can generate correct code in this case. To prevent an incorrect call from
pavolmarko@117
   456
		// ever being made, on MSVC6 we generate a warning, and call a function to
pavolmarko@117
   457
		// make the program crash instantly.
pavolmarko@1
   458
		typedef char ERROR_VC6CompilerBug[-100];
pavolmarko@117
   459
		return 0;
pavolmarko@1
   460
	}
pavolmarko@1
   461
};
pavolmarko@1
   462
pavolmarko@1
   463
pavolmarko@117
   464
#else
pavolmarko@1
   465
pavolmarko@1
   466
// Nasty hack for Microsoft and Intel (IA32 and Itanium)
pavolmarko@117
   467
// unknown_inheritance classes go here
pavolmarko@1
   468
// This is probably the ugliest bit of code I've ever written. Look at the casts!
pavolmarko@1
   469
// There is a compiler bug in MSVC6 which prevents it from using this code.
pavolmarko@1
   470
template <>
pavolmarko@1
   471
struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE + 3*sizeof(int) >
pavolmarko@1
   472
{
pavolmarko@1
   473
	template <class X, class XFuncType, class GenericMemFuncType>
pavolmarko@117
   474
	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
pavolmarko@1
   475
			GenericMemFuncType &bound_func) {
pavolmarko@1
   476
		// The member function pointer is 16 bytes long. We can't use a normal cast, but
pavolmarko@1
   477
		// we can use a union to do the conversion.
pavolmarko@1
   478
		union {
pavolmarko@1
   479
			XFuncType func;
pavolmarko@117
   480
			// In VC++ and ICL, an unknown_inheritance member pointer
pavolmarko@1
   481
			// is internally defined as:
pavolmarko@1
   482
			struct {
pavolmarko@1
   483
				GenericMemFuncType m_funcaddress; // points to the actual member function
pavolmarko@1
   484
				int delta;		// #bytes to be added to the 'this' pointer
pavolmarko@1
   485
				int vtordisp;		// #bytes to add to 'this' to find the vtable
pavolmarko@1
   486
				int vtable_index; // or 0 if no virtual inheritance
pavolmarko@1
   487
			} s;
pavolmarko@1
   488
		} u;
pavolmarko@1
   489
		// Check that the horrible_cast will work
pavolmarko@1
   490
		typedef int ERROR_CantUsehorrible_cast[sizeof(XFuncType)==sizeof(u.s)? 1 : -1];
pavolmarko@1
   491
		u.func = function_to_bind;
pavolmarko@1
   492
		bound_func = u.s.funcaddress;
pavolmarko@1
   493
		int virtual_delta = 0;
pavolmarko@1
   494
		if (u.s.vtable_index) { // Virtual inheritance is used
pavolmarko@117
   495
			// First, get to the vtable.
pavolmarko@1
   496
			// It is 'vtordisp' bytes from the start of the class.
pavolmarko@1
   497
			const int * vtable = *reinterpret_cast<const int *const*>(
pavolmarko@1
   498
				reinterpret_cast<const char *>(pthis) + u.s.vtordisp );
pavolmarko@1
   499
pavolmarko@1
   500
			// 'vtable_index' tells us where in the table we should be looking.
pavolmarko@117
   501
			virtual_delta = u.s.vtordisp + *reinterpret_cast<const int *>(
pavolmarko@1
   502
				reinterpret_cast<const char *>(vtable) + u.s.vtable_index);
pavolmarko@1
   503
		}
pavolmarko@1
   504
		// The int at 'virtual_delta' gives us the amount to add to 'this'.
pavolmarko@1
   505
        // Finally we can add the three components together. Phew!
pavolmarko@1
   506
        return reinterpret_cast<GenericClass *>(
pavolmarko@1
   507
			reinterpret_cast<char *>(pthis) + u.s.delta + virtual_delta);
pavolmarko@1
   508
	};
pavolmarko@1
   509
};
pavolmarko@1
   510
#endif // MSVC 7 and greater
pavolmarko@1
   511
pavolmarko@1
   512
#endif // MS/Intel hacks
pavolmarko@1
   513
pavolmarko@1
   514
}  // namespace detail
pavolmarko@1
   515
pavolmarko@1
   516
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   517
//						Fast Delegates, part 2:
pavolmarko@1
   518
//
pavolmarko@1
   519
//	Define the delegate storage, and cope with static functions
pavolmarko@1
   520
//
pavolmarko@1
   521
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   522
pavolmarko@1
   523
// DelegateMemento -- an opaque structure which can hold an arbitary delegate.
pavolmarko@1
   524
// It knows nothing about the calling convention or number of arguments used by
pavolmarko@1
   525
// the function pointed to.
pavolmarko@1
   526
// It supplies comparison operators so that it can be stored in STL collections.
pavolmarko@117
   527
// It cannot be set to anything other than null, nor invoked directly:
pavolmarko@1
   528
//   it must be converted to a specific delegate.
pavolmarko@1
   529
pavolmarko@1
   530
// Implementation:
pavolmarko@1
   531
// There are two possible implementations: the Safe method and the Evil method.
pavolmarko@1
   532
//				DelegateMemento - Safe version
pavolmarko@1
   533
//
pavolmarko@1
   534
// This implementation is standard-compliant, but a bit tricky.
pavolmarko@117
   535
// A static function pointer is stored inside the class.
pavolmarko@1
   536
// Here are the valid values:
pavolmarko@1
   537
// +-- Static pointer --+--pThis --+-- pMemFunc-+-- Meaning------+
pavolmarko@1
   538
// |   0				|  0       |   0        | Empty          |
pavolmarko@1
   539
// |   !=0              |(dontcare)|  Invoker   | Static function|
pavolmarko@134
   540
// |   0                |  !=0     |  !=0*      | Method call    |
pavolmarko@1
   541
// +--------------------+----------+------------+----------------+
pavolmarko@134
   542
//  * For Metrowerks, this can be 0. (first virtual function in a 
pavolmarko@134
   543
//       single_inheritance class).
pavolmarko@1
   544
// When stored stored inside a specific delegate, the 'dontcare' entries are replaced
pavolmarko@1
   545
// with a reference to the delegate itself. This complicates the = and == operators
pavolmarko@1
   546
// for the delegate class.
pavolmarko@1
   547
pavolmarko@1
   548
//				DelegateMemento - Evil version
pavolmarko@1
   549
//
pavolmarko@117
   550
// For compilers where data pointers are at least as big as code pointers, it is
pavolmarko@117
   551
// possible to store the function pointer in the this pointer, using another
pavolmarko@1
   552
// horrible_cast. In this case the DelegateMemento implementation is simple:
pavolmarko@1
   553
// +--pThis --+-- pMemFunc-+-- Meaning---------------------+
pavolmarko@1
   554
// |    0     |  0         | Empty                         |
pavolmarko@134
   555
// |  !=0     |  !=0*      | Static function or method call|
pavolmarko@1
   556
// +----------+------------+-------------------------------+
pavolmarko@134
   557
//  * For Metrowerks, this can be 0. (first virtual function in a 
pavolmarko@134
   558
//       single_inheritance class).
pavolmarko@134
   559
// Note that the Sun C++ and MSVC documentation explicitly state that they 
pavolmarko@1
   560
// support static_cast between void * and function pointers.
pavolmarko@1
   561
pavolmarko@1
   562
class DelegateMemento {
pavolmarko@117
   563
protected:
pavolmarko@1
   564
	// the data is protected, not private, because many
pavolmarko@1
   565
	// compilers have problems with template friends.
pavolmarko@1
   566
	typedef void (detail::GenericClass::*GenericMemFuncType)(); // arbitrary MFP.
pavolmarko@1
   567
	detail::GenericClass *m_pthis;
pavolmarko@1
   568
	GenericMemFuncType m_pFunction;
pavolmarko@1
   569
pavolmarko@1
   570
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   571
	typedef void (*GenericFuncPtr)(); // arbitrary code pointer
pavolmarko@1
   572
	GenericFuncPtr m_pStaticFunction;
pavolmarko@1
   573
#endif
pavolmarko@1
   574
pavolmarko@1
   575
public:
pavolmarko@1
   576
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   577
	DelegateMemento() : m_pthis(0), m_pFunction(0), m_pStaticFunction(0) {};
pavolmarko@1
   578
	void clear() {
pavolmarko@1
   579
		m_pthis=0; m_pFunction=0; m_pStaticFunction=0;
pavolmarko@1
   580
	}
pavolmarko@1
   581
#else
pavolmarko@1
   582
	DelegateMemento() : m_pthis(0), m_pFunction(0) {};
pavolmarko@134
   583
	void clear() {	m_pthis=0; m_pFunction=0;	}
pavolmarko@1
   584
#endif
pavolmarko@1
   585
public:
pavolmarko@1
   586
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   587
	inline bool IsEqual (const DelegateMemento &x) const{
pavolmarko@1
   588
	    // We have to cope with the static function pointers as a special case
pavolmarko@1
   589
		if (m_pFunction!=x.m_pFunction) return false;
pavolmarko@1
   590
		// the static function ptrs must either both be equal, or both be 0.
pavolmarko@1
   591
		if (m_pStaticFunction!=x.m_pStaticFunction) return false;
pavolmarko@1
   592
		if (m_pStaticFunction!=0) return m_pthis==x.m_pthis;
pavolmarko@1
   593
		else return true;
pavolmarko@1
   594
	}
pavolmarko@1
   595
#else // Evil Method
pavolmarko@1
   596
	inline bool IsEqual (const DelegateMemento &x) const{
pavolmarko@1
   597
		return m_pthis==x.m_pthis && m_pFunction==x.m_pFunction;
pavolmarko@1
   598
	}
pavolmarko@1
   599
#endif
pavolmarko@1
   600
	// Provide a strict weak ordering for DelegateMementos.
pavolmarko@1
   601
	inline bool IsLess(const DelegateMemento &right) const {
pavolmarko@1
   602
		// deal with static function pointers first
pavolmarko@1
   603
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@117
   604
		if (m_pStaticFunction !=0 || right.m_pStaticFunction!=0)
pavolmarko@1
   605
				return m_pStaticFunction < right.m_pStaticFunction;
pavolmarko@1
   606
#endif
pavolmarko@1
   607
		if (m_pthis !=right.m_pthis) return m_pthis < right.m_pthis;
pavolmarko@117
   608
	// There are no ordering operators for member function pointers,
pavolmarko@1
   609
	// but we can fake one by comparing each byte. The resulting ordering is
pavolmarko@1
   610
	// arbitrary (and compiler-dependent), but it permits storage in ordered STL containers.
pavolmarko@1
   611
		return memcmp(&m_pFunction, &right.m_pFunction, sizeof(m_pFunction)) < 0;
pavolmarko@1
   612
pavolmarko@1
   613
	}
pavolmarko@134
   614
	// BUGFIX (Mar 2005):
pavolmarko@134
   615
	// We can't just compare m_pFunction because on Metrowerks,
pavolmarko@134
   616
	// m_pFunction can be zero even if the delegate is not empty!
pavolmarko@1
   617
	inline bool operator ! () const		// Is it bound to anything?
pavolmarko@134
   618
	{ return m_pthis==0 && m_pFunction==0; }
pavolmarko@134
   619
	inline bool empty() const		// Is it bound to anything?
pavolmarko@134
   620
	{ return m_pthis==0 && m_pFunction==0; }
pavolmarko@1
   621
public:
pavolmarko@1
   622
	DelegateMemento & operator = (const DelegateMemento &right)  {
pavolmarko@117
   623
		SetMementoFrom(right);
pavolmarko@1
   624
		return *this;
pavolmarko@1
   625
	}
pavolmarko@1
   626
	inline bool operator <(const DelegateMemento &right) {
pavolmarko@1
   627
		return IsLess(right);
pavolmarko@1
   628
	}
pavolmarko@1
   629
	inline bool operator >(const DelegateMemento &right) {
pavolmarko@1
   630
		return right.IsLess(*this);
pavolmarko@1
   631
	}
pavolmarko@117
   632
	DelegateMemento (const DelegateMemento &right)  :
pavolmarko@117
   633
		m_pthis(right.m_pthis), m_pFunction(right.m_pFunction)
pavolmarko@1
   634
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   635
		, m_pStaticFunction (right.m_pStaticFunction)
pavolmarko@1
   636
#endif
pavolmarko@1
   637
		{}
pavolmarko@1
   638
protected:
pavolmarko@1
   639
	void SetMementoFrom(const DelegateMemento &right)  {
pavolmarko@1
   640
		m_pFunction = right.m_pFunction;
pavolmarko@1
   641
		m_pthis = right.m_pthis;
pavolmarko@1
   642
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   643
		m_pStaticFunction = right.m_pStaticFunction;
pavolmarko@1
   644
#endif
pavolmarko@1
   645
	}
pavolmarko@1
   646
};
pavolmarko@1
   647
pavolmarko@1
   648
pavolmarko@1
   649
//						ClosurePtr<>
pavolmarko@1
   650
//
pavolmarko@1
   651
// A private wrapper class that adds function signatures to DelegateMemento.
pavolmarko@1
   652
// It's the class that does most of the actual work.
pavolmarko@1
   653
// The signatures are specified by:
pavolmarko@117
   654
// GenericMemFunc: must be a type of GenericClass member function pointer.
pavolmarko@117
   655
// StaticFuncPtr:  must be a type of function pointer with the same signature
pavolmarko@1
   656
//                 as GenericMemFunc.
pavolmarko@1
   657
// UnvoidStaticFuncPtr: is the same as StaticFuncPtr, except on VC6
pavolmarko@1
   658
//                 where it never returns void (returns DefaultVoid instead).
pavolmarko@1
   659
pavolmarko@1
   660
// An outer class, FastDelegateN<>, handles the invoking and creates the
pavolmarko@1
   661
// necessary typedefs.
pavolmarko@1
   662
// This class does everything else.
pavolmarko@1
   663
pavolmarko@1
   664
namespace detail {
pavolmarko@1
   665
pavolmarko@1
   666
template < class GenericMemFunc, class StaticFuncPtr, class UnvoidStaticFuncPtr>
pavolmarko@1
   667
class ClosurePtr : public DelegateMemento {
pavolmarko@1
   668
public:
pavolmarko@1
   669
	// These functions are for setting the delegate to a member function.
pavolmarko@1
   670
pavolmarko@117
   671
	// Here's the clever bit: we convert an arbitrary member function into a
pavolmarko@117
   672
	// standard form. XMemFunc should be a member function of class X, but I can't
pavolmarko@1
   673
	// enforce that here. It needs to be enforced by the wrapper class.
pavolmarko@1
   674
	template < class X, class XMemFunc >
pavolmarko@1
   675
	inline void bindmemfunc(X *pthis, XMemFunc function_to_bind ) {
pavolmarko@1
   676
		m_pthis = SimplifyMemFunc< sizeof(function_to_bind) >
pavolmarko@1
   677
			::Convert(pthis, function_to_bind, m_pFunction);
pavolmarko@1
   678
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   679
		m_pStaticFunction = 0;
pavolmarko@1
   680
#endif
pavolmarko@1
   681
	}
pavolmarko@1
   682
	// For const member functions, we only need a const class pointer.
pavolmarko@117
   683
	// Since we know that the member function is const, it's safe to
pavolmarko@1
   684
	// remove the const qualifier from the 'this' pointer with a const_cast.
pavolmarko@1
   685
	// VC6 has problems if we just overload 'bindmemfunc', so we give it a different name.
pavolmarko@1
   686
	template < class X, class XMemFunc>
pavolmarko@1
   687
	inline void bindconstmemfunc(const X *pthis, XMemFunc function_to_bind) {
pavolmarko@1
   688
		m_pthis= SimplifyMemFunc< sizeof(function_to_bind) >
pavolmarko@1
   689
			::Convert(const_cast<X*>(pthis), function_to_bind, m_pFunction);
pavolmarko@1
   690
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   691
		m_pStaticFunction = 0;
pavolmarko@1
   692
#endif
pavolmarko@1
   693
	}
pavolmarko@1
   694
#ifdef FASTDELEGATE_GCC_BUG_8271	// At present, GCC doesn't recognize constness of MFPs in templates
pavolmarko@1
   695
	template < class X, class XMemFunc>
pavolmarko@1
   696
	inline void bindmemfunc(const X *pthis, XMemFunc function_to_bind) {
pavolmarko@1
   697
		bindconstmemfunc(pthis, function_to_bind);
pavolmarko@1
   698
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   699
		m_pStaticFunction = 0;
pavolmarko@1
   700
#endif
pavolmarko@1
   701
	}
pavolmarko@1
   702
#endif
pavolmarko@1
   703
	// These functions are required for invoking the stored function
pavolmarko@1
   704
	inline GenericClass *GetClosureThis() const { return m_pthis; }
pavolmarko@1
   705
	inline GenericMemFunc GetClosureMemPtr() const { return reinterpret_cast<GenericMemFunc>(m_pFunction); }
pavolmarko@1
   706
pavolmarko@1
   707
// There are a few ways of dealing with static function pointers.
pavolmarko@1
   708
// There's a standard-compliant, but tricky method.
pavolmarko@1
   709
// There's also a straightforward hack, that won't work on DOS compilers using the
pavolmarko@1
   710
// medium memory model. It's so evil that I can't recommend it, but I've
pavolmarko@1
   711
// implemented it anyway because it produces very nice asm code.
pavolmarko@1
   712
pavolmarko@1
   713
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   714
pavolmarko@1
   715
//				ClosurePtr<> - Safe version
pavolmarko@1
   716
//
pavolmarko@1
   717
// This implementation is standard-compliant, but a bit tricky.
pavolmarko@1
   718
// I store the function pointer inside the class, and the delegate then
pavolmarko@1
   719
// points to itself. Whenever the delegate is copied, these self-references
pavolmarko@1
   720
// must be transformed, and this complicates the = and == operators.
pavolmarko@1
   721
public:
pavolmarko@1
   722
	// The next two functions are for operator ==, =, and the copy constructor.
pavolmarko@1
   723
	// We may need to convert the m_pthis pointers, so that
pavolmarko@1
   724
	// they remain as self-references.
pavolmarko@1
   725
	template< class DerivedClass >
pavolmarko@1
   726
	inline void CopyFrom (DerivedClass *pParent, const DelegateMemento &x) {
pavolmarko@1
   727
		SetMementoFrom(x);
pavolmarko@1
   728
		if (m_pStaticFunction!=0) {
pavolmarko@1
   729
			// transform self references...
pavolmarko@1
   730
			m_pthis=reinterpret_cast<GenericClass *>(pParent);
pavolmarko@1
   731
		}
pavolmarko@1
   732
	}
pavolmarko@117
   733
	// For static functions, the 'static_function_invoker' class in the parent
pavolmarko@117
   734
	// will be called. The parent then needs to call GetStaticFunction() to find out
pavolmarko@1
   735
	// the actual function to invoke.
pavolmarko@1
   736
	template < class DerivedClass, class ParentInvokerSig >
pavolmarko@117
   737
	inline void bindstaticfunc(DerivedClass *pParent, ParentInvokerSig static_function_invoker,
pavolmarko@1
   738
				StaticFuncPtr function_to_bind ) {
pavolmarko@134
   739
		if (function_to_bind==0) { // cope with assignment to 0
pavolmarko@134
   740
			m_pFunction=0;
pavolmarko@134
   741
		} else {
pavolmarko@134
   742
			bindmemfunc(pParent, static_function_invoker);
pavolmarko@134
   743
        }
pavolmarko@1
   744
		m_pStaticFunction=reinterpret_cast<GenericFuncPtr>(function_to_bind);
pavolmarko@1
   745
	}
pavolmarko@117
   746
	inline UnvoidStaticFuncPtr GetStaticFunction() const {
pavolmarko@117
   747
		return reinterpret_cast<UnvoidStaticFuncPtr>(m_pStaticFunction);
pavolmarko@1
   748
	}
pavolmarko@1
   749
#else
pavolmarko@1
   750
pavolmarko@1
   751
//				ClosurePtr<> - Evil version
pavolmarko@1
   752
//
pavolmarko@117
   753
// For compilers where data pointers are at least as big as code pointers, it is
pavolmarko@117
   754
// possible to store the function pointer in the this pointer, using another
pavolmarko@1
   755
// horrible_cast. Invocation isn't any faster, but it saves 4 bytes, and
pavolmarko@1
   756
// speeds up comparison and assignment. If C++ provided direct language support
pavolmarko@1
   757
// for delegates, they would produce asm code that was almost identical to this.
pavolmarko@117
   758
// Note that the Sun C++ and MSVC documentation explicitly state that they
pavolmarko@1
   759
// support static_cast between void * and function pointers.
pavolmarko@1
   760
pavolmarko@1
   761
	template< class DerivedClass >
pavolmarko@1
   762
	inline void CopyFrom (DerivedClass *pParent, const DelegateMemento &right) {
pavolmarko@1
   763
		SetMementoFrom(right);
pavolmarko@1
   764
	}
pavolmarko@117
   765
	// For static functions, the 'static_function_invoker' class in the parent
pavolmarko@117
   766
	// will be called. The parent then needs to call GetStaticFunction() to find out
pavolmarko@1
   767
	// the actual function to invoke.
pavolmarko@1
   768
	// ******** EVIL, EVIL CODE! *******
pavolmarko@1
   769
	template < 	class DerivedClass, class ParentInvokerSig>
pavolmarko@117
   770
	inline void bindstaticfunc(DerivedClass *pParent, ParentInvokerSig static_function_invoker,
pavolmarko@1
   771
				StaticFuncPtr function_to_bind) {
pavolmarko@134
   772
		if (function_to_bind==0) { // cope with assignment to 0
pavolmarko@134
   773
			m_pFunction=0;
pavolmarko@134
   774
		} else { 
pavolmarko@134
   775
		   // We'll be ignoring the 'this' pointer, but we need to make sure we pass
pavolmarko@134
   776
		   // a valid value to bindmemfunc().
pavolmarko@134
   777
			bindmemfunc(pParent, static_function_invoker);
pavolmarko@134
   778
        }
pavolmarko@1
   779
pavolmarko@1
   780
		// WARNING! Evil hack. We store the function in the 'this' pointer!
pavolmarko@117
   781
		// Ensure that there's a compilation failure if function pointers
pavolmarko@1
   782
		// and data pointers have different sizes.
pavolmarko@1
   783
		// If you get this error, you need to #undef FASTDELEGATE_USESTATICFUNCTIONHACK.
pavolmarko@1
   784
		typedef int ERROR_CantUseEvilMethod[sizeof(GenericClass *)==sizeof(function_to_bind) ? 1 : -1];
pavolmarko@1
   785
		m_pthis = horrible_cast<GenericClass *>(function_to_bind);
pavolmarko@1
   786
		// MSVC, SunC++ and DMC accept the following (non-standard) code:
pavolmarko@1
   787
//		m_pthis = static_cast<GenericClass *>(static_cast<void *>(function_to_bind));
pavolmarko@1
   788
		// BCC32, Comeau and DMC accept this method. MSVC7.1 needs __int64 instead of long
pavolmarko@1
   789
//		m_pthis = reinterpret_cast<GenericClass *>(reinterpret_cast<long>(function_to_bind));
pavolmarko@1
   790
	}
pavolmarko@1
   791
	// ******** EVIL, EVIL CODE! *******
pavolmarko@1
   792
	// This function will be called with an invalid 'this' pointer!!
pavolmarko@1
   793
	// We're just returning the 'this' pointer, converted into
pavolmarko@1
   794
	// a function pointer!
pavolmarko@1
   795
	inline UnvoidStaticFuncPtr GetStaticFunction() const {
pavolmarko@117
   796
		// Ensure that there's a compilation failure if function pointers
pavolmarko@1
   797
		// and data pointers have different sizes.
pavolmarko@1
   798
		// If you get this error, you need to #undef FASTDELEGATE_USESTATICFUNCTIONHACK.
pavolmarko@1
   799
		typedef int ERROR_CantUseEvilMethod[sizeof(UnvoidStaticFuncPtr)==sizeof(this) ? 1 : -1];
pavolmarko@1
   800
		return horrible_cast<UnvoidStaticFuncPtr>(this);
pavolmarko@1
   801
	}
pavolmarko@1
   802
#endif // !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   803
pavolmarko@134
   804
	// Does the closure contain this static function?
pavolmarko@134
   805
	inline bool IsEqualToStaticFuncPtr(StaticFuncPtr funcptr){
pavolmarko@134
   806
		if (funcptr==0) return empty();
pavolmarko@134
   807
	// For the Evil method, if it doesn't actually contain a static function, this will return an arbitrary
pavolmarko@134
   808
	// value that is not equal to any valid function pointer.
pavolmarko@134
   809
		else return funcptr==reinterpret_cast<StaticFuncPtr>(GetStaticFunction());
pavolmarko@134
   810
	}
pavolmarko@1
   811
};
pavolmarko@1
   812
pavolmarko@1
   813
pavolmarko@1
   814
} // namespace detail
pavolmarko@1
   815
pavolmarko@1
   816
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   817
//						Fast Delegates, part 3:
pavolmarko@1
   818
//
pavolmarko@1
   819
//				Wrapper classes to ensure type safety
pavolmarko@1
   820
//
pavolmarko@1
   821
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   822
pavolmarko@1
   823
pavolmarko@1
   824
// Once we have the member function conversion templates, it's easy to make the
pavolmarko@117
   825
// wrapper classes. So that they will work with as many compilers as possible,
pavolmarko@1
   826
// the classes are of the form
pavolmarko@1
   827
//   FastDelegate3<int, char *, double>
pavolmarko@1
   828
// They can cope with any combination of parameters. The max number of parameters
pavolmarko@1
   829
// allowed is 8, but it is trivial to increase this limit.
pavolmarko@1
   830
// Note that we need to treat const member functions seperately.
pavolmarko@1
   831
// All this class does is to enforce type safety, and invoke the delegate with
pavolmarko@1
   832
// the correct list of parameters.
pavolmarko@1
   833
pavolmarko@1
   834
// Because of the weird rule about the class of derived member function pointers,
pavolmarko@1
   835
// you sometimes need to apply a downcast to the 'this' pointer.
pavolmarko@117
   836
// This is the reason for the use of "implicit_cast<X*>(pthis)" in the code below.
pavolmarko@1
   837
// If CDerivedClass is derived from CBaseClass, but doesn't override SimpleVirtualFunction,
pavolmarko@1
   838
// without this trick you'd need to write:
pavolmarko@1
   839
//		MyDelegate(static_cast<CBaseClass *>(&d), &CDerivedClass::SimpleVirtualFunction);
pavolmarko@1
   840
// but with the trick you can write
pavolmarko@1
   841
//		MyDelegate(&d, &CDerivedClass::SimpleVirtualFunction);
pavolmarko@1
   842
pavolmarko@1
   843
// RetType is the type the compiler uses in compiling the template. For VC6,
pavolmarko@1
   844
// it cannot be void. DesiredRetType is the real type which is returned from
pavolmarko@1
   845
// all of the functions. It can be void.
pavolmarko@1
   846
pavolmarko@134
   847
// Implicit conversion to "bool" is achieved using the safe_bool idiom,
pavolmarko@134
   848
// using member data pointers (MDP). This allows "if (dg)..." syntax
pavolmarko@134
   849
// Because some compilers (eg codeplay) don't have a unique value for a zero
pavolmarko@134
   850
// MDP, an extra padding member is added to the SafeBool struct.
pavolmarko@134
   851
// Some compilers (eg VC6) won't implicitly convert from 0 to an MDP, so
pavolmarko@134
   852
// in that case the static function constructor is not made explicit; this
pavolmarko@134
   853
// allows "if (dg==0) ..." to compile.
pavolmarko@134
   854
pavolmarko@1
   855
@VARARGS
pavolmarko@1
   856
template<@CLASSARGS, class RetType=detail::DefaultVoid>
pavolmarko@1
   857
class FastDelegate@NUM {
pavolmarko@1
   858
private:
pavolmarko@1
   859
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
   860
	typedef DesiredRetType (*StaticFunctionPtr)(@FUNCARGS);
pavolmarko@1
   861
	typedef RetType (*UnvoidStaticFunctionPtr)(@FUNCARGS);
pavolmarko@1
   862
	typedef RetType (detail::GenericClass::*GenericMemFn)(@FUNCARGS);
pavolmarko@134
   863
	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
pavolmarko@134
   864
	ClosureType m_Closure;
pavolmarko@1
   865
public:
pavolmarko@1
   866
	// Typedefs to aid generic programming
pavolmarko@1
   867
	typedef FastDelegate@NUM type;
pavolmarko@1
   868
pavolmarko@1
   869
	// Construction and comparison functions
pavolmarko@1
   870
	FastDelegate@NUM() { clear(); }
pavolmarko@1
   871
	FastDelegate@NUM(const FastDelegate@NUM &x) {
pavolmarko@1
   872
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
   873
	void operator = (const FastDelegate@NUM &x)  {
pavolmarko@1
   874
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
   875
	bool operator ==(const FastDelegate@NUM &x) const {
pavolmarko@1
   876
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
   877
	bool operator !=(const FastDelegate@NUM &x) const {
pavolmarko@1
   878
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
   879
	bool operator <(const FastDelegate@NUM &x) const {
pavolmarko@1
   880
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
   881
	bool operator >(const FastDelegate@NUM &x) const {
pavolmarko@1
   882
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
   883
	// Binding to non-const member functions
pavolmarko@1
   884
	template < class X, class Y >
pavolmarko@1
   885
	FastDelegate@NUM(Y *pthis, DesiredRetType (X::* function_to_bind)(@FUNCARGS) ) {
pavolmarko@1
   886
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
   887
	template < class X, class Y >
pavolmarko@1
   888
	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(@FUNCARGS)) {
pavolmarko@1
   889
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
   890
	// Binding to const member functions.
pavolmarko@1
   891
	template < class X, class Y >
pavolmarko@1
   892
	FastDelegate@NUM(const Y *pthis, DesiredRetType (X::* function_to_bind)(@FUNCARGS) const) {
pavolmarko@1
   893
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
   894
	template < class X, class Y >
pavolmarko@1
   895
	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(@FUNCARGS) const) {
pavolmarko@1
   896
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
   897
	// Static functions. We convert them into a member function call.
pavolmarko@134
   898
	// This constructor also provides implicit conversion
pavolmarko@1
   899
	FastDelegate@NUM(DesiredRetType (*function_to_bind)(@FUNCARGS) ) {
pavolmarko@1
   900
		bind(function_to_bind);	}
pavolmarko@134
   901
	// for efficiency, prevent creation of a temporary
pavolmarko@134
   902
	void operator = (DesiredRetType (*function_to_bind)(@FUNCARGS) ) {
pavolmarko@134
   903
		bind(function_to_bind);	}
pavolmarko@1
   904
	inline void bind(DesiredRetType (*function_to_bind)(@FUNCARGS)) {
pavolmarko@117
   905
		m_Closure.bindstaticfunc(this, &FastDelegate@NUM::InvokeStaticFunction,
pavolmarko@1
   906
			function_to_bind); }
pavolmarko@134
   907
	// Invoke the delegate
pavolmarko@134
   908
	RetType operator() (@FUNCARGS) const {
pavolmarko@1
   909
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(@INVOKEARGS); }
pavolmarko@134
   910
	// Implicit conversion to "bool" using the safe_bool idiom
pavolmarko@134
   911
private:
pavolmarko@134
   912
	typedef struct SafeBoolStruct {
pavolmarko@134
   913
		int a_data_pointer_to_this_is_0_on_buggy_compilers;
pavolmarko@134
   914
		StaticFunctionPtr m_nonzero;
pavolmarko@134
   915
	} UselessTypedef;
pavolmarko@134
   916
    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
pavolmarko@134
   917
public:
pavolmarko@134
   918
	operator unspecified_bool_type() const {
pavolmarko@134
   919
        return empty()? 0: &SafeBoolStruct::m_nonzero;
pavolmarko@134
   920
    }
pavolmarko@134
   921
	// necessary to allow ==0 to work despite the safe_bool idiom
pavolmarko@134
   922
	inline bool operator==(StaticFunctionPtr funcptr) {
pavolmarko@134
   923
		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
pavolmarko@134
   924
	inline bool operator!=(StaticFunctionPtr funcptr) { 
pavolmarko@134
   925
		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
pavolmarko@1
   926
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
   927
			return !m_Closure; }
pavolmarko@1
   928
	inline bool empty() const	{
pavolmarko@1
   929
			return !m_Closure; }
pavolmarko@1
   930
	void clear() { m_Closure.clear();}
pavolmarko@1
   931
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
   932
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
   933
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
   934
pavolmarko@1
   935
private:	// Invoker for static functions
pavolmarko@1
   936
	RetType InvokeStaticFunction(@FUNCARGS) const {
pavolmarko@1
   937
	return (*(m_Closure.GetStaticFunction()))(@INVOKEARGS); }
pavolmarko@1
   938
};
pavolmarko@1
   939
pavolmarko@1
   940
@ENDVAR
pavolmarko@1
   941
pavolmarko@1
   942
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   943
//						Fast Delegates, part 4:
pavolmarko@117
   944
//
pavolmarko@1
   945
//				FastDelegate<> class (Original author: Jody Hagins)
pavolmarko@1
   946
//	Allows boost::function style syntax like:
pavolmarko@1
   947
//			FastDelegate< double (int, long) >
pavolmarko@1
   948
// instead of:
pavolmarko@1
   949
//			FastDelegate2< int, long, double >
pavolmarko@1
   950
//
pavolmarko@1
   951
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   952
pavolmarko@1
   953
#ifdef FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
pavolmarko@1
   954
pavolmarko@1
   955
// Declare FastDelegate as a class template.  It will be specialized
pavolmarko@1
   956
// later for all number of arguments.
pavolmarko@1
   957
template <typename Signature>
pavolmarko@1
   958
class FastDelegate;
pavolmarko@1
   959
pavolmarko@1
   960
@VARARGS
pavolmarko@1
   961
// Specialization to allow use of
pavolmarko@1
   962
// FastDelegate< R ( @SELARGS ) >
pavolmarko@1
   963
// instead of
pavolmarko@1
   964
// FastDelegate@NUM < @SELARGS, R >
pavolmarko@1
   965
template<typename R, @CLASSARGS>
pavolmarko@1
   966
class FastDelegate< R ( @SELARGS ) >
pavolmarko@134
   967
  // Inherit from FastDelegate@NUM so that it can be treated just like a FastDelegate@NUM
pavolmarko@1
   968
  : public FastDelegate@NUM < @SELARGS, R >
pavolmarko@1
   969
{
pavolmarko@1
   970
public:
pavolmarko@1
   971
  // Make using the base type a bit easier via typedef.
pavolmarko@1
   972
  typedef FastDelegate@NUM < @SELARGS, R > BaseType;
pavolmarko@1
   973
pavolmarko@1
   974
  // Allow users access to the specific type of this delegate.
pavolmarko@1
   975
  typedef FastDelegate SelfType;
pavolmarko@1
   976
pavolmarko@1
   977
  // Mimic the base class constructors.
pavolmarko@1
   978
  FastDelegate() : BaseType() { }
pavolmarko@1
   979
pavolmarko@1
   980
  template < class X, class Y >
pavolmarko@117
   981
  FastDelegate(Y * pthis,
pavolmarko@1
   982
    R (X::* function_to_bind)( @FUNCARGS ))
pavolmarko@1
   983
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
   984
pavolmarko@1
   985
  template < class X, class Y >
pavolmarko@1
   986
  FastDelegate(const Y *pthis,
pavolmarko@1
   987
      R (X::* function_to_bind)( @FUNCARGS ) const)
pavolmarko@1
   988
    : BaseType(pthis, function_to_bind)
pavolmarko@1
   989
  {  }
pavolmarko@1
   990
pavolmarko@1
   991
  FastDelegate(R (*function_to_bind)( @FUNCARGS ))
pavolmarko@1
   992
    : BaseType(function_to_bind)  { }
pavolmarko@117
   993
  void operator = (const BaseType &x)  {
pavolmarko@1
   994
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
   995
};
pavolmarko@1
   996
pavolmarko@1
   997
@ENDVAR
pavolmarko@1
   998
pavolmarko@1
   999
#endif //FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
pavolmarko@1
  1000
pavolmarko@1
  1001
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
  1002
//						Fast Delegates, part 5:
pavolmarko@1
  1003
//
pavolmarko@1
  1004
//				MakeDelegate() helper function
pavolmarko@1
  1005
//
pavolmarko@1
  1006
//			MakeDelegate(&x, &X::func) returns a fastdelegate of the type
pavolmarko@1
  1007
//			necessary for calling x.func() with the correct number of arguments.
pavolmarko@1
  1008
//			This makes it possible to eliminate many typedefs from user code.
pavolmarko@1
  1009
//
pavolmarko@1
  1010
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
  1011
pavolmarko@117
  1012
// Also declare overloads of a MakeDelegate() global function to
pavolmarko@1
  1013
// reduce the need for typedefs.
pavolmarko@1
  1014
// We need seperate overloads for const and non-const member functions.
pavolmarko@1
  1015
// Also, because of the weird rule about the class of derived member function pointers,
pavolmarko@1
  1016
// implicit downcasts may need to be applied later to the 'this' pointer.
pavolmarko@1
  1017
// That's why two classes (X and Y) appear in the definitions. Y must be implicitly
pavolmarko@1
  1018
// castable to X.
pavolmarko@1
  1019
pavolmarko@1
  1020
// Workaround for VC6. VC6 needs void return types converted into DefaultVoid.
pavolmarko@1
  1021
// GCC 3.2 and later won't compile this unless it's preceded by 'typename',
pavolmarko@1
  1022
// but VC6 doesn't allow 'typename' in this context.
pavolmarko@1
  1023
// So, I have to use a macro.
pavolmarko@1
  1024
pavolmarko@1
  1025
#ifdef FASTDLGT_VC6
pavolmarko@1
  1026
#define FASTDLGT_RETTYPE detail::VoidToDefaultVoid<RetType>::type
pavolmarko@117
  1027
#else
pavolmarko@1
  1028
#define FASTDLGT_RETTYPE RetType
pavolmarko@1
  1029
#endif
pavolmarko@1
  1030
pavolmarko@1
  1031
@VARARGS
pavolmarko@1
  1032
template <class X, class Y, @CLASSARGS, class RetType>
pavolmarko@117
  1033
FastDelegate@NUM<@SELARGS, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(@FUNCARGS)) {
pavolmarko@1
  1034
	return FastDelegate@NUM<@SELARGS, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  1035
}
pavolmarko@1
  1036
pavolmarko@1
  1037
template <class X, class Y, @CLASSARGS, class RetType>
pavolmarko@117
  1038
FastDelegate@NUM<@SELARGS, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(@FUNCARGS) const) {
pavolmarko@1
  1039
	return FastDelegate@NUM<@SELARGS, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  1040
}
pavolmarko@1
  1041
pavolmarko@45
  1042
template <@CLASSARGS, class RetType>
pavolmarko@117
  1043
FastDelegate@NUM<@SELARGS, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(@FUNCARGS)) {
pavolmarko@45
  1044
	return FastDelegate@NUM<@SELARGS, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  1045
}
pavolmarko@45
  1046
pavolmarko@1
  1047
@ENDVAR
pavolmarko@1
  1048
pavolmarko@1
  1049
 // clean up after ourselves...
pavolmarko@1
  1050
#undef FASTDLGT_RETTYPE
pavolmarko@1
  1051
pavolmarko@1
  1052
} // namespace fastdelegate
pavolmarko@1
  1053
pavolmarko@1
  1054
#endif // !defined(FASTDELEGATE_H)