//=============================================================================
//
// file :         SpectrumAnalyzerClass.h
//
// description :  Include for the SpectrumAnalyzerClass root class.
//                This class is represents the singleton class for
//                the SpectrumAnalyzer device class.
//                It contains all properties and methods which the 
//                SpectrumAnalyzer requires only once e.g. the commands.
//			
// project :      TANGO Device Server
//
// $Author: claudio $
//
// $Revision: 1.1 $
//
// $Log: SpectrumAnalyzerClass.h,v $
// Revision 1.1  2008/04/23 12:27:46  claudio
// first import
//
//
// copyleft :     European Synchrotron Radiation Facility
//                BP 220, Grenoble 38043
//                FRANCE
//
//=============================================================================
//
//  		This file is generated by POGO
//	(Program Obviously used to Generate tango Object)
//
//         (c) - Software Engineering Group - ESRF
//=============================================================================

#ifndef _SPECTRUMANALYZERCLASS_H
#define _SPECTRUMANALYZERCLASS_H

#include <tango.h>
#include <SpectrumAnalyzer.h>
#include <SpectrumAnalyzer.h>


namespace SpectrumAnalyzer_ns
{
//=====================================
//	Define classes for attributes
//=====================================
class NumberOfSweepsAttrib: public Tango::Attr
{
public:
	NumberOfSweepsAttrib():Attr("NumberOfSweeps", Tango::DEV_LONG, Tango::READ_WRITE) {};
	~NumberOfSweepsAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_NumberOfSweeps(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_NumberOfSweeps(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_NumberOfSweeps_allowed(ty);}
};

class WindowAttrib: public Tango::Attr
{
public:
	WindowAttrib():Attr("Window", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~WindowAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_Window(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_Window(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_Window_allowed(ty);}
};

class WindowFsAttrib: public Tango::Attr
{
public:
	WindowFsAttrib():Attr("WindowFs", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~WindowFsAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_WindowFs(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_WindowFs(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_WindowFs_allowed(ty);}
};

class FsAttrib: public Tango::Attr
{
public:
	FsAttrib():Attr("Fs", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~FsAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_Fs(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_Fs(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_Fs_allowed(ty);}
};

class GetSignalPeaksAttrib: public Tango::SpectrumAttr
{
public:
	GetSignalPeaksAttrib():SpectrumAttr("GetSignalPeaks", Tango::DEV_DOUBLE, Tango::READ, 100) {};
	~GetSignalPeaksAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_GetSignalPeaks(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_GetSignalPeaks_allowed(ty);}
};

class PeakExcursionAttrib: public Tango::Attr
{
public:
	PeakExcursionAttrib():Attr("PeakExcursion", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~PeakExcursionAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_PeakExcursion(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_PeakExcursion(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_PeakExcursion_allowed(ty);}
};

class PeakThresholdAttrib: public Tango::Attr
{
public:
	PeakThresholdAttrib():Attr("PeakThreshold", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~PeakThresholdAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_PeakThreshold(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_PeakThreshold(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_PeakThreshold_allowed(ty);}
};

class ResolutionBandwidthAttrib: public Tango::Attr
{
public:
	ResolutionBandwidthAttrib():Attr("ResolutionBandwidth", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~ResolutionBandwidthAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_ResolutionBandwidth(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_ResolutionBandwidth(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_ResolutionBandwidth_allowed(ty);}
};

class OPCAttrib: public Tango::Attr
{
public:
	OPCAttrib():Attr("OPC", Tango::DEV_SHORT, Tango::READ_WRITE) {};
	~OPCAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_OPC(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_OPC(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_OPC_allowed(ty);}
};

class TraceInt32Attrib: public Tango::SpectrumAttr
{
public:
	TraceInt32Attrib():SpectrumAttr("TraceInt32", Tango::DEV_LONG, Tango::READ, 401) {};
	~TraceInt32Attrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_TraceInt32(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_TraceInt32_allowed(ty);}
};

class TraceReal32Attrib: public Tango::SpectrumAttr
{
public:
	TraceReal32Attrib():SpectrumAttr("TraceReal32", Tango::DEV_DOUBLE, Tango::READ, 401) {};
	~TraceReal32Attrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_TraceReal32(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_TraceReal32_allowed(ty);}
};

class StartStopAttrib: public Tango::SpectrumAttr
{
public:
	StartStopAttrib():SpectrumAttr("StartStop", Tango::DEV_DOUBLE, Tango::READ_WRITE, 2) {};
	~StartStopAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_StartStop(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_StartStop(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_StartStop_allowed(ty);}
};

class ReferenceLevelAttrib: public Tango::Attr
{
public:
	ReferenceLevelAttrib():Attr("ReferenceLevel", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~ReferenceLevelAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_ReferenceLevel(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_ReferenceLevel(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_ReferenceLevel_allowed(ty);}
};

class FreqOffsetAttrib: public Tango::Attr
{
public:
	FreqOffsetAttrib():Attr("FreqOffset", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~FreqOffsetAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_FreqOffset(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_FreqOffset(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_FreqOffset_allowed(ty);}
};

class StopFrequencyAttrib: public Tango::Attr
{
public:
	StopFrequencyAttrib():Attr("StopFrequency", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~StopFrequencyAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_StopFrequency(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_StopFrequency(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_StopFrequency_allowed(ty);}
};

class StartFrequencyAttrib: public Tango::Attr
{
public:
	StartFrequencyAttrib():Attr("StartFrequency", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~StartFrequencyAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_StartFrequency(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_StartFrequency(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_StartFrequency_allowed(ty);}
};

class DetectorTypeAttrib: public Tango::Attr
{
public:
	DetectorTypeAttrib():Attr("DetectorType", Tango::DEV_STRING, Tango::READ_WRITE) {};
	~DetectorTypeAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_DetectorType(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_DetectorType(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_DetectorType_allowed(ty);}
};

class AttenuationAttrib: public Tango::Attr
{
public:
	AttenuationAttrib():Attr("Attenuation", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~AttenuationAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_Attenuation(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_Attenuation(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_Attenuation_allowed(ty);}
};

class ErrorPollingAttrib: public Tango::Attr
{
public:
	ErrorPollingAttrib():Attr("ErrorPolling", Tango::DEV_STRING, Tango::READ) {};
	~ErrorPollingAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_ErrorPolling(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_ErrorPolling_allowed(ty);}
};

class MarkerYAttrib: public Tango::Attr
{
public:
	MarkerYAttrib():Attr("MarkerY", Tango::DEV_DOUBLE, Tango::READ) {};
	~MarkerYAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_MarkerY(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_MarkerY_allowed(ty);}
};

class MarkerXAttrib: public Tango::Attr
{
public:
	MarkerXAttrib():Attr("MarkerX", Tango::DEV_DOUBLE, Tango::READ) {};
	~MarkerXAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_MarkerX(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_MarkerX_allowed(ty);}
};

class CenterFrequencyAttrib: public Tango::Attr
{
public:
	CenterFrequencyAttrib():Attr("CenterFrequency", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~CenterFrequencyAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_CenterFrequency(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_CenterFrequency(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_CenterFrequency_allowed(ty);}
};

class SpanAttrib: public Tango::Attr
{
public:
	SpanAttrib():Attr("Span", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
	~SpanAttrib() {};
	
	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->read_Span(att);}
	virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
	{(static_cast<SpectrumAnalyzer *>(dev))->write_Span(att);}
	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
	{return (static_cast<SpectrumAnalyzer *>(dev))->is_Span_allowed(ty);}
};

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

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



class SaveDataClass : public Tango::Command
{
public:
	SaveDataClass(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)	{};

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



class GetDataFormatClass : public Tango::Command
{
public:
	GetDataFormatClass(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)	{};

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



class SetReal32DataClass : public Tango::Command
{
public:
	SetReal32DataClass(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)	{};

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



class SetINT32DataClass : public Tango::Command
{
public:
	SetINT32DataClass(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)	{};

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



class SetAsciiDataClass : public Tango::Command
{
public:
	SetAsciiDataClass(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)	{};

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



class GetAutoAttenuationClass : public Tango::Command
{
public:
	GetAutoAttenuationClass(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)	{};

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



class SetAutoAttenuationClass : public Tango::Command
{
public:
	SetAutoAttenuationClass(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)	{};

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



class RestartMeasurementClass : public Tango::Command
{
public:
	RestartMeasurementClass(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)	{};

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



class SetContinuousSweepClass : public Tango::Command
{
public:
	SetContinuousSweepClass(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)	{};

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



class GetMinClass : public Tango::Command
{
public:
	GetMinClass(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)	{};

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



class GetErrorInfoClass : public Tango::Command
{
public:
	GetErrorInfoClass(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)	{};

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



class ChangePowUnitsClass : public Tango::Command
{
public:
	ChangePowUnitsClass(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)	{};

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



class SetSingleSweepClass : public Tango::Command
{
public:
	SetSingleSweepClass(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)	{};

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



class GetPeakClass : public Tango::Command
{
public:
	GetPeakClass(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)	{};

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



class LocalClass : public Tango::Command
{
public:
	LocalClass(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)	{};

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



class RemoteClass : public Tango::Command
{
public:
	RemoteClass(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)	{};

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



class ClearStatusClass : public Tango::Command
{
public:
	ClearStatusClass(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)	{};

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



class ResetClass : public Tango::Command
{
public:
	ResetClass(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)	{};

	ResetClass(const char   *name,
	               Tango::CmdArgType in,
				   Tango::CmdArgType out)
	:Command(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<SpectrumAnalyzer *>(dev))->is_Reset_allowed(any);}
};



//
// The SpectrumAnalyzerClass singleton definition
//

class SpectrumAnalyzerClass : public Tango::DeviceClass
{
public:

//	add your own data members here
//------------------------------------

public:

protected:
	SpectrumAnalyzerClass(string &);
	void command_factory();
	void attribute_factory(vector<Tango::Attr *> &);

private:
};


}	//	namespace SpectrumAnalyzer_ns

#endif // _SPECTRUMANALYZERCLASS_H