src/DiffractometerDeviceClass.h

   1 //=============================================================================
   2 //
   3 // file :         DiffractometerDeviceClass.h
   4 //
   5 // description :  Include for the DiffractometerDeviceClass root class.
   6 //                This class is represents the singleton class for
   7 //                the DiffractometerDevice device class.
   8 //                It contains all properties and methods which the
   9 //                DiffractometerDevice requires only once e.g. the commands.
  10 //
  11 // project :      TANGO Device Server
  12 //
  13 // $Author: vince_soleil $
  14 //
  15 // $Revision: 1.4 $
  16 //
  17 // $Log: DiffractometerDeviceClass.h,v $
  18 // Revision 1.4  2008/09/22 16:20:35  vince_soleil
  19 // Set first character of attribute name in minus
  20 //
  21 // Revision 1.3  2008/09/22 10:26:44  vince_soleil
  22 // * change dimension of attribute CrystalReflections" (6+6=11 !!)
  23 //
  24 // Revision 1.2  2008/09/22 08:46:25  piccaf
  25 // * add files from the new diffractometer Device
  26 //
  27 //
  28 // copyleft :     European Synchrotron Radiation Facility
  29 //                BP 220, Grenoble 38043
  30 //                FRANCE
  31 //
  32 //=============================================================================
  33 //
  34 //              This file is generated by POGO
  35 //      (Program Obviously used to Generate tango Object)
  36 //
  37 //         (c) - Software Engineering Group - ESRF
  38 //=============================================================================
  39
  40 #ifndef _DIFFRACTOMETERDEVICECLASS_H
  41 #define _DIFFRACTOMETERDEVICECLASS_H
  42
  43 #include <tango.h>
  44 #include <DiffractometerDevice.h>
  45
  46
  47 namespace DiffractometerDevice_ns
  48 {//=====================================
  49 //      Define classes for attributes
  50 //=====================================
  51 class UBAttrib: public Tango::ImageAttr
  52 {
  53 public:
  54         UBAttrib():ImageAttr("UB", Tango::DEV_DOUBLE, Tango::READ, 3, 3) {};
  55         ~UBAttrib() {};
  56
  57         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
  58         {(static_cast<DiffractometerDevice *>(dev))->read_UB(att);}
  59         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
  60         {return (static_cast<DiffractometerDevice *>(dev))->is_UB_allowed(ty);}
  61 };
  62
  63 class ReflectionsAnglesAttrib: public Tango::ImageAttr
  64 {
  65 public:
  66         ReflectionsAnglesAttrib():ImageAttr("ReflectionsAngles", Tango::DEV_DOUBLE, Tango::READ, 2000, 2000) {};
  67         ~ReflectionsAnglesAttrib() {};
  68
  69         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
  70         {(static_cast<DiffractometerDevice *>(dev))->read_ReflectionsAngles(att);}
  71         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
  72         {return (static_cast<DiffractometerDevice *>(dev))->is_ReflectionsAngles_allowed(ty);}
  73 };
  74
  75 class ReflectionsAttrib: public Tango::ImageAttr
  76 {
  77 public:
  78         ReflectionsAttrib():ImageAttr("Reflections", Tango::DEV_DOUBLE, Tango::READ_WRITE, 12, 50) {};
  79         ~ReflectionsAttrib() {};
  80
  81         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
  82         {(static_cast<DiffractometerDevice *>(dev))->read_Reflections(att);}
  83         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
  84         {(static_cast<DiffractometerDevice *>(dev))->write_Reflections(att);}
  85         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
  86         {return (static_cast<DiffractometerDevice *>(dev))->is_Reflections_allowed(ty);}
  87 };
  88
  89 class CrystalReflectionsAttrib: public Tango::ImageAttr
  90 {
  91 public:
  92         CrystalReflectionsAttrib():ImageAttr("CrystalReflections", Tango::DEV_DOUBLE, Tango::READ, 12, 50) {};
  93         ~CrystalReflectionsAttrib() {};
  94
  95         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
  96         {(static_cast<DiffractometerDevice *>(dev))->read_CrystalReflections(att);}
  97         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
  98         {return (static_cast<DiffractometerDevice *>(dev))->is_CrystalReflections_allowed(ty);}
  99 };
 100
 101 class ComputedAnglesAttrib: public Tango::ImageAttr
 102 {
 103 public:
 104         ComputedAnglesAttrib():ImageAttr("ComputedAngles", Tango::DEV_DOUBLE, Tango::READ, 20, 1000) {};
 105         ~ComputedAnglesAttrib() {};
 106
 107         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 108         {(static_cast<DiffractometerDevice *>(dev))->read_ComputedAngles(att);}
 109         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 110         {return (static_cast<DiffractometerDevice *>(dev))->is_ComputedAngles_allowed(ty);}
 111 };
 112
 113 class AnglesRangeCheckAttrib: public Tango::ImageAttr
 114 {
 115 public:
 116         AnglesRangeCheckAttrib():ImageAttr("AnglesRangeCheck", Tango::DEV_BOOLEAN, Tango::READ, 20, 1000) {};
 117         ~AnglesRangeCheckAttrib() {};
 118
 119         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 120         {(static_cast<DiffractometerDevice *>(dev))->read_AnglesRangeCheck(att);}
 121         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 122         {return (static_cast<DiffractometerDevice *>(dev))->is_AnglesRangeCheck_allowed(ty);}
 123 };
 124
 125 class AnglesDegeneratedAttrib: public Tango::ImageAttr
 126 {
 127 public:
 128         AnglesDegeneratedAttrib():ImageAttr("AnglesDegenerated", Tango::DEV_BOOLEAN, Tango::READ, 20, 1000) {};
 129         ~AnglesDegeneratedAttrib() {};
 130
 131         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 132         {(static_cast<DiffractometerDevice *>(dev))->read_AnglesDegenerated(att);}
 133         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 134         {return (static_cast<DiffractometerDevice *>(dev))->is_AnglesDegenerated_allowed(ty);}
 135 };
 136
 137 class AnglesAttrib: public Tango::ImageAttr
 138 {
 139 public:
 140         AnglesAttrib():ImageAttr("Angles", Tango::DEV_DOUBLE, Tango::READ, 20, 1000) {};
 141         ~AnglesAttrib() {};
 142
 143         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 144         {(static_cast<DiffractometerDevice *>(dev))->read_Angles(att);}
 145         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 146         {return (static_cast<DiffractometerDevice *>(dev))->is_Angles_allowed(ty);}
 147 };
 148
 149 class ModeNamesAttrib: public Tango::SpectrumAttr
 150 {
 151 public:
 152         ModeNamesAttrib():SpectrumAttr("ModeNames", Tango::DEV_STRING, Tango::READ, 10) {};
 153         ~ModeNamesAttrib() {};
 154
 155         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 156         {(static_cast<DiffractometerDevice *>(dev))->read_ModeNames(att);}
 157         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 158         {return (static_cast<DiffractometerDevice *>(dev))->is_ModeNames_allowed(ty);}
 159 };
 160
 161 class PseudoAxesNamesAttrib: public Tango::SpectrumAttr
 162 {
 163 public:
 164         PseudoAxesNamesAttrib():SpectrumAttr("PseudoAxesNames", Tango::DEV_STRING, Tango::READ, 100) {};
 165         ~PseudoAxesNamesAttrib() {};
 166
 167         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 168         {(static_cast<DiffractometerDevice *>(dev))->read_PseudoAxesNames(att);}
 169         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 170         {return (static_cast<DiffractometerDevice *>(dev))->is_PseudoAxesNames_allowed(ty);}
 171 };
 172
 173 class AxesNamesAttrib: public Tango::SpectrumAttr
 174 {
 175 public:
 176         AxesNamesAttrib():SpectrumAttr("AxesNames", Tango::DEV_STRING, Tango::READ, 10) {};
 177         ~AxesNamesAttrib() {};
 178
 179         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 180         {(static_cast<DiffractometerDevice *>(dev))->read_AxesNames(att);}
 181         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 182         {return (static_cast<DiffractometerDevice *>(dev))->is_AxesNames_allowed(ty);}
 183 };
 184
 185 class CrystalNamesAttrib: public Tango::SpectrumAttr
 186 {
 187 public:
 188         CrystalNamesAttrib():SpectrumAttr("CrystalNames", Tango::DEV_STRING, Tango::READ, 100) {};
 189         ~CrystalNamesAttrib() {};
 190
 191         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 192         {(static_cast<DiffractometerDevice *>(dev))->read_CrystalNames(att);}
 193         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 194         {return (static_cast<DiffractometerDevice *>(dev))->is_CrystalNames_allowed(ty);}
 195 };
 196
 197 class GammaStarAttrib: public Tango::Attr
 198 {
 199 public:
 200         GammaStarAttrib():Attr("GammaStar", Tango::DEV_DOUBLE, Tango::READ) {};
 201         ~GammaStarAttrib() {};
 202
 203         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 204         {(static_cast<DiffractometerDevice *>(dev))->read_GammaStar(att);}
 205         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 206         {return (static_cast<DiffractometerDevice *>(dev))->is_GammaStar_allowed(ty);}
 207 };
 208
 209 class BetaStarAttrib: public Tango::Attr
 210 {
 211 public:
 212         BetaStarAttrib():Attr("BetaStar", Tango::DEV_DOUBLE, Tango::READ) {};
 213         ~BetaStarAttrib() {};
 214
 215         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 216         {(static_cast<DiffractometerDevice *>(dev))->read_BetaStar(att);}
 217         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 218         {return (static_cast<DiffractometerDevice *>(dev))->is_BetaStar_allowed(ty);}
 219 };
 220
 221 class AlphaStarAttrib: public Tango::Attr
 222 {
 223 public:
 224         AlphaStarAttrib():Attr("AlphaStar", Tango::DEV_DOUBLE, Tango::READ) {};
 225         ~AlphaStarAttrib() {};
 226
 227         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 228         {(static_cast<DiffractometerDevice *>(dev))->read_AlphaStar(att);}
 229         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 230         {return (static_cast<DiffractometerDevice *>(dev))->is_AlphaStar_allowed(ty);}
 231 };
 232
 233 class CStarAttrib: public Tango::Attr
 234 {
 235 public:
 236         CStarAttrib():Attr("CStar", Tango::DEV_DOUBLE, Tango::READ) {};
 237         ~CStarAttrib() {};
 238
 239         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 240         {(static_cast<DiffractometerDevice *>(dev))->read_CStar(att);}
 241         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 242         {return (static_cast<DiffractometerDevice *>(dev))->is_CStar_allowed(ty);}
 243 };
 244
 245 class BStarAttrib: public Tango::Attr
 246 {
 247 public:
 248         BStarAttrib():Attr("BStar", Tango::DEV_DOUBLE, Tango::READ) {};
 249         ~BStarAttrib() {};
 250
 251         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 252         {(static_cast<DiffractometerDevice *>(dev))->read_BStar(att);}
 253         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 254         {return (static_cast<DiffractometerDevice *>(dev))->is_BStar_allowed(ty);}
 255 };
 256
 257 class AStarAttrib: public Tango::Attr
 258 {
 259 public:
 260         AStarAttrib():Attr("AStar", Tango::DEV_DOUBLE, Tango::READ) {};
 261         ~AStarAttrib() {};
 262
 263         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 264         {(static_cast<DiffractometerDevice *>(dev))->read_AStar(att);}
 265         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 266         {return (static_cast<DiffractometerDevice *>(dev))->is_AStar_allowed(ty);}
 267 };
 268
 269 class UzAttrib: public Tango::Attr
 270 {
 271 public:
 272         UzAttrib():Attr("Uz", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
 273         ~UzAttrib() {};
 274
 275         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 276         {(static_cast<DiffractometerDevice *>(dev))->read_Uz(att);}
 277         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 278         {(static_cast<DiffractometerDevice *>(dev))->write_Uz(att);}
 279         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 280         {return (static_cast<DiffractometerDevice *>(dev))->is_Uz_allowed(ty);}
 281 };
 282
 283 class UyAttrib: public Tango::Attr
 284 {
 285 public:
 286         UyAttrib():Attr("Uy", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
 287         ~UyAttrib() {};
 288
 289         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 290         {(static_cast<DiffractometerDevice *>(dev))->read_Uy(att);}
 291         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 292         {(static_cast<DiffractometerDevice *>(dev))->write_Uy(att);}
 293         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 294         {return (static_cast<DiffractometerDevice *>(dev))->is_Uy_allowed(ty);}
 295 };
 296
 297 class UxAttrib: public Tango::Attr
 298 {
 299 public:
 300         UxAttrib():Attr("Ux", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
 301         ~UxAttrib() {};
 302
 303         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 304         {(static_cast<DiffractometerDevice *>(dev))->read_Ux(att);}
 305         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 306         {(static_cast<DiffractometerDevice *>(dev))->write_Ux(att);}
 307         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 308         {return (static_cast<DiffractometerDevice *>(dev))->is_Ux_allowed(ty);}
 309 };
 310
 311 class GammaAttrib: public Tango::Attr
 312 {
 313 public:
 314         GammaAttrib():Attr("Gamma", Tango::DEV_DOUBLE, Tango::READ) {};
 315         ~GammaAttrib() {};
 316
 317         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 318         {(static_cast<DiffractometerDevice *>(dev))->read_Gamma(att);}
 319         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 320         {return (static_cast<DiffractometerDevice *>(dev))->is_Gamma_allowed(ty);}
 321 };
 322
 323 class BetaAttrib: public Tango::Attr
 324 {
 325 public:
 326         BetaAttrib():Attr("Beta", Tango::DEV_DOUBLE, Tango::READ) {};
 327         ~BetaAttrib() {};
 328
 329         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 330         {(static_cast<DiffractometerDevice *>(dev))->read_Beta(att);}
 331         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 332         {return (static_cast<DiffractometerDevice *>(dev))->is_Beta_allowed(ty);}
 333 };
 334
 335 class AlphaAttrib: public Tango::Attr
 336 {
 337 public:
 338         AlphaAttrib():Attr("Alpha", Tango::DEV_DOUBLE, Tango::READ) {};
 339         ~AlphaAttrib() {};
 340
 341         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 342         {(static_cast<DiffractometerDevice *>(dev))->read_Alpha(att);}
 343         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 344         {return (static_cast<DiffractometerDevice *>(dev))->is_Alpha_allowed(ty);}
 345 };
 346
 347 class CAttrib: public Tango::Attr
 348 {
 349 public:
 350         CAttrib():Attr("C", Tango::DEV_DOUBLE, Tango::READ) {};
 351         ~CAttrib() {};
 352
 353         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 354         {(static_cast<DiffractometerDevice *>(dev))->read_C(att);}
 355         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 356         {return (static_cast<DiffractometerDevice *>(dev))->is_C_allowed(ty);}
 357 };
 358
 359 class BAttrib: public Tango::Attr
 360 {
 361 public:
 362         BAttrib():Attr("B", Tango::DEV_DOUBLE, Tango::READ) {};
 363         ~BAttrib() {};
 364
 365         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 366         {(static_cast<DiffractometerDevice *>(dev))->read_B(att);}
 367         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 368         {return (static_cast<DiffractometerDevice *>(dev))->is_B_allowed(ty);}
 369 };
 370
 371 class AAttrib: public Tango::Attr
 372 {
 373 public:
 374         AAttrib():Attr("A", Tango::DEV_DOUBLE, Tango::READ) {};
 375         ~AAttrib() {};
 376
 377         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 378         {(static_cast<DiffractometerDevice *>(dev))->read_A(att);}
 379         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 380         {return (static_cast<DiffractometerDevice *>(dev))->is_A_allowed(ty);}
 381 };
 382
 383 class CrystalAttrib: public Tango::Attr
 384 {
 385 public:
 386         CrystalAttrib():Attr("Crystal", Tango::DEV_STRING, Tango::READ_WRITE) {};
 387         ~CrystalAttrib() {};
 388
 389         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 390         {(static_cast<DiffractometerDevice *>(dev))->read_Crystal(att);}
 391         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 392         {(static_cast<DiffractometerDevice *>(dev))->write_Crystal(att);}
 393         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 394         {return (static_cast<DiffractometerDevice *>(dev))->is_Crystal_allowed(ty);}
 395 };
 396
 397 class WaveLengthAttrib: public Tango::Attr
 398 {
 399 public:
 400         WaveLengthAttrib():Attr("WaveLength", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
 401         ~WaveLengthAttrib() {};
 402
 403         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 404         {(static_cast<DiffractometerDevice *>(dev))->read_WaveLength(att);}
 405         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 406         {(static_cast<DiffractometerDevice *>(dev))->write_WaveLength(att);}
 407         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 408         {return (static_cast<DiffractometerDevice *>(dev))->is_WaveLength_allowed(ty);}
 409 };
 410
 411 class SimulatedAttrib: public Tango::Attr
 412 {
 413 public:
 414         SimulatedAttrib():Attr("Simulated", Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
 415         ~SimulatedAttrib() {};
 416
 417         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 418         {(static_cast<DiffractometerDevice *>(dev))->read_Simulated(att);}
 419         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 420         {(static_cast<DiffractometerDevice *>(dev))->write_Simulated(att);}
 421         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 422         {return (static_cast<DiffractometerDevice *>(dev))->is_Simulated_allowed(ty);}
 423 };
 424
 425 class AnglesIdxAttrib: public Tango::Attr
 426 {
 427 public:
 428         AnglesIdxAttrib():Attr("AnglesIdx", Tango::DEV_SHORT, Tango::READ_WRITE) {};
 429         ~AnglesIdxAttrib() {};
 430
 431         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 432         {(static_cast<DiffractometerDevice *>(dev))->read_AnglesIdx(att);}
 433         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 434         {(static_cast<DiffractometerDevice *>(dev))->write_AnglesIdx(att);}
 435         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 436         {return (static_cast<DiffractometerDevice *>(dev))->is_AnglesIdx_allowed(ty);}
 437 };
 438
 439 class ModeAttrib: public Tango::Attr
 440 {
 441 public:
 442         ModeAttrib():Attr("Mode", Tango::DEV_STRING, Tango::READ_WRITE) {};
 443         ~ModeAttrib() {};
 444
 445         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 446         {(static_cast<DiffractometerDevice *>(dev))->read_Mode(att);}
 447         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 448         {(static_cast<DiffractometerDevice *>(dev))->write_Mode(att);}
 449         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 450         {return (static_cast<DiffractometerDevice *>(dev))->is_Mode_allowed(ty);}
 451 };
 452
 453 class LAttrib: public Tango::Attr
 454 {
 455 public:
 456         LAttrib():Attr("L", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
 457         ~LAttrib() {};
 458
 459         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 460         {(static_cast<DiffractometerDevice *>(dev))->read_L(att);}
 461         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 462         {(static_cast<DiffractometerDevice *>(dev))->write_L(att);}
 463         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 464         {return (static_cast<DiffractometerDevice *>(dev))->is_L_allowed(ty);}
 465 };
 466
 467 class KAttrib: public Tango::Attr
 468 {
 469 public:
 470         KAttrib():Attr("K", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
 471         ~KAttrib() {};
 472
 473         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 474         {(static_cast<DiffractometerDevice *>(dev))->read_K(att);}
 475         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 476         {(static_cast<DiffractometerDevice *>(dev))->write_K(att);}
 477         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 478         {return (static_cast<DiffractometerDevice *>(dev))->is_K_allowed(ty);}
 479 };
 480
 481 class HAttrib: public Tango::Attr
 482 {
 483 public:
 484         HAttrib():Attr("H", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
 485         ~HAttrib() {};
 486
 487         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 488         {(static_cast<DiffractometerDevice *>(dev))->read_H(att);}
 489         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 490         {(static_cast<DiffractometerDevice *>(dev))->write_H(att);}
 491         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 492         {return (static_cast<DiffractometerDevice *>(dev))->is_H_allowed(ty);}
 493 };
 494
 495 //=========================================
 496 //      Define classes for commands
 497 //=========================================
 498 class SetReflectionClass : public Tango::Command
 499 {
 500 public:
 501         SetReflectionClass(const char   *name,
 502                        Tango::CmdArgType in,
 503                                    Tango::CmdArgType out,
 504                                    const char        *in_desc,
 505                                    const char        *out_desc,
 506                                    Tango::DispLevel  level)
 507         :Command(name,in,out,in_desc,out_desc, level)   {};
 508
 509         SetReflectionClass(const char   *name,
 510                        Tango::CmdArgType in,
 511                                    Tango::CmdArgType out)
 512         :Command(name,in,out)   {};
 513         ~SetReflectionClass() {};
 514
 515         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 516         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 517         {return (static_cast<DiffractometerDevice *>(dev))->is_SetReflection_allowed(any);}
 518 };
 519
 520
 521
 522 class SetModeParametersValuesClass : public Tango::Command
 523 {
 524 public:
 525         SetModeParametersValuesClass(const char   *name,
 526                        Tango::CmdArgType in,
 527                                    Tango::CmdArgType out,
 528                                    const char        *in_desc,
 529                                    const char        *out_desc,
 530                                    Tango::DispLevel  level)
 531         :Command(name,in,out,in_desc,out_desc, level)   {};
 532
 533         SetModeParametersValuesClass(const char   *name,
 534                        Tango::CmdArgType in,
 535                                    Tango::CmdArgType out)
 536         :Command(name,in,out)   {};
 537         ~SetModeParametersValuesClass() {};
 538
 539         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 540         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 541         {return (static_cast<DiffractometerDevice *>(dev))->is_SetModeParametersValues_allowed(any);}
 542 };
 543
 544
 545
 546 class SetHKLClass : public Tango::Command
 547 {
 548 public:
 549         SetHKLClass(const char   *name,
 550                        Tango::CmdArgType in,
 551                                    Tango::CmdArgType out,
 552                                    const char        *in_desc,
 553                                    const char        *out_desc,
 554                                    Tango::DispLevel  level)
 555         :Command(name,in,out,in_desc,out_desc, level)   {};
 556
 557         SetHKLClass(const char   *name,
 558                        Tango::CmdArgType in,
 559                                    Tango::CmdArgType out)
 560         :Command(name,in,out)   {};
 561         ~SetHKLClass() {};
 562
 563         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 564         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 565         {return (static_cast<DiffractometerDevice *>(dev))->is_SetHKL_allowed(any);}
 566 };
 567
 568
 569
 570 class SetCrystalParameterValuesClass : public Tango::Command
 571 {
 572 public:
 573         SetCrystalParameterValuesClass(const char   *name,
 574                        Tango::CmdArgType in,
 575                                    Tango::CmdArgType out,
 576                                    const char        *in_desc,
 577                                    const char        *out_desc,
 578                                    Tango::DispLevel  level)
 579         :Command(name,in,out,in_desc,out_desc, level)   {};
 580
 581         SetCrystalParameterValuesClass(const char   *name,
 582                        Tango::CmdArgType in,
 583                                    Tango::CmdArgType out)
 584         :Command(name,in,out)   {};
 585         ~SetCrystalParameterValuesClass() {};
 586
 587         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 588         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 589         {return (static_cast<DiffractometerDevice *>(dev))->is_SetCrystalParameterValues_allowed(any);}
 590 };
 591
 592
 593
 594 class SetAffinementMaxIterationClass : public Tango::Command
 595 {
 596 public:
 597         SetAffinementMaxIterationClass(const char   *name,
 598                        Tango::CmdArgType in,
 599                                    Tango::CmdArgType out,
 600                                    const char        *in_desc,
 601                                    const char        *out_desc,
 602                                    Tango::DispLevel  level)
 603         :Command(name,in,out,in_desc,out_desc, level)   {};
 604
 605         SetAffinementMaxIterationClass(const char   *name,
 606                        Tango::CmdArgType in,
 607                                    Tango::CmdArgType out)
 608         :Command(name,in,out)   {};
 609         ~SetAffinementMaxIterationClass() {};
 610
 611         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 612         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 613         {return (static_cast<DiffractometerDevice *>(dev))->is_SetAffinementMaxIteration_allowed(any);}
 614 };
 615
 616
 617
 618 class SaveClass : public Tango::Command
 619 {
 620 public:
 621         SaveClass(const char   *name,
 622                        Tango::CmdArgType in,
 623                                    Tango::CmdArgType out,
 624                                    const char        *in_desc,
 625                                    const char        *out_desc,
 626                                    Tango::DispLevel  level)
 627         :Command(name,in,out,in_desc,out_desc, level)   {};
 628
 629         SaveClass(const char   *name,
 630                        Tango::CmdArgType in,
 631                                    Tango::CmdArgType out)
 632         :Command(name,in,out)   {};
 633         ~SaveClass() {};
 634
 635         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 636         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 637         {return (static_cast<DiffractometerDevice *>(dev))->is_Save_allowed(any);}
 638 };
 639
 640
 641
 642 class RemoveReflectionClass : public Tango::Command
 643 {
 644 public:
 645         RemoveReflectionClass(const char   *name,
 646                        Tango::CmdArgType in,
 647                                    Tango::CmdArgType out,
 648                                    const char        *in_desc,
 649                                    const char        *out_desc,
 650                                    Tango::DispLevel  level)
 651         :Command(name,in,out,in_desc,out_desc, level)   {};
 652
 653         RemoveReflectionClass(const char   *name,
 654                        Tango::CmdArgType in,
 655                                    Tango::CmdArgType out)
 656         :Command(name,in,out)   {};
 657         ~RemoveReflectionClass() {};
 658
 659         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 660         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 661         {return (static_cast<DiffractometerDevice *>(dev))->is_RemoveReflection_allowed(any);}
 662 };
 663
 664
 665
 666 class LoadClass : public Tango::Command
 667 {
 668 public:
 669         LoadClass(const char   *name,
 670                        Tango::CmdArgType in,
 671                                    Tango::CmdArgType out,
 672                                    const char        *in_desc,
 673                                    const char        *out_desc,
 674                                    Tango::DispLevel  level)
 675         :Command(name,in,out,in_desc,out_desc, level)   {};
 676
 677         LoadClass(const char   *name,
 678                        Tango::CmdArgType in,
 679                                    Tango::CmdArgType out)
 680         :Command(name,in,out)   {};
 681         ~LoadClass() {};
 682
 683         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 684         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 685         {return (static_cast<DiffractometerDevice *>(dev))->is_Load_allowed(any);}
 686 };
 687
 688
 689
 690 class GotoReflectionClass : public Tango::Command
 691 {
 692 public:
 693         GotoReflectionClass(const char   *name,
 694                        Tango::CmdArgType in,
 695                                    Tango::CmdArgType out,
 696                                    const char        *in_desc,
 697                                    const char        *out_desc,
 698                                    Tango::DispLevel  level)
 699         :Command(name,in,out,in_desc,out_desc, level)   {};
 700
 701         GotoReflectionClass(const char   *name,
 702                        Tango::CmdArgType in,
 703                                    Tango::CmdArgType out)
 704         :Command(name,in,out)   {};
 705         ~GotoReflectionClass() {};
 706
 707         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 708         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 709         {return (static_cast<DiffractometerDevice *>(dev))->is_GotoReflection_allowed(any);}
 710 };
 711
 712
 713
 714 class GotoComputedAnglesClass : public Tango::Command
 715 {
 716 public:
 717         GotoComputedAnglesClass(const char   *name,
 718                        Tango::CmdArgType in,
 719                                    Tango::CmdArgType out,
 720                                    const char        *in_desc,
 721                                    const char        *out_desc,
 722                                    Tango::DispLevel  level)
 723         :Command(name,in,out,in_desc,out_desc, level)   {};
 724
 725         GotoComputedAnglesClass(const char   *name,
 726                        Tango::CmdArgType in,
 727                                    Tango::CmdArgType out)
 728         :Command(name,in,out)   {};
 729         ~GotoComputedAnglesClass() {};
 730
 731         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 732         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 733         {return (static_cast<DiffractometerDevice *>(dev))->is_GotoComputedAngles_allowed(any);}
 734 };
 735
 736
 737
 738 class GetReflectionSizeClass : public Tango::Command
 739 {
 740 public:
 741         GetReflectionSizeClass(const char   *name,
 742                        Tango::CmdArgType in,
 743                                    Tango::CmdArgType out,
 744                                    const char        *in_desc,
 745                                    const char        *out_desc,
 746                                    Tango::DispLevel  level)
 747         :Command(name,in,out,in_desc,out_desc, level)   {};
 748
 749         GetReflectionSizeClass(const char   *name,
 750                        Tango::CmdArgType in,
 751                                    Tango::CmdArgType out)
 752         :Command(name,in,out)   {};
 753         ~GetReflectionSizeClass() {};
 754
 755         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 756         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 757         {return (static_cast<DiffractometerDevice *>(dev))->is_GetReflectionSize_allowed(any);}
 758 };
 759
 760
 761
 762 class GetReflectionCmd : public Tango::Command
 763 {
 764 public:
 765         GetReflectionCmd(const char   *name,
 766                        Tango::CmdArgType in,
 767                                    Tango::CmdArgType out,
 768                                    const char        *in_desc,
 769                                    const char        *out_desc,
 770                                    Tango::DispLevel  level)
 771         :Command(name,in,out,in_desc,out_desc, level)   {};
 772
 773         GetReflectionCmd(const char   *name,
 774                        Tango::CmdArgType in,
 775                                    Tango::CmdArgType out)
 776         :Command(name,in,out)   {};
 777         ~GetReflectionCmd() {};
 778
 779         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 780         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 781         {return (static_cast<DiffractometerDevice *>(dev))->is_GetReflection_allowed(any);}
 782 };
 783
 784
 785
 786 class GetModeParameterValueClass : public Tango::Command
 787 {
 788 public:
 789         GetModeParameterValueClass(const char   *name,
 790                        Tango::CmdArgType in,
 791                                    Tango::CmdArgType out,
 792                                    const char        *in_desc,
 793                                    const char        *out_desc,
 794                                    Tango::DispLevel  level)
 795         :Command(name,in,out,in_desc,out_desc, level)   {};
 796
 797         GetModeParameterValueClass(const char   *name,
 798                        Tango::CmdArgType in,
 799                                    Tango::CmdArgType out)
 800         :Command(name,in,out)   {};
 801         ~GetModeParameterValueClass() {};
 802
 803         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 804         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 805         {return (static_cast<DiffractometerDevice *>(dev))->is_GetModeParameterValue_allowed(any);}
 806 };
 807
 808
 809
 810 class GetModeParametersValuesClass : public Tango::Command
 811 {
 812 public:
 813         GetModeParametersValuesClass(const char   *name,
 814                        Tango::CmdArgType in,
 815                                    Tango::CmdArgType out,
 816                                    const char        *in_desc,
 817                                    const char        *out_desc,
 818                                    Tango::DispLevel  level)
 819         :Command(name,in,out,in_desc,out_desc, level)   {};
 820
 821         GetModeParametersValuesClass(const char   *name,
 822                        Tango::CmdArgType in,
 823                                    Tango::CmdArgType out)
 824         :Command(name,in,out)   {};
 825         ~GetModeParametersValuesClass() {};
 826
 827         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 828         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 829         {return (static_cast<DiffractometerDevice *>(dev))->is_GetModeParametersValues_allowed(any);}
 830 };
 831
 832
 833
 834 class GetModeParametersNamesClass : public Tango::Command
 835 {
 836 public:
 837         GetModeParametersNamesClass(const char   *name,
 838                        Tango::CmdArgType in,
 839                                    Tango::CmdArgType out,
 840                                    const char        *in_desc,
 841                                    const char        *out_desc,
 842                                    Tango::DispLevel  level)
 843         :Command(name,in,out,in_desc,out_desc, level)   {};
 844
 845         GetModeParametersNamesClass(const char   *name,
 846                        Tango::CmdArgType in,
 847                                    Tango::CmdArgType out)
 848         :Command(name,in,out)   {};
 849         ~GetModeParametersNamesClass() {};
 850
 851         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 852         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 853         {return (static_cast<DiffractometerDevice *>(dev))->is_GetModeParametersNames_allowed(any);}
 854 };
 855
 856
 857
 858 class GetModeDescriptionClass : public Tango::Command
 859 {
 860 public:
 861         GetModeDescriptionClass(const char   *name,
 862                        Tango::CmdArgType in,
 863                                    Tango::CmdArgType out,
 864                                    const char        *in_desc,
 865                                    const char        *out_desc,
 866                                    Tango::DispLevel  level)
 867         :Command(name,in,out,in_desc,out_desc, level)   {};
 868
 869         GetModeDescriptionClass(const char   *name,
 870                        Tango::CmdArgType in,
 871                                    Tango::CmdArgType out)
 872         :Command(name,in,out)   {};
 873         ~GetModeDescriptionClass() {};
 874
 875         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 876         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 877         {return (static_cast<DiffractometerDevice *>(dev))->is_GetModeDescription_allowed(any);}
 878 };
 879
 880
 881
 882 class GetCrystalParameterValuesCmd : public Tango::Command
 883 {
 884 public:
 885         GetCrystalParameterValuesCmd(const char   *name,
 886                        Tango::CmdArgType in,
 887                                    Tango::CmdArgType out,
 888                                    const char        *in_desc,
 889                                    const char        *out_desc,
 890                                    Tango::DispLevel  level)
 891         :Command(name,in,out,in_desc,out_desc, level)   {};
 892
 893         GetCrystalParameterValuesCmd(const char   *name,
 894                        Tango::CmdArgType in,
 895                                    Tango::CmdArgType out)
 896         :Command(name,in,out)   {};
 897         ~GetCrystalParameterValuesCmd() {};
 898
 899         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 900         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 901         {return (static_cast<DiffractometerDevice *>(dev))->is_GetCrystalParameterValues_allowed(any);}
 902 };
 903
 904
 905
 906 class GetCrystalNamesClass : public Tango::Command
 907 {
 908 public:
 909         GetCrystalNamesClass(const char   *name,
 910                        Tango::CmdArgType in,
 911                                    Tango::CmdArgType out,
 912                                    const char        *in_desc,
 913                                    const char        *out_desc,
 914                                    Tango::DispLevel  level)
 915         :Command(name,in,out,in_desc,out_desc, level)   {};
 916
 917         GetCrystalNamesClass(const char   *name,
 918                        Tango::CmdArgType in,
 919                                    Tango::CmdArgType out)
 920         :Command(name,in,out)   {};
 921         ~GetCrystalNamesClass() {};
 922
 923         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 924         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 925         {return (static_cast<DiffractometerDevice *>(dev))->is_GetCrystalNames_allowed(any);}
 926 };
 927
 928
 929
 930 class GetAxesNamesClass : public Tango::Command
 931 {
 932 public:
 933         GetAxesNamesClass(const char   *name,
 934                        Tango::CmdArgType in,
 935                                    Tango::CmdArgType out,
 936                                    const char        *in_desc,
 937                                    const char        *out_desc,
 938                                    Tango::DispLevel  level)
 939         :Command(name,in,out,in_desc,out_desc, level)   {};
 940
 941         GetAxesNamesClass(const char   *name,
 942                        Tango::CmdArgType in,
 943                                    Tango::CmdArgType out)
 944         :Command(name,in,out)   {};
 945         ~GetAxesNamesClass() {};
 946
 947         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 948         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 949         {return (static_cast<DiffractometerDevice *>(dev))->is_GetAxesNames_allowed(any);}
 950 };
 951
 952
 953
 954 class GetAffinementMaxIterationClass : public Tango::Command
 955 {
 956 public:
 957         GetAffinementMaxIterationClass(const char   *name,
 958                        Tango::CmdArgType in,
 959                                    Tango::CmdArgType out,
 960                                    const char        *in_desc,
 961                                    const char        *out_desc,
 962                                    Tango::DispLevel  level)
 963         :Command(name,in,out,in_desc,out_desc, level)   {};
 964
 965         GetAffinementMaxIterationClass(const char   *name,
 966                        Tango::CmdArgType in,
 967                                    Tango::CmdArgType out)
 968         :Command(name,in,out)   {};
 969         ~GetAffinementMaxIterationClass() {};
 970
 971         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 972         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 973         {return (static_cast<DiffractometerDevice *>(dev))->is_GetAffinementMaxIteration_allowed(any);}
 974 };
 975
 976
 977
 978 class GetReflectionsSizeClass : public Tango::Command
 979 {
 980 public:
 981         GetReflectionsSizeClass(const char   *name,
 982                        Tango::CmdArgType in,
 983                                    Tango::CmdArgType out,
 984                                    const char        *in_desc,
 985                                    const char        *out_desc,
 986                                    Tango::DispLevel  level)
 987         :Command(name,in,out,in_desc,out_desc, level)   {};
 988
 989         GetReflectionsSizeClass(const char   *name,
 990                        Tango::CmdArgType in,
 991                                    Tango::CmdArgType out)
 992         :Command(name,in,out)   {};
 993         ~GetReflectionsSizeClass() {};
 994
 995         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
 996         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
 997         {return (static_cast<DiffractometerDevice *>(dev))->is_GetAffinementList_allowed(any);}
 998 };
 999
1000
1001
1002 class GetAffinementIterationClass : public Tango::Command
1003 {
1004 public:
1005         GetAffinementIterationClass(const char   *name,
1006                        Tango::CmdArgType in,
1007                                    Tango::CmdArgType out,
1008                                    const char        *in_desc,
1009                                    const char        *out_desc,
1010                                    Tango::DispLevel  level)
1011         :Command(name,in,out,in_desc,out_desc, level)   {};
1012
1013         GetAffinementIterationClass(const char   *name,
1014                        Tango::CmdArgType in,
1015                                    Tango::CmdArgType out)
1016         :Command(name,in,out)   {};
1017         ~GetAffinementIterationClass() {};
1018
1019         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
1020         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
1021         {return (static_cast<DiffractometerDevice *>(dev))->is_GetAffinementIteration_allowed(any);}
1022 };
1023
1024
1025
1026 class DeleteCurrentCrystalClass : public Tango::Command
1027 {
1028 public:
1029         DeleteCurrentCrystalClass(const char   *name,
1030                        Tango::CmdArgType in,
1031                                    Tango::CmdArgType out,
1032                                    const char        *in_desc,
1033                                    const char        *out_desc,
1034                                    Tango::DispLevel  level)
1035         :Command(name,in,out,in_desc,out_desc, level)   {};
1036
1037         DeleteCurrentCrystalClass(const char   *name,
1038                        Tango::CmdArgType in,
1039                                    Tango::CmdArgType out)
1040         :Command(name,in,out)   {};
1041         ~DeleteCurrentCrystalClass() {};
1042
1043         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
1044         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
1045         {return (static_cast<DiffractometerDevice *>(dev))->is_DeleteCurrentCrystal_allowed(any);}
1046 };
1047
1048
1049
1050 class CopyReflectionToCmd : public Tango::Command
1051 {
1052 public:
1053         CopyReflectionToCmd(const char   *name,
1054                        Tango::CmdArgType in,
1055                                    Tango::CmdArgType out,
1056                                    const char        *in_desc,
1057                                    const char        *out_desc,
1058                                    Tango::DispLevel  level)
1059         :Command(name,in,out,in_desc,out_desc, level)   {};
1060
1061         CopyReflectionToCmd(const char   *name,
1062                        Tango::CmdArgType in,
1063                                    Tango::CmdArgType out)
1064         :Command(name,in,out)   {};
1065         ~CopyReflectionToCmd() {};
1066
1067         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
1068         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
1069         {return (static_cast<DiffractometerDevice *>(dev))->is_CopyReflectionTo_allowed(any);}
1070 };
1071
1072
1073
1074 class CopyCurrentCrystalAsClass : public Tango::Command
1075 {
1076 public:
1077         CopyCurrentCrystalAsClass(const char   *name,
1078                        Tango::CmdArgType in,
1079                                    Tango::CmdArgType out,
1080                                    const char        *in_desc,
1081                                    const char        *out_desc,
1082                                    Tango::DispLevel  level)
1083         :Command(name,in,out,in_desc,out_desc, level)   {};
1084
1085         CopyCurrentCrystalAsClass(const char   *name,
1086                        Tango::CmdArgType in,
1087                                    Tango::CmdArgType out)
1088         :Command(name,in,out)   {};
1089         ~CopyCurrentCrystalAsClass() {};
1090
1091         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
1092         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
1093         {return (static_cast<DiffractometerDevice *>(dev))->is_CopyCurrentCrystalAs_allowed(any);}
1094 };
1095
1096
1097
1098 class ConfigureCrystalCmd : public Tango::Command
1099 {
1100 public:
1101         ConfigureCrystalCmd(const char   *name,
1102                        Tango::CmdArgType in,
1103                                    Tango::CmdArgType out,
1104                                    const char        *in_desc,
1105                                    const char        *out_desc,
1106                                    Tango::DispLevel  level)
1107         :Command(name,in,out,in_desc,out_desc, level)   {};
1108
1109         ConfigureCrystalCmd(const char   *name,
1110                        Tango::CmdArgType in,
1111                                    Tango::CmdArgType out)
1112         :Command(name,in,out)   {};
1113         ~ConfigureCrystalCmd() {};
1114
1115         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
1116         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
1117         {return (static_cast<DiffractometerDevice *>(dev))->is_ConfigureCrystal_allowed(any);}
1118 };
1119
1120
1121
1122 class ComputeUCmd : public Tango::Command
1123 {
1124 public:
1125         ComputeUCmd(const char   *name,
1126                        Tango::CmdArgType in,
1127                                    Tango::CmdArgType out,
1128                                    const char        *in_desc,
1129                                    const char        *out_desc,
1130                                    Tango::DispLevel  level)
1131         :Command(name,in,out,in_desc,out_desc, level)   {};
1132
1133         ComputeUCmd(const char   *name,
1134                        Tango::CmdArgType in,
1135                                    Tango::CmdArgType out)
1136         :Command(name,in,out)   {};
1137         ~ComputeUCmd() {};
1138
1139         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
1140         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
1141         {return (static_cast<DiffractometerDevice *>(dev))->is_ComputeU_allowed(any);}
1142 };
1143
1144
1145
1146 class ComputedAnglesHKLListClass : public Tango::Command
1147 {
1148 public:
1149         ComputedAnglesHKLListClass(const char   *name,
1150                        Tango::CmdArgType in,
1151                                    Tango::CmdArgType out,
1152                                    const char        *in_desc,
1153                                    const char        *out_desc,
1154                                    Tango::DispLevel  level)
1155         :Command(name,in,out,in_desc,out_desc, level)   {};
1156
1157         ComputedAnglesHKLListClass(const char   *name,
1158                        Tango::CmdArgType in,
1159                                    Tango::CmdArgType out)
1160         :Command(name,in,out)   {};
1161         ~ComputedAnglesHKLListClass() {};
1162
1163         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
1164         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
1165         {return (static_cast<DiffractometerDevice *>(dev))->is_ComputedAnglesHKLList_allowed(any);}
1166 };
1167
1168
1169
1170 class ComputedAnglesClearCmd : public Tango::Command
1171 {
1172 public:
1173         ComputedAnglesClearCmd(const char   *name,
1174                        Tango::CmdArgType in,
1175                                    Tango::CmdArgType out,
1176                                    const char        *in_desc,
1177                                    const char        *out_desc,
1178                                    Tango::DispLevel  level)
1179         :Command(name,in,out,in_desc,out_desc, level)   {};
1180
1181         ComputedAnglesClearCmd(const char   *name,
1182                        Tango::CmdArgType in,
1183                                    Tango::CmdArgType out)
1184         :Command(name,in,out)   {};
1185         ~ComputedAnglesClearCmd() {};
1186
1187         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
1188         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
1189         {return (static_cast<DiffractometerDevice *>(dev))->is_ComputedAnglesClear_allowed(any);}
1190 };
1191
1192
1193
1194 class AffineCrystalCmd : public Tango::Command
1195 {
1196 public:
1197         AffineCrystalCmd(const char   *name,
1198                        Tango::CmdArgType in,
1199                                    Tango::CmdArgType out,
1200                                    const char        *in_desc,
1201                                    const char        *out_desc,
1202                                    Tango::DispLevel  level)
1203         :Command(name,in,out,in_desc,out_desc, level)   {};
1204
1205         AffineCrystalCmd(const char   *name,
1206                        Tango::CmdArgType in,
1207                                    Tango::CmdArgType out)
1208         :Command(name,in,out)   {};
1209         ~AffineCrystalCmd() {};
1210
1211         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
1212         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
1213         {return (static_cast<DiffractometerDevice *>(dev))->is_AffineCrystal_allowed(any);}
1214 };
1215
1216
1217
1218 class AddReflectionClass : public Tango::Command
1219 {
1220 public:
1221         AddReflectionClass(const char   *name,
1222                        Tango::CmdArgType in,
1223                                    Tango::CmdArgType out,
1224                                    const char        *in_desc,
1225                                    const char        *out_desc,
1226                                    Tango::DispLevel  level)
1227         :Command(name,in,out,in_desc,out_desc, level)   {};
1228
1229         AddReflectionClass(const char   *name,
1230                        Tango::CmdArgType in,
1231                                    Tango::CmdArgType out)
1232         :Command(name,in,out)   {};
1233         ~AddReflectionClass() {};
1234
1235         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
1236         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
1237         {return (static_cast<DiffractometerDevice *>(dev))->is_AddReflection_allowed(any);}
1238 };
1239
1240
1241
1242 class AddNewCrystalClass : public Tango::Command
1243 {
1244 public:
1245         AddNewCrystalClass(const char   *name,
1246                        Tango::CmdArgType in,
1247                                    Tango::CmdArgType out,
1248                                    const char        *in_desc,
1249                                    const char        *out_desc,
1250                                    Tango::DispLevel  level)
1251         :Command(name,in,out,in_desc,out_desc, level)   {};
1252
1253         AddNewCrystalClass(const char   *name,
1254                        Tango::CmdArgType in,
1255                                    Tango::CmdArgType out)
1256         :Command(name,in,out)   {};
1257         ~AddNewCrystalClass() {};
1258
1259         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
1260         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
1261         {return (static_cast<DiffractometerDevice *>(dev))->is_AddNewCrystal_allowed(any);}
1262 };
1263
1264
1265
1266 class AbortCmd : public Tango::Command
1267 {
1268 public:
1269         AbortCmd(const char   *name,
1270                        Tango::CmdArgType in,
1271                                    Tango::CmdArgType out,
1272                                    const char        *in_desc,
1273                                    const char        *out_desc,
1274                                    Tango::DispLevel  level)
1275         :Command(name,in,out,in_desc,out_desc, level)   {};
1276
1277         AbortCmd(const char   *name,
1278                        Tango::CmdArgType in,
1279                                    Tango::CmdArgType out)
1280         :Command(name,in,out)   {};
1281         ~AbortCmd() {};
1282
1283         virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
1284         virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
1285         {return (static_cast<DiffractometerDevice *>(dev))->is_Abort_allowed(any);}
1286 };
1287
1288
1289
1290 //
1291 // The DiffractometerDeviceClass singleton definition
1292 //
1293
1294 class DiffractometerDeviceClass : public Tango::DeviceClass
1295 {
1296 public:
1297 //      properties member data
1298
1299 //      add your own data members here
1300 //------------------------------------
1301
1302 public:
1303         Tango::DbData   cl_prop;
1304         Tango::DbData   cl_def_prop;
1305         Tango::DbData   dev_def_prop;
1306
1307 //      Method prototypes
1308         static DiffractometerDeviceClass *init(const char *);
1309         static DiffractometerDeviceClass *instance();
1310         ~DiffractometerDeviceClass();
1311         Tango::DbDatum  get_class_property(string &);
1312         Tango::DbDatum  get_default_device_property(string &);
1313         Tango::DbDatum  get_default_class_property(string &);
1314
1315 protected:
1316         DiffractometerDeviceClass(string &);
1317         static DiffractometerDeviceClass *_instance;
1318         void command_factory();
1319         void get_class_property();
1320         void attribute_factory(vector<Tango::Attr *> &);
1321         void write_class_property();
1322         void set_default_property();
1323
1324 private:
1325         void device_factory(const Tango::DevVarStringArray *);
1326 };
1327
1328
1329 }       //      namespace DiffractometerDevice_ns
1330
1331 #endif // _DIFFRACTOMETERDEVICECLASS_H