AlarmHandlerClass.h

/*----- PROTECTED REGION ID(AlarmHandlerClass.h) ENABLED START -----*/
//=============================================================================
//
// file :        AlarmHandlerClass.h
//
// description : Include for the AlarmHandler root class.
//               This class is the singleton class for
//                the AlarmHandler device class.
//               It contains all properties and methods which the 
//               AlarmHandler requires only once e.g. the commands.
//
// project :     Elettra alarm handler device server
//
// 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/>.
// 
//
//
//=============================================================================
//                This file is generated by POGO
//        (Program Obviously used to Generate tango Object)
//=============================================================================


#ifndef AlarmHandlerClass_H
#define AlarmHandlerClass_H

#include <tango.h>
#include <AlarmHandler.h>


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


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


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

//=========================================
//	Define classes for attributes
//=========================================
//	Attribute alarmAudible class definition
class alarmAudibleAttrib: public Tango::Attr
{
public:
	alarmAudibleAttrib():Attr("alarmAudible",
			Tango::DEV_BOOLEAN, Tango::READ) {};
	~alarmAudibleAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_alarmAudible(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_alarmAudible_allowed(ty);}
};

//	Attribute StatisticsResetTime class definition
class StatisticsResetTimeAttrib: public Tango::Attr
{
public:
	StatisticsResetTimeAttrib():Attr("StatisticsResetTime",
			Tango::DEV_DOUBLE, Tango::READ) {};
	~StatisticsResetTimeAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_StatisticsResetTime(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_StatisticsResetTime_allowed(ty);}
};

//	Attribute alarm class definition
class alarmAttrib: public Tango::SpectrumAttr
{
public:
	alarmAttrib():SpectrumAttr("alarm",
			Tango::DEV_STRING, Tango::READ, 1024) {};
	~alarmAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_alarm(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_alarm_allowed(ty);}
};

//	Attribute alarmNormal class definition
class alarmNormalAttrib: public Tango::SpectrumAttr
{
public:
	alarmNormalAttrib():SpectrumAttr("alarmNormal",
			Tango::DEV_STRING, Tango::READ, 10000) {};
	~alarmNormalAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_alarmNormal(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_alarmNormal_allowed(ty);}
};

//	Attribute alarmUnacknowledged class definition
class alarmUnacknowledgedAttrib: public Tango::SpectrumAttr
{
public:
	alarmUnacknowledgedAttrib():SpectrumAttr("alarmUnacknowledged",
			Tango::DEV_STRING, Tango::READ, 10000) {};
	~alarmUnacknowledgedAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_alarmUnacknowledged(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_alarmUnacknowledged_allowed(ty);}
};

//	Attribute alarmAcknowledged class definition
class alarmAcknowledgedAttrib: public Tango::SpectrumAttr
{
public:
	alarmAcknowledgedAttrib():SpectrumAttr("alarmAcknowledged",
			Tango::DEV_STRING, Tango::READ, 10000) {};
	~alarmAcknowledgedAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_alarmAcknowledged(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_alarmAcknowledged_allowed(ty);}
};

//	Attribute alarmUnacknowledgedNormal class definition
class alarmUnacknowledgedNormalAttrib: public Tango::SpectrumAttr
{
public:
	alarmUnacknowledgedNormalAttrib():SpectrumAttr("alarmUnacknowledgedNormal",
			Tango::DEV_STRING, Tango::READ, 10000) {};
	~alarmUnacknowledgedNormalAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_alarmUnacknowledgedNormal(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_alarmUnacknowledgedNormal_allowed(ty);}
};

//	Attribute alarmShelved class definition
class alarmShelvedAttrib: public Tango::SpectrumAttr
{
public:
	alarmShelvedAttrib():SpectrumAttr("alarmShelved",
			Tango::DEV_STRING, Tango::READ, 10000) {};
	~alarmShelvedAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_alarmShelved(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_alarmShelved_allowed(ty);}
};

//	Attribute alarmOutOfService class definition
class alarmOutOfServiceAttrib: public Tango::SpectrumAttr
{
public:
	alarmOutOfServiceAttrib():SpectrumAttr("alarmOutOfService",
			Tango::DEV_STRING, Tango::READ, 10000) {};
	~alarmOutOfServiceAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_alarmOutOfService(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_alarmOutOfService_allowed(ty);}
};

//	Attribute alarmSilenced class definition
class alarmSilencedAttrib: public Tango::SpectrumAttr
{
public:
	alarmSilencedAttrib():SpectrumAttr("alarmSilenced",
			Tango::DEV_STRING, Tango::READ, 10000) {};
	~alarmSilencedAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_alarmSilenced(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_alarmSilenced_allowed(ty);}
};

//	Attribute alarmList class definition
class alarmListAttrib: public Tango::SpectrumAttr
{
public:
	alarmListAttrib():SpectrumAttr("alarmList",
			Tango::DEV_STRING, Tango::READ, 10000) {};
	~alarmListAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_alarmList(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_alarmList_allowed(ty);}
};

//	Attribute alarmFrequency class definition
class alarmFrequencyAttrib: public Tango::SpectrumAttr
{
public:
	alarmFrequencyAttrib():SpectrumAttr("alarmFrequency",
			Tango::DEV_DOUBLE, Tango::READ, 10000) {};
	~alarmFrequencyAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_alarmFrequency(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_alarmFrequency_allowed(ty);}
};

//	Attribute alarmSummary class definition
class alarmSummaryAttrib: public Tango::SpectrumAttr
{
public:
	alarmSummaryAttrib():SpectrumAttr("alarmSummary",
			Tango::DEV_STRING, Tango::READ, 10000) {};
	~alarmSummaryAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_alarmSummary(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_alarmSummary_allowed(ty);}
};

//	Attribute eventList class definition
class eventListAttrib: public Tango::SpectrumAttr
{
public:
	eventListAttrib():SpectrumAttr("eventList",
			Tango::DEV_STRING, Tango::READ, 10000) {};
	~eventListAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_eventList(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_eventList_allowed(ty);}
};

//	Attribute eventSummary class definition
class eventSummaryAttrib: public Tango::SpectrumAttr
{
public:
	eventSummaryAttrib():SpectrumAttr("eventSummary",
			Tango::DEV_STRING, Tango::READ, 10000) {};
	~eventSummaryAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_eventSummary(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_eventSummary_allowed(ty);}
};


//=========================================
//	Define classes for dynamic attributes
//=========================================
//	Attribute AlarmState class definition
class AlarmStateAttrib: public Tango::Attr
{
public:
	AlarmStateAttrib(const string &att_name):Attr(att_name.c_str(), 
			Tango::DEV_ENUM, Tango::READ) {};
	~AlarmStateAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_AlarmState(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_AlarmState_allowed(ty);}
	virtual bool same_type(const type_info &in_type) {return typeid(AlarmStateEnum) == in_type;}
	virtual string get_enum_type() {return string("AlarmStateEnum");}
};

//	Attribute AlarmFormula class definition
class AlarmFormulaAttrib: public Tango::Attr
{
public:
	AlarmFormulaAttrib(const string &att_name):Attr(att_name.c_str(), 
			Tango::DEV_STRING, Tango::READ) {};
	~AlarmFormulaAttrib() {};
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<AlarmHandler *>(dev))->read_AlarmFormula(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<AlarmHandler *>(dev))->is_AlarmFormula_allowed(ty);}
};


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/**
 *	The AlarmHandlerClass singleton definition
 */

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

	//	Class properties data members
	public:
		//	GroupNames:	Labels for Group mask, first is for mask 0x00
		vector<string>	groupNames;
		//	SubscribeRetryPeriod:	Retry subscription period in seconds
		Tango::DevLong	subscribeRetryPeriod;
		//	StatisticsTimeWindow:	Time window to compute statistics in seconds
		vector<Tango::DevLong>	statisticsTimeWindow;
		//	ErrorDelay:	Delay in seconds before changing to ERROR state after an exception is received.
		Tango::DevULong	errorDelay;
	public:
		//	write class properties data members
		Tango::DbData	cl_prop;
		Tango::DbData	cl_def_prop;
		Tango::DbData	dev_def_prop;
	
		//	Method prototypes
		static AlarmHandlerClass *init(const char *);
		static AlarmHandlerClass *instance();
		~AlarmHandlerClass();
		Tango::DbDatum	get_class_property(string &);
		Tango::DbDatum	get_default_device_property(string &);
		Tango::DbDatum	get_default_class_property(string &);
	
	protected:
		AlarmHandlerClass(string &);
		static AlarmHandlerClass *_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   //	AlarmHandler_H