vcfrttiimpl.h

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

		deleteFunc1_ = prop.deleteFunc1_;
		deleteFunc2_ = prop.deleteFunc2_;
	};

	virtual ~TypedObjectCollectionProperty(){};

	void init(){
		getFunction_ = NULL;
		isCollection_ = true;
		enumeration_ = NULL;
		isReadOnly_ = true;
		addFunc_ = NULL;
		insertFunc_ = NULL;
		deleteFunc1_ = NULL;
		deleteFunc2_ = NULL;
		setType( pdObject );
	};

	virtual String getTypeClassName() {
		return StringUtils::getClassNameFromTypeInfo( typeid(ITEM_TYPE) );
	}

	virtual VariantData* get( Object* source ){
		return NULL;
	};

	virtual void set( Object* source, VariantData* value ){
		//no-op
	};

	virtual bool hasMoreElements( Object* source ){
		_typename_ std::map<Object*,Enumerator<ITEM_TYPE>*>::iterator it = enumerationMap_.find( source );
		if ( it != enumerationMap_.end() ){
			Enumerator<ITEM_TYPE>* enumeration = it->second;
			bool result = false;
			if ( NULL != enumeration ){
				result = enumeration->hasMoreElements();
				if ( false == result ){
					enumerationMap_.erase( source );
				}
			}
			return result;
		}
		else {
			return false;
		}
	};

	virtual VariantData* nextElement( Object* source ){
		VariantData* element = NULL;
		_typename_ std::map<Object*,Enumerator<ITEM_TYPE>*>::iterator it = enumerationMap_.find( source );
		if ( it != enumerationMap_.end() ){
			Enumerator<ITEM_TYPE>* enumeration = it->second;
			if ( NULL != enumeration ){
				if ( true == enumeration->hasMoreElements() ){
					value_ = enumeration->nextElement();
					element = &value_;
				}
			}
		}
		return element;
	};

	virtual void startCollection( Object* source ){
		enumeration_ = NULL;
		if ( NULL != source ) {
			enumeration_ = (source->*getFunction_)();
			enumerationMap_[ source ] = enumeration_;
		}
	};

	virtual Property* clone(){
		return new TypedObjectCollectionProperty<ITEM_TYPE>(*this);
	};

	virtual void add( Object* source, VariantData* value ){
		if ( (NULL != value) && (NULL != addFunc_) ){
			if ( pdObject == value->type ){
				ITEM_TYPE valToAdd = (ITEM_TYPE)(Object*)(*value);
				(source->*addFunc_)( valToAdd );
			}
		}
	};

	virtual void insert( Object* source, const unsigned long& index, VariantData* value ){
		if ( (NULL != value) && (NULL != insertFunc_) ){
			if ( pdObject == value->type ){
				ITEM_TYPE valToInsert = (ITEM_TYPE)(Object*)(*value);
				(source->*insertFunc_)( index, valToInsert );
			}
		}
	};

	virtual void remove( Object* source, VariantData* value ){
		if ( (NULL != value) && (NULL != deleteFunc1_) ){
			ITEM_TYPE valToRemove = (ITEM_TYPE)(Object*)(*value);
			(source->*deleteFunc1_)( valToRemove );
		}
	};

	virtual void remove( Object* source, const unsigned long& index ){
		if ( NULL != deleteFunc2_ ){
			(source->*deleteFunc2_)( index );
		}
	};

	virtual bool collectionSupportsEditing(){
		if ( NULL != enumeration_ ){
			return enumeration_->supportsEditing();
		}
		else{
			return false;
		}
	};
private:
	GetFunction getFunction_;
	AddFunction addFunc_;
	InsertFunction insertFunc_;
	DeleteFunction1 deleteFunc1_;
	DeleteFunction2 deleteFunc2_;

	Enumerator<ITEM_TYPE>* enumeration_;
	std::map<Object*, Enumerator<ITEM_TYPE>*> enumerationMap_;
};















/**
\class TypedMethod VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Base template class for methods that do NOT return values
*/
template <typename SOURCE_TYPE>
class TypedMethod : public Method {
public:

	typedef SOURCE_TYPE SrcType;

	TypedMethod( const String& argTypes="", SOURCE_TYPE* source=NULL ){
		source_ = source;
		argTypes_ = argTypes;
		objSource_ = NULL;
	}


	TypedMethod( const TypedMethod<SOURCE_TYPE>& method ) : Method() {
		*this = method;
	}

	TypedMethod<SOURCE_TYPE>& operator=( const TypedMethod<SOURCE_TYPE>& rhs ) {
		source_ = rhs.source_;
		argTypes_ = rhs.argTypes_;
		objSource_ = rhs.objSource_;
		argCount_ = rhs.argCount_;
		name_ = rhs.name_;
		hasReturnValue_ = rhs.hasReturnValue_;
		return *this;
	}

	virtual ~TypedMethod(){	}

	virtual Object* getSource(){
		return objSource_;
	}

	virtual void setSource( Object* source ){
		//does the source actually support this interface/class ?
		source_ = dynamic_cast<SOURCE_TYPE*>( source );
		objSource_ = NULL;
		if ( NULL != source_ ){
			objSource_ = source;
		}
	}

protected:

	SOURCE_TYPE* source_;
	Object* objSource_;
};


/**
\class TypedMethodReturn VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Base template class for methodsthat DO return values
*/

template <typename SOURCE_TYPE, typename RETURN_TYPE>
class TypedMethodReturn : 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 RETURN_TYPE ReturnType;

	TypedMethodReturn( const String& argTypes="", SOURCE_TYPE* source=NULL ):
		TypedMethod<SOURCE_TYPE>( argTypes, source ) {
		hasReturnValue_ = true;
	}

	TypedMethodReturn( const TypedMethodReturn<SOURCE_TYPE,RETURN_TYPE>& rhs ) {
		hasReturnValue_ = true;
		*this = rhs;
	}

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

	virtual ~TypedMethodReturn(){}

protected:
	VariantData returnVal_;
};


/**
\class TypedMethodArg0 VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Method template class for methods have 0 arguments
*/
template <class SOURCE_TYPE>
class TypedMethodArg0 : 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 void (SOURCE_TYPE::*MemberFunc)();

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

	TypedMethodArg0( const TypedMethodArg0<SOURCE_TYPE>& method ) : TypedMethod<SOURCE_TYPE>( method )  {
		*this = method;
	}

	TypedMethodArg0<SOURCE_TYPE>& operator=( const TypedMethodArg0<SOURCE_TYPE>& rhs ) {
		TypedMethod<SOURCE_TYPE>::operator =(rhs);
		methodPtr_ = rhs.methodPtr_;

		return *this;
	}

	virtual ~TypedMethodArg0(){	}

	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_ ) {
				(source_->*methodPtr_)();
			}
		}

		return NULL;
	}

	virtual Method* clone() {
		return new TypedMethodArg0<SOURCE_TYPE>(*this);
	}

protected:
	MemberFunc methodPtr_;
};

/**
\class TypedMethodArg1 VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Method template class for methods have 1 argument
*/
template <typename SOURCE_TYPE, typename ARG1_TYPE>
class TypedMethodArg1 : 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 void (SOURCE_TYPE::*MemberFunc)(ARG1_TYPE arg1);


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

	TypedMethodArg1( const TypedMethodArg1<SOURCE_TYPE,ARG1_TYPE>& method )  {
		*this = method;
	}


	TypedMethodArg1<SOURCE_TYPE,ARG1_TYPE>& operator=( const TypedMethodArg1<SOURCE_TYPE,ARG1_TYPE>& rhs ) {
		TypedMethod<SOURCE_TYPE>::operator =(rhs);
		methodPtr_ = rhs.methodPtr_;
		return *this;
	}

	virtual Method* clone() {
		return new TypedMethodArg1<SOURCE_TYPE,ARG1_TYPE>(*this);
	}

	virtual ~TypedMethodArg1(){	}

	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_ ) {
				(source_->*methodPtr_)( (Argument1) *(arguments[0]) );
			}
		}

		return NULL;
	}
protected:
	MemberFunc methodPtr_;
};


/**
\class TypedMethodArg2 VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Accepts methds with 2 arguments - no return value
*/
template <typename SOURCE_TYPE, typename ARG1_TYPE, typename ARG2_TYPE >
class TypedMethodArg2 : 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 void (SOURCE_TYPE::*MemberFunc)(ARG1_TYPE arg1, ARG2_TYPE arg2);

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

	}

	TypedMethodArg2( const TypedMethodArg2<SOURCE_TYPE,ARG1_TYPE,ARG2_TYPE>& method ) : TypedMethod<SOURCE_TYPE>( method )  {
		*this = method;
	}

	TypedMethodArg2<SOURCE_TYPE,ARG1_TYPE,ARG2_TYPE>& operator=( const TypedMethodArg2<SOURCE_TYPE,ARG1_TYPE,ARG2_TYPE>& rhs ) {
		TypedMethod<SOURCE_TYPE>::operator =(rhs);

		methodPtr_ = rhs.methodPtr_;
		return *this;
	}

	virtual Method* clone() {
		return new TypedMethodArg2<SOURCE_TYPE,ARG1_TYPE,ARG2_TYPE>(*this);
	}

	virtual ~TypedMethodArg2(){	}

	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_ ) {
				(source_->*methodPtr_)(	(Argument1)*(arguments[0]),
											(Argument2)*(arguments[1])		);
			}
		}

		return NULL;
	}
protected:
	MemberFunc methodPtr_;
};


/**
\class TypedMethodArg3 VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Accepts methds with 3 arguments - no return value
*/
template <typename SOURCE_TYPE, typename ARG1_TYPE, typename ARG2_TYPE, typename ARG3_TYPE>
class TypedMethodArg3 : 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 void (SOURCE_TYPE::*MemberFunc)(ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3);

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

	TypedMethodArg3( const TypedMethodArg3<SOURCE_TYPE,ARG1_TYPE,ARG2_TYPE,ARG3_TYPE>& method )  {
		*this = method;
	}

	TypedMethodArg3<SOURCE_TYPE,ARG1_TYPE,ARG2_TYPE,ARG3_TYPE>& operator=( const TypedMethodArg3<SOURCE_TYPE,ARG1_TYPE,ARG2_TYPE,ARG3_TYPE>& rhs ) {

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

		methodPtr_ = rhs.methodPtr_;

		return *this;
	}

	virtual Method* clone() {
		return new TypedMethodArg3<SOURCE_TYPE,ARG1_TYPE,ARG2_TYPE,ARG3_TYPE>(*this);
	}

	virtual ~TypedMethodArg3(){	}

	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_ ) {
				(source_->*methodPtr_)(	(Argument1)*(arguments[0]),
											(Argument2)*(arguments[1]),
											(Argument3)*(arguments[2])		);
			}
		}

		return NULL;
	}
protected:
	MemberFunc methodPtr_;
};



/**
\class TypedMethodArg4 VCFRTTIImpl.h "vcf/FoundationKit/VCFRTTIImpl.h"
*Accepts methds with 4 arguments - no return value
*/
template <typename SOURCE_TYPE, typename ARG1_TYPE, typename ARG2_TYPE, typename ARG3_TYPE, typename ARG4_TYPE>
class TypedMethodArg4 : 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 void (SOURCE_TYPE::*MemberFunc)(ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4);

	typedef TypedMethodArg4<SOURCE_TYPE,ARG1_TYPE,ARG2_TYPE,ARG3_TYPE,ARG4_TYPE> TypedMethodArg4Type;

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

	TypedMethodArg4( const TypedMethodArg4Type& method )  {
		*this = method;
	}

	TypedMethodArg4Type& operator=( const TypedMethodArg4Type& rhs ) {

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

		methodPtr_ = rhs.methodPtr_;

		return *this;
	}


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


	virtual ~TypedMethodArg4(){	}