Standa8smc4usbStateMachine.cpp

/*----- PROTECTED REGION ID(Standa8smc4usbStateMachine.cpp) ENABLED START -----*/
static const char *RcsId = "$Id:  $";
//=============================================================================
//
// file :        Standa8smc4usbStateMachine.cpp
//
// description : State machine file for the Standa8smc4usb class
//
// 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)
//=============================================================================

#include <Standa8smc4usb.h>

/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::Standa8smc4usbStateMachine.cpp

//================================================================
//  States  |  Description
//================================================================


namespace Standa8smc4usb_ns
{
//=================================================
//		Attributes Allowed Methods
//=================================================

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_speed_allowed()
 *	Description : Execution allowed for speed attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_speed_allowed(TANGO_UNUSED(Tango::AttReqType type))
{
	//	Not any excluded states for speed attribute in Write access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::speedStateAllowed_WRITE) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::speedStateAllowed_WRITE

	//	Not any excluded states for speed attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::speedStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::speedStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_accel_allowed()
 *	Description : Execution allowed for accel attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_accel_allowed(TANGO_UNUSED(Tango::AttReqType type))
{
	//	Not any excluded states for accel attribute in Write access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::accelStateAllowed_WRITE) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::accelStateAllowed_WRITE

	//	Not any excluded states for accel attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::accelStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::accelStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_decel_allowed()
 *	Description : Execution allowed for decel attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_decel_allowed(TANGO_UNUSED(Tango::AttReqType type))
{
	//	Not any excluded states for decel attribute in Write access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::decelStateAllowed_WRITE) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::decelStateAllowed_WRITE

	//	Not any excluded states for decel attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::decelStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::decelStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_antiplaySpeed_allowed()
 *	Description : Execution allowed for antiplaySpeed attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_antiplaySpeed_allowed(TANGO_UNUSED(Tango::AttReqType type))
{
	//	Not any excluded states for antiplaySpeed attribute in Write access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::antiplaySpeedStateAllowed_WRITE) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::antiplaySpeedStateAllowed_WRITE

	//	Not any excluded states for antiplaySpeed attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::antiplaySpeedStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::antiplaySpeedStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_moveSts_allowed()
 *	Description : Execution allowed for moveSts attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_moveSts_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for moveSts attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::moveStsStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::moveStsStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_mvCmdSts_allowed()
 *	Description : Execution allowed for mvCmdSts attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_mvCmdSts_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for mvCmdSts attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::mvCmdStsStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::mvCmdStsStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_pwrSts_allowed()
 *	Description : Execution allowed for pwrSts attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_pwrSts_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for pwrSts attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::pwrStsStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::pwrStsStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_encSts_allowed()
 *	Description : Execution allowed for encSts attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_encSts_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for encSts attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::encStsStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::encStsStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_windSts_allowed()
 *	Description : Execution allowed for windSts attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_windSts_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for windSts attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::windStsStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::windStsStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_curPosition_allowed()
 *	Description : Execution allowed for curPosition attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_curPosition_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for curPosition attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::curPositionStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::curPositionStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_encPosition_allowed()
 *	Description : Execution allowed for encPosition attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_encPosition_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for encPosition attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::encPositionStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::encPositionStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_curSpeed_allowed()
 *	Description : Execution allowed for curSpeed attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_curSpeed_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for curSpeed attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::curSpeedStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::curSpeedStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_ipwr_allowed()
 *	Description : Execution allowed for ipwr attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_ipwr_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for ipwr attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::ipwrStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::ipwrStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_upwr_allowed()
 *	Description : Execution allowed for upwr attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_upwr_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for upwr attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::upwrStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::upwrStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_iusb_allowed()
 *	Description : Execution allowed for iusb attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_iusb_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for iusb attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::iusbStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::iusbStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_uusb_allowed()
 *	Description : Execution allowed for uusb attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_uusb_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for uusb attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::uusbStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::uusbStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_curT_allowed()
 *	Description : Execution allowed for curT attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_curT_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for curT attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::curTStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::curTStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_flags_allowed()
 *	Description : Execution allowed for flags attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_flags_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for flags attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::flagsStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::flagsStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_gpioFlags_allowed()
 *	Description : Execution allowed for gpioFlags attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_gpioFlags_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for gpioFlags attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::gpioFlagsStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::gpioFlagsStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_cmdBufFreeSpace_allowed()
 *	Description : Execution allowed for cmdBufFreeSpace attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_cmdBufFreeSpace_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for cmdBufFreeSpace attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::cmdBufFreeSpaceStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::cmdBufFreeSpaceStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_windingVoltageA_allowed()
 *	Description : Execution allowed for windingVoltageA attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_windingVoltageA_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for windingVoltageA attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::windingVoltageAStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::windingVoltageAStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_windingVoltageB_allowed()
 *	Description : Execution allowed for windingVoltageB attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_windingVoltageB_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for windingVoltageB attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::windingVoltageBStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::windingVoltageBStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_windingVoltageC_allowed()
 *	Description : Execution allowed for windingVoltageC attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_windingVoltageC_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for windingVoltageC attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::windingVoltageCStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::windingVoltageCStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_windingCurrentA_allowed()
 *	Description : Execution allowed for windingCurrentA attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_windingCurrentA_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for windingCurrentA attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::windingCurrentAStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::windingCurrentAStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_windingCurrentB_allowed()
 *	Description : Execution allowed for windingCurrentB attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_windingCurrentB_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for windingCurrentB attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::windingCurrentBStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::windingCurrentBStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_windingCurrentC_allowed()
 *	Description : Execution allowed for windingCurrentC attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_windingCurrentC_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for windingCurrentC attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::windingCurrentCStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::windingCurrentCStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_pot_allowed()
 *	Description : Execution allowed for pot attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_pot_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for pot attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::potStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::potStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_joy_allowed()
 *	Description : Execution allowed for joy attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_joy_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for joy attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::joyStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::joyStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_dutyCycle_allowed()
 *	Description : Execution allowed for dutyCycle attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_dutyCycle_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for dutyCycle attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::dutyCycleStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::dutyCycleStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_manufacturer_allowed()
 *	Description : Execution allowed for manufacturer attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_manufacturer_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for manufacturer attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::manufacturerStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::manufacturerStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_manufacturerId_allowed()
 *	Description : Execution allowed for manufacturerId attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_manufacturerId_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for manufacturerId attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::manufacturerIdStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::manufacturerIdStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_ProductDescription_allowed()
 *	Description : Execution allowed for ProductDescription attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_ProductDescription_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for ProductDescription attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::ProductDescriptionStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::ProductDescriptionStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_major_allowed()
 *	Description : Execution allowed for major attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_major_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for major attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::majorStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::majorStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_minor_allowed()
 *	Description : Execution allowed for minor attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_minor_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for minor attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::minorStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::minorStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_release_allowed()
 *	Description : Execution allowed for release attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_release_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for release attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::releaseStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::releaseStateAllowed_READ
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_serialNumber_allowed()
 *	Description : Execution allowed for serialNumber attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_serialNumber_allowed(TANGO_UNUSED(Tango::AttReqType type))
{

	//	Not any excluded states for serialNumber attribute in read access.
	/*----- PROTECTED REGION ID(Standa8smc4usb::serialNumberStateAllowed_READ) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::serialNumberStateAllowed_READ
	return true;
}

//=================================================
//		Commands Allowed Methods
//=================================================

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_Left_allowed()
 *	Description : Execution allowed for Left attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_Left_allowed(TANGO_UNUSED(const CORBA::Any &any))
{
	//	Not any excluded states for Left command.
	/*----- PROTECTED REGION ID(Standa8smc4usb::LeftStateAllowed) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::LeftStateAllowed
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_Right_allowed()
 *	Description : Execution allowed for Right attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_Right_allowed(TANGO_UNUSED(const CORBA::Any &any))
{
	//	Not any excluded states for Right command.
	/*----- PROTECTED REGION ID(Standa8smc4usb::RightStateAllowed) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::RightStateAllowed
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_Stop_allowed()
 *	Description : Execution allowed for Stop attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_Stop_allowed(TANGO_UNUSED(const CORBA::Any &any))
{
	//	Not any excluded states for Stop command.
	/*----- PROTECTED REGION ID(Standa8smc4usb::StopStateAllowed) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::StopStateAllowed
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_Sstop_allowed()
 *	Description : Execution allowed for Sstop attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_Sstop_allowed(TANGO_UNUSED(const CORBA::Any &any))
{
	//	Not any excluded states for Sstop command.
	/*----- PROTECTED REGION ID(Standa8smc4usb::SstopStateAllowed) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::SstopStateAllowed
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_Move_allowed()
 *	Description : Execution allowed for Move attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_Move_allowed(TANGO_UNUSED(const CORBA::Any &any))
{
	//	Not any excluded states for Move command.
	/*----- PROTECTED REGION ID(Standa8smc4usb::MoveStateAllowed) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::MoveStateAllowed
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_Mover_allowed()
 *	Description : Execution allowed for Mover attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_Mover_allowed(TANGO_UNUSED(const CORBA::Any &any))
{
	//	Not any excluded states for Mover command.
	/*----- PROTECTED REGION ID(Standa8smc4usb::MoverStateAllowed) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::MoverStateAllowed
	return true;
}

//--------------------------------------------------------
/**
 *	Method      : Standa8smc4usb::is_Home_allowed()
 *	Description : Execution allowed for Home attribute
 */
//--------------------------------------------------------
bool Standa8smc4usb::is_Home_allowed(TANGO_UNUSED(const CORBA::Any &any))
{
	//	Not any excluded states for Home command.
	/*----- PROTECTED REGION ID(Standa8smc4usb::HomeStateAllowed) ENABLED START -----*/
	
	/*----- PROTECTED REGION END -----*/	//	Standa8smc4usb::HomeStateAllowed
	return true;
}

}	//	End of namespace