Keithley428Class.h

//=============================================================================
//
// file :         Keithley428Class.h
//
// description :  Include for the Keithley428Class root class.
//                This class is the singleton class for
//                the Keithley428 device class.
//                It contains all properties and methods which the 
//                Keithley428 requires only once e.g. the commands.
//			
// project :      TANGO Device Server
//
// $Author:  $
//
// $Revision:  $
// $Date:  $
//
// SVN only:
// $HeadURL: $
//
// CVS only:
// $Source:  $
// $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
//=============================================================================

#ifndef _KEITHLEY428CLASS_H
#define _KEITHLEY428CLASS_H

#include <tango.h>
#include <Keithley428.h>


namespace Keithley428_ns
{//=====================================
//	Define classes for attributes
//=====================================
class RiseTimeStrAttrib: public Tango::Attr
{
public:
	RiseTimeStrAttrib():Attr("RiseTimeStr", Tango::DEV_STRING, Tango::READ) {};
	~RiseTimeStrAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<Keithley428 *>(dev))->read_RiseTimeStr(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<Keithley428 *>(dev))->is_RiseTimeStr_allowed(ty);}
};

class RiseTimeAttrib: public Tango::Attr
{
public:
	RiseTimeAttrib():Attr("RiseTime", Tango::DEV_LONG, Tango::READ_WRITE) {};
	~RiseTimeAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<Keithley428 *>(dev))->read_RiseTime(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<Keithley428 *>(dev))->write_RiseTime(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<Keithley428 *>(dev))->is_RiseTime_allowed(ty);}
};

class autoFilterStateAttrib: public Tango::Attr
{
public:
	autoFilterStateAttrib():Attr("autoFilterState", Tango::DEV_STRING, Tango::READ) {};
	~autoFilterStateAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<Keithley428 *>(dev))->read_autoFilterState(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<Keithley428 *>(dev))->is_autoFilterState_allowed(ty);}
};

class filterStateAttrib: public Tango::Attr
{
public:
	filterStateAttrib():Attr("filterState", Tango::DEV_STRING, Tango::READ) {};
	~filterStateAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<Keithley428 *>(dev))->read_filterState(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<Keithley428 *>(dev))->is_filterState_allowed(ty);}
};

class BypassAttrib: public Tango::Attr
{
public:
	BypassAttrib():Attr("Bypass", Tango::DEV_LONG, Tango::READ_WRITE) {};
	~BypassAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<Keithley428 *>(dev))->read_Bypass(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<Keithley428 *>(dev))->write_Bypass(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<Keithley428 *>(dev))->is_Bypass_allowed(ty);}
};

class OverloadedAttrib: public Tango::Attr
{
public:
	OverloadedAttrib():Attr("Overloaded", Tango::DEV_LONG, Tango::READ) {};
	~OverloadedAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<Keithley428 *>(dev))->read_Overloaded(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<Keithley428 *>(dev))->is_Overloaded_allowed(ty);}
};

class GainStrAttrib: public Tango::Attr
{
public:
	GainStrAttrib():Attr("GainStr", Tango::DEV_STRING, Tango::READ) {};
	~GainStrAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<Keithley428 *>(dev))->read_GainStr(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<Keithley428 *>(dev))->is_GainStr_allowed(ty);}
};

class GainAttrib: public Tango::Attr
{
public:
	GainAttrib():Attr("Gain", Tango::DEV_LONG, Tango::READ_WRITE) {};
	~GainAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<Keithley428 *>(dev))->read_Gain(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<Keithley428 *>(dev))->write_Gain(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<Keithley428 *>(dev))->is_Gain_allowed(ty);}
};

//=========================================
//	Define classes for commands
//=========================================
class AutoFilterOffClass : public Tango::Command
{
public:
	AutoFilterOffClass(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out,
				   const char        *in_desc,
				   const char        *out_desc,
				   Tango::DispLevel  level)
	:Command(name,in,out,in_desc,out_desc, level)	{};

	AutoFilterOffClass(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(name,in,out)	{};
	~AutoFilterOffClass() {};
	
	virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
	virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
	{return (static_cast<Keithley428 *>(dev))->is_AutoFilterOff_allowed(any);}
};



class AutoFilterOnClass : public Tango::Command
{
public:
	AutoFilterOnClass(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out,
				   const char        *in_desc,
				   const char        *out_desc,
				   Tango::DispLevel  level)
	:Command(name,in,out,in_desc,out_desc, level)	{};

	AutoFilterOnClass(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(name,in,out)	{};
	~AutoFilterOnClass() {};
	
	virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
	virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
	{return (static_cast<Keithley428 *>(dev))->is_AutoFilterOn_allowed(any);}
};



class FilterOffCmd : public Tango::Command
{
public:
	FilterOffCmd(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out,
				   const char        *in_desc,
				   const char        *out_desc,
				   Tango::DispLevel  level)
	:Command(name,in,out,in_desc,out_desc, level)	{};

	FilterOffCmd(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(name,in,out)	{};
	~FilterOffCmd() {};
	
	virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
	virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
	{return (static_cast<Keithley428 *>(dev))->is_FilterOff_allowed(any);}
};



class FilterOnCmd : public Tango::Command
{
public:
	FilterOnCmd(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out,
				   const char        *in_desc,
				   const char        *out_desc,
				   Tango::DispLevel  level)
	:Command(name,in,out,in_desc,out_desc, level)	{};

	FilterOnCmd(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(name,in,out)	{};
	~FilterOnCmd() {};
	
	virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
	virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
	{return (static_cast<Keithley428 *>(dev))->is_FilterOn_allowed(any);}
};



class PerformZeroCorrectClass : public Tango::Command
{
public:
	PerformZeroCorrectClass(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out,
				   const char        *in_desc,
				   const char        *out_desc,
				   Tango::DispLevel  level)
	:Command(name,in,out,in_desc,out_desc, level)	{};

	PerformZeroCorrectClass(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(name,in,out)	{};
	~PerformZeroCorrectClass() {};
	
	virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
	virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
	{return (static_cast<Keithley428 *>(dev))->is_PerformZeroCorrect_allowed(any);}
};



//
// The Keithley428Class singleton definition
//

class
#ifdef WIN32
	__declspec(dllexport)
#endif
	Keithley428Class : public Tango::DeviceClass
{
public:
//	properties member data

//	add your own data members here
//------------------------------------

public:
	Tango::DbData	cl_prop;
	Tango::DbData	cl_def_prop;
	Tango::DbData	dev_def_prop;

//	Method prototypes
	static Keithley428Class *init(const char *);
	static Keithley428Class *instance();
	~Keithley428Class();
	Tango::DbDatum	get_class_property(string &);
	Tango::DbDatum	get_default_device_property(string &);
	Tango::DbDatum	get_default_class_property(string &);
	
protected:
	Keithley428Class(string &);
	static Keithley428Class *_instance;
	void command_factory();
	void get_class_property();
	void attribute_factory(vector<Tango::Attr *> &);
	void write_class_property();
	void set_default_property();
	string get_cvstag();
	string get_cvsroot();

private:
	void device_factory(const Tango::DevVarStringArray *);
};


}	//	namespace Keithley428_ns

#endif // _KEITHLEY428CLASS_H