ryzom/server/src/entities_game_service/fame_pd.h

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17
  18 #ifndef FAME_PD_H
  19 #define FAME_PD_H
  20
  21 #include <nel/misc/types_nl.h>
  22 #include <nel/misc/debug.h>
  23 #include <nel/misc/common.h>
  24 #include <nel/misc/entity_id.h>
  25 #include <nel/misc/sheet_id.h>
  26 #include <vector>
  27 #include <map>
  28 #include <pd_lib/pd_lib.h>
  29 #include <game_share/persistent_data.h>
  30
  31 // User #includes
  32
  33 namespace EGSPD
  34 {
  35
  36 //
  37 // Forward declarations
  38 //
  39
  40
  41
  42 //
  43 // Typedefs & Enums
  44 //
  45
  46 /** TFameTrend
  47  * defined at entities_game_service/pd_scripts/fame.pds:4
  48  */
  49 class CFameTrend
  50 {
  51
  52 public:
  53
  54         /// \name Enum values
  55         // @{
  56
  57         enum TFameTrend
  58         {
  59                 FameUpward = 0,
  60                 FameDownward = 1,
  61                 FameSteady = 2,
  62                 ___TFameTrend_useSize = 3,
  63                 Unknown = 3,
  64                 EndFameTrend = 3,
  65         };
  66
  67         // @}
  68
  69
  70 public:
  71
  72         /// \name Conversion methods
  73         // @{
  74
  75         /**
  76          * Use these methods to convert from enum value to string (and vice versa)
  77          */
  78
  79         static const std::string&               toString(TFameTrend v);
  80         static CFameTrend::TFameTrend   fromString(const std::string& v);
  81
  82         // @}
  83
  84
  85 private:
  86
  87         /// \name Enum initialisation
  88         // @{
  89
  90         static void                                             init();
  91         static bool                                             _Initialised;
  92         static std::string                              _UnknownString;
  93         static std::vector<std::string> _StrTable;
  94         static std::map<std::string, TFameTrend>        _ValueMap;
  95
  96         // @}
  97
  98 };
  99
 100 /** CFameContainerEntryPD
 101  * defined at entities_game_service/pd_scripts/fame.pds:11
 102  */
 103 class CFameContainerEntryPD : public RY_PDS::IPDBaseData
 104 {
 105
 106 public:
 107
 108         /// \name Accessors and Mutators methods
 109         // @{
 110
 111         /**
 112          * Use these methods to change a value, add or delete elements.
 113          */
 114
 115         NLMISC::CSheetId                                getSheet() const;
 116
 117         sint32                                                  getFame() const;
 118         void                                                    setFame(sint32 __v, bool forceWrite=false);
 119
 120         sint32                                                  getFameMemory() const;
 121         void                                                    setFameMemory(sint32 __v, bool forceWrite=false);
 122
 123         CFameTrend::TFameTrend                  getLastFameChangeTrend() const;
 124         void                                                    setLastFameChangeTrend(CFameTrend::TFameTrend __v, bool forceWrite=false);
 125
 126         CFameContainerPD*                               getParent();
 127         const CFameContainerPD*                 getParent() const;
 128
 129         // @}
 130
 131
 132 public:
 133
 134         /// \name Public Management methods
 135         // @{
 136
 137         /**
 138          * Use these methods to create, load, unload and get
 139          * an object from database.
 140          */
 141
 142
 143         /**
 144          * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
 145          */
 146         void                                                    clear();
 147
 148         /**
 149          * Cast base object to CFameContainerEntryPD
 150          */
 151         static CFameContainerEntryPD*   cast(RY_PDS::IPDBaseData* obj);
 152
 153         /**
 154          * Cast base object to const CFameContainerEntryPD
 155          */
 156         static const CFameContainerEntryPD*     cast(const RY_PDS::IPDBaseData* obj);
 157
 158         // @}
 159
 160
 161 public:
 162
 163         /// \name Public constructor
 164         // @{
 165
 166         /**
 167          * This constructor is public to allow direct instanciation of the class
 168          */
 169
 170         CFameContainerEntryPD();
 171         ~CFameContainerEntryPD();
 172
 173         // @}
 174
 175
 176 public:
 177
 178         /// \name Persistent methods declaration
 179         // @{
 180
 181         void                                                    apply(CPersistentDataRecord &__pdr);
 182         void                                                    store(CPersistentDataRecord &__pdr) const;
 183
 184         // @}
 185
 186
 187 protected:
 188
 189         /// \name Attributes
 190         // @{
 191
 192         /**
 193          * Don't modify those value manually, use accessors and mutators above
 194          */
 195
 196         NLMISC::CSheetId                                _Sheet;
 197         sint32                                                  _Fame;
 198         sint32                                                  _FameMemory;
 199         CFameTrend::TFameTrend                  _LastFameChangeTrend;
 200         CFameContainerPD*                               _Parent;
 201
 202         // @}
 203
 204
 205 protected:
 206
 207         /// \name Internal Management methods
 208         // @{
 209
 210         void                                                    pds__init(const NLMISC::CSheetId &Sheet);
 211         void                                                    pds__destroy();
 212         void                                                    pds__fetch(RY_PDS::CPData &data);
 213         void                                                    pds__register();
 214         void                                                    pds__registerAttributes();
 215         void                                                    pds__unregister();
 216         void                                                    pds__unregisterAttributes();
 217         void                                                    pds__setParent(CFameContainerPD* __parent);
 218         void                                                    pds__setParentUnnotified(CFameContainerPD* __parent);
 219         void                                                    pds__notifyInit();
 220         void                                                    pds__notifyRelease();
 221         static void                                             pds_static__init();
 222
 223         // @}
 224
 225
 226 protected:
 227
 228         /// \name Default Factory and Fetch methods
 229         // @{
 230
 231         static RY_PDS::CIndexAllocator  _IndexAllocator;
 232
 233         // @}
 234
 235
 236 protected:
 237
 238         friend class CFameContainerPD;
 239         friend class RY_PDS::CPDSLib;
 240         friend void EGSPD::init(uint32);
 241 };
 242
 243 /** CFameContainerPD
 244  * defined at entities_game_service/pd_scripts/fame.pds:20
 245  */
 246 class CFameContainerPD : public RY_PDS::IPDBaseData
 247 {
 248
 249 public:
 250
 251         /// \name Accessors and Mutators methods
 252         // @{
 253
 254         /**
 255          * Use these methods to change a value, add or delete elements.
 256          */
 257
 258         NLMISC::CEntityId                               getContId() const;
 259
 260         CFameContainerEntryPD*                  getEntries(const NLMISC::CSheetId& __k);
 261         const CFameContainerEntryPD*    getEntries(const NLMISC::CSheetId& __k) const;
 262         std::map<NLMISC::CSheetId, CFameContainerEntryPD>::iterator     getEntriesBegin();
 263         std::map<NLMISC::CSheetId, CFameContainerEntryPD>::iterator     getEntriesEnd();
 264         std::map<NLMISC::CSheetId, CFameContainerEntryPD>::const_iterator       getEntriesBegin() const;
 265         std::map<NLMISC::CSheetId, CFameContainerEntryPD>::const_iterator       getEntriesEnd() const;
 266         const std::map<NLMISC::CSheetId, CFameContainerEntryPD> &       getEntries() const;
 267         CFameContainerEntryPD*                  addToEntries(const NLMISC::CSheetId &__k);
 268         void                                                    deleteFromEntries(const NLMISC::CSheetId &__k);
 269
 270         uint32                                                  getLastGuildStatusChange() const;
 271         void                                                    setLastGuildStatusChange(uint32 __v, bool forceWrite=false);
 272
 273         uint32                                                  getLastFameChangeDate() const;
 274         void                                                    setLastFameChangeDate(uint32 __v, bool forceWrite=false);
 275
 276         // @}
 277
 278
 279 public:
 280
 281         /// \name Public Management methods
 282         // @{
 283
 284         /**
 285          * Use these methods to create, load, unload and get
 286          * an object from database.
 287          */
 288
 289
 290         /**
 291          * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
 292          */
 293         virtual void                                    clear();
 294
 295         /**
 296          * Cast base object to CFameContainerPD
 297          */
 298         static CFameContainerPD*                cast(RY_PDS::IPDBaseData* obj);
 299
 300         /**
 301          * Cast base object to const CFameContainerPD
 302          */
 303         static const CFameContainerPD*  cast(const RY_PDS::IPDBaseData* obj);
 304
 305         /**
 306          * Create an object of the CFameContainerPD class, and declare it to the PDS.
 307          */
 308         static CFameContainerPD*                create(const NLMISC::CEntityId &ContId);
 309
 310         /**
 311          * Destroy an object from the PDS. Caution! Object will no longer exist in database.
 312          * Also children (that is objects that belong to this object) are also destroyed.
 313          */
 314         static void                                             remove(const NLMISC::CEntityId& ContId);
 315
 316         /**
 317          * Retrieve an object from the database.
 318          * Data are sent asynchronously, so the load callback is called when data are ready.
 319          * Use get() to access to the loaded object.
 320          */
 321         static void                                             load(const NLMISC::CEntityId& ContId);
 322
 323         /**
 324          * Setup load callback so client is warned that load succeded or failed.
 325          */
 326         static void                                             setLoadCallback(void (*callback)(const NLMISC::CEntityId& key, CFameContainerPD* object));
 327
 328         /**
 329          * Unload an object from the client memory. Object still exists in database and can be retrieved again using load.
 330          */
 331         static void                                             unload(const NLMISC::CEntityId &ContId);
 332
 333         /**
 334          * Get an object in client. Object must have been previously loaded from database with a load.
 335          */
 336         static CFameContainerPD*                get(const NLMISC::CEntityId &ContId);
 337
 338         /**
 339          * Return the begin iterator of the global map of CFameContainerPD
 340          */
 341         static std::map<NLMISC::CEntityId, CFameContainerPD*>::iterator begin();
 342
 343         /**
 344          * Return the end iterator of the global map of CFameContainerPD
 345          */
 346         static std::map<NLMISC::CEntityId, CFameContainerPD*>::iterator end();
 347
 348         // @}
 349
 350
 351 public:
 352
 353         /// \name Public constructor
 354         // @{
 355
 356         /**
 357          * This constructor is public to allow direct instanciation of the class
 358          */
 359
 360         CFameContainerPD();
 361         virtual ~CFameContainerPD();
 362
 363         // @}
 364
 365
 366 public:
 367
 368         /// \name Persistent methods declaration
 369         // @{
 370
 371         virtual void                                    apply(CPersistentDataRecord &__pdr);
 372         virtual void                                    store(CPersistentDataRecord &__pdr) const;
 373
 374         // @}
 375
 376
 377 protected:
 378
 379         /// \name Attributes
 380         // @{
 381
 382         /**
 383          * Don't modify those value manually, use accessors and mutators above
 384          */
 385
 386         NLMISC::CEntityId                               _ContId;
 387         std::map<NLMISC::CSheetId, CFameContainerEntryPD>       _Entries;
 388         uint32                                                  _LastGuildStatusChange;
 389         uint32                                                  _LastFameChangeDate;
 390
 391         // @}
 392
 393
 394 protected:
 395
 396         /// \name Internal Management methods
 397         // @{
 398
 399         virtual void                                    pds__init(const NLMISC::CEntityId &ContId);
 400         virtual void                                    pds__destroy();
 401         virtual void                                    pds__fetch(RY_PDS::CPData &data);
 402         virtual void                                    pds__register();
 403         virtual void                                    pds__registerAttributes();
 404         virtual void                                    pds__unregister();
 405         virtual void                                    pds__unregisterAttributes();
 406         virtual void                                    pds__notifyInit();
 407         virtual void                                    pds__notifyRelease();
 408         static void                                             pds_static__init();
 409
 410         // @}
 411
 412
 413 protected:
 414
 415         static std::map<NLMISC::CEntityId,CFameContainerPD*>    _Map;
 416
 417 protected:
 418
 419         /// \name Default Factory and Fetch methods
 420         // @{
 421
 422         static void                                             pds_static__setFactory(RY_PDS::TPDFactory userFactory);
 423         static bool                                             _FactoryInitialised;
 424         static void                                             pds_static__notifyFailure(uint64 key);
 425         static void                                             (*__pds__LoadCallback)(const NLMISC::CEntityId& key, CFameContainerPD* object);
 426         static RY_PDS::CIndexAllocator  _IndexAllocator;
 427         static RY_PDS::IPDBaseData*             pds_static__factory();
 428         static void                                             pds_static__fetch(RY_PDS::IPDBaseData *object, RY_PDS::CPData &data);
 429
 430         // @}
 431
 432
 433 protected:
 434
 435         friend class CFameContainerEntryPD;
 436         friend class RY_PDS::CPDSLib;
 437         friend void EGSPD::init(uint32);
 438 };
 439
 440 /** CGuildFameContainerPD
 441  * defined at entities_game_service/pd_scripts/fame.pds:30
 442  */
 443 class CGuildFameContainerPD : public CFameContainerPD
 444 {
 445
 446 public:
 447
 448         /// \name Accessors and Mutators methods
 449         // @{
 450
 451         /**
 452          * Use these methods to change a value, add or delete elements.
 453          */
 454
 455         CGuildPD*                                               getParent();
 456         const CGuildPD*                                 getParent() const;
 457
 458         // @}
 459
 460
 461 public:
 462
 463         /// \name Public Management methods
 464         // @{
 465
 466         /**
 467          * Use these methods to create, load, unload and get
 468          * an object from database.
 469          */
 470
 471
 472         /**
 473          * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
 474          */
 475         virtual void                                    clear();
 476
 477         /**
 478          * Cast base object to CGuildFameContainerPD
 479          */
 480         static CGuildFameContainerPD*   cast(RY_PDS::IPDBaseData* obj);
 481
 482         /**
 483          * Cast base object to const CGuildFameContainerPD
 484          */
 485         static const CGuildFameContainerPD*     cast(const RY_PDS::IPDBaseData* obj);
 486
 487         /**
 488          * Create an object of the CGuildFameContainerPD class, and declare it to the PDS.
 489          */
 490         static CGuildFameContainerPD*   create(const NLMISC::CEntityId &ContId);
 491
 492         // @}
 493
 494
 495 public:
 496
 497         /// \name Public constructor
 498         // @{
 499
 500         /**
 501          * This constructor is public to allow direct instanciation of the class
 502          */
 503
 504         CGuildFameContainerPD();
 505         virtual ~CGuildFameContainerPD();
 506
 507         // @}
 508
 509
 510 public:
 511
 512         /// \name Persistent methods declaration
 513         // @{
 514
 515         virtual void                                    apply(CPersistentDataRecord &__pdr);
 516         virtual void                                    store(CPersistentDataRecord &__pdr) const;
 517
 518         // @}
 519
 520
 521 protected:
 522
 523         /// \name Attributes
 524         // @{
 525
 526         /**
 527          * Don't modify those value manually, use accessors and mutators above
 528          */
 529
 530         CGuildPD*                                               _Parent;
 531
 532         // @}
 533
 534
 535 protected:
 536
 537         /// \name Internal Management methods
 538         // @{
 539
 540         virtual void                                    pds__init(const NLMISC::CEntityId &ContId);
 541         virtual void                                    pds__destroy();
 542         virtual void                                    pds__fetch(RY_PDS::CPData &data);
 543         virtual void                                    pds__register();
 544         virtual void                                    pds__registerAttributes();
 545         virtual void                                    pds__unregister();
 546         virtual void                                    pds__unregisterAttributes();
 547         void                                                    pds__setParent(CGuildPD* __parent);
 548         void                                                    pds__setParentUnnotified(CGuildPD* __parent);
 549         virtual void                                    pds__notifyInit();
 550         virtual void                                    pds__notifyRelease();
 551         static void                                             pds_static__init();
 552
 553         // @}
 554
 555
 556 protected:
 557
 558         /// \name Default Factory and Fetch methods
 559         // @{
 560
 561         static void                                             pds_static__setFactory(RY_PDS::TPDFactory userFactory);
 562         static bool                                             _FactoryInitialised;
 563         static RY_PDS::CIndexAllocator  _IndexAllocator;
 564         static RY_PDS::IPDBaseData*             pds_static__factory();
 565
 566         // @}
 567
 568
 569 protected:
 570
 571         friend class CGuildContainerPD;
 572         friend class CGuildPD;
 573         friend class RY_PDS::CPDSLib;
 574         friend void EGSPD::init(uint32);
 575 };
 576
 577
 578 } // End of EGSPD
 579
 580 #endif