vcfrttiimpl.h

来自「这是VCF框架的代码」· C头文件 代码 · 共 2,696 行 · 第 1/5 页

	virtual VariantData* invoke( VariantData** arguments,
								 Object* source=NULL ){

		if ( NULL != source ) {
			source_ = dynamic_cast<SOURCE_TYPE*>( source );
		}

		if ( (NULL != source_) && (NULL != methodPtr_) ){
			if  ( 4 == argCount_ ) {
				(source_->*methodPtr_)(	(Argument1)*(arguments[0]),
											(Argument2)*(arguments[1]),
											(Argument3)*(arguments[2]),
											(Argument4)*(arguments[3])		);
			}
		}

		return NULL;
	}
protected:
	MemberFunc methodPtr_;
};


/**
\class TypedMethodArg5 VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Accepts methds with 5 arguments - no return value
*/
template <typename SOURCE_TYPE, typename ARG1_TYPE, typename ARG2_TYPE,
			typename ARG3_TYPE, typename ARG4_TYPE, typename ARG5_TYPE>
class TypedMethodArg5 : public TypedMethod<SOURCE_TYPE> {
public:

	#if defined(VCF_MINGW) || defined(VCF_GCC)
	using  TypedMethod<SOURCE_TYPE>::hasReturnValue_;
	using  TypedMethod<SOURCE_TYPE>::argCount_;
	using  TypedMethod<SOURCE_TYPE>::objSource_;
	using  TypedMethod<SOURCE_TYPE>::source_;
	#endif

	typedef ARG1_TYPE Argument1;
	typedef ARG2_TYPE Argument2;
	typedef ARG3_TYPE Argument3;
	typedef ARG4_TYPE Argument4;
	typedef ARG5_TYPE Argument5;

	typedef void (SOURCE_TYPE::*MemberFunc)(ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5);

	typedef TypedMethodArg5<SOURCE_TYPE,ARG1_TYPE,ARG2_TYPE,ARG3_TYPE,ARG4_TYPE,ARG5_TYPE> TypedMethodArg5Type;

	TypedMethodArg5( MemberFunc methodPtr=NULL, const String& argTypes="", SOURCE_TYPE* source=NULL ):
	  TypedMethod<SOURCE_TYPE>( argTypes, source ){
		argCount_ = 5;
		methodPtr_ = methodPtr;
	}

	TypedMethodArg5( const TypedMethodArg5Type& method )  {

		*this = method;
	}

	TypedMethodArg5Type& operator=( const TypedMethodArg5Type& rhs ) {

		TypedMethod<SOURCE_TYPE>::operator =( rhs );

		methodPtr_ = rhs.methodPtr_;

		return *this;
	}

	virtual Method* clone() {
		return new TypedMethodArg5Type( *this );
	}

	virtual ~TypedMethodArg5(){	}

	virtual VariantData* invoke( VariantData** arguments,
								 Object* source=NULL ){

		if ( NULL != source ) {
			source_ = dynamic_cast<SOURCE_TYPE*>( source );
		}

		if ( (NULL != source_) && (NULL != methodPtr_) ){
			if  ( 5 == argCount_ ) {
				(source_->*methodPtr_)(	(Argument1)*(arguments[0]),
											(Argument2)*(arguments[1]),
											(Argument3)*(arguments[2]),
											(Argument4)*(arguments[3]),
											(Argument5)*(arguments[4])		);
			}
		}

		return NULL;
	}
protected:
	MemberFunc methodPtr_;
};


/**
\class TypedMethodArg6 VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Accepts methds with 6 arguments - no return value
*/
template <typename SOURCE_TYPE, typename ARG1_TYPE, typename ARG2_TYPE,
			typename ARG3_TYPE, typename ARG4_TYPE, typename ARG5_TYPE, typename ARG6_TYPE>
class TypedMethodArg6 : public TypedMethod<SOURCE_TYPE> {
public:

	#if defined(VCF_MINGW) || defined(VCF_GCC)
	using  TypedMethod<SOURCE_TYPE>::hasReturnValue_;
	using  TypedMethod<SOURCE_TYPE>::argCount_;
	using  TypedMethod<SOURCE_TYPE>::objSource_;
	using  TypedMethod<SOURCE_TYPE>::source_;
	#endif

	typedef ARG1_TYPE Argument1;
	typedef ARG2_TYPE Argument2;
	typedef ARG3_TYPE Argument3;
	typedef ARG4_TYPE Argument4;
	typedef ARG5_TYPE Argument5;
	typedef ARG6_TYPE Argument6;

	typedef void (SOURCE_TYPE::*MemberFunc)(ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG5_TYPE arg6);

	typedef TypedMethodArg6<SOURCE_TYPE,ARG1_TYPE,ARG2_TYPE,ARG3_TYPE,ARG4_TYPE,ARG5_TYPE,ARG6_TYPE> TypedMethodArg6Type;


	TypedMethodArg6( MemberFunc methodPtr=NULL, const String& argTypes="", SOURCE_TYPE* source=NULL ):
	  TypedMethod<SOURCE_TYPE>( argTypes, source ){
		argCount_ = 6;
		methodPtr_ = methodPtr;
	}

	TypedMethodArg6( const TypedMethodArg6Type& method )  {
		TypedMethod<SOURCE_TYPE>::operator =( method ); /* was rhs instead of method (why??) */

		methodPtr_ = method.methodPtr_; /* was rhs instead of method (why??) */
		*this = method;
	}

	virtual Method* clone() {
		return new TypedMethodArg6Type(*this);
	}

	TypedMethodArg6Type& operator=( const TypedMethodArg6Type& rhs ) {

		return *this;
	}

	virtual ~TypedMethodArg6(){	}

	virtual VariantData* invoke( VariantData** arguments,
								 Object* source=NULL ){

		if ( NULL != source ) {
			source_ = dynamic_cast<SOURCE_TYPE*>( source );
		}

		if ( (NULL != source_) && (NULL != methodPtr_) ){
			if  ( 6 == argCount_ ) {
				(source_->*methodPtr_)(	(Argument1)*(arguments[0]),
											(Argument2)*(arguments[1]),
											(Argument3)*(arguments[2]),
											(Argument4)*(arguments[3]),
											(Argument5)*(arguments[4]),
											(Argument6)*(arguments[5])		);
			}
		}

		return NULL;
	}
protected:
	MemberFunc methodPtr_;
};


/**
\class TypedMethodArg0Return VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Method template for methods with 0 argument and a return value
*/
template <typename SOURCE_TYPE, typename RETURN_TYPE>
class TypedMethodArg0Return : public TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE> {
public:

	#if defined(VCF_MINGW) || defined(VCF_GCC)
	using  TypedMethod<SOURCE_TYPE>::hasReturnValue_;
	using  TypedMethod<SOURCE_TYPE>::argCount_;
	using  TypedMethod<SOURCE_TYPE>::objSource_;
	using  TypedMethod<SOURCE_TYPE>::source_;
	using  TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>::returnVal_;
	#endif

	typedef RETURN_TYPE (SOURCE_TYPE::*MemberFunc)();

	typedef TypedMethodArg0Return<SOURCE_TYPE,RETURN_TYPE> TypedMethodArg0ReturnType;


	TypedMethodArg0Return( MemberFunc methodPtr=NULL, const String& argTypes="", SOURCE_TYPE* source=NULL ):
	  TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>( argTypes, source ){
		argCount_ = 0;
		methodPtr_ = methodPtr;
	}

	TypedMethodArg0Return( const TypedMethodArg0ReturnType& method )  {
		*this = method;
	}

	TypedMethodArg0ReturnType& operator=( const TypedMethodArg0ReturnType& rhs ) {
		TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>::operator =( rhs );
		methodPtr_ = rhs.methodPtr_;
		return *this;
	}

	virtual Method* clone() {
		return new TypedMethodArg0ReturnType(*this);
	}

	virtual ~TypedMethodArg0Return(){	}

	virtual VariantData* invoke( VariantData** arguments,
								 Object* source=NULL ){

		if ( NULL != source ) {
			source_ = dynamic_cast<SOURCE_TYPE*>( source );
		}

		if ( (NULL != source_) && (NULL != methodPtr_) ){
			if  ( 0 == argCount_ ) {
				returnVal_ = (source_->*methodPtr_)();
			}
		}

		return &returnVal_;
	}
protected:
	MemberFunc methodPtr_;
};


/**
\class TypedMethodArg1Return VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Method template for methods with 1 argument and a return value
*/
template <typename SOURCE_TYPE, typename RETURN_TYPE, typename ARG1_TYPE>
class TypedMethodArg1Return : public TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE> {
public:

	#if defined(VCF_MINGW) || defined(VCF_GCC)
	using  TypedMethod<SOURCE_TYPE>::hasReturnValue_;
	using  TypedMethod<SOURCE_TYPE>::argCount_;
	using  TypedMethod<SOURCE_TYPE>::objSource_;
	using  TypedMethod<SOURCE_TYPE>::source_;
	using  TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>::returnVal_;
	#endif

	typedef ARG1_TYPE Argument1;

	typedef RETURN_TYPE (SOURCE_TYPE::*MemberFunc)(ARG1_TYPE arg1);

	typedef TypedMethodArg1Return<SOURCE_TYPE,RETURN_TYPE,ARG1_TYPE> TypedMethodArg1ReturnType;


	TypedMethodArg1Return( MemberFunc methodPtr=NULL, const String& argTypes="", SOURCE_TYPE* source=NULL ):
	  TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>( argTypes, source ){
		argCount_ = 1;
		methodPtr_ = methodPtr;
	}

	TypedMethodArg1Return( const TypedMethodArg1ReturnType& method )  {
		*this = method;
	}

	TypedMethodArg1ReturnType& operator=( const TypedMethodArg1ReturnType& rhs ) {
		TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>::operator =( rhs );

		methodPtr_ = rhs.methodPtr_;
		return *this;
	}

	virtual Method* clone() {
		return new TypedMethodArg1ReturnType( *this );
	}


	virtual ~TypedMethodArg1Return(){	}

	virtual VariantData* invoke( VariantData** arguments,
								 Object* source=NULL ){

		if ( NULL != source ) {
			source_ = dynamic_cast<SOURCE_TYPE*>( source );
		}

		if ( (NULL != source_) && (NULL != methodPtr_) ){
			if  ( 1 == argCount_ ) {
				returnVal_ = (source_->*methodPtr_)((Argument1)*(arguments[0]));
			}
		}

		return &returnVal_;
	}
protected:
	MemberFunc methodPtr_;
};


/**
\class TypedMethodArg2Return VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Method template for methods with 2 arguments and a return value
*/
template <typename SOURCE_TYPE, typename RETURN_TYPE, typename ARG1_TYPE, typename ARG2_TYPE>
class TypedMethodArg2Return : public TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE> {
public:

	#if defined(VCF_MINGW) || defined(VCF_GCC)
	using  TypedMethod<SOURCE_TYPE>::hasReturnValue_;
	using  TypedMethod<SOURCE_TYPE>::argCount_;
	using  TypedMethod<SOURCE_TYPE>::objSource_;
	using  TypedMethod<SOURCE_TYPE>::source_;
	using  TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>::returnVal_;
	#endif

	typedef ARG1_TYPE Argument1;
	typedef ARG2_TYPE Argument2;

	typedef RETURN_TYPE (SOURCE_TYPE::*MemberFunc)(ARG1_TYPE arg1, ARG2_TYPE arg2);

	typedef TypedMethodArg2Return<SOURCE_TYPE,RETURN_TYPE,ARG1_TYPE, ARG2_TYPE> TypedMethodArg2ReturnType;



	TypedMethodArg2Return( MemberFunc methodPtr=NULL, const String& argTypes="", SOURCE_TYPE* source=NULL ):
	  TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>( argTypes, source ){
		argCount_ = 2;
		methodPtr_ = methodPtr;
	}

	TypedMethodArg2Return( const TypedMethodArg2ReturnType& method )  {
		*this = method;
	}

	TypedMethodArg2ReturnType& operator=( const TypedMethodArg2ReturnType& rhs ) {
		TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>::operator =( rhs );
		methodPtr_ = rhs.methodPtr_;

		return *this;
	}

	virtual Method* clone() {
		return new TypedMethodArg2ReturnType( *this );
	}

	virtual ~TypedMethodArg2Return(){	}

	virtual VariantData* invoke( VariantData** arguments,
								 Object* source=NULL ){

		if ( NULL != source ) {
			source_ = dynamic_cast<SOURCE_TYPE*>( source );
		}

		if ( (NULL != source_) && (NULL != methodPtr_) ){
			if  ( 2 == argCount_ ) {
				returnVal_ = (source_->*methodPtr_)(	(Argument1)*(arguments[0]),
														(Argument2)*(arguments[1]) );
			}
		}

		return &returnVal_;
	}
protected:
	MemberFunc methodPtr_;
};


/**
\class TypedMethodArg3Return VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Method template for methods with 3 arguments and a return value
*/
template <typename SOURCE_TYPE, typename RETURN_TYPE, typename ARG1_TYPE, typename ARG2_TYPE, typename ARG3_TYPE>
class TypedMethodArg3Return : public TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE> {
public:

	#if defined(VCF_MINGW) || defined(VCF_GCC)
	using  TypedMethod<SOURCE_TYPE>::hasReturnValue_;
	using  TypedMethod<SOURCE_TYPE>::argCount_;
	using  TypedMethod<SOURCE_TYPE>::objSource_;
	using  TypedMethod<SOURCE_TYPE>::source_;
	using  TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>::returnVal_;
	#endif

	typedef ARG1_TYPE Argument1;
	typedef ARG2_TYPE Argument2;
	typedef ARG3_TYPE Argument3;

	typedef RETURN_TYPE (SOURCE_TYPE::*MemberFunc)(ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3);

	typedef TypedMethodArg3Return<SOURCE_TYPE,RETURN_TYPE,ARG1_TYPE, ARG2_TYPE,ARG3_TYPE> TypedMethodArg3ReturnType;

	TypedMethodArg3Return( MemberFunc methodPtr=NULL, const String& argTypes="", SOURCE_TYPE* source=NULL ):
	  TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>( argTypes, source ){
		argCount_ = 3;
		methodPtr_ = methodPtr;
	}

	TypedMethodArg3Return( const TypedMethodArg3ReturnType& rhs )  {
		*this = rhs;
	}

	TypedMethodArg3ReturnType& operator=( const TypedMethodArg3ReturnType& rhs ) {
		TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>::operator =( rhs );
		methodPtr_ = rhs.methodPtr_;

		return *this;
	}

	virtual Method* clone() {
		return new TypedMethodArg3ReturnType( *this );
	}


	virtual ~TypedMethodArg3Return(){	}

	virtual VariantData* invoke( VariantData** arguments,
								 Object* source=NULL ){

		if ( NULL != source ) {
			source_ = dynamic_cast<SOURCE_TYPE*>( source );
		}

		if ( (NULL != source_) && (NULL != methodPtr_) ){
			if  ( 3 == argCount_ ) {
				returnVal_ = (source_->*methodPtr_)(	(Argument1)*(arguments[0]),
														(Argument2)*(arguments[1]),
														(Argument3)*(arguments[2]) );
			}
		}

		return &returnVal_;
	}
protected:
	MemberFunc methodPtr_;
};


/**
\class TypedMethodArg4Return VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Method template for methods with 4 arguments and a return value
*/
template <typename SOURCE_TYPE, typename RETURN_TYPE, typename ARG1_TYPE, typename ARG2_TYPE,
			typename ARG3_TYPE, typename ARG4_TYPE>
class TypedMethodArg4Return : public TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE> {
public:

	#if defined(VCF_MINGW) || defined(VCF_GCC)
	using  TypedMethod<SOURCE_TYPE>::hasReturnValue_;
	using  TypedMethod<SOURCE_TYPE>::argCount_;
	using  TypedMethod<SOURCE_TYPE>::objSource_;
	using  TypedMethod<SOURCE_TYPE>::source_;
	using  TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>::returnVal_;
	#endif

	typedef ARG1_TYPE Argument1;
	typedef ARG2_TYPE Argument2;
	typedef ARG3_TYPE Argument3;
	typedef ARG4_TYPE Argument4;

	typedef RETURN_TYPE (SOURCE_TYPE::*MemberFunc)(ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4);

	typedef TypedMethodArg4Return<SOURCE_TYPE,RETURN_TYPE,ARG1_TYPE, ARG2_TYPE,ARG3_TYPE,ARG4_TYPE> TypedMethodArg4ReturnType;


	TypedMethodArg4Return( MemberFunc methodPtr=NULL, const String& argTypes="", SOURCE_TYPE* source=NULL ):
	  TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>( argTypes, source ){
		argCount_ = 4;
		methodPtr_ = methodPtr;
	}

	TypedMethodArg4Return( const TypedMethodArg4ReturnType& method )  {
		*this = method;
	}

	TypedMethodArg4ReturnType& operator=( const TypedMethodArg4ReturnType& rhs ) {
		TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>::operator =( rhs );
		methodPtr_ = rhs.methodPtr_;

		return *this;
	}

	virtual Method* clone() {
		return new TypedMethodArg4ReturnType( *this );
	}


	virtual ~TypedMethodArg4Return(){	}

	virtual VariantData* invoke( VariantData** arguments,
								 Object* source=NULL ){

		if ( NULL != source ) {
			source_ = dynamic_cast<SOURCE_TYPE*>( source );
		}

		if ( (NULL != source_) && (NULL != methodPtr_) ){
			if  ( 4 == argCount_ ) {
				returnVal_ = (source_->*methodPtr_)(	(Argument1)*(arguments[0]),
														(Argument2)*(arguments[1]),
														(Argument3)*(arguments[2]),
														(Argument4)*(arguments[3]) );
			}
		}

		return &returnVal_;
	}
protected:
	MemberFunc methodPtr_;
};


/**
\class TypedMethodArg5Return VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Method template for methods with 5 arguments and a return value
*/
template <typename SOURCE_TYPE, typename RETURN_TYPE, typename ARG1_TYPE, typename ARG2_TYPE,
			typename ARG3_TYPE, typename ARG4_TYPE, typename ARG5_TYPE>
class TypedMethodArg5Return : public TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE> {
public:

	#if defined(VCF_MINGW) || defined(VCF_GCC)
	using  TypedMethod<SOURCE_TYPE>::hasReturnValue_;
	using  TypedMethod<SOURCE_TYPE>::argCount_;
	using  TypedMethod<SOURCE_TYPE>::objSource_;
	using  TypedMethod<SOURCE_TYPE>::source_;
	using  TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>::returnVal_;
	#endif

	typedef ARG1_TYPE Argument1;
	typedef ARG2_TYPE Argument2;
	typedef ARG3_TYPE Argument3;