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

#include <tango/tango.h>
#include "SimulatedE2PS.h"

/* clang-format off */
/*----- PROTECTED REGION END -----*/	//	SimulatedE2PSClass.h


namespace SimulatedE2PS_ns
{
/*----- PROTECTED REGION ID(SimulatedE2PSClass::classes for dynamic creation) ENABLED START -----*/
/* clang-format on */

/* clang-format off */
/*----- PROTECTED REGION END -----*/	//	SimulatedE2PSClass::classes for dynamic creation

//=========================================
//	Define classes for attributes
//=========================================
//	Attribute current class definition
class currentAttrib: public Tango::Attr
{
public:
	currentAttrib():Attr("current",
			Tango::DEV_DOUBLE, Tango::READ_WRITE) {}
	~currentAttrib() {}
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<SimulatedE2PS *>(dev))->read_current(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<SimulatedE2PS *>(dev))->write_current(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<SimulatedE2PS *>(dev))->is_current_allowed(ty);}
};

//	Attribute voltage class definition
class voltageAttrib: public Tango::Attr
{
public:
	voltageAttrib():Attr("voltage",
			Tango::DEV_DOUBLE, Tango::READ) {}
	~voltageAttrib() {}
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<SimulatedE2PS *>(dev))->read_voltage(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<SimulatedE2PS *>(dev))->is_voltage_allowed(ty);}
};

//	Attribute currentSet class definition
class currentSetAttrib: public Tango::Attr
{
public:
	currentSetAttrib():Attr("currentSet",
			Tango::DEV_DOUBLE, Tango::READ) {}
	~currentSetAttrib() {}
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<SimulatedE2PS *>(dev))->read_currentSet(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<SimulatedE2PS *>(dev))->is_currentSet_allowed(ty);}
};

//	Attribute CurrentRipple class definition
class CurrentRippleAttrib: public Tango::Attr
{
public:
	CurrentRippleAttrib():Attr("CurrentRipple",
			Tango::DEV_DOUBLE, Tango::READ_WRITE) {}
	~CurrentRippleAttrib() {}
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<SimulatedE2PS *>(dev))->read_CurrentRipple(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<SimulatedE2PS *>(dev))->write_CurrentRipple(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<SimulatedE2PS *>(dev))->is_CurrentRipple_allowed(ty);}
};

//	Attribute AddRipple class definition
class AddRippleAttrib: public Tango::Attr
{
public:
	AddRippleAttrib():Attr("AddRipple",
			Tango::DEV_BOOLEAN, Tango::READ_WRITE) {}
	~AddRippleAttrib() {}
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
		{(static_cast<SimulatedE2PS *>(dev))->read_AddRipple(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
		{(static_cast<SimulatedE2PS *>(dev))->write_AddRipple(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
		{return (static_cast<SimulatedE2PS *>(dev))->is_AddRipple_allowed(ty);}
};


//=========================================
//	Define classes for commands
//=========================================
//	Command On class definition
class OnClass : public Tango::Command
{
public:
	OnClass(const char   *cmd_name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out,
				   const char        *in_desc,
				   const char        *out_desc,
				   Tango::DispLevel  level)
	:Command(cmd_name,in,out,in_desc,out_desc, level)	{}

	OnClass(const char   *cmd_name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(cmd_name,in,out)	{}
	~OnClass() {}

	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<SimulatedE2PS *>(dev))->is_On_allowed(any);}
};

//	Command Off class definition
class OffClass : public Tango::Command
{
public:
	OffClass(const char   *cmd_name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out,
				   const char        *in_desc,
				   const char        *out_desc,
				   Tango::DispLevel  level)
	:Command(cmd_name,in,out,in_desc,out_desc, level)	{}

	OffClass(const char   *cmd_name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(cmd_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<SimulatedE2PS *>(dev))->is_Off_allowed(any);}
};

//	Command Reset class definition
class ResetClass : public Tango::Command
{
public:
	ResetClass(const char   *cmd_name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out,
				   const char        *in_desc,
				   const char        *out_desc,
				   Tango::DispLevel  level)
	:Command(cmd_name,in,out,in_desc,out_desc, level)	{}

	ResetClass(const char   *cmd_name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(cmd_name,in,out)	{}
	~ResetClass() {}

	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<SimulatedE2PS *>(dev))->is_Reset_allowed(any);}
};

//	Command StartCycling class definition
class StartCyclingClass : public Tango::Command
{
public:
	StartCyclingClass(const char   *cmd_name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out,
				   const char        *in_desc,
				   const char        *out_desc,
				   Tango::DispLevel  level)
	:Command(cmd_name,in,out,in_desc,out_desc, level)	{}

	StartCyclingClass(const char   *cmd_name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(cmd_name,in,out)	{}
	~StartCyclingClass() {}

	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<SimulatedE2PS *>(dev))->is_StartCycling_allowed(any);}
};

//	Command Abort class definition
class AbortClass : public Tango::Command
{
public:
	AbortClass(const char   *cmd_name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out,
				   const char        *in_desc,
				   const char        *out_desc,
				   Tango::DispLevel  level)
	:Command(cmd_name,in,out,in_desc,out_desc, level)	{}

	AbortClass(const char   *cmd_name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(cmd_name,in,out)	{}
	~AbortClass() {}

	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<SimulatedE2PS *>(dev))->is_Abort_allowed(any);}
};

//	Command Fault class definition
class FaultClass : public Tango::Command
{
public:
	FaultClass(const char   *cmd_name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out,
				   const char        *in_desc,
				   const char        *out_desc,
				   Tango::DispLevel  level)
	:Command(cmd_name,in,out,in_desc,out_desc, level)	{}

	FaultClass(const char   *cmd_name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(cmd_name,in,out)	{}
	~FaultClass() {}

	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<SimulatedE2PS *>(dev))->is_Fault_allowed(any);}
};


/**
 *	The SimulatedE2PSClass singleton definition
 */

#ifdef _TG_WINDOWS_
class __declspec(dllexport)  SimulatedE2PSClass : public Tango::DeviceClass
#else
class SimulatedE2PSClass : public Tango::DeviceClass
#endif
{
	/*----- PROTECTED REGION ID(SimulatedE2PSClass::Additional DServer data members) ENABLED START -----*/
	/* clang-format on */
	//	Add your own code
	/* clang-format off */
	/*----- PROTECTED REGION END -----*/	//	SimulatedE2PSClass::Additional 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 SimulatedE2PSClass *init(const char *);
		static SimulatedE2PSClass *instance();
		~SimulatedE2PSClass();
		Tango::DbDatum	get_class_property(std::string &);
		Tango::DbDatum	get_default_device_property(std::string &);
		Tango::DbDatum	get_default_class_property(std::string &);

	protected:
		SimulatedE2PSClass(std::string &);
		static SimulatedE2PSClass *_instance;
		void command_factory();
		void attribute_factory(std::vector<Tango::Attr *> &);
		void pipe_factory();
		void write_class_property();
		void set_default_property();
		void get_class_property();
		std::string get_cvstag();
		std::string get_cvsroot();

	private:
		void device_factory(TANGO_UNUSED(const Tango::DevVarStringArray *));
		void create_static_attribute_list(std::vector<Tango::Attr *> &);
		void erase_dynamic_attributes(const Tango::DevVarStringArray *,std::vector<Tango::Attr *> &);
		std::vector<std::string>	defaultAttList;
		Tango::Attr *get_attr_object_by_name(std::vector<Tango::Attr *> &att_list, std::string attname);
};

}	//	End of namespace

#endif   //	SimulatedE2PS_H