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 AnglesRangeCheckAttrib: public Tango::ImageAttr
  81 {
  82 public:
  83         AnglesRangeCheckAttrib():ImageAttr("AnglesRangeCheck", Tango::DEV_BOOLEAN, Tango::READ, 20, 1000) {};
  84         ~AnglesRangeCheckAttrib() {};
  85
  86         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
  87         {(static_cast<Diffractometer *>(dev))->read_AnglesRangeCheck(att);}
  88         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
  89         {return (static_cast<Diffractometer *>(dev))->is_AnglesRangeCheck_allowed(ty);}
  90 };
  91
  92 class AnglesDegeneratedAttrib: public Tango::ImageAttr
  93 {
  94 public:
  95         AnglesDegeneratedAttrib():ImageAttr("AnglesDegenerated", Tango::DEV_BOOLEAN, Tango::READ, 20, 1000) {};
  96         ~AnglesDegeneratedAttrib() {};
  97
  98         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
  99         {(static_cast<Diffractometer *>(dev))->read_AnglesDegenerated(att);}
 100         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 101         {return (static_cast<Diffractometer *>(dev))->is_AnglesDegenerated_allowed(ty);}
 102 };
 103
 104 class AnglesAttrib: public Tango::ImageAttr
 105 {
 106 public:
 107         AnglesAttrib():ImageAttr("Angles", Tango::DEV_DOUBLE, Tango::READ, 20, 1000) {};
 108         ~AnglesAttrib() {};
 109
 110         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 111         {(static_cast<Diffractometer *>(dev))->read_Angles(att);}
 112         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 113         {return (static_cast<Diffractometer *>(dev))->is_Angles_allowed(ty);}
 114 };
 115
 116 class pseudoAxesProxiesAttrib: public Tango::SpectrumAttr
 117 {
 118 public:
 119         pseudoAxesProxiesAttrib():SpectrumAttr("pseudoAxesProxies", Tango::DEV_STRING, Tango::READ, 100) {};
 120         ~pseudoAxesProxiesAttrib() {};
 121
 122         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 123         {(static_cast<Diffractometer *>(dev))->read_pseudoAxesProxies(att);}
 124         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 125         {return (static_cast<Diffractometer *>(dev))->is_pseudoAxesProxies_allowed(ty);}
 126 };
 127
 128 class AxesNamesAttrib: public Tango::SpectrumAttr
 129 {
 130 public:
 131         AxesNamesAttrib():SpectrumAttr("AxesNames", Tango::DEV_STRING, Tango::READ, 100) {};
 132         ~AxesNamesAttrib() {};
 133
 134         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 135         {(static_cast<Diffractometer *>(dev))->read_AxesNames(att);}
 136         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 137         {return (static_cast<Diffractometer *>(dev))->is_AxesNames_allowed(ty);}
 138 };
 139
 140 class CrystalNamesAttrib: public Tango::SpectrumAttr
 141 {
 142 public:
 143         CrystalNamesAttrib():SpectrumAttr("CrystalNames", Tango::DEV_STRING, Tango::READ, 100) {};
 144         ~CrystalNamesAttrib() {};
 145
 146         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 147         {(static_cast<Diffractometer *>(dev))->read_CrystalNames(att);}
 148         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 149         {return (static_cast<Diffractometer *>(dev))->is_CrystalNames_allowed(ty);}
 150 };
 151
 152 class SimulatedAttrib: public Tango::Attr
 153 {
 154 public:
 155         SimulatedAttrib():Attr("Simulated", Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
 156         ~SimulatedAttrib() {};
 157
 158         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 159         {(static_cast<Diffractometer *>(dev))->read_Simulated(att);}
 160         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 161         {(static_cast<Diffractometer *>(dev))->write_Simulated(att);}
 162         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 163         {return (static_cast<Diffractometer *>(dev))->is_Simulated_allowed(ty);}
 164 };
 165
 166 class GammaStarAttrib: public Tango::Attr
 167 {
 168 public:
 169         GammaStarAttrib():Attr("GammaStar", Tango::DEV_DOUBLE, Tango::READ) {};
 170         ~GammaStarAttrib() {};
 171
 172         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 173         {(static_cast<Diffractometer *>(dev))->read_GammaStar(att);}
 174         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 175         {return (static_cast<Diffractometer *>(dev))->is_GammaStar_allowed(ty);}
 176 };
 177
 178 class BetaStarAttrib: public Tango::Attr
 179 {
 180 public:
 181         BetaStarAttrib():Attr("BetaStar", Tango::DEV_DOUBLE, Tango::READ) {};
 182         ~BetaStarAttrib() {};
 183
 184         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 185         {(static_cast<Diffractometer *>(dev))->read_BetaStar(att);}
 186         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 187         {return (static_cast<Diffractometer *>(dev))->is_BetaStar_allowed(ty);}
 188 };
 189
 190 class AlphaStarAttrib: public Tango::Attr
 191 {
 192 public:
 193         AlphaStarAttrib():Attr("AlphaStar", Tango::DEV_DOUBLE, Tango::READ) {};
 194         ~AlphaStarAttrib() {};
 195
 196         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 197         {(static_cast<Diffractometer *>(dev))->read_AlphaStar(att);}
 198         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 199         {return (static_cast<Diffractometer *>(dev))->is_AlphaStar_allowed(ty);}
 200 };
 201
 202 class CStarAttrib: public Tango::Attr
 203 {
 204 public:
 205         CStarAttrib():Attr("CStar", Tango::DEV_DOUBLE, Tango::READ) {};
 206         ~CStarAttrib() {};
 207
 208         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 209         {(static_cast<Diffractometer *>(dev))->read_CStar(att);}
 210         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 211         {return (static_cast<Diffractometer *>(dev))->is_CStar_allowed(ty);}
 212 };
 213
 214 class BStarAttrib: public Tango::Attr
 215 {
 216 public:
 217         BStarAttrib():Attr("BStar", Tango::DEV_DOUBLE, Tango::READ) {};
 218         ~BStarAttrib() {};
 219
 220         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 221         {(static_cast<Diffractometer *>(dev))->read_BStar(att);}
 222         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 223         {return (static_cast<Diffractometer *>(dev))->is_BStar_allowed(ty);}
 224 };
 225
 226 class AStarAttrib: public Tango::Attr
 227 {
 228 public:
 229         AStarAttrib():Attr("AStar", Tango::DEV_DOUBLE, Tango::READ) {};
 230         ~AStarAttrib() {};
 231
 232         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 233         {(static_cast<Diffractometer *>(dev))->read_AStar(att);}
 234         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 235         {return (static_cast<Diffractometer *>(dev))->is_AStar_allowed(ty);}
 236 };
 237
 238 class UzFitAttrib: public Tango::Attr
 239 {
 240 public:
 241         UzFitAttrib():Attr("UzFit", Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
 242         ~UzFitAttrib() {};
 243
 244         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 245         {(static_cast<Diffractometer *>(dev))->read_UzFit(att);}
 246         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 247         {(static_cast<Diffractometer *>(dev))->write_UzFit(att);}
 248         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 249         {return (static_cast<Diffractometer *>(dev))->is_UzFit_allowed(ty);}
 250 };
 251
 252 class UzAttrib: public Tango::Attr
 253 {
 254 public:
 255         UzAttrib():Attr("Uz", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
 256         ~UzAttrib() {};
 257
 258         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 259         {(static_cast<Diffractometer *>(dev))->read_Uz(att);}
 260         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 261         {(static_cast<Diffractometer *>(dev))->write_Uz(att);}
 262         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 263         {return (static_cast<Diffractometer *>(dev))->is_Uz_allowed(ty);}
 264 };
 265
 266 class UyFitAttrib: public Tango::Attr
 267 {
 268 public:
 269         UyFitAttrib():Attr("UyFit", Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
 270         ~UyFitAttrib() {};
 271
 272         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 273         {(static_cast<Diffractometer *>(dev))->read_UyFit(att);}
 274         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 275         {(static_cast<Diffractometer *>(dev))->write_UyFit(att);}
 276         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 277         {return (static_cast<Diffractometer *>(dev))->is_UyFit_allowed(ty);}
 278 };
 279
 280 class UyAttrib: public Tango::Attr
 281 {
 282 public:
 283         UyAttrib():Attr("Uy", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
 284         ~UyAttrib() {};
 285
 286         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 287         {(static_cast<Diffractometer *>(dev))->read_Uy(att);}
 288         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 289         {(static_cast<Diffractometer *>(dev))->write_Uy(att);}
 290         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 291         {return (static_cast<Diffractometer *>(dev))->is_Uy_allowed(ty);}
 292 };
 293
 294 class UxFitAttrib: public Tango::Attr
 295 {
 296 public:
 297         UxFitAttrib():Attr("UxFit", Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
 298         ~UxFitAttrib() {};
 299
 300         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 301         {(static_cast<Diffractometer *>(dev))->read_UxFit(att);}
 302         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 303         {(static_cast<Diffractometer *>(dev))->write_UxFit(att);}
 304         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 305         {return (static_cast<Diffractometer *>(dev))->is_UxFit_allowed(ty);}
 306 };
 307
 308 class UxAttrib: public Tango::Attr
 309 {
 310 public:
 311         UxAttrib():Attr("Ux", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
 312         ~UxAttrib() {};
 313
 314         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 315         {(static_cast<Diffractometer *>(dev))->read_Ux(att);}
 316         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 317         {(static_cast<Diffractometer *>(dev))->write_Ux(att);}
 318         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 319         {return (static_cast<Diffractometer *>(dev))->is_Ux_allowed(ty);}
 320 };
 321
 322 class GammaFitAttrib: public Tango::Attr
 323 {
 324 public:
 325         GammaFitAttrib():Attr("GammaFit", Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
 326         ~GammaFitAttrib() {};
 327
 328         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 329         {(static_cast<Diffractometer *>(dev))->read_GammaFit(att);}
 330         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 331         {(static_cast<Diffractometer *>(dev))->write_GammaFit(att);}
 332         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 333         {return (static_cast<Diffractometer *>(dev))->is_GammaFit_allowed(ty);}
 334 };
 335
 336 class GammaAttrib: public Tango::Attr
 337 {
 338 public:
 339         GammaAttrib():Attr("Gamma", Tango::DEV_DOUBLE, Tango::READ) {};
 340         ~GammaAttrib() {};
 341
 342         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 343         {(static_cast<Diffractometer *>(dev))->read_Gamma(att);}
 344         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 345         {return (static_cast<Diffractometer *>(dev))->is_Gamma_allowed(ty);}
 346 };
 347
 348 class BetaFitAttrib: public Tango::Attr
 349 {
 350 public:
 351         BetaFitAttrib():Attr("BetaFit", Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
 352         ~BetaFitAttrib() {};
 353
 354         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 355         {(static_cast<Diffractometer *>(dev))->read_BetaFit(att);}
 356         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 357         {(static_cast<Diffractometer *>(dev))->write_BetaFit(att);}
 358         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 359         {return (static_cast<Diffractometer *>(dev))->is_BetaFit_allowed(ty);}
 360 };
 361
 362 class BetaAttrib: public Tango::Attr
 363 {
 364 public:
 365         BetaAttrib():Attr("Beta", Tango::DEV_DOUBLE, Tango::READ) {};
 366         ~BetaAttrib() {};
 367
 368         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 369         {(static_cast<Diffractometer *>(dev))->read_Beta(att);}
 370         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 371         {return (static_cast<Diffractometer *>(dev))->is_Beta_allowed(ty);}
 372 };
 373
 374 class AlphaFitAttrib: public Tango::Attr
 375 {
 376 public:
 377         AlphaFitAttrib():Attr("AlphaFit", Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
 378         ~AlphaFitAttrib() {};
 379
 380         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 381         {(static_cast<Diffractometer *>(dev))->read_AlphaFit(att);}
 382         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 383         {(static_cast<Diffractometer *>(dev))->write_AlphaFit(att);}
 384         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 385         {return (static_cast<Diffractometer *>(dev))->is_AlphaFit_allowed(ty);}
 386 };
 387
 388 class AlphaAttrib: public Tango::Attr
 389 {
 390 public:
 391         AlphaAttrib():Attr("Alpha", Tango::DEV_DOUBLE, Tango::READ) {};
 392         ~AlphaAttrib() {};
 393
 394         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 395         {(static_cast<Diffractometer *>(dev))->read_Alpha(att);}
 396         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 397         {return (static_cast<Diffractometer *>(dev))->is_Alpha_allowed(ty);}
 398 };
 399
 400 class CFitAttrib: public Tango::Attr
 401 {
 402 public:
 403         CFitAttrib():Attr("CFit", Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
 404         ~CFitAttrib() {};
 405
 406         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 407         {(static_cast<Diffractometer *>(dev))->read_CFit(att);}
 408         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 409         {(static_cast<Diffractometer *>(dev))->write_CFit(att);}
 410         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 411         {return (static_cast<Diffractometer *>(dev))->is_CFit_allowed(ty);}
 412 };
 413
 414 class CAttrib: public Tango::Attr
 415 {
 416 public:
 417         CAttrib():Attr("C", Tango::DEV_DOUBLE, Tango::READ) {};
 418         ~CAttrib() {};
 419
 420         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 421         {(static_cast<Diffractometer *>(dev))->read_C(att);}
 422         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 423         {return (static_cast<Diffractometer *>(dev))->is_C_allowed(ty);}
 424 };
 425
 426 class BFitAttrib: public Tango::Attr
 427 {
 428 public:
 429         BFitAttrib():Attr("BFit", Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
 430         ~BFitAttrib() {};
 431
 432         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 433         {(static_cast<Diffractometer *>(dev))->read_BFit(att);}
 434         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 435         {(static_cast<Diffractometer *>(dev))->write_BFit(att);}
 436         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 437         {return (static_cast<Diffractometer *>(dev))->is_BFit_allowed(ty);}
 438 };
 439
 440 class BAttrib: public Tango::Attr
 441 {
 442 public:
 443         BAttrib():Attr("B", Tango::DEV_DOUBLE, Tango::READ) {};
 444         ~BAttrib() {};
 445
 446         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 447         {(static_cast<Diffractometer *>(dev))->read_B(att);}
 448         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 449         {return (static_cast<Diffractometer *>(dev))->is_B_allowed(ty);}
 450 };
 451
 452 class AFitAttrib: public Tango::Attr
 453 {
 454 public:
 455         AFitAttrib():Attr("AFit", Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
 456         ~AFitAttrib() {};
 457
 458         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 459         {(static_cast<Diffractometer *>(dev))->read_AFit(att);}
 460         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 461         {(static_cast<Diffractometer *>(dev))->write_AFit(att);}
 462         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 463         {return (static_cast<Diffractometer *>(dev))->is_AFit_allowed(ty);}
 464 };
 465
 466 class AAttrib: public Tango::Attr
 467 {
 468 public:
 469         AAttrib():Attr("A", Tango::DEV_DOUBLE, Tango::READ) {};
 470         ~AAttrib() {};
 471
 472         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 473         {(static_cast<Diffractometer *>(dev))->read_A(att);}
 474         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 475         {return (static_cast<Diffractometer *>(dev))->is_A_allowed(ty);}
 476 };
 477
 478 class CrystalAttrib: public Tango::Attr
 479 {
 480 public:
 481         CrystalAttrib():Attr("Crystal", Tango::DEV_STRING, Tango::READ_WRITE) {};
 482         ~CrystalAttrib() {};
 483
 484         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 485         {(static_cast<Diffractometer *>(dev))->read_Crystal(att);}
 486         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 487         {(static_cast<Diffractometer *>(dev))->write_Crystal(att);}
 488         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 489         {return (static_cast<Diffractometer *>(dev))->is_Crystal_allowed(ty);}
 490 };
 491
 492 class WaveLengthAttrib: public Tango::Attr
 493 {
 494 public:
 495         WaveLengthAttrib():Attr("WaveLength", Tango::DEV_DOUBLE, Tango::READ_WRITE) {};
 496         ~WaveLengthAttrib() {};
 497
 498         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 499         {(static_cast<Diffractometer *>(dev))->read_WaveLength(att);}
 500         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 501         {(static_cast<Diffractometer *>(dev))->write_WaveLength(att);}
 502         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 503         {return (static_cast<Diffractometer *>(dev))->is_WaveLength_allowed(ty);}
 504 };
 505
 506 class AutoUpdateFromProxiesAttrib: public Tango::Attr
 507 {
 508 public:
 509         AutoUpdateFromProxiesAttrib():Attr("AutoUpdateFromProxies", Tango::DEV_BOOLEAN, Tango::READ_WRITE) {};
 510         ~AutoUpdateFromProxiesAttrib() {};
 511
 512         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 513         {(static_cast<Diffractometer *>(dev))->read_AutoUpdateFromProxies(att);}
 514         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 515         {(static_cast<Diffractometer *>(dev))->write_AutoUpdateFromProxies(att);}
 516         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 517         {return (static_cast<Diffractometer *>(dev))->is_AutoUpdateFromProxies_allowed(ty);}
 518 };
 519
 520 class AnglesIdxAttrib: public Tango::Attr
 521 {
 522 public:
 523         AnglesIdxAttrib():Attr("AnglesIdx", Tango::DEV_SHORT, Tango::READ_WRITE) {};
 524         ~AnglesIdxAttrib() {};
 525
 526         virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
 527         {(static_cast<Diffractometer *>(dev))->read_AnglesIdx(att);}
 528         virtual void write(Tango::DeviceImpl *dev,Tango::WAttribute &att)
 529         {(static_cast<Diffractometer *>(dev))->write_AnglesIdx(att);}
 530         virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
 531         {return (static_cast<Diffractometer *>(dev))->is_AnglesIdx_allowed(ty);}
 532 };
 533
 534 //=========================================
 535 //      Define classes for commands
 536 //=========================================
 537 class SetCrystalParameterValuesClass : public Tango::Command
 538 {
 539 public:
 540         SetCrystalParameterValuesClass(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         SetCrystalParameterValuesClass(const char   *name,
 549                        Tango::CmdArgType in,
 550                                    Tango::CmdArgType out)
 551         :Command(name,in,out)   {};
 552         ~SetCrystalParameterValuesClass() {};
 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_SetCrystalParameterValues_allowed(any);}
 557 };
 558
 559
 560
 561 class SaveClass : public Tango::Command
 562 {
 563 public:
 564         SaveClass(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         SaveClass(const char   *name,
 573                        Tango::CmdArgType in,
 574                                    Tango::CmdArgType out)
 575         :Command(name,in,out)   {};
 576         ~SaveClass() {};
 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_Save_allowed(any);}
 581 };
 582
 583
 584
 585 class RemoveReflectionClass : public Tango::Command
 586 {
 587 public:
 588         RemoveReflectionClass(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         RemoveReflectionClass(const char   *name,
 597                        Tango::CmdArgType in,
 598                                    Tango::CmdArgType out)
 599         :Command(name,in,out)   {};
 600         ~RemoveReflectionClass() {};
 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_RemoveReflection_allowed(any);}
 605 };
 606
 607
 608
 609 class LoadClass : public Tango::Command
 610 {
 611 public:
 612         LoadClass(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         LoadClass(const char   *name,
 621                        Tango::CmdArgType in,
 622                                    Tango::CmdArgType out)
 623         :Command(name,in,out)   {};
 624         ~LoadClass() {};
 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_Load_allowed(any);}
 629 };
 630
 631
 632
 633 class GetCrystalParameterValuesCmd : public Tango::Command
 634 {
 635 public:
 636         GetCrystalParameterValuesCmd(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         GetCrystalParameterValuesCmd(const char   *name,
 645                        Tango::CmdArgType in,
 646                                    Tango::CmdArgType out)
 647         :Command(name,in,out)   {};
 648         ~GetCrystalParameterValuesCmd() {};
 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_GetCrystalParameterValues_allowed(any);}
 653 };
 654
 655
 656
 657 class DeleteCurrentCrystalClass : public Tango::Command
 658 {
 659 public:
 660         DeleteCurrentCrystalClass(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         DeleteCurrentCrystalClass(const char   *name,
 669                        Tango::CmdArgType in,
 670                                    Tango::CmdArgType out)
 671         :Command(name,in,out)   {};
 672         ~DeleteCurrentCrystalClass() {};
 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_DeleteCurrentCrystal_allowed(any);}
 677 };
 678
 679
 680
 681 class CopyReflectionToCmd : public Tango::Command
 682 {
 683 public:
 684         CopyReflectionToCmd(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         CopyReflectionToCmd(const char   *name,
 693                        Tango::CmdArgType in,
 694                                    Tango::CmdArgType out)
 695         :Command(name,in,out)   {};
 696         ~CopyReflectionToCmd() {};
 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_CopyReflectionTo_allowed(any);}
 701 };
 702
 703
 704
 705 class CopyCurrentCrystalAsClass : public Tango::Command
 706 {
 707 public:
 708         CopyCurrentCrystalAsClass(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         CopyCurrentCrystalAsClass(const char   *name,
 717                        Tango::CmdArgType in,
 718                                    Tango::CmdArgType out)
 719         :Command(name,in,out)   {};
 720         ~CopyCurrentCrystalAsClass() {};
 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_CopyCurrentCrystalAs_allowed(any);}
 725 };
 726
 727
 728
 729 class ConfigureCrystalCmd : public Tango::Command
 730 {
 731 public:
 732         ConfigureCrystalCmd(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         ConfigureCrystalCmd(const char   *name,
 741                        Tango::CmdArgType in,
 742                                    Tango::CmdArgType out)
 743         :Command(name,in,out)   {};
 744         ~ConfigureCrystalCmd() {};
 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_ConfigureCrystal_allowed(any);}
 749 };
 750
 751
 752
 753 class ComputeUCmd : public Tango::Command
 754 {
 755 public:
 756         ComputeUCmd(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         ComputeUCmd(const char   *name,
 765                        Tango::CmdArgType in,
 766                                    Tango::CmdArgType out)
 767         :Command(name,in,out)   {};
 768         ~ComputeUCmd() {};
 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_ComputeU_allowed(any);}
 773 };
 774
 775
 776
 777 class AffineCrystalCmd : public Tango::Command
 778 {
 779 public:
 780         AffineCrystalCmd(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         AffineCrystalCmd(const char   *name,
 789                        Tango::CmdArgType in,
 790                                    Tango::CmdArgType out)
 791         :Command(name,in,out)   {};
 792         ~AffineCrystalCmd() {};
 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_AffineCrystal_allowed(any);}
 797 };
 798
 799
 800
 801 class AddReflectionClass : public Tango::Command
 802 {
 803 public:
 804         AddReflectionClass(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         AddReflectionClass(const char   *name,
 813                        Tango::CmdArgType in,
 814                                    Tango::CmdArgType out)
 815         :Command(name,in,out)   {};
 816         ~AddReflectionClass() {};
 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_AddReflection_allowed(any);}
 821 };
 822
 823
 824
 825 class AddNewCrystalClass : public Tango::Command
 826 {
 827 public:
 828         AddNewCrystalClass(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         AddNewCrystalClass(const char   *name,
 837                        Tango::CmdArgType in,
 838                                    Tango::CmdArgType out)
 839         :Command(name,in,out)   {};
 840         ~AddNewCrystalClass() {};
 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_AddNewCrystal_allowed(any);}
 845 };
 846
 847
 848
 849 class AbortCmd : public Tango::Command
 850 {
 851 public:
 852         AbortCmd(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         AbortCmd(const char   *name,
 861                        Tango::CmdArgType in,
 862                                    Tango::CmdArgType out)
 863         :Command(name,in,out)   {};
 864         ~AbortCmd() {};
 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_Abort_allowed(any);}
 869 };
 870
 871
 872
 873 //
 874 // The DiffractometerClass singleton definition
 875 //
 876
 877 class DiffractometerClass : public Tango::DeviceClass
 878 {
 879 public:
 880 //      properties member data
 881
 882 //      add your own data members here
 883 //------------------------------------
 884
 885 public:
 886         Tango::DbData   cl_prop;
 887         Tango::DbData   cl_def_prop;
 888         Tango::DbData   dev_def_prop;
 889
 890 //      Method prototypes
 891         static DiffractometerClass *init(const char *);
 892         static DiffractometerClass *instance();
 893         ~DiffractometerClass();
 894         Tango::DbDatum  get_class_property(string &);
 895         Tango::DbDatum  get_default_device_property(string &);
 896         Tango::DbDatum  get_default_class_property(string &);
 897
 898 protected:
 899         DiffractometerClass(string &);
 900         static DiffractometerClass *_instance;
 901         void command_factory();
 902         void get_class_property();
 903         void attribute_factory(vector<Tango::Attr *> &);
 904         void write_class_property();
 905         void set_default_property();
 906
 907 private:
 908         void device_factory(const Tango::DevVarStringArray *);
 909 };
 910
 911
 912 }       //      namespace Diffractometer_ns
 913
 914 #endif // _DIFFRACTOMETERCLASS_H