Mks651dClass.cpp

/*----- PROTECTED REGION ID(Mks651dClass.cpp) ENABLED START -----*/
static const char *RcsId      = "$Id: Mks651dClass.cpp,v 1.2 2012-03-08 09:50:01 mdm Exp $";
static const char *TagName    = "$Name:  $";
static const char *CvsPath    = "$Source: /home/cvsadm/cvsroot/fermi/servers/651d/src/Mks651dClass.cpp,v $";
static const char *SvnPath    = "$HeadURL:  $";
static const char *HttpServer = "http://www.esrf.eu/computing/cs/tango/tango_doc/ds_doc/";
//=============================================================================
//
// file :        Mks651dClass.cpp
//
// description : C++ source for the Mks651dClass. A singleton
//               class derived from DeviceClass. It implements the
//               command list and all properties and methods required
//               by the «name» once per process.
//
// project :     Mks651d.
//
// $Author: mdm $
//
// $Revision: 1.2 $
// $Date: 2012-03-08 09:50:01 $
//
// SVN only:
// $HeadURL:  $
//
// CVS only:
// $Source: /home/cvsadm/cvsroot/fermi/servers/651d/src/Mks651dClass.cpp,v $
// $Log: Mks651dClass.cpp,v $
// Revision 1.2  2012-03-08 09:50:01  mdm
// New version of server
//
//
//=============================================================================
//                This file is generated by POGO
//        (Program Obviously used to Generate tango Object)
//=============================================================================


#include <Mks651dClass.h>

/*----- PROTECTED REGION END -----*/

//-------------------------------------------------------------------
/**
 *	Create Mks651dClass singleton and
 *	return it in a C function for Python usage
 */
//-------------------------------------------------------------------
extern "C" {
#ifdef _TG_WINDOWS_

__declspec(dllexport)

#endif

	Tango::DeviceClass *_create_Mks651d_class(const char *name) {
		return Mks651d_ns::Mks651dClass::init(name);
	}
}


namespace Mks651d_ns
{


//===================================================================
//	Initialize pointer for singleton pattern
//===================================================================
Mks651dClass *Mks651dClass::_instance = NULL;

//--------------------------------------------------------
/**
 * method : 		Mks651dClass::Mks651dClass(string &s)
 * description : 	constructor for the Mks651dClass
 *
 * @param s	The class name
 */
//--------------------------------------------------------
Mks651dClass::Mks651dClass(string &s):DeviceClass(s)
{
	cout2 << "Entering Mks651dClass constructor" << endl;
	set_default_property();
	get_class_property();
	write_class_property();

	/*----- PROTECTED REGION ID(Mks651d::Class::constructor) ENABLED START -----*/

	/*----- PROTECTED REGION END -----*/	//	Mks651d::Class::constructor

	cout2 << "Leaving Mks651dClass constructor" << endl;
}


//--------------------------------------------------------
/**
 * method : 		Mks651dClass::~Mks651dClass()
 * description : 	destructor for the Mks651dClass
 */
//--------------------------------------------------------
Mks651dClass::~Mks651dClass()
{
	/*----- PROTECTED REGION ID(Mks651d::Class::destructor) ENABLED START -----*/

	/*----- PROTECTED REGION END -----*/	//	Mks651d::Class::destructor

	_instance = NULL;
}


//--------------------------------------------------------
/**
 * method : 		Mks651dClass::init
 * description : 	Create the object if not already done.
 *                  Otherwise, just return a pointer to the object
 *
 * @param	name	The class name
 */
//--------------------------------------------------------
Mks651dClass *Mks651dClass::init(const char *name)
{
	if (_instance == NULL)
	{
		try
		{
			string s(name);
			_instance = new Mks651dClass(s);
		}
		catch (bad_alloc)
		{
			throw;
		}		
	}		
	return _instance;
}

//--------------------------------------------------------
/**
 * method : 		Mks651dClass::instance
 * description : 	Check if object already created,
 *                  and return a pointer to the object
 */
//--------------------------------------------------------
Mks651dClass *Mks651dClass::instance()
{
	if (_instance == NULL)
	{
		cerr << "Class is not initialised !!" << endl;
		exit(-1);
	}
	return _instance;
}




//===================================================================
//	Command execution method calls
//===================================================================
//--------------------------------------------------------
/**
 * method : 		OpenClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *OpenClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "OpenClass::execute(): arrived" << endl;

	
	((static_cast<Mks651d *>(device))->open());
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		CloseClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *CloseClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "CloseClass::execute(): arrived" << endl;

	
	((static_cast<Mks651d *>(device))->close());
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		StopClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *StopClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "StopClass::execute(): arrived" << endl;

	
	((static_cast<Mks651d *>(device))->stop());
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		SelectSPClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *SelectSPClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "SelectSPClass::execute(): arrived" << endl;

	Tango::DevShort	argin;
	extract(in_any, argin);
	((static_cast<Mks651d *>(device))->select_sp(argin));
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		ReadSPLevelClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *ReadSPLevelClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "ReadSPLevelClass::execute(): arrived" << endl;

	Tango::DevShort	argin;
	extract(in_any, argin);
	return insert((static_cast<Mks651d *>(device))->read_splevel(argin));
}
//--------------------------------------------------------
/**
 * method : 		WriteSPLevelClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *WriteSPLevelClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "WriteSPLevelClass::execute(): arrived" << endl;

	const Tango::DevVarDoubleArray	*argin;
	extract(in_any, argin);
	((static_cast<Mks651d *>(device))->write_splevel(argin));
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		ReadSPTypeClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *ReadSPTypeClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "ReadSPTypeClass::execute(): arrived" << endl;

	Tango::DevShort	argin;
	extract(in_any, argin);
	return insert((static_cast<Mks651d *>(device))->read_sptype(argin));
}
//--------------------------------------------------------
/**
 * method : 		WriteSPTypeClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *WriteSPTypeClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "WriteSPTypeClass::execute(): arrived" << endl;

	const Tango::DevVarShortArray	*argin;
	extract(in_any, argin);
	((static_cast<Mks651d *>(device))->write_sptype(argin));
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		ReadSoftStartClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *ReadSoftStartClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "ReadSoftStartClass::execute(): arrived" << endl;

	Tango::DevShort	argin;
	extract(in_any, argin);
	return insert((static_cast<Mks651d *>(device))->read_soft_start(argin));
}
//--------------------------------------------------------
/**
 * method : 		WriteSoftStartClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *WriteSoftStartClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "WriteSoftStartClass::execute(): arrived" << endl;

	const Tango::DevVarDoubleArray	*argin;
	extract(in_any, argin);
	((static_cast<Mks651d *>(device))->write_soft_start(argin));
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		ReadSPGainClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *ReadSPGainClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "ReadSPGainClass::execute(): arrived" << endl;

	Tango::DevShort	argin;
	extract(in_any, argin);
	return insert((static_cast<Mks651d *>(device))->read_spgain(argin));
}
//--------------------------------------------------------
/**
 * method : 		WriteSPGainClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *WriteSPGainClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "WriteSPGainClass::execute(): arrived" << endl;

	const Tango::DevVarDoubleArray	*argin;
	extract(in_any, argin);
	((static_cast<Mks651d *>(device))->write_spgain(argin));
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		ReadSPLeadClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *ReadSPLeadClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "ReadSPLeadClass::execute(): arrived" << endl;

	Tango::DevShort	argin;
	extract(in_any, argin);
	return insert((static_cast<Mks651d *>(device))->read_splead(argin));
}
//--------------------------------------------------------
/**
 * method : 		WriteSPLeadClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *WriteSPLeadClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "WriteSPLeadClass::execute(): arrived" << endl;

	const Tango::DevVarLongArray	*argin;
	extract(in_any, argin);
	((static_cast<Mks651d *>(device))->write_splead(argin));
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		ReadThresholdClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *ReadThresholdClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "ReadThresholdClass::execute(): arrived" << endl;

	Tango::DevShort	argin;
	extract(in_any, argin);
	return insert((static_cast<Mks651d *>(device))->read_threshold(argin));
}
//--------------------------------------------------------
/**
 * method : 		WriteThresholdClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *WriteThresholdClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "WriteThresholdClass::execute(): arrived" << endl;

	const Tango::DevVarDoubleArray	*argin;
	extract(in_any, argin);
	((static_cast<Mks651d *>(device))->write_threshold(argin));
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		StartLearningClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *StartLearningClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "StartLearningClass::execute(): arrived" << endl;

	
	((static_cast<Mks651d *>(device))->start_learning());
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		StopLearningClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *StopLearningClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "StopLearningClass::execute(): arrived" << endl;

	
	((static_cast<Mks651d *>(device))->stop_learning());
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		LearnAnalogClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *LearnAnalogClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "LearnAnalogClass::execute(): arrived" << endl;

	
	((static_cast<Mks651d *>(device))->learn_analog());
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		CalibrateAdcClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *CalibrateAdcClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "CalibrateAdcClass::execute(): arrived" << endl;

	Tango::DevDouble	argin;
	extract(in_any, argin);
	((static_cast<Mks651d *>(device))->calibrate_adc(argin));
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		ZeroSensorClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *ZeroSensorClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "ZeroSensorClass::execute(): arrived" << endl;

	
	((static_cast<Mks651d *>(device))->zero_sensor());
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		RemoveZeroClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *RemoveZeroClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "RemoveZeroClass::execute(): arrived" << endl;

	
	((static_cast<Mks651d *>(device))->remove_zero());
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		SetZeroClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *SetZeroClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "SetZeroClass::execute(): arrived" << endl;

	Tango::DevDouble	argin;
	extract(in_any, argin);
	((static_cast<Mks651d *>(device))->set_zero(argin));
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		LearnZeroClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *LearnZeroClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "LearnZeroClass::execute(): arrived" << endl;

	
	((static_cast<Mks651d *>(device))->learn_zero());
	return new CORBA::Any();
}
//--------------------------------------------------------
/**
 * method : 		DirectCommandClass::execute()
 * description : 	method to trigger the execution of the command.
 *
 * @param	device	The device on which the command must be executed
 * @param	in_any	The command input data
 *
 *	returns The command output data (packed in the Any object)
 */
//--------------------------------------------------------
CORBA::Any *DirectCommandClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
	cout2 << "DirectCommandClass::execute(): arrived" << endl;

	Tango::DevString	argin;
	extract(in_any, argin);
	return insert((static_cast<Mks651d *>(device))->direct_command(argin));
}




//===================================================================
//	Properties management
//===================================================================

//--------------------------------------------------------
/**
 * method : 		Mks651dClass::get_class_property
 * description : 	Get the class property for specified name.
 *
 * @param	name  The property name
 */
//--------------------------------------------------------
Tango::DbDatum Mks651dClass::get_class_property(string &prop_name)
{
	for (unsigned int i=0 ; i<cl_prop.size() ; i++)
		if (cl_prop[i].name == prop_name)
			return cl_prop[i];
	//	if not found, returns  an empty DbDatum
	return Tango::DbDatum(prop_name);
}


//--------------------------------------------------------
/**
 *	Method      : Mks651d::Mks651dClass::get_default_device_property()()
 *	Description : Return the default value for device property.
 */
//--------------------------------------------------------
Tango::DbDatum Mks651dClass::get_default_device_property(string &prop_name)
{
	for (unsigned int i=0 ; i<dev_def_prop.size() ; i++)
		if (dev_def_prop[i].name == prop_name)
			return dev_def_prop[i];
	//	if not found, return  an empty DbDatum
	return Tango::DbDatum(prop_name);
}


//--------------------------------------------------------
/**
 *	Method      : Mks651d::Mks651dClass::get_default_class_property()()
 *	Description : Return the default value for class property.
 */
//--------------------------------------------------------
Tango::DbDatum Mks651dClass::get_default_class_property(string &prop_name)
{
	for (unsigned int i=0 ; i<cl_def_prop.size() ; i++)
		if (cl_def_prop[i].name == prop_name)
			return cl_def_prop[i];
	//	if not found, return  an empty DbDatum
	return Tango::DbDatum(prop_name);
}


//--------------------------------------------------------
/**
 *	Method      : Mks651d::Mks651dClass::get_class_property()
 *	Description : //	Add your own code to initialize
 */
//--------------------------------------------------------
void Mks651dClass::get_class_property()
{
}


//--------------------------------------------------------
/**
 *	Method      : Mks651d::Mks651dClass::set_default_property()
 *	Description : Set default property (class and device) for wizard.
 *	              For each property, add to wizard property name and description.
 *	              If default value has been set, add it to wizard property and.
 *	              store it in a DbDatum.
 */
//--------------------------------------------------------
void Mks651dClass::set_default_property()
{
	string	prop_name;
	string	prop_desc;
	string	prop_def;
	vector<string>	vect_data;
	
	//	Set Default Class Properties

	//	Set Default Device Properties

	prop_name = "SerialDevice";
	prop_desc = "";
	prop_def  = "undefined\n";
	vect_data.clear();
	vect_data.push_back("undefined");
	if (prop_def.length()>0)
	{
		Tango::DbDatum	data(prop_name);
		data << vect_data ;
		dev_def_prop.push_back(data);
		add_wiz_dev_prop(prop_name, prop_desc,  prop_def);
	}
	else
		add_wiz_dev_prop(prop_name, prop_desc);

	prop_name = "Timeout";
	prop_desc = "";
	prop_def  = "3500\n";
	vect_data.clear();
	vect_data.push_back("3500");
	if (prop_def.length()>0)
	{
		Tango::DbDatum	data(prop_name);
		data << vect_data ;
		dev_def_prop.push_back(data);
		add_wiz_dev_prop(prop_name, prop_desc,  prop_def);
	}
	else
		add_wiz_dev_prop(prop_name, prop_desc);

	prop_name = "MaxBackOff";
	prop_desc = "";
	prop_def  = "60\n";
	vect_data.clear();
	vect_data.push_back("60");
	if (prop_def.length()>0)
	{
		Tango::DbDatum	data(prop_name);
		data << vect_data ;
		dev_def_prop.push_back(data);
		add_wiz_dev_prop(prop_name, prop_desc,  prop_def);
	}
	else
		add_wiz_dev_prop(prop_name, prop_desc);

	prop_name = "ShowPressure";
	prop_desc = "";
	prop_def  = "false\n";
	vect_data.clear();
	vect_data.push_back("false");
	if (prop_def.length()>0)
	{
		Tango::DbDatum	data(prop_name);
		data << vect_data ;
		dev_def_prop.push_back(data);
		add_wiz_dev_prop(prop_name, prop_desc,  prop_def);
	}
	else
		add_wiz_dev_prop(prop_name, prop_desc);
}


//--------------------------------------------------------
/**
 *	Method      : Mks651d::Mks651dClass::write_class_property()
 *	Description : Set class description fields as property in database
 */
//--------------------------------------------------------
void Mks651dClass::write_class_property()
{
	//	First time, check if database used
	if (Tango::Util::_UseDb == false)
		return;

	Tango::DbData	data;
	string	classname = get_name();
	string	header;
	string::size_type	start, end;

	//	Put title
	Tango::DbDatum	title("ProjectTitle");
	string	str_title("Mks651d");
	title << str_title;
	data.push_back(title);

	//	Put Description
	Tango::DbDatum	description("Description");
	vector<string>	str_desc;
	str_desc.push_back("");
	description << str_desc;
	data.push_back(description);
		
	//	put cvs or svn location
	string	filename("Mks651d");
	filename += "Class.cpp";
	
	// check for cvs information
	string	src_path(CvsPath);
	start = src_path.find("/");
	if (start!=string::npos)
	{
		end   = src_path.find(filename);
		if (end>start)
		{
			string	strloc = src_path.substr(start, end-start);
			//	Check if specific repository
			start = strloc.find("/cvsroot/");
			if (start!=string::npos && start>0)
			{
				string	repository = strloc.substr(0, start);
				if (repository.find("/segfs/")!=string::npos)
					strloc = "ESRF:" + strloc.substr(start, strloc.length()-start);
			}
			Tango::DbDatum	cvs_loc("cvs_location");
			cvs_loc << strloc;
			data.push_back(cvs_loc);
		}
	}
	// check for svn information
	else
	{
		string	src_path(SvnPath);
		start = src_path.find("://");
		if (start!=string::npos)
		{
			end = src_path.find(filename);
			if (end>start)
			{
				header = "$HeadURL: ";
				start = header.length();
				string	strloc = src_path.substr(start, (end-start));
				
				Tango::DbDatum	svn_loc("svn_location");
				svn_loc << strloc;
				data.push_back(svn_loc);
			}
		}
	}

	//	Get CVS or SVN revision tag
	
	// CVS tag
	string	tagname(TagName);
	header = "$Name: ";
	start = header.length();
	string	endstr(" $");
	
	end   = tagname.find(endstr);
	if (end!=string::npos && end>start)
	{
		string	strtag = tagname.substr(start, end-start);
		Tango::DbDatum	cvs_tag("cvs_tag");
		cvs_tag << strtag;
		data.push_back(cvs_tag);
	}
	
	// SVN tag
	string	svnpath(SvnPath);
	header = "$HeadURL: ";
	start = header.length();
	
	end   = svnpath.find(endstr);
	if (end!=string::npos && end>start)
	{
		string	strloc = svnpath.substr(start, end-start);
		
		string tagstr ("/tags/");
		start = strloc.find(tagstr);
		if ( start!=string::npos )
		{
			start = start + tagstr.length();
			end   = strloc.find(filename);
			string	strtag = strloc.substr(start, end-start-1);
			
			Tango::DbDatum	svn_tag("svn_tag");
			svn_tag << strtag;
			data.push_back(svn_tag);
		}
	}

	//	Get URL location
	string	httpServ(HttpServer);
	if (httpServ.length()>0)
	{
		Tango::DbDatum	db_doc_url("doc_url");
		db_doc_url << httpServ;
		data.push_back(db_doc_url);
	}

	//  Put inheritance
	Tango::DbDatum	inher_datum("InheritedFrom");
	vector<string> inheritance;
	inheritance.push_back("Device_Impl");
	inher_datum << inheritance;
	data.push_back(inher_datum);

	//	Call database and and values
	get_db_class()->put_property(data);
}




//===================================================================
//	Factory methods
//===================================================================


//--------------------------------------------------------
/**
 * method : 		Mks651dClass::device_factory
 * description : 	Create the device object(s)
 *                  and store them in the device list
 *
 * @param	*devlist_ptr	The device name list
 */
//--------------------------------------------------------
void Mks651dClass::device_factory(const Tango::DevVarStringArray *devlist_ptr)
{

	/*----- PROTECTED REGION ID(Mks651d::Class::device_factory_before) ENABLED START -----*/

	//	Add your own code

	/*----- PROTECTED REGION END -----*/	//	Mks651d::Class::device_factory_before

	//	Create devices and add it into the device list
	for (unsigned long i=0 ; i<devlist_ptr->length() ; i++)
	{
		cout4 << "Device name : " << (*devlist_ptr)[i].in() << endl;
		device_list.push_back(new Mks651d(this, (*devlist_ptr)[i]));							 
	}

	//	Manage dynamic attributes if any
	erase_dynamic_attributes(devlist_ptr, get_class_attr()->get_attr_list());

	//	Export devices to the outside world
	for (unsigned long i=1 ; i<=devlist_ptr->length() ; i++)
	{
		//	Add dynamic attributes if any
		Mks651d *dev = static_cast<Mks651d *>(device_list[device_list.size()-i]);
		dev->add_dynamic_attributes();

		//	Check before if database used.
		if ((Tango::Util::_UseDb == true) && (Tango::Util::_FileDb == false))
			export_device(dev);
		else
			export_device(dev, dev->get_name().c_str());
	}

	/*----- PROTECTED REGION ID(Mks651d::Class::device_factory_after) ENABLED START -----*/

	//	Add your own code

	/*----- PROTECTED REGION END -----*/	//	Mks651d::Class::device_factory_after

	
}


//--------------------------------------------------------
/**
 *	Method      : Mks651d::Mks651dClass::attribute_factory()
 *	Description : Create the attribute object(s)
 *	              and store them in the attribute list
 */
//--------------------------------------------------------
void Mks651dClass::attribute_factory(vector<Tango::Attr *> &att_list)
{