src/Diffractometer/DiffractometerClass.h

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