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