Keithley428Class.cpp

static const char *ClassId    = "$Id:  $";
static const char *TagName    = "$Name:  $";
static const char *CvsPath    = "$Source:  $";
static const char *SvnPath    = "$HeadURL: $";
static const char *HttpServer = "http://www.esrf.fr/computing/cs/tango/tango_doc/ds_doc/";
//+=============================================================================
//
// file :        Keithley428Class.cpp
//
// description : C++ source for the Keithley428Class. A singleton
//               class derived from DeviceClass. It implements the
//               command list and all properties and methods required
//               by the Keithley428 once per process.
//
// project :     TANGO Device Server
//
// $Author:  $
//
// $Revision:  $
//
// $Log:  $
//
// copyleft :   European Synchrotron Radiation Facility
//              BP 220, Grenoble 38043
//              FRANCE
//
//-=============================================================================
//
//  		This file is generated by POGO
//	(Program Obviously used to Generate tango Object)
//
//         (c) - Software Engineering Group - ESRF
//=============================================================================


#include <tango.h>

#include <Keithley428.h>
#include <Keithley428Class.h>


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

__declspec(dllexport)

#endif

	Tango::DeviceClass *_create_Keithley428_class(const char *name) {
		return Keithley428_ns::Keithley428Class::init(name);
	}
}


namespace Keithley428_ns
{
//+----------------------------------------------------------------------------
//
// method : 		AutoFilterOffClass::execute()
// 
// description : 	method to trigger the execution of the command.
//                PLEASE DO NOT MODIFY this method core without pogo   
//
// in : - device : The device on which the command must be executed
//		- in_any : The command input data
//
// returns : The command output data (packed in the Any object)
//
//-----------------------------------------------------------------------------
CORBA::Any *AutoFilterOffClass::execute(Tango::DeviceImpl *device,const CORBA::Any &in_any)
{

	cout2 << "AutoFilterOffClass::execute(): arrived" << endl;

	((static_cast<Keithley428 *>(device))->auto_filter_off());
	return new CORBA::Any();
}

//+----------------------------------------------------------------------------
//
// method : 		AutoFilterOnClass::execute()
// 
// description : 	method to trigger the execution of the command.
//                PLEASE DO NOT MODIFY this method core without pogo   
//
// in : - device : The device on which the command must be executed
//		- in_any : The command input data
//
// returns : The command output data (packed in the Any object)
//
//-----------------------------------------------------------------------------
CORBA::Any *AutoFilterOnClass::execute(Tango::DeviceImpl *device,const CORBA::Any &in_any)
{

	cout2 << "AutoFilterOnClass::execute(): arrived" << endl;

	((static_cast<Keithley428 *>(device))->auto_filter_on());
	return new CORBA::Any();
}

//+----------------------------------------------------------------------------
//
// method : 		FilterOffCmd::execute()
// 
// description : 	method to trigger the execution of the command.
//                PLEASE DO NOT MODIFY this method core without pogo   
//
// in : - device : The device on which the command must be executed
//		- in_any : The command input data
//
// returns : The command output data (packed in the Any object)
//
//-----------------------------------------------------------------------------
CORBA::Any *FilterOffCmd::execute(Tango::DeviceImpl *device,const CORBA::Any &in_any)
{

	cout2 << "FilterOffCmd::execute(): arrived" << endl;

	((static_cast<Keithley428 *>(device))->filter_off());
	return new CORBA::Any();
}

//+----------------------------------------------------------------------------
//
// method : 		FilterOnCmd::execute()
// 
// description : 	method to trigger the execution of the command.
//                PLEASE DO NOT MODIFY this method core without pogo   
//
// in : - device : The device on which the command must be executed
//		- in_any : The command input data
//
// returns : The command output data (packed in the Any object)
//
//-----------------------------------------------------------------------------
CORBA::Any *FilterOnCmd::execute(Tango::DeviceImpl *device,const CORBA::Any &in_any)
{

	cout2 << "FilterOnCmd::execute(): arrived" << endl;

	((static_cast<Keithley428 *>(device))->filter_on());
	return new CORBA::Any();
}


//+----------------------------------------------------------------------------
//
// method : 		PerformZeroCorrectClass::execute()
// 
// description : 	method to trigger the execution of the command.
//                PLEASE DO NOT MODIFY this method core without pogo   
//
// in : - device : The device on which the command must be executed
//		- in_any : The command input data
//
// returns : The command output data (packed in the Any object)
//
//-----------------------------------------------------------------------------
CORBA::Any *PerformZeroCorrectClass::execute(Tango::DeviceImpl *device,const CORBA::Any &in_any)
{

	cout2 << "PerformZeroCorrectClass::execute(): arrived" << endl;

	((static_cast<Keithley428 *>(device))->perform_zero_correct());
	return new CORBA::Any();
}



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

//+----------------------------------------------------------------------------
//
// method : 		Keithley428Class::Keithley428Class(string &s)
// 
// description : 	constructor for the Keithley428Class
//
// in : - s : The class name
//
//-----------------------------------------------------------------------------
Keithley428Class::Keithley428Class(string &s):DeviceClass(s)
{

	cout2 << "Entering Keithley428Class constructor" << endl;
	set_default_property();
	get_class_property();
	write_class_property();
	
	cout2 << "Leaving Keithley428Class constructor" << endl;

}
//+----------------------------------------------------------------------------
//
// method : 		Keithley428Class::~Keithley428Class()
// 
// description : 	destructor for the Keithley428Class
//
//-----------------------------------------------------------------------------
Keithley428Class::~Keithley428Class()
{
	_instance = NULL;
}

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

Keithley428Class *Keithley428Class::instance()
{
	if (_instance == NULL)
	{
		cerr << "Class is not initialised !!" << endl;
		exit(-1);
	}
	return _instance;
}

//+----------------------------------------------------------------------------
//
// method : 		Keithley428Class::command_factory
// 
// description : 	Create the command object(s) and store them in the 
//			command list
//
//-----------------------------------------------------------------------------
void Keithley428Class::command_factory()
{
	command_list.push_back(new PerformZeroCorrectClass("PerformZeroCorrect",
		Tango::DEV_VOID, Tango::DEV_VOID,
		"",
		"",
		Tango::OPERATOR));
	command_list.push_back(new FilterOnCmd("FilterOn",
		Tango::DEV_VOID, Tango::DEV_VOID,
		"",
		"",
		Tango::OPERATOR));
	command_list.push_back(new FilterOffCmd("FilterOff",
		Tango::DEV_VOID, Tango::DEV_VOID,
		"",
		"",
		Tango::OPERATOR));
	command_list.push_back(new AutoFilterOnClass("AutoFilterOn",
		Tango::DEV_VOID, Tango::DEV_VOID,
		"",
		"",
		Tango::OPERATOR));
	command_list.push_back(new AutoFilterOffClass("AutoFilterOff",
		Tango::DEV_VOID, Tango::DEV_VOID,
		"",
		"",
		Tango::OPERATOR));

	//	add polling if any
	for (unsigned int i=0 ; i<command_list.size(); i++)
	{
	}
}

//+----------------------------------------------------------------------------
//
// method : 		Keithley428Class::get_class_property
// 
// description : 	Get the class property for specified name.
//
// in :		string	name : The property name
//
//+----------------------------------------------------------------------------
Tango::DbDatum Keithley428Class::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, return  an empty DbDatum
	return Tango::DbDatum(prop_name);
}
//+----------------------------------------------------------------------------
//
// method : 		Keithley428Class::get_default_device_property()
// 
// description : 	Return the default value for device property.
//
//-----------------------------------------------------------------------------
Tango::DbDatum Keithley428Class::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 : 		Keithley428Class::get_default_class_property()
// 
// description : 	Return the default value for class property.
//
//-----------------------------------------------------------------------------
Tango::DbDatum Keithley428Class::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 : 		Keithley428Class::device_factory
// 
// description : 	Create the device object(s) and store them in the 
//			device list
//
// in :		Tango::DevVarStringArray *devlist_ptr : The device name list
//
//-----------------------------------------------------------------------------
void Keithley428Class::device_factory(const Tango::DevVarStringArray *devlist_ptr)
{

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

		// Export device to the outside world
		// Check before if database used.
		//---------------------------------------------
		if ((Tango::Util::_UseDb == true) && (Tango::Util::_FileDb == false))
			export_device(device_list.back());
		else
			export_device(device_list.back(), (*devlist_ptr)[i]);
	}
	//	End of Automatic code generation
	//-------------------------------------------------------------

}
//+----------------------------------------------------------------------------
//	Method: Keithley428Class::attribute_factory(vector<Tango::Attr *> &att_list)
//-----------------------------------------------------------------------------
void Keithley428Class::attribute_factory(vector<Tango::Attr *> &att_list)
{
	//	Attribute : Gain
	GainAttrib	*gain = new GainAttrib();
	Tango::UserDefaultAttrProp	gain_prop;
	gain_prop.set_unit(" ");
	gain_prop.set_format("%d");
	gain_prop.set_max_value("11");
	gain_prop.set_min_value("0");
	gain_prop.set_description("0, 1, 2, 3 -> 10e3 V/A\n4 -> 10e4 V/A\n5 -> 10e5 V/A\n6 -> 10e6 V/A\n7 -> 10e7 V/A\n8 -> 10e8 V/A\n9 -> 10e9 V/A\n10 -> 10e10 V/A\n11 -> 10e11 V/A");
	gain->set_default_properties(gain_prop);
	gain->set_memorized();
	gain->set_memorized_init(true);
	att_list.push_back(gain);

	//	Attribute : GainStr
	GainStrAttrib	*gain_str = new GainStrAttrib();
	att_list.push_back(gain_str);

	//	Attribute : Overloaded
	OverloadedAttrib	*overloaded = new OverloadedAttrib();
	Tango::UserDefaultAttrProp	overloaded_prop;
	overloaded_prop.set_unit(" ");
	overloaded_prop.set_format("%d");
	overloaded_prop.set_description("1 if device is overloaded");
	overloaded->set_default_properties(overloaded_prop);
	att_list.push_back(overloaded);

	//	Attribute : Bypass
	BypassAttrib	*bypass = new BypassAttrib();
	Tango::UserDefaultAttrProp	bypass_prop;
	bypass_prop.set_unit(" ");
	bypass_prop.set_format("%d");
	bypass_prop.set_max_value("2");
	bypass_prop.set_min_value("0");
	bypass_prop.set_description("0 -> zero check off, 1 -> zero check on, 2 (only read) zero correction last selected.");
	bypass->set_default_properties(bypass_prop);
	att_list.push_back(bypass);

	//	Attribute : filterState
	filterStateAttrib	*filter_state = new filterStateAttrib();
	Tango::UserDefaultAttrProp	filter_state_prop;
	filter_state_prop.set_description("State of the manual filter");
	filter_state->set_default_properties(filter_state_prop);
	att_list.push_back(filter_state);

	//	Attribute : autoFilterState
	autoFilterStateAttrib	*auto_filter_state = new autoFilterStateAttrib();
	Tango::UserDefaultAttrProp	auto_filter_state_prop;
	auto_filter_state_prop.set_description("State of the auto Filter");
	auto_filter_state->set_default_properties(auto_filter_state_prop);
	att_list.push_back(auto_filter_state);

	//	End of Automatic code generation
	//-------------------------------------------------------------
}

//+----------------------------------------------------------------------------
//
// method : 		Keithley428Class::get_class_property()
// 
// description : 	Read the class properties from database.
//
//-----------------------------------------------------------------------------
void Keithley428Class::get_class_property()
{
	//	Initialize your default values here (if not done with  POGO).
	//------------------------------------------------------------------

	//	Read class properties from database.(Automatic code generation)
	//------------------------------------------------------------------

	//	Call database and extract values
	//--------------------------------------------
	if (Tango::Util::instance()->_UseDb==true)
		get_db_class()->get_property(cl_prop);
	Tango::DbDatum	def_prop;
	int	i = -1;


	//	End of Automatic code generation
	//------------------------------------------------------------------

}

//+----------------------------------------------------------------------------
//
// method : 	Keithley428Class::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 Keithley428Class::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 = "GpibDevice";
	prop_desc = "Name of the gpib device connected to the hardware.";
	prop_def  = "";
	vect_data.clear();
	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 = "GpibDeviceType";
	prop_desc = "Type of the Gpib device used to communicate with the Keithley.\nthis can be:\n1 -> Desy GpibDevice (default value)\n2 -> Soleil GpibDeviceServer";
	prop_def  = "1";
	vect_data.clear();
	vect_data.push_back("1");
	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 : 		Keithley428Class::write_class_property
// 
// description : 	Set class description as property in database
//
//-----------------------------------------------------------------------------
void Keithley428Class::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("Keithley428 Current Amplifier");
	title << str_title;
	data.push_back(title);

	//	Put Description
	Tango::DbDatum	description("Description");
	vector<string>	str_desc;
	str_desc.push_back("Class for controlling the Keithley428 current amplifier.");
	description << str_desc;
	data.push_back(description);
		
	//	put cvs or svn location
	string	filename(classname);
	filename += "Class.cpp";
	
	// Create a string with the class ID to
	// get the string into the binary
	string	class_id(ClassId);
	
	// 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_4Impl");
	inher_datum << inheritance;
	data.push_back(inher_datum);

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

}	// namespace