XTDC4Class.h

/*----- PROTECTED REGION ID(XTDC4Class.h) ENABLED START -----*/
//=============================================================================
//
// file :        XTDC4Class.h
//
// description : Include for the XTDC4 root class.
//               This class is the singleton class for
//                the XTDC4 device class.
//               It contains all properties and methods which the 
//               XTDC4 requires only once e.g. the commands.
//
// project :     xTDC4_DevServer
//
// This file is part of Tango device class.
// 
// Tango is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// Tango is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with Tango.  If not, see <http://www.gnu.org/licenses/>.
// 
// $Author:  $
//
// $Revision:  $
// $Date:  $
//
// $HeadURL:  $
//
//=============================================================================
//                This file is generated by POGO
//        (Program Obviously used to Generate tango Object)
//=============================================================================


#ifndef XTDC4Class_H
#define XTDC4Class_H

#include <tango.h>
#include <XTDC4.h>


/*----- PROTECTED REGION END -----*/	//	XTDC4Class.h


namespace XTDC4_ns
{
/*----- PROTECTED REGION ID(XTDC4Class::classes for dynamic creation) ENABLED START -----*/


/*----- PROTECTED REGION END -----*/	//	XTDC4Class::classes for dynamic creation

//=========================================
//	Define classes for attributes
//=========================================
//	Attribute error_code class definition
class error_codeAttrib: public Tango::Attr
{
public:
	error_codeAttrib():Attr("error_code",
			Tango::DEV_LONG, Tango::READ) {};
	~error_codeAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_error_code(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_error_code_allowed(ty);}
};

//	Attribute error_message class definition
class error_messageAttrib: public Tango::Attr
{
public:
	error_messageAttrib():Attr("error_message",
			Tango::DEV_STRING, Tango::READ) {};
	~error_messageAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_error_message(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_error_message_allowed(ty);}
};

//	Attribute device_type class definition
class device_typeAttrib: public Tango::Attr
{
public:
	device_typeAttrib():Attr("device_type",
			Tango::DEV_SHORT, Tango::READ) {};
	~device_typeAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_device_type(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_device_type_allowed(ty);}
};

//	Attribute START_RISING class definition
class START_RISINGAttrib: public Tango::Attr
{
public:
	START_RISINGAttrib():Attr("START_RISING",
			Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
	~START_RISINGAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_START_RISING(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_START_RISING(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_START_RISING_allowed(ty);}
};

//	Attribute START_DC_OFFSET class definition
class START_DC_OFFSETAttrib: public Tango::Attr
{
public:
	START_DC_OFFSETAttrib():Attr("START_DC_OFFSET",
			Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~START_DC_OFFSETAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_START_DC_OFFSET(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_START_DC_OFFSET(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_START_DC_OFFSET_allowed(ty);}
};

//	Attribute CH0_ENABLED class definition
class CH0_ENABLEDAttrib: public Tango::Attr
{
public:
	CH0_ENABLEDAttrib():Attr("CH0_ENABLED",
			Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
	~CH0_ENABLEDAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH0_ENABLED(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_CH0_ENABLED(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH0_ENABLED_allowed(ty);}
};

//	Attribute CH0_RISING class definition
class CH0_RISINGAttrib: public Tango::Attr
{
public:
	CH0_RISINGAttrib():Attr("CH0_RISING",
			Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
	~CH0_RISINGAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH0_RISING(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_CH0_RISING(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH0_RISING_allowed(ty);}
};

//	Attribute CH0_DC_OFFSET class definition
class CH0_DC_OFFSETAttrib: public Tango::Attr
{
public:
	CH0_DC_OFFSETAttrib():Attr("CH0_DC_OFFSET",
			Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~CH0_DC_OFFSETAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH0_DC_OFFSET(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_CH0_DC_OFFSET(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH0_DC_OFFSET_allowed(ty);}
};

//	Attribute CH1_ENABLED class definition
class CH1_ENABLEDAttrib: public Tango::Attr
{
public:
	CH1_ENABLEDAttrib():Attr("CH1_ENABLED",
			Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
	~CH1_ENABLEDAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH1_ENABLED(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_CH1_ENABLED(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH1_ENABLED_allowed(ty);}
};

//	Attribute CH1_RISING class definition
class CH1_RISINGAttrib: public Tango::Attr
{
public:
	CH1_RISINGAttrib():Attr("CH1_RISING",
			Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
	~CH1_RISINGAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH1_RISING(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_CH1_RISING(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH1_RISING_allowed(ty);}
};

//	Attribute CH1_DC_OFFSET class definition
class CH1_DC_OFFSETAttrib: public Tango::Attr
{
public:
	CH1_DC_OFFSETAttrib():Attr("CH1_DC_OFFSET",
			Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~CH1_DC_OFFSETAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH1_DC_OFFSET(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_CH1_DC_OFFSET(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH1_DC_OFFSET_allowed(ty);}
};

//	Attribute CH2_ENABLED class definition
class CH2_ENABLEDAttrib: public Tango::Attr
{
public:
	CH2_ENABLEDAttrib():Attr("CH2_ENABLED",
			Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
	~CH2_ENABLEDAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH2_ENABLED(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_CH2_ENABLED(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH2_ENABLED_allowed(ty);}
};

//	Attribute CH2_RISING class definition
class CH2_RISINGAttrib: public Tango::Attr
{
public:
	CH2_RISINGAttrib():Attr("CH2_RISING",
			Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
	~CH2_RISINGAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH2_RISING(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_CH2_RISING(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH2_RISING_allowed(ty);}
};

//	Attribute CH2_DC_OFFSET class definition
class CH2_DC_OFFSETAttrib: public Tango::Attr
{
public:
	CH2_DC_OFFSETAttrib():Attr("CH2_DC_OFFSET",
			Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~CH2_DC_OFFSETAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH2_DC_OFFSET(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_CH2_DC_OFFSET(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH2_DC_OFFSET_allowed(ty);}
};

//	Attribute CH3_ENABLED class definition
class CH3_ENABLEDAttrib: public Tango::Attr
{
public:
	CH3_ENABLEDAttrib():Attr("CH3_ENABLED",
			Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
	~CH3_ENABLEDAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH3_ENABLED(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_CH3_ENABLED(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH3_ENABLED_allowed(ty);}
};

//	Attribute CH3_RISING class definition
class CH3_RISINGAttrib: public Tango::Attr
{
public:
	CH3_RISINGAttrib():Attr("CH3_RISING",
			Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
	~CH3_RISINGAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH3_RISING(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_CH3_RISING(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH3_RISING_allowed(ty);}
};

//	Attribute CH3_DC_OFFSET class definition
class CH3_DC_OFFSETAttrib: public Tango::Attr
{
public:
	CH3_DC_OFFSETAttrib():Attr("CH3_DC_OFFSET",
			Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~CH3_DC_OFFSETAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH3_DC_OFFSET(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_CH3_DC_OFFSET(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH3_DC_OFFSET_allowed(ty);}
};

//	Attribute TW_START class definition
class TW_STARTAttrib: public Tango::Attr
{
public:
	TW_STARTAttrib():Attr("TW_START",
			Tango::DEV_LONG64, Tango::READ_WRITE) {};
	~TW_STARTAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_TW_START(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_TW_START(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_TW_START_allowed(ty);}
};

//	Attribute TW_END class definition
class TW_ENDAttrib: public Tango::Attr
{
public:
	TW_ENDAttrib():Attr("TW_END",
			Tango::DEV_LONG64, Tango::READ_WRITE) {};
	~TW_ENDAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_TW_END(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_TW_END(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_TW_END_allowed(ty);}
};

//	Attribute config_changed class definition
class config_changedAttrib: public Tango::Attr
{
public:
	config_changedAttrib():Attr("config_changed",
			Tango::DEV_BOOLEAN, Tango::READ) {};
	~config_changedAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_config_changed(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_config_changed_allowed(ty);}
};

//	Attribute start_trigger_generator class definition
class start_trigger_generatorAttrib: public Tango::Attr
{
public:
	start_trigger_generatorAttrib():Attr("start_trigger_generator",
			Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
	~start_trigger_generatorAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_start_trigger_generator(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_start_trigger_generator(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_start_trigger_generator_allowed(ty);}
};

//	Attribute last_run_valid_starts class definition
class last_run_valid_startsAttrib: public Tango::Attr
{
public:
	last_run_valid_startsAttrib():Attr("last_run_valid_starts",
			Tango::DEV_LONG, Tango::READ) {};
	~last_run_valid_startsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_last_run_valid_starts(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_last_run_valid_starts_allowed(ty);}
};

//	Attribute last_run_empty_starts class definition
class last_run_empty_startsAttrib: public Tango::Attr
{
public:
	last_run_empty_startsAttrib():Attr("last_run_empty_starts",
			Tango::DEV_LONG, Tango::READ) {};
	~last_run_empty_startsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_last_run_empty_starts(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_last_run_empty_starts_allowed(ty);}
};

//	Attribute last_run_hits class definition
class last_run_hitsAttrib: public Tango::Attr
{
public:
	last_run_hitsAttrib():Attr("last_run_hits",
			Tango::DEV_LONG, Tango::READ) {};
	~last_run_hitsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_last_run_hits(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_last_run_hits_allowed(ty);}
};

//	Attribute last_run_start_errors class definition
class last_run_start_errorsAttrib: public Tango::Attr
{
public:
	last_run_start_errorsAttrib():Attr("last_run_start_errors",
			Tango::DEV_LONG, Tango::READ) {};
	~last_run_start_errorsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_last_run_start_errors(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_last_run_start_errors_allowed(ty);}
};

//	Attribute start_trigger_generator_frequency class definition
class start_trigger_generator_frequencyAttrib: public Tango::Attr
{
public:
	start_trigger_generator_frequencyAttrib():Attr("start_trigger_generator_frequency",
			Tango::DEV_LONG, Tango::READ_WRITE) {};
	~start_trigger_generator_frequencyAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_start_trigger_generator_frequency(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_start_trigger_generator_frequency(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_start_trigger_generator_frequency_allowed(ty);}
};

//	Attribute run_timeout class definition
class run_timeoutAttrib: public Tango::Attr
{
public:
	run_timeoutAttrib():Attr("run_timeout",
			Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~run_timeoutAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_run_timeout(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<XTDC4 *>(dev))->write_run_timeout(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_run_timeout_allowed(ty);}
};

//	Attribute firmware_revision class definition
class firmware_revisionAttrib: public Tango::Attr
{
public:
	firmware_revisionAttrib():Attr("firmware_revision",
			Tango::DEV_LONG, Tango::READ) {};
	~firmware_revisionAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_firmware_revision(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_firmware_revision_allowed(ty);}
};

//	Attribute driver_version class definition
class driver_versionAttrib: public Tango::Attr
{
public:
	driver_versionAttrib():Attr("driver_version",
			Tango::DEV_LONG, Tango::READ) {};
	~driver_versionAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_driver_version(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_driver_version_allowed(ty);}
};

//	Attribute board_serial class definition
class board_serialAttrib: public Tango::Attr
{
public:
	board_serialAttrib():Attr("board_serial",
			Tango::DEV_LONG, Tango::READ) {};
	~board_serialAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_board_serial(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_board_serial_allowed(ty);}
};

//	Attribute bin_size class definition
class bin_sizeAttrib: public Tango::Attr
{
public:
	bin_sizeAttrib():Attr("bin_size",
			Tango::DEV_DOUBLE, Tango::READ) {};
	~bin_sizeAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_bin_size(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_bin_size_allowed(ty);}
};

//	Attribute trigger_number class definition
class trigger_numberAttrib: public Tango::Attr
{
public:
	trigger_numberAttrib():Attr("trigger_number",
			Tango::DEV_ULONG64, Tango::READ) {};
	~trigger_numberAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_trigger_number(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_trigger_number_allowed(ty);}
};

//	Attribute CH0_Timestamps class definition
class CH0_TimestampsAttrib: public Tango::SpectrumAttr
{
public:
	CH0_TimestampsAttrib():SpectrumAttr("CH0_Timestamps",
			Tango::DEV_ULONG64, Tango::READ, 1400000) {};
	~CH0_TimestampsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH0_Timestamps(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH0_Timestamps_allowed(ty);}
};

//	Attribute CH1_Timestamps class definition
class CH1_TimestampsAttrib: public Tango::SpectrumAttr
{
public:
	CH1_TimestampsAttrib():SpectrumAttr("CH1_Timestamps",
			Tango::DEV_ULONG64, Tango::READ, 1400000) {};
	~CH1_TimestampsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH1_Timestamps(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH1_Timestamps_allowed(ty);}
};

//	Attribute CH2_Timestamps class definition
class CH2_TimestampsAttrib: public Tango::SpectrumAttr
{
public:
	CH2_TimestampsAttrib():SpectrumAttr("CH2_Timestamps",
			Tango::DEV_ULONG64, Tango::READ, 1400000) {};
	~CH2_TimestampsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH2_Timestamps(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH2_Timestamps_allowed(ty);}
};

//	Attribute CH3_Timestamps class definition
class CH3_TimestampsAttrib: public Tango::SpectrumAttr
{
public:
	CH3_TimestampsAttrib():SpectrumAttr("CH3_Timestamps",
			Tango::DEV_ULONG64, Tango::READ, 1400000) {};
	~CH3_TimestampsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<XTDC4 *>(dev))->read_CH3_Timestamps(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<XTDC4 *>(dev))->is_CH3_Timestamps_allowed(ty);}
};


//=========================================
//	Define classes for commands
//=========================================
//	Command Start class definition
class StartClass : public Tango::Command
{
public:
	StartClass(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)	{};

	StartClass(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(name,in,out)	{};
	~StartClass() {};
	
	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<XTDC4 *>(dev))->is_Start_allowed(any);}
};

//	Command Stop class definition
class StopClass : public Tango::Command
{
public:
	StopClass(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)	{};

	StopClass(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(name,in,out)	{};
	~StopClass() {};
	
	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<XTDC4 *>(dev))->is_Stop_allowed(any);}
};

//	Command Off class definition
class OffClass : public Tango::Command
{
public:
	OffClass(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)	{};

	OffClass(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(name,in,out)	{};
	~OffClass() {};
	
	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<XTDC4 *>(dev))->is_Off_allowed(any);}
};

//	Command apply_config class definition
class apply_configClass : public Tango::Command
{
public:
	apply_configClass(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)	{};

	apply_configClass(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(name,in,out)	{};
	~apply_configClass() {};
	
	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<XTDC4 *>(dev))->is_apply_config_allowed(any);}
};

//	Command Clear class definition
class ClearClass : public Tango::Command
{
public:
	ClearClass(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)	{};

	ClearClass(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(name,in,out)	{};
	~ClearClass() {};
	
	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<XTDC4 *>(dev))->is_Clear_allowed(any);}
};


/**
 *	The XTDC4Class singleton definition
 */

#ifdef _TG_WINDOWS_
class __declspec(dllexport)  XTDC4Class : public Tango::DeviceClass
#else
class XTDC4Class : public Tango::DeviceClass
#endif
{
	/*----- PROTECTED REGION ID(XTDC4Class::Additionnal DServer data members) ENABLED START -----*/
	
	
	/*----- PROTECTED REGION END -----*/	//	XTDC4Class::Additionnal DServer data members

	public:
		//	write class properties data members
		Tango::DbData	cl_prop;
		Tango::DbData	cl_def_prop;
		Tango::DbData	dev_def_prop;
	
		//	Method prototypes
		static XTDC4Class *init(const char *);
		static XTDC4Class *instance();
		~XTDC4Class();
		Tango::DbDatum	get_class_property(string &);
		Tango::DbDatum	get_default_device_property(string &);
		Tango::DbDatum	get_default_class_property(string &);
	
	protected:
		XTDC4Class(string &);
		static XTDC4Class *_instance;
		void command_factory();
		void attribute_factory(vector<Tango::Attr *> &);
		void pipe_factory();
		void write_class_property();
		void set_default_property();
		void get_class_property();
		string get_cvstag();
		string get_cvsroot();
	
	private:
		void device_factory(const Tango::DevVarStringArray *);
		void create_static_attribute_list(vector<Tango::Attr *> &);
		void erase_dynamic_attributes(const Tango::DevVarStringArray *,vector<Tango::Attr *> &);
		vector<string>	defaultAttList;
		Tango::Attr *get_attr_object_by_name(vector<Tango::Attr *> &att_list, string attname);
};

}	//	End of namespace

#endif   //	XTDC4_H