checkreflection.h

The article describes a smart binding of C++ objects February, 2009: Version 1.0 Environment: Visu

#ifndef	__Exchange_Manager_H
#define	__Exchange_Manager_H

#pragma warning(disable : 4996)

#include "Reflection.h"
#include "TransformHelper.h"
#include "ConversionHelper.h"

ExchangeManager*	ExchangeManager::instance_	= null;
TransformHelper*	TransformHelper::instance_	= null;
ConversionHelper*	ConversionHelper::instance_	= null;

Destroyer<ExchangeManager>	ExchangeManager::destroyer_;
Destroyer<TransformHelper>	TransformHelper::destroyer_;
Destroyer<ConversionHelper> ConversionHelper::destroyer_;

void	fooConversion(object_ptr& element, void* object);

class	History : public IReflection
{
public:
	History() : entity_(""), number__(0), value__(0), message__("")
	{
		InitReflection();
	}

//	Destructor
	virtual	~History()	{}

//	Properties
	Int&	Number	()	{	return	number__;	}
	Long&	Value	()	{	return	value__;	}
	String&	Message	()	{	return	message__;	}
	string&	Entity	()	{	return	entity_;	}

	void	Print	()
	{
		printf ("History={\"%s\"}",entity_.c_str());
	}

private:

	Int		number__;
	Long	value__;
	String	message__;

	string	entity_;

	REFLECTION_START
		REFLECTED_OBJECT_ACTION(number__,	/*fooHistory4Number*/fooConversion)
		REFLECTED_OBJECT_ACTION(value__,	/*fooHistory4Value*/fooConversion)
		REFLECTED_OBJECT_ACTION(message__,	/*fooHistory4Message*/fooConversion)
	REFLECTION_FINAL

};

class	Object1 : public IReflection
{
public:
//	Constructor
	Object1() : number__(0), value__(0), message__("")
	{
		InitReflection();
	}

//	Destructor
	virtual	~Object1()	{}

//	Properties
	Int&	Number	()	{	return	number__;	}
	Long&	Value	()	{	return	value__;	}
	String&	Message	()	{	return	message__;	}

//	Methods
	void	Print	()
	{
		printf ("Object1={%d,\"%s\",%d}\n",number__.Object(),message__.Object().c_str(),value__.Object());
	}

private:

	Int		number__;
	Long	value__;
	String	message__;

	REFLECTION_START
		REFLECTED_OBJECT(number__)
		REFLECTED_OBJECT(value__)
		REFLECTED_OBJECT(message__)
	REFLECTION_FINAL

};

class	Object2 : public IReflection
{
public:
	Object2()  : number__(0), message__("")
	{
		InitReflection();
	}

	Int&	Number	()	{	return	number__;	}
	String&	Message	()	{	return	message__;	}

	virtual	~Object2()	{}

	void	Print	()
	{
		printf ("Object2={%d,\"%s\"}\n",number__.Object(),message__.Object().c_str());
	}

private:

	Int		number__;
	String	message__;

	REFLECTION_START
		REFLECTED_OBJECT(number__)
		REFLECTED_OBJECT(message__)
	REFLECTION_FINAL

};

class	Object3 : public IReflection
{
public:
//	Constructor
	Object3()  : number__(0), value__(0)
	{
		InitReflection();
	}

//	Destructor
	virtual	~Object3()	{}

//	Properties
	Int&	Number	()	{	return	number__;	}
	Long&	Value	()	{	return	value__;	}

//	Methods
	void	Print	()
	{
		printf ("Object3={%d,%d}\n",number__.Object(),value__.Object());
	}

private:

	Int		number__;
	Long	value__;

	REFLECTION_START
		REFLECTED_OBJECT(number__)
		REFLECTED_OBJECT(value__)
	REFLECTION_FINAL

};

void	fooConversion(object_ptr& element, void* object)
{
	IConversion*
	conversion	= ConversionHelper::Instance()->Get(element.type());
	if (!conversion
	)	return
	;
	string
	value	= conversion->Object2String(element);
	History*
	history	= reinterpret_cast<History*>(object);
	if (!history->Entity().length())
		history->Entity()	= value;
	else
		history->Entity()	+= string(",") + value
	;
}

#endif