Logo Search packages:      
Sourcecode: tango version File versions  Download package

TangoTestClass.h

//=============================================================================
//
// file :         TangoTestClass.h
//
// description :  Include for the TangoTestClass  class.
//                This class is represents the singleton class for
//                the TangoTest device class.
//                It contains all properties and methods which the 
//                TangoTest requires only once e.g. the commands.
//                
// project :      TANGO Device Server
//
// $Author: taurel $
//
// Copyright (C) :      2004,2005,2006,2007,2008,2009,2010
//                                  Synchrotron SOLEIL
//                            L'Orme des Merisiers
//                            Saint-Aubin - BP 48 - France
//
// This file is part of Tango.
//
// 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/>.
//
// $Revision: 16156 $
//
// $Log$
// Revision 1.11  2010/09/10 17:21:30  nleclercq
// Added support for crash report  (i.e. google breakpad)
// Added ClassID to the cvs repository
//
// Revision 1.10  2010/03/01 16:57:18  nleclercq
// Added 64bits attributes (scalars, spectra & images)
// Tested from a 64bits Matlab session (seems to work :-)
//
// Revision 1.9  2008/02/20 16:00:34  pierrejoseph
// Add a property (UShort_image_ro_size) which determines the size of the ushort_image_ro attribute.
//
// Revision 1.8  2007/12/11 19:07:52  nleclercq
// added a "no_value" and a "throw_exception" attribute
//
// Revision 1.7  2007/12/04 11:30:40  nleclercq
// Added string spectrum and image attributes
//
// Revision 1.6  2006/03/20 15:21:51  jensmeyer
// Added some castings for porting to VC8
//
// Revision 1.5  2006/02/08 16:14:28  nleclercq
// Minor modifs in RW spectrum and image attributes
//
//
// copyleft :     Synchrotron SOLEIL
//                L'Orme des Merisiers
//                Saint-Aubin - BP 48
//
//=============================================================================
//
//          This file is generated by POGO
//    (Program Obviously used to Generate tango Object)
//
//         (c) - Software Engineering Group - ESRF
//=============================================================================

#ifndef _TANGOTESTCLASS_H
#define _TANGOTESTCLASS_H

#include <tango.h>
#include <TangoTest.h>


namespace TangoTest_ns
{
//=====================================
//    Define classes for attributes
//=====================================
00086 class ushort_image_roAttrib: public Tango::ImageAttr
{
public:
      ushort_image_roAttrib():ImageAttr("ushort_image_ro", Tango::DEV_USHORT, Tango::READ, 8192, 8192) {};
      ~ushort_image_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_ushort_image_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_ushort_image_ro_allowed(ty);}
};

00098 class ushort_imageAttrib: public Tango::ImageAttr
{
public:
      ushort_imageAttrib():ImageAttr("ushort_image", Tango::DEV_USHORT, Tango::READ_WRITE, 251, 251) {};
      ~ushort_imageAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_ushort_image(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_ushort_image(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_ushort_image_allowed(ty);}
};

00112 class ulong_image_roAttrib: public Tango::ImageAttr
{
public:
      ulong_image_roAttrib():ImageAttr("ulong_image_ro", Tango::DEV_ULONG, Tango::READ, 251, 251) {};
      ~ulong_image_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_ulong_image_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_ulong_image_ro_allowed(ty);}
};

00124 class ulong64_image_roAttrib: public Tango::ImageAttr
{
public:
      ulong64_image_roAttrib():ImageAttr("ulong64_image_ro", Tango::DEV_ULONG64, Tango::READ, 251, 251) {};
      ~ulong64_image_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_ulong64_image_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_ulong64_image_ro_allowed(ty);}
};

00136 class uchar_image_roAttrib: public Tango::ImageAttr
{
public:
      uchar_image_roAttrib():ImageAttr("uchar_image_ro", Tango::DEV_UCHAR, Tango::READ, 251, 251) {};
      ~uchar_image_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_uchar_image_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_uchar_image_ro_allowed(ty);}
};

00148 class uchar_imageAttrib: public Tango::ImageAttr
{
public:
      uchar_imageAttrib():ImageAttr("uchar_image", Tango::DEV_UCHAR, Tango::READ_WRITE, 251, 251) {};
      ~uchar_imageAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_uchar_image(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_uchar_image(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_uchar_image_allowed(ty);}
};

00162 class string_image_roAttrib: public Tango::ImageAttr
{
public:
      string_image_roAttrib():ImageAttr("string_image_ro", Tango::DEV_STRING, Tango::READ, 256, 256) {};
      ~string_image_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_string_image_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_string_image_ro_allowed(ty);}
};

00174 class string_imageAttrib: public Tango::ImageAttr
{
public:
      string_imageAttrib():ImageAttr("string_image", Tango::DEV_STRING, Tango::READ_WRITE, 256, 256) {};
      ~string_imageAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_string_image(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_string_image(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_string_image_allowed(ty);}
};

00188 class short_image_roAttrib: public Tango::ImageAttr
{
public:
      short_image_roAttrib():ImageAttr("short_image_ro", Tango::DEV_SHORT, Tango::READ, 251, 251) {};
      ~short_image_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_short_image_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_short_image_ro_allowed(ty);}
};

00200 class short_imageAttrib: public Tango::ImageAttr
{
public:
      short_imageAttrib():ImageAttr("short_image", Tango::DEV_SHORT, Tango::READ_WRITE, 251, 251) {};
      ~short_imageAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_short_image(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_short_image(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_short_image_allowed(ty);}
};

00214 class long_image_roAttrib: public Tango::ImageAttr
{
public:
      long_image_roAttrib():ImageAttr("long_image_ro", Tango::DEV_LONG, Tango::READ, 251, 251) {};
      ~long_image_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_long_image_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_long_image_ro_allowed(ty);}
};

00226 class long_imageAttrib: public Tango::ImageAttr
{
public:
      long_imageAttrib():ImageAttr("long_image", Tango::DEV_LONG, Tango::READ_WRITE, 251, 251) {};
      ~long_imageAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_long_image(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_long_image(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_long_image_allowed(ty);}
};

00240 class long64_image_roAttrib: public Tango::ImageAttr
{
public:
      long64_image_roAttrib():ImageAttr("long64_image_ro", Tango::DEV_LONG64, Tango::READ, 251, 251) {};
      ~long64_image_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_long64_image_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_long64_image_ro_allowed(ty);}
};

00252 class float_image_roAttrib: public Tango::ImageAttr
{
public:
      float_image_roAttrib():ImageAttr("float_image_ro", Tango::DEV_FLOAT, Tango::READ, 251, 251) {};
      ~float_image_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_float_image_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_float_image_ro_allowed(ty);}
};

00264 class float_imageAttrib: public Tango::ImageAttr
{
public:
      float_imageAttrib():ImageAttr("float_image", Tango::DEV_FLOAT, Tango::READ_WRITE, 251, 251) {};
      ~float_imageAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_float_image(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_float_image(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_float_image_allowed(ty);}
};

00278 class double_image_roAttrib: public Tango::ImageAttr
{
public:
      double_image_roAttrib():ImageAttr("double_image_ro", Tango::DEV_DOUBLE, Tango::READ, 251, 251) {};
      ~double_image_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_double_image_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_double_image_ro_allowed(ty);}
};

00290 class double_imageAttrib: public Tango::ImageAttr
{
public:
      double_imageAttrib():ImageAttr("double_image", Tango::DEV_DOUBLE, Tango::READ_WRITE, 251, 251) {};
      ~double_imageAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_double_image(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_double_image(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_double_image_allowed(ty);}
};

00304 class boolean_image_roAttrib: public Tango::ImageAttr
{
public:
      boolean_image_roAttrib():ImageAttr("boolean_image_ro", Tango::DEV_BOOLEAN, Tango::READ, 251, 251) {};
      ~boolean_image_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_boolean_image_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_boolean_image_ro_allowed(ty);}
};

00316 class boolean_imageAttrib: public Tango::ImageAttr
{
public:
      boolean_imageAttrib():ImageAttr("boolean_image", Tango::DEV_BOOLEAN, Tango::READ_WRITE, 251, 251) {};
      ~boolean_imageAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_boolean_image(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_boolean_image(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_boolean_image_allowed(ty);}
};

00330 class waveAttrib: public Tango::SpectrumAttr
{
public:
      waveAttrib():SpectrumAttr("wave", Tango::DEV_DOUBLE, Tango::READ, 4096) {};
      ~waveAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_wave(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_wave_allowed(ty);}
};

00342 class ushort_spectrum_roAttrib: public Tango::SpectrumAttr
{
public:
      ushort_spectrum_roAttrib():SpectrumAttr("ushort_spectrum_ro", Tango::DEV_USHORT, Tango::READ, 4096) {};
      ~ushort_spectrum_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_ushort_spectrum_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_ushort_spectrum_ro_allowed(ty);}
};

00354 class ushort_spectrumAttrib: public Tango::SpectrumAttr
{
public:
      ushort_spectrumAttrib():SpectrumAttr("ushort_spectrum", Tango::DEV_USHORT, Tango::READ_WRITE, 4096) {};
      ~ushort_spectrumAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_ushort_spectrum(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_ushort_spectrum(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_ushort_spectrum_allowed(ty);}
};

00368 class ulong_spectrum_roAttrib: public Tango::SpectrumAttr
{
public:
      ulong_spectrum_roAttrib():SpectrumAttr("ulong_spectrum_ro", Tango::DEV_ULONG, Tango::READ, 4096) {};
      ~ulong_spectrum_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_ulong_spectrum_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_ulong_spectrum_ro_allowed(ty);}
};

00380 class ulong64_spectrum_roAttrib: public Tango::SpectrumAttr
{
public:
      ulong64_spectrum_roAttrib():SpectrumAttr("ulong64_spectrum_ro", Tango::DEV_ULONG64, Tango::READ, 4096) {};
      ~ulong64_spectrum_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_ulong64_spectrum_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_ulong64_spectrum_ro_allowed(ty);}
};

00392 class uchar_spectrum_roAttrib: public Tango::SpectrumAttr
{
public:
      uchar_spectrum_roAttrib():SpectrumAttr("uchar_spectrum_ro", Tango::DEV_UCHAR, Tango::READ, 4096) {};
      ~uchar_spectrum_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_uchar_spectrum_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_uchar_spectrum_ro_allowed(ty);}
};

00404 class uchar_spectrumAttrib: public Tango::SpectrumAttr
{
public:
      uchar_spectrumAttrib():SpectrumAttr("uchar_spectrum", Tango::DEV_UCHAR, Tango::READ_WRITE, 4096) {};
      ~uchar_spectrumAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_uchar_spectrum(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_uchar_spectrum(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_uchar_spectrum_allowed(ty);}
};

00418 class string_spectrum_roAttrib: public Tango::SpectrumAttr
{
public:
      string_spectrum_roAttrib():SpectrumAttr("string_spectrum_ro", Tango::DEV_STRING, Tango::READ, 256) {};
      ~string_spectrum_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_string_spectrum_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_string_spectrum_ro_allowed(ty);}
};

00430 class string_spectrumAttrib: public Tango::SpectrumAttr
{
public:
      string_spectrumAttrib():SpectrumAttr("string_spectrum", Tango::DEV_STRING, Tango::READ_WRITE, 256) {};
      ~string_spectrumAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_string_spectrum(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_string_spectrum(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_string_spectrum_allowed(ty);}
};

00444 class short_spectrum_roAttrib: public Tango::SpectrumAttr
{
public:
      short_spectrum_roAttrib():SpectrumAttr("short_spectrum_ro", Tango::DEV_SHORT, Tango::READ, 4096) {};
      ~short_spectrum_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_short_spectrum_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_short_spectrum_ro_allowed(ty);}
};

00456 class short_spectrumAttrib: public Tango::SpectrumAttr
{
public:
      short_spectrumAttrib():SpectrumAttr("short_spectrum", Tango::DEV_SHORT, Tango::READ_WRITE, 4096) {};
      ~short_spectrumAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_short_spectrum(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_short_spectrum(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_short_spectrum_allowed(ty);}
};

00470 class long_spectrum_roAttrib: public Tango::SpectrumAttr
{
public:
      long_spectrum_roAttrib():SpectrumAttr("long_spectrum_ro", Tango::DEV_LONG, Tango::READ, 4096) {};
      ~long_spectrum_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_long_spectrum_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_long_spectrum_ro_allowed(ty);}
};

00482 class long_spectrumAttrib: public Tango::SpectrumAttr
{
public:
      long_spectrumAttrib():SpectrumAttr("long_spectrum", Tango::DEV_LONG, Tango::READ_WRITE, 4096) {};
      ~long_spectrumAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_long_spectrum(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_long_spectrum(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_long_spectrum_allowed(ty);}
};

00496 class long64_spectrum_roAttrib: public Tango::SpectrumAttr
{
public:
      long64_spectrum_roAttrib():SpectrumAttr("long64_spectrum_ro", Tango::DEV_LONG64, Tango::READ, 4096) {};
      ~long64_spectrum_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_long64_spectrum_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_long64_spectrum_ro_allowed(ty);}
};

00508 class float_spectrum_roAttrib: public Tango::SpectrumAttr
{
public:
      float_spectrum_roAttrib():SpectrumAttr("float_spectrum_ro", Tango::DEV_FLOAT, Tango::READ, 4096) {};
      ~float_spectrum_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_float_spectrum_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_float_spectrum_ro_allowed(ty);}
};

00520 class float_spectrumAttrib: public Tango::SpectrumAttr
{
public:
      float_spectrumAttrib():SpectrumAttr("float_spectrum", Tango::DEV_FLOAT, Tango::READ_WRITE, 4096) {};
      ~float_spectrumAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_float_spectrum(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_float_spectrum(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_float_spectrum_allowed(ty);}
};

00534 class double_spectrum_roAttrib: public Tango::SpectrumAttr
{
public:
      double_spectrum_roAttrib():SpectrumAttr("double_spectrum_ro", Tango::DEV_DOUBLE, Tango::READ, 4096) {};
      ~double_spectrum_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_double_spectrum_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_double_spectrum_ro_allowed(ty);}
};

00546 class double_spectrumAttrib: public Tango::SpectrumAttr
{
public:
      double_spectrumAttrib():SpectrumAttr("double_spectrum", Tango::DEV_DOUBLE, Tango::READ_WRITE, 4096) {};
      ~double_spectrumAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_double_spectrum(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_double_spectrum(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_double_spectrum_allowed(ty);}
};

00560 class boolean_spectrum_roAttrib: public Tango::SpectrumAttr
{
public:
      boolean_spectrum_roAttrib():SpectrumAttr("boolean_spectrum_ro", Tango::DEV_BOOLEAN, Tango::READ, 4096) {};
      ~boolean_spectrum_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_boolean_spectrum_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_boolean_spectrum_ro_allowed(ty);}
};

00572 class boolean_spectrumAttrib: public Tango::SpectrumAttr
{
public:
      boolean_spectrumAttrib():SpectrumAttr("boolean_spectrum", Tango::DEV_BOOLEAN, Tango::READ_WRITE, 4096) {};
      ~boolean_spectrumAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_boolean_spectrum(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_boolean_spectrum(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_boolean_spectrum_allowed(ty);}
};

00586 class ulong_scalarAttrib: public Tango::Attr
{
public:
      ulong_scalarAttrib():Attr("ulong_scalar", Tango::DEV_ULONG, Tango::READ_WRITE) {};
      ~ulong_scalarAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_ulong_scalar(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_ulong_scalar(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_ulong_scalar_allowed(ty);}
};

00600 class ushort_scalarAttrib: public Tango::Attr
{
public:
      ushort_scalarAttrib():Attr("ushort_scalar", Tango::DEV_USHORT, Tango::READ_WRITE) {};
      ~ushort_scalarAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_ushort_scalar(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_ushort_scalar(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_ushort_scalar_allowed(ty);}
};

00614 class ulong64_scalarAttrib: public Tango::Attr
{
public:
      ulong64_scalarAttrib():Attr("ulong64_scalar", Tango::DEV_ULONG64, Tango::READ_WRITE) {};
      ~ulong64_scalarAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_ulong64_scalar(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_ulong64_scalar(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_ulong64_scalar_allowed(ty);}
};

00628 class uchar_scalarAttrib: public Tango::Attr
{
public:
      uchar_scalarAttrib():Attr("uchar_scalar", Tango::DEV_UCHAR, Tango::READ_WRITE) {};
      ~uchar_scalarAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_uchar_scalar(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_uchar_scalar(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_uchar_scalar_allowed(ty);}
};

00642 class throw_exceptionAttrib: public Tango::Attr
{
public:
      throw_exceptionAttrib():Attr("throw_exception", Tango::DEV_LONG, Tango::READ) {};
      ~throw_exceptionAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_throw_exception(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_throw_exception_allowed(ty);}
};

00654 class string_scalarAttrib: public Tango::Attr
{
public:
      string_scalarAttrib():Attr("string_scalar", Tango::DEV_STRING, Tango::READ_WRITE) {};
      ~string_scalarAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_string_scalar(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_string_scalar(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_string_scalar_allowed(ty);}
};

00668 class short_scalar_wAttrib: public Tango::Attr
{
public:
      short_scalar_wAttrib():Attr("short_scalar_w", Tango::DEV_SHORT, Tango::WRITE) {};
      ~short_scalar_wAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_short_scalar_w(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_short_scalar_w(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_short_scalar_w_allowed(ty);}
};

00682 class short_scalar_rwwAttrib: public Tango::Attr
{
public:
      short_scalar_rwwAttrib():Attr("short_scalar_rww", Tango::DEV_SHORT, Tango::READ_WITH_WRITE, "short_scalar_w") {};
      ~short_scalar_rwwAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_short_scalar_rww(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_short_scalar_rww_allowed(ty);}
};

00694 class short_scalar_roAttrib: public Tango::Attr
{
public:
      short_scalar_roAttrib():Attr("short_scalar_ro", Tango::DEV_SHORT, Tango::READ) {};
      ~short_scalar_roAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_short_scalar_ro(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_short_scalar_ro_allowed(ty);}
};

00706 class short_scalarAttrib: public Tango::Attr
{
public:
      short_scalarAttrib():Attr("short_scalar", Tango::DEV_SHORT, Tango::READ_WRITE) {};
      ~short_scalarAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_short_scalar(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_short_scalar(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_short_scalar_allowed(ty);}
};

00720 class no_valueAttrib: public Tango::Attr
{
public:
      no_valueAttrib():Attr("no_value", Tango::DEV_LONG, Tango::READ) {};
      ~no_valueAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_no_value(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_no_value_allowed(ty);}
};

00732 class long_scalar_wAttrib: public Tango::Attr
{
public:
      long_scalar_wAttrib():Attr("long_scalar_w", Tango::DEV_LONG, Tango::WRITE) {};
      ~long_scalar_wAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_long_scalar_w(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_long_scalar_w(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_long_scalar_w_allowed(ty);}
};

00746 class long_scalar_rwwAttrib: public Tango::Attr
{
public:
      long_scalar_rwwAttrib():Attr("long_scalar_rww", Tango::DEV_LONG, Tango::READ_WITH_WRITE, "long_scalar_w") {};
      ~long_scalar_rwwAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_long_scalar_rww(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_long_scalar_rww_allowed(ty);}
};

00758 class long_scalarAttrib: public Tango::Attr
{
public:
      long_scalarAttrib():Attr("long_scalar", Tango::DEV_LONG, Tango::READ_WRITE) {};
      ~long_scalarAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_long_scalar(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_long_scalar(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_long_scalar_allowed(ty);}
};

00772 class long64_scalarAttrib: public Tango::Attr
{
public:
      long64_scalarAttrib():Attr("long64_scalar", Tango::DEV_LONG64, Tango::READ_WRITE) {};
      ~long64_scalarAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_long64_scalar(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_long64_scalar(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_long64_scalar_allowed(ty);}
};

00786 class float_scalarAttrib: public Tango::Attr
{
public:
      float_scalarAttrib():Attr("float_scalar", Tango::DEV_FLOAT, Tango::READ_WRITE) {};
      ~float_scalarAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_float_scalar(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_float_scalar(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_float_scalar_allowed(ty);}
};

00800 class double_scalar_wAttrib: public Tango::Attr
{
public:
      double_scalar_wAttrib():Attr("double_scalar_w", Tango::DEV_DOUBLE, Tango::WRITE) {};
      ~double_scalar_wAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_double_scalar_w(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_double_scalar_w(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_double_scalar_w_allowed(ty);}
};

00814 class double_scalar_rwwAttrib: public Tango::Attr
{
public:
      double_scalar_rwwAttrib():Attr("double_scalar_rww", Tango::DEV_DOUBLE, Tango::READ_WITH_WRITE, "double_scalar_w") {};
      ~double_scalar_rwwAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_double_scalar_rww(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_double_scalar_rww_allowed(ty);}
};

00826 class double_scalarAttrib: public Tango::Attr
{
public:
      double_scalarAttrib():Attr("double_scalar", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
      ~double_scalarAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_double_scalar(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_double_scalar(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_double_scalar_allowed(ty);}
};

00840 class boolean_scalarAttrib: public Tango::Attr
{
public:
      boolean_scalarAttrib():Attr("boolean_scalar", Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
      ~boolean_scalarAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_boolean_scalar(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_boolean_scalar(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_boolean_scalar_allowed(ty);}
};

00854 class ampliAttrib: public Tango::Attr
{
public:
      ampliAttrib():Attr("ampli", Tango::DEV_DOUBLE, Tango::WRITE) {};
      ~ampliAttrib() {};
      
      virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
      {(static_cast<TangoTest *>(dev))->read_ampli(att);}
      virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
      {(static_cast<TangoTest *>(dev))->write_ampli(att);}
      virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
      {return (static_cast<TangoTest *>(dev))->is_ampli_allowed(ty);}
};

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

      SwitchStatesClass(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~SwitchStatesClass() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
00889       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_SwitchStates_allowed(any);}
};



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

      DumpExecutionStateCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DumpExecutionStateCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
00913       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DumpExecutionState_allowed(any);}
};



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

      DevVoidCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevVoidCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
00937       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevVoid_allowed(any);}
};



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

      DevVarUShortArrayCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevVarUShortArrayCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
00961       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevVarUShortArray_allowed(any);}
};



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

      DevVarULongArrayCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevVarULongArrayCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
00985       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevVarULongArray_allowed(any);}
};



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

      DevVarULong64ArrayCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevVarULong64ArrayCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01009       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevVarULong64Array_allowed(any);}
};



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

      DevVarStringArrayCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevVarStringArrayCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01033       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevVarStringArray_allowed(any);}
};



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

      DevVarShortArrayCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevVarShortArrayCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01057       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevVarShortArray_allowed(any);}
};



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

      DevVarLongStringArrayCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevVarLongStringArrayCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01081       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevVarLongStringArray_allowed(any);}
};



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

      DevVarLongArrayCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevVarLongArrayCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01105       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevVarLongArray_allowed(any);}
};



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

      DevVarLong64ArrayCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevVarLong64ArrayCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01129       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevVarLong64Array_allowed(any);}
};



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

      DevVarFloatArrayCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevVarFloatArrayCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01153       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevVarFloatArray_allowed(any);}
};



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

      DevVarDoubleStringArrayCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevVarDoubleStringArrayCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01177       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevVarDoubleStringArray_allowed(any);}
};



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

      DevVarDoubleArrayCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevVarDoubleArrayCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01201       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevVarDoubleArray_allowed(any);}
};



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

      DevVarCharArrayCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevVarCharArrayCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01225       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevVarCharArray_allowed(any);}
};



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

      DevUShortCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevUShortCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01249       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevUShort_allowed(any);}
};



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

      DevULong64Cmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevULong64Cmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01273       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevULong64_allowed(any);}
};



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

      DevULongCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevULongCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01297       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevULong_allowed(any);}
};



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

      DevStringCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevStringCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01321       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevString_allowed(any);}
};



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

      DevShortCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevShortCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01345       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevShort_allowed(any);}
};



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

      DevLong64Cmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevLong64Cmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01369       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevLong64_allowed(any);}
};



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

      DevLongCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevLongCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01393       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevLong_allowed(any);}
};



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

      DevFloatCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevFloatCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01417       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevFloat_allowed(any);}
};



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

      DevDoubleCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevDoubleCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01441       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevDouble_allowed(any);}
};



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

      DevBooleanCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~DevBooleanCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01465       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_DevBoolean_allowed(any);}
};



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

      CrashFromOmniThreadCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~CrashFromOmniThreadCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01489       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_CrashFromOmniThread_allowed(any);}
};



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

      CrashFromDevelopperThreadCmd(const char   *name,
                     Tango::CmdArgType in,
                           Tango::CmdArgType out)
      :Command(name,in,out)   {};
      ~CrashFromDevelopperThreadCmd() {};
      
      virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
01513       virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
      {return (static_cast<TangoTest *>(dev))->is_CrashFromDevelopperThread_allowed(any);}
};



//
// The TangoTestClass singleton definition
//

01523 class
#ifdef WIN32
      __declspec(dllexport)
#endif
      TangoTestClass : public Tango::DeviceClass
{
public:
//    properties member data

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

public:
      Tango::DbData     cl_prop;
      Tango::DbData     cl_def_prop;
      Tango::DbData     dev_def_prop;

//    Method prototypes
      static TangoTestClass *init(const char *);
      static TangoTestClass *instance();
      ~TangoTestClass();
      Tango::DbDatum    get_class_property(string &);
      Tango::DbDatum    get_default_device_property(string &);
      Tango::DbDatum    get_default_class_property(string &);
      
protected:
      TangoTestClass(string &);
      static TangoTestClass *_instance;
      void command_factory();
      void get_class_property();
      void attribute_factory(vector<Tango::Attr *> &);
      void write_class_property();
      void set_default_property();
      string get_cvstag();
      string get_cvsroot();

private:
      void device_factory(const Tango::DevVarStringArray *);
};


}     //    namespace TangoTest_ns

#endif // _TANGOTESTCLASS_H

Generated by  Doxygen 1.6.0   Back to index