// -----------------------------------------------------------------------------------------------
// The ARG_COUNT macro.
//
// A variadic macro that outputs a constant number which is the number of arguments in the list.
// The complexity arises from needing to support the empty list in a cross platform way.
// NOTE: Only works for lists up to 24 arguments.
//
// i.e. 
//  int i = ARG_COUNT(1, 2, 3);
//    preprocesses to
//  int i = 3;
//
#define _EXPAND(x) x
#define _COMMA(...) ,
#define _PASTE(_0, _1) _0 ## _1
#define _PASTE3(_0, _1, _2) _0 ## _1 ## _2
#define _ARG24(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, N, ...) N
#define _HAS_COMMA(...) _EXPAND( _ARG24( __VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0) )

#define _IS_EMPTY01 ,
#define _IS_EMPTY(_0, _1) _PASTE3( _IS_EMPTY, _0, _1 )
#define IS_EMPTY(...) _HAS_COMMA( _IS_EMPTY(_HAS_COMMA(__VA_ARGS__), _HAS_COMMA(_COMMA __VA_ARGS__ (~))) )

#define _ARG_COUNT1(...) 0
#define _ARG_COUNT0(...) _EXPAND( _ARG24( __VA_ARGS__, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1) )
#define _ARG_COUNT(isEmpty, ...) _PASTE( _ARG_COUNT, isEmpty )(__VA_ARGS__)
#define ARG_COUNT(...) _ARG_COUNT( IS_EMPTY(__VA_ARGS__), __VA_ARGS__ )
// -----------------------------------------------------------------------------------------------


// "Macro overloading" technique
#define OVERLOAD_EXAMPLE(...) _OVERLOAD_EXAMPLE( ARG_COUNT(__VA_ARGS__), __VA_ARGS__ )
#define _OVERLOAD_EXAMPLE(argCount, ...) _EXPAND( _PASTE( _OVERLOAD_EXAMPLE, argCount )(__VA_ARGS__) )
#define _OVERLOAD_EXAMPLE0() void zeroArgFunc() {}
#define _OVERLOAD_EXAMPLE1(t1) void oneArgFunc(t1 arg1) {}
#define _OVERLOAD_EXAMPLE2(t1, t2) void twoArgFunc(t1 arg1, t2 arg2) {}
#define _OVERLOAD_EXAMPLE3(t1, t2, t3) void threeArgFunc(t1 arg1, t2 arg2, t3 arg3) {}
// .
// .
// and (potentially) so on..

class TestClass
{
public:

	OVERLOAD_EXAMPLE(); // Declare a zero argument function accepting no params
	OVERLOAD_EXAMPLE(int); // Declare a one argument function accepting an int
	OVERLOAD_EXAMPLE(float, int); // Declare a two argument function accepting a float and an int
	OVERLOAD_EXAMPLE(float, int, short); // .. you get the idea
};

int main()
{
	TestClass t;

	// This compiles, but VAX is unable to display any information about these functions or syntax highlight them :(
	t.zeroArgFunc();
	t.oneArgFunc(1);
	t.twoArgFunc(1.0f, 1);
	t.threeArgFunc(1.0f, 1, 1);

	return 0;
}

#define OVERLOAD_EXAMPLE \    void zeroArgFunc() {}\    void oneArgFunc(t1 arg1) {}\    void twoArgFunc(t1 arg1, t2 arg2) {}\    void threeArgFunc(t1 arg1, t2 arg2, t3 arg3) {}

// Assume the ARG_COUNT macro exists / works. It is in the first post. 

// Declare class RPCs
#define DECLARE_NET_FUNC(retType, name, ...) _DECLARE_NET_FUNC( ARG_COUNT(__VA_ARGS__), retType, name, __VA_ARGS__ )
#define _DECLARE_NET_FUNC(argCount, retType, name, ...) _EXPAND( _PASTE( _DECLARE_NET_FUNC, argCount )(retType, name, __VA_ARGS__) )
#define _DECLARE_NET_FUNC0(retType, name, null ) \    retType name() { /* some special code that fires you off as an rpc */ return name##_impl(); } \    retType name##_impl()

#define _DECLARE_NET_FUNC2(retType, name, t1, p1) \    retType name(t1 p1) { /* some special code that fires you off as an rpc */ return name##_impl(p1); } \    retType name##_impl(t1 p1)

#define _DECLARE_NET_FUNC4(retType, name, t1, p1, t2, p2) \    retType name(t1 p1, t2 p2) { /* some special code that fires you off as an rpc */ return name##_impl(p1, p2); } \    retType name##_impl(t1 p1, t2 p2)

// Implement class RPCs
#define IMPLEMENT_NET_FUNC(retType, class, name, ...) _IMPLEMENT_NET_FUNC( ARG_COUNT(__VA_ARGS__), retType, class, name, __VA_ARGS__ )
#define _IMPLEMENT_NET_FUNC(argCount, retType, class, name, ...) _EXPAND( _PASTE( _IMPLEMENT_NET_FUNC, argCount )(retType, class, name, __VA_ARGS__) )
#define _IMPLEMENT_NET_FUNC0(retType, class, name, null) retType class::name##_impl()
#define _IMPLEMENT_NET_FUNC2(retType, class, name, t1, p1) retType class::name##_impl(t1 p1)
#define _IMPLEMENT_NET_FUNC4(retType, class, name, t1, p1, t2, p2) retType class::name##_impl(t1 p1, t2 p2)


// Now I can very cleanly declare RPCs of any signature automatically with NO overhead!
class MyRPCClass
{
    DECLARE_NET_FUNC(void, netSignalOne);
    DECLARE_NET_FUNC(void, netSignalTwo, int, errCode);
    DECLARE_NET_FUNC(void, netSignalThree, int, errCode, const char*, errMessage);
};

IMPLEMENT_NET_FUNC(void, MyRPCClass, netSignalOne)
{
// code for signal one
}

IMPLEMENT_NET_FUNC(void, MyRPCClass, netSignalTwo, int, errCode)
{
// code for signal two
}

IMPLEMENT_NET_FUNC(void, MyRPCClass, netSignalThree, int, errCode, const char*, errMessage)
{
// code for signal three
}