Standa8smc4usbClass.h

/*----- PROTECTED REGION ID(Standa8smc4usbClass.h) ENABLED START -----*/
//=============================================================================
//
// file :        Standa8smc4usbClass.h
//
// description : Include for the Standa8smc4usb root class.
//               This class is the singleton class for
//                the Standa8smc4usb device class.
//               It contains all properties and methods which the 
//               Standa8smc4usb requires only once e.g. the commands.
//
// project :     StandaTango
//
// 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 Standa8smc4usbClass_H
#define Standa8smc4usbClass_H

#include <tango.h>
#include <Standa8smc4usb.h>


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


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


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

//=========================================
//	Define classes for attributes
//=========================================
//	Attribute speed class definition
class speedAttrib: public Tango::Attr
{
public:
	speedAttrib():Attr("speed",
			Tango::DEV_FLOAT, Tango::READ_WRITE) {};
	~speedAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_speed(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->write_speed(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_speed_allowed(ty);}
};

//	Attribute accel class definition
class accelAttrib: public Tango::Attr
{
public:
	accelAttrib():Attr("accel",
			Tango::DEV_FLOAT, Tango::READ_WRITE) {};
	~accelAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_accel(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->write_accel(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_accel_allowed(ty);}
};

//	Attribute decel class definition
class decelAttrib: public Tango::Attr
{
public:
	decelAttrib():Attr("decel",
			Tango::DEV_FLOAT, Tango::READ_WRITE) {};
	~decelAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_decel(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->write_decel(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_decel_allowed(ty);}
};

//	Attribute antiplaySpeed class definition
class antiplaySpeedAttrib: public Tango::Attr
{
public:
	antiplaySpeedAttrib():Attr("antiplaySpeed",
			Tango::DEV_FLOAT, Tango::READ_WRITE) {};
	~antiplaySpeedAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_antiplaySpeed(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->write_antiplaySpeed(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_antiplaySpeed_allowed(ty);}
};

//	Attribute moveSts class definition
class moveStsAttrib: public Tango::Attr
{
public:
	moveStsAttrib():Attr("moveSts",
			Tango::DEV_ULONG, Tango::READ) {};
	~moveStsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_moveSts(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_moveSts_allowed(ty);}
};

//	Attribute mvCmdSts class definition
class mvCmdStsAttrib: public Tango::Attr
{
public:
	mvCmdStsAttrib():Attr("mvCmdSts",
			Tango::DEV_ULONG, Tango::READ) {};
	~mvCmdStsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_mvCmdSts(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_mvCmdSts_allowed(ty);}
};

//	Attribute pwrSts class definition
class pwrStsAttrib: public Tango::Attr
{
public:
	pwrStsAttrib():Attr("pwrSts",
			Tango::DEV_ULONG, Tango::READ) {};
	~pwrStsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_pwrSts(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_pwrSts_allowed(ty);}
};

//	Attribute encSts class definition
class encStsAttrib: public Tango::Attr
{
public:
	encStsAttrib():Attr("encSts",
			Tango::DEV_ULONG, Tango::READ) {};
	~encStsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_encSts(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_encSts_allowed(ty);}
};

//	Attribute windSts class definition
class windStsAttrib: public Tango::Attr
{
public:
	windStsAttrib():Attr("windSts",
			Tango::DEV_ULONG, Tango::READ) {};
	~windStsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_windSts(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_windSts_allowed(ty);}
};

//	Attribute curPosition class definition
class curPositionAttrib: public Tango::Attr
{
public:
	curPositionAttrib():Attr("curPosition",
			Tango::DEV_FLOAT, Tango::READ) {};
	~curPositionAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_curPosition(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_curPosition_allowed(ty);}
};

//	Attribute encPosition class definition
class encPositionAttrib: public Tango::Attr
{
public:
	encPositionAttrib():Attr("encPosition",
			Tango::DEV_LONG64, Tango::READ) {};
	~encPositionAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_encPosition(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_encPosition_allowed(ty);}
};

//	Attribute curSpeed class definition
class curSpeedAttrib: public Tango::Attr
{
public:
	curSpeedAttrib():Attr("curSpeed",
			Tango::DEV_FLOAT, Tango::READ) {};
	~curSpeedAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_curSpeed(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_curSpeed_allowed(ty);}
};

//	Attribute ipwr class definition
class ipwrAttrib: public Tango::Attr
{
public:
	ipwrAttrib():Attr("ipwr",
			Tango::DEV_LONG, Tango::READ) {};
	~ipwrAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_ipwr(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_ipwr_allowed(ty);}
};

//	Attribute upwr class definition
class upwrAttrib: public Tango::Attr
{
public:
	upwrAttrib():Attr("upwr",
			Tango::DEV_LONG, Tango::READ) {};
	~upwrAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_upwr(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_upwr_allowed(ty);}
};

//	Attribute iusb class definition
class iusbAttrib: public Tango::Attr
{
public:
	iusbAttrib():Attr("iusb",
			Tango::DEV_LONG, Tango::READ) {};
	~iusbAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_iusb(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_iusb_allowed(ty);}
};

//	Attribute uusb class definition
class uusbAttrib: public Tango::Attr
{
public:
	uusbAttrib():Attr("uusb",
			Tango::DEV_LONG, Tango::READ) {};
	~uusbAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_uusb(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_uusb_allowed(ty);}
};

//	Attribute curT class definition
class curTAttrib: public Tango::Attr
{
public:
	curTAttrib():Attr("curT",
			Tango::DEV_LONG, Tango::READ) {};
	~curTAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_curT(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_curT_allowed(ty);}
};

//	Attribute flags class definition
class flagsAttrib: public Tango::Attr
{
public:
	flagsAttrib():Attr("flags",
			Tango::DEV_ULONG, Tango::READ) {};
	~flagsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_flags(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_flags_allowed(ty);}
};

//	Attribute gpioFlags class definition
class gpioFlagsAttrib: public Tango::Attr
{
public:
	gpioFlagsAttrib():Attr("gpioFlags",
			Tango::DEV_ULONG, Tango::READ) {};
	~gpioFlagsAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_gpioFlags(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_gpioFlags_allowed(ty);}
};

//	Attribute cmdBufFreeSpace class definition
class cmdBufFreeSpaceAttrib: public Tango::Attr
{
public:
	cmdBufFreeSpaceAttrib():Attr("cmdBufFreeSpace",
			Tango::DEV_ULONG, Tango::READ) {};
	~cmdBufFreeSpaceAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_cmdBufFreeSpace(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_cmdBufFreeSpace_allowed(ty);}
};

//	Attribute windingVoltageA class definition
class windingVoltageAAttrib: public Tango::Attr
{
public:
	windingVoltageAAttrib():Attr("windingVoltageA",
			Tango::DEV_LONG, Tango::READ) {};
	~windingVoltageAAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_windingVoltageA(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_windingVoltageA_allowed(ty);}
};

//	Attribute windingVoltageB class definition
class windingVoltageBAttrib: public Tango::Attr
{
public:
	windingVoltageBAttrib():Attr("windingVoltageB",
			Tango::DEV_LONG, Tango::READ) {};
	~windingVoltageBAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_windingVoltageB(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_windingVoltageB_allowed(ty);}
};

//	Attribute windingVoltageC class definition
class windingVoltageCAttrib: public Tango::Attr
{
public:
	windingVoltageCAttrib():Attr("windingVoltageC",
			Tango::DEV_LONG, Tango::READ) {};
	~windingVoltageCAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_windingVoltageC(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_windingVoltageC_allowed(ty);}
};

//	Attribute windingCurrentA class definition
class windingCurrentAAttrib: public Tango::Attr
{
public:
	windingCurrentAAttrib():Attr("windingCurrentA",
			Tango::DEV_LONG, Tango::READ) {};
	~windingCurrentAAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_windingCurrentA(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_windingCurrentA_allowed(ty);}
};

//	Attribute windingCurrentB class definition
class windingCurrentBAttrib: public Tango::Attr
{
public:
	windingCurrentBAttrib():Attr("windingCurrentB",
			Tango::DEV_LONG, Tango::READ) {};
	~windingCurrentBAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_windingCurrentB(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_windingCurrentB_allowed(ty);}
};

//	Attribute windingCurrentC class definition
class windingCurrentCAttrib: public Tango::Attr
{
public:
	windingCurrentCAttrib():Attr("windingCurrentC",
			Tango::DEV_LONG, Tango::READ) {};
	~windingCurrentCAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_windingCurrentC(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_windingCurrentC_allowed(ty);}
};

//	Attribute pot class definition
class potAttrib: public Tango::Attr
{
public:
	potAttrib():Attr("pot",
			Tango::DEV_ULONG, Tango::READ) {};
	~potAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_pot(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_pot_allowed(ty);}
};

//	Attribute joy class definition
class joyAttrib: public Tango::Attr
{
public:
	joyAttrib():Attr("joy",
			Tango::DEV_ULONG, Tango::READ) {};
	~joyAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_joy(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_joy_allowed(ty);}
};

//	Attribute dutyCycle class definition
class dutyCycleAttrib: public Tango::Attr
{
public:
	dutyCycleAttrib():Attr("dutyCycle",
			Tango::DEV_LONG, Tango::READ) {};
	~dutyCycleAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_dutyCycle(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_dutyCycle_allowed(ty);}
};

//	Attribute manufacturer class definition
class manufacturerAttrib: public Tango::Attr
{
public:
	manufacturerAttrib():Attr("manufacturer",
			Tango::DEV_STRING, Tango::READ) {};
	~manufacturerAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_manufacturer(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_manufacturer_allowed(ty);}
};

//	Attribute manufacturerId class definition
class manufacturerIdAttrib: public Tango::Attr
{
public:
	manufacturerIdAttrib():Attr("manufacturerId",
			Tango::DEV_STRING, Tango::READ) {};
	~manufacturerIdAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_manufacturerId(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_manufacturerId_allowed(ty);}
};

//	Attribute ProductDescription class definition
class ProductDescriptionAttrib: public Tango::Attr
{
public:
	ProductDescriptionAttrib():Attr("ProductDescription",
			Tango::DEV_STRING, Tango::READ) {};
	~ProductDescriptionAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_ProductDescription(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_ProductDescription_allowed(ty);}
};

//	Attribute major class definition
class majorAttrib: public Tango::Attr
{
public:
	majorAttrib():Attr("major",
			Tango::DEV_ULONG, Tango::READ) {};
	~majorAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_major(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_major_allowed(ty);}
};

//	Attribute minor class definition
class minorAttrib: public Tango::Attr
{
public:
	minorAttrib():Attr("minor",
			Tango::DEV_ULONG, Tango::READ) {};
	~minorAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_minor(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_minor_allowed(ty);}
};

//	Attribute release class definition
class releaseAttrib: public Tango::Attr
{
public:
	releaseAttrib():Attr("release",
			Tango::DEV_ULONG, Tango::READ) {};
	~releaseAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_release(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_release_allowed(ty);}
};

//	Attribute serialNumber class definition
class serialNumberAttrib: public Tango::Attr
{
public:
	serialNumberAttrib():Attr("serialNumber",
			Tango::DEV_ULONG, Tango::READ) {};
	~serialNumberAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<Standa8smc4usb *>(dev))->read_serialNumber(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<Standa8smc4usb *>(dev))->is_serialNumber_allowed(ty);}
};


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

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

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

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

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

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

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

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

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

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

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

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


/**
 *	The Standa8smc4usbClass singleton definition
 */

#ifdef _TG_WINDOWS_
class __declspec(dllexport)  Standa8smc4usbClass : public Tango::DeviceClass
#else
class Standa8smc4usbClass : public Tango::DeviceClass
#endif
{
	/*----- PROTECTED REGION ID(Standa8smc4usbClass::Additionnal DServer data members) ENABLED START -----*/
	
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usbClass::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 Standa8smc4usbClass *init(const char *);
		static Standa8smc4usbClass *instance();
		~Standa8smc4usbClass();
		Tango::DbDatum	get_class_property(string &);
		Tango::DbDatum	get_default_device_property(string &);
		Tango::DbDatum	get_default_class_property(string &);
	
	protected:
		Standa8smc4usbClass(string &);
		static Standa8smc4usbClass *_instance;
		void command_factory();
		void attribute_factory(vector<Tango::Attr *> &);
		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   //	Standa8smc4usb_H