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