ryzom/server/src/entities_game_service/database_guild.h

   1
   2
   3 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   4 // Copyright (C) 2010  Winch Gate Property Limited
   5 //
   6 // This program is free software: you can redistribute it and/or modify
   7 // it under the terms of the GNU Affero General Public License as
   8 // published by the Free Software Foundation, either version 3 of the
   9 // License, or (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU Affero General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Affero General Public License
  17 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 /////////////////////////////////////////////////////////////////
  20 // WARNING : this is a generated file, don't change it !
  21 /////////////////////////////////////////////////////////////////
  22
  23 #ifndef INCLUDED_DATABASE_database_GUILD_H
  24 #define INCLUDED_DATABASE_database_GUILD_H
  25
  26 #include "nel/misc/string_common.h"
  27 #include "cdb_group.h"
  28 #include "player_manager/cdb.h"
  29 #include "player_manager/cdb_synchronised.h"
  30
  31
  32 #include "game_share/far_position.h"
  33         inline void _setProp(CCDBSynchronised &db,
  34       ICDBStructNode *node, TCharConnectionState value, bool
  35       forceSending = false) { db.x_setProp(node, uint64(value),
  36       forceSending); } inline void _getProp(const CCDBSynchronised
  37       &db, ICDBStructNode *node, TCharConnectionState
  38       &value) { value =
  39       (TCharConnectionState)db.x_getProp(node); }
  40
  41
  42 #ifndef _SET_PROP_ACCESSOR_
  43 #define _SET_PROP_ACCESSOR_
  44 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, bool value, bool forceSending = false)
  45 {
  46         db.x_setProp(node, uint64(value), forceSending);
  47 }
  48 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, uint8 value, bool forceSending = false)
  49 {
  50         db.x_setProp(node, uint64(value), forceSending);
  51 }
  52 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, uint16 value, bool forceSending = false)
  53 {
  54         db.x_setProp(node, uint64(value), forceSending);
  55 }
  56 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, uint32 value, bool forceSending = false)
  57 {
  58         db.x_setProp(node, uint64(value), forceSending);
  59 }
  60 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, uint64 value, bool forceSending = false)
  61 {
  62         db.x_setProp(node, uint64(value), forceSending);
  63 }
  64 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, sint8 value, bool forceSending = false)
  65 {
  66         db.x_setProp(node, uint64(value), forceSending);
  67 }
  68 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, sint16 value, bool forceSending = false)
  69 {
  70         db.x_setProp(node, uint64(value), forceSending);
  71 }
  72 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, sint32 value, bool forceSending = false)
  73 {
  74         db.x_setProp(node, uint64(value), forceSending);
  75 }
  76 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, sint64 value, bool forceSending = false)
  77 {
  78         db.x_setProp(node, uint64(value), forceSending);
  79 }
  80 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, const std::string &value, bool forceSending = false)
  81 {
  82         db.x_setPropString(node, value, forceSending);
  83 }
  84 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, const ucstring &value, bool forceSending = false)
  85 {
  86         db.x_setPropString(node, value, forceSending);
  87 }
  88 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, const NLMISC::CSheetId &value, bool forceSending = false)
  89 {
  90         db.x_setProp(node, uint64(value.asInt()), forceSending);
  91 }
  92
  93
  94 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, bool &value)
  95 {
  96         value = db.x_getProp(node) != 0;
  97 }
  98 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, uint8 &value)
  99 {
 100         value = uint8(db.x_getProp(node));
 101 }
 102 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, uint16 &value)
 103 {
 104         value = uint16(db.x_getProp(node));
 105 }
 106 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, uint32 &value)
 107 {
 108         value = uint32(db.x_getProp(node));
 109 }
 110 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, uint64 &value)
 111 {
 112         value = db.x_getProp(node);
 113 }
 114 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, sint8 &value)
 115 {
 116         value = uint8(db.x_getProp(node));
 117 }
 118 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, sint16 &value)
 119 {
 120         value = uint16(db.x_getProp(node));
 121 }
 122 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, sint32 &value)
 123 {
 124         value = uint32(db.x_getProp(node));
 125 }
 126 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, sint64 &value)
 127 {
 128         value = db.x_getProp(node);
 129 }
 130 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, std::string &value)
 131 {
 132         value = db.x_getPropString(node);
 133 }
 134 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, ucstring &value)
 135 {
 136         value = db.x_getPropUcstring(node);
 137 }
 138 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, NLMISC::CSheetId &value)
 139 {
 140         value = uint32(db.x_getProp(node));
 141 }
 142 #endif // _SET_PROP_ACCESSOR_
 143
 144
 145
 146         class CBankAccessor_GUILD : public CCDBGroup
 147         {
 148         public:
 149                 static TCDBBank BankTag;
 150
 151
 152         class TGUILD
 153         {
 154         public:
 155
 156         class TFAME
 157         {
 158         public:
 159
 160         class TArray
 161         {
 162         public:
 163
 164
 165         private:
 166                 ICDBStructNode  *_BranchNode;
 167
 168                 ICDBStructNode  *_VALUE;
 169                 ICDBStructNode  *_THRESHOLD;
 170                 ICDBStructNode  *_TREND;
 171
 172
 173         public:
 174                 void init(ICDBStructNode *parent, uint index);
 175
 176                 // accessor to branch node
 177                 ICDBStructNode *getCDBNode()
 178                 {
 179                         return _BranchNode;
 180                 }
 181
 182
 183                 void setVALUE(CCDBGroup &dbGroup, sint8 value, bool forceSending = false)
 184                 {
 185
 186
 187                         _setProp(dbGroup.Database, _VALUE, value, forceSending);
 188                 }
 189
 190                 sint8 getVALUE(const CCDBGroup &dbGroup)
 191                 {
 192                         sint8 value;
 193                         _getProp(dbGroup.Database, _VALUE, value);
 194
 195                         return value;
 196                 }
 197
 198                 ICDBStructNode *getVALUECDBNode()
 199                 {
 200                         return _VALUE;
 201                 }
 202
 203                 void setTHRESHOLD(CCDBGroup &dbGroup, sint8 value, bool forceSending = false)
 204                 {
 205
 206
 207                         _setProp(dbGroup.Database, _THRESHOLD, value, forceSending);
 208                 }
 209
 210                 sint8 getTHRESHOLD(const CCDBGroup &dbGroup)
 211                 {
 212                         sint8 value;
 213                         _getProp(dbGroup.Database, _THRESHOLD, value);
 214
 215                         return value;
 216                 }
 217
 218                 ICDBStructNode *getTHRESHOLDCDBNode()
 219                 {
 220                         return _THRESHOLD;
 221                 }
 222
 223                 void setTREND(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
 224                 {
 225
 226
 227                         _setProp(dbGroup.Database, _TREND, value, forceSending);
 228                 }
 229
 230                 uint8 getTREND(const CCDBGroup &dbGroup)
 231                 {
 232                         uint8 value;
 233                         _getProp(dbGroup.Database, _TREND, value);
 234
 235                         return value;
 236                 }
 237
 238                 ICDBStructNode *getTRENDCDBNode()
 239                 {
 240                         return _TREND;
 241                 }
 242
 243         };
 244
 245
 246         private:
 247                 ICDBStructNode  *_BranchNode;
 248
 249                 ICDBStructNode  *_CULT_ALLEGIANCE;
 250                 ICDBStructNode  *_CIV_ALLEGIANCE;
 251                 TArray _Array[7];
 252
 253
 254         public:
 255                 void init(ICDBStructNode *parent);
 256
 257                 // accessor to branch node
 258                 ICDBStructNode *getCDBNode()
 259                 {
 260                         return _BranchNode;
 261                 }
 262
 263
 264                 void setCULT_ALLEGIANCE(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
 265                 {
 266
 267                         // Check that the value is not out of database precision
 268                         STOP_IF(value > (1<<3)-1, "setCULT_ALLEGIANCE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
 269
 270
 271                         _setProp(dbGroup.Database, _CULT_ALLEGIANCE, value, forceSending);
 272                 }
 273
 274                 uint8 getCULT_ALLEGIANCE(const CCDBGroup &dbGroup)
 275                 {
 276                         uint8 value;
 277                         _getProp(dbGroup.Database, _CULT_ALLEGIANCE, value);
 278
 279                         return value;
 280                 }
 281
 282                 ICDBStructNode *getCULT_ALLEGIANCECDBNode()
 283                 {
 284                         return _CULT_ALLEGIANCE;
 285                 }
 286
 287                 void setCIV_ALLEGIANCE(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
 288                 {
 289
 290                         // Check that the value is not out of database precision
 291                         STOP_IF(value > (1<<3)-1, "setCIV_ALLEGIANCE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
 292
 293
 294                         _setProp(dbGroup.Database, _CIV_ALLEGIANCE, value, forceSending);
 295                 }
 296
 297                 uint8 getCIV_ALLEGIANCE(const CCDBGroup &dbGroup)
 298                 {
 299                         uint8 value;
 300                         _getProp(dbGroup.Database, _CIV_ALLEGIANCE, value);
 301
 302                         return value;
 303                 }
 304
 305                 ICDBStructNode *getCIV_ALLEGIANCECDBNode()
 306                 {
 307                         return _CIV_ALLEGIANCE;
 308                 }
 309         TArray &getArray(uint32 index)
 310                 {
 311                         nlassert(index < 7);
 312                         return _Array[index];
 313                 }
 314
 315         };
 316
 317         class TMEMBERS
 318         {
 319         public:
 320
 321         class TArray
 322         {
 323         public:
 324
 325
 326         private:
 327                 ICDBStructNode  *_BranchNode;
 328
 329                 ICDBStructNode  *_NAME;
 330                 ICDBStructNode  *_GRADE;
 331                 ICDBStructNode  *_ONLINE;
 332                 ICDBStructNode  *_ENTER_DATE;
 333
 334
 335         public:
 336                 void init(ICDBStructNode *parent, uint index);
 337
 338                 // accessor to branch node
 339                 ICDBStructNode *getCDBNode()
 340                 {
 341                         return _BranchNode;
 342                 }
 343
 344
 345                 void setNAME(CCDBGroup &dbGroup, ucstring value, bool forceSending = false)
 346                 {
 347
 348
 349                         _setProp(dbGroup.Database, _NAME, value, forceSending);
 350                 }
 351
 352                 ucstring getNAME(const CCDBGroup &dbGroup)
 353                 {
 354                         ucstring value;
 355                         _getProp(dbGroup.Database, _NAME, value);
 356
 357                         return value;
 358                 }
 359
 360                 void setNAME(CCDBGroup &dbGroup, uint32 stringId, bool forceSending = false)
 361                 {
 362                         _setProp(dbGroup.Database, _NAME, stringId, forceSending);
 363                 }
 364                 uint32 getNAME_id(const CCDBGroup &dbGroup)
 365                 {
 366                         uint32 value;
 367                         _getProp(dbGroup.Database, _NAME, value);
 368
 369                         return value;
 370                 }
 371
 372                 ICDBStructNode *getNAMECDBNode()
 373                 {
 374                         return _NAME;
 375                 }
 376
 377                 void setGRADE(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
 378                 {
 379
 380                         // Check that the value is not out of database precision
 381                         STOP_IF(value > (1<<3)-1, "setGRADE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
 382
 383
 384                         _setProp(dbGroup.Database, _GRADE, value, forceSending);
 385                 }
 386
 387                 uint8 getGRADE(const CCDBGroup &dbGroup)
 388                 {
 389                         uint8 value;
 390                         _getProp(dbGroup.Database, _GRADE, value);
 391
 392                         return value;
 393                 }
 394
 395                 ICDBStructNode *getGRADECDBNode()
 396                 {
 397                         return _GRADE;
 398                 }
 399
 400                 void setONLINE(CCDBGroup &dbGroup, TCharConnectionState value, bool forceSending = false)
 401                 {
 402
 403
 404                         _setProp(dbGroup.Database, _ONLINE, value, forceSending);
 405                 }
 406
 407                 TCharConnectionState getONLINE(const CCDBGroup &dbGroup)
 408                 {
 409                         TCharConnectionState value;
 410                         _getProp(dbGroup.Database, _ONLINE, value);
 411
 412                         return value;
 413                 }
 414
 415                 ICDBStructNode *getONLINECDBNode()
 416                 {
 417                         return _ONLINE;
 418                 }
 419
 420                 void setENTER_DATE(CCDBGroup &dbGroup, uint32 value, bool forceSending = false)
 421                 {
 422
 423
 424                         _setProp(dbGroup.Database, _ENTER_DATE, value, forceSending);
 425                 }
 426
 427                 uint32 getENTER_DATE(const CCDBGroup &dbGroup)
 428                 {
 429                         uint32 value;
 430                         _getProp(dbGroup.Database, _ENTER_DATE, value);
 431
 432                         return value;
 433                 }
 434
 435                 ICDBStructNode *getENTER_DATECDBNode()
 436                 {
 437                         return _ENTER_DATE;
 438                 }
 439
 440         };
 441
 442
 443         private:
 444                 ICDBStructNode  *_BranchNode;
 445
 446                 TArray _Array[256];
 447
 448
 449         public:
 450                 void init(ICDBStructNode *parent);
 451
 452                 // accessor to branch node
 453                 ICDBStructNode *getCDBNode()
 454                 {
 455                         return _BranchNode;
 456                 }
 457
 458                 TArray &getArray(uint32 index)
 459                 {
 460                         nlassert(index < 256);
 461                         return _Array[index];
 462                 }
 463
 464         };
 465
 466         class TINVENTORY
 467         {
 468         public:
 469
 470
 471         private:
 472                 ICDBStructNode  *_BranchNode;
 473
 474                 ICDBStructNode  *_SESSION;
 475                 ICDBStructNode  *_BULK_MAX;
 476                 ICDBStructNode  *_MONEY;
 477
 478
 479         public:
 480                 void init(ICDBStructNode *parent);
 481
 482                 // accessor to branch node
 483                 ICDBStructNode *getCDBNode()
 484                 {
 485                         return _BranchNode;
 486                 }
 487
 488
 489                 void setSESSION(CCDBGroup &dbGroup, uint16 value, bool forceSending = false)
 490                 {
 491
 492
 493                         _setProp(dbGroup.Database, _SESSION, value, forceSending);
 494                 }
 495
 496                 uint16 getSESSION(const CCDBGroup &dbGroup)
 497                 {
 498                         uint16 value;
 499                         _getProp(dbGroup.Database, _SESSION, value);
 500
 501                         return value;
 502                 }
 503
 504                 ICDBStructNode *getSESSIONCDBNode()
 505                 {
 506                         return _SESSION;
 507                 }
 508
 509                 void setBULK_MAX(CCDBGroup &dbGroup, uint32 value, bool forceSending = false)
 510                 {
 511
 512
 513                         _setProp(dbGroup.Database, _BULK_MAX, value, forceSending);
 514                 }
 515
 516                 uint32 getBULK_MAX(const CCDBGroup &dbGroup)
 517                 {
 518                         uint32 value;
 519                         _getProp(dbGroup.Database, _BULK_MAX, value);
 520
 521                         return value;
 522                 }
 523
 524                 ICDBStructNode *getBULK_MAXCDBNode()
 525                 {
 526                         return _BULK_MAX;
 527                 }
 528
 529                 void setMONEY(CCDBGroup &dbGroup, uint64 value, bool forceSending = false)
 530                 {
 531
 532
 533                         _setProp(dbGroup.Database, _MONEY, value, forceSending);
 534                 }
 535
 536                 uint64 getMONEY(const CCDBGroup &dbGroup)
 537                 {
 538                         uint64 value;
 539                         _getProp(dbGroup.Database, _MONEY, value);
 540
 541                         return value;
 542                 }
 543
 544                 ICDBStructNode *getMONEYCDBNode()
 545                 {
 546                         return _MONEY;
 547                 }
 548
 549         };
 550
 551         class TOUTPOST
 552         {
 553         public:
 554
 555         class TO
 556         {
 557         public:
 558
 559         class TGUILD
 560         {
 561         public:
 562
 563
 564         private:
 565                 ICDBStructNode  *_BranchNode;
 566
 567                 ICDBStructNode  *_NAME;
 568                 ICDBStructNode  *_ICON;
 569                 ICDBStructNode  *_TRIBE;
 570                 ICDBStructNode  *_NAME_ATT;
 571
 572
 573         public:
 574                 void init(ICDBStructNode *parent);
 575
 576                 // accessor to branch node
 577                 ICDBStructNode *getCDBNode()
 578                 {
 579                         return _BranchNode;
 580                 }
 581
 582
 583                 void setNAME(CCDBGroup &dbGroup, ucstring value, bool forceSending = false)
 584                 {
 585
 586
 587                         _setProp(dbGroup.Database, _NAME, value, forceSending);
 588                 }
 589
 590                 ucstring getNAME(const CCDBGroup &dbGroup)
 591                 {
 592                         ucstring value;
 593                         _getProp(dbGroup.Database, _NAME, value);
 594
 595                         return value;
 596                 }
 597
 598                 void setNAME(CCDBGroup &dbGroup, uint32 stringId, bool forceSending = false)
 599                 {
 600                         _setProp(dbGroup.Database, _NAME, stringId, forceSending);
 601                 }
 602                 uint32 getNAME_id(const CCDBGroup &dbGroup)
 603                 {
 604                         uint32 value;
 605                         _getProp(dbGroup.Database, _NAME, value);
 606
 607                         return value;
 608                 }
 609
 610                 ICDBStructNode *getNAMECDBNode()
 611                 {
 612                         return _NAME;
 613                 }
 614
 615                 void setICON(CCDBGroup &dbGroup, uint64 value, bool forceSending = false)
 616                 {
 617
 618
 619                         _setProp(dbGroup.Database, _ICON, value, forceSending);
 620                 }
 621
 622                 uint64 getICON(const CCDBGroup &dbGroup)
 623                 {
 624                         uint64 value;
 625                         _getProp(dbGroup.Database, _ICON, value);
 626
 627                         return value;
 628                 }
 629
 630                 ICDBStructNode *getICONCDBNode()
 631                 {
 632                         return _ICON;
 633                 }
 634
 635                 void setTRIBE(CCDBGroup &dbGroup, bool value, bool forceSending = false)
 636                 {
 637
 638
 639                         _setProp(dbGroup.Database, _TRIBE, value, forceSending);
 640                 }
 641
 642                 bool getTRIBE(const CCDBGroup &dbGroup)
 643                 {
 644                         bool value;
 645                         _getProp(dbGroup.Database, _TRIBE, value);
 646
 647                         return value;
 648                 }
 649
 650                 ICDBStructNode *getTRIBECDBNode()
 651                 {
 652                         return _TRIBE;
 653                 }
 654
 655                 void setNAME_ATT(CCDBGroup &dbGroup, ucstring value, bool forceSending = false)
 656                 {
 657
 658
 659                         _setProp(dbGroup.Database, _NAME_ATT, value, forceSending);
 660                 }
 661
 662                 ucstring getNAME_ATT(const CCDBGroup &dbGroup)
 663                 {
 664                         ucstring value;
 665                         _getProp(dbGroup.Database, _NAME_ATT, value);
 666
 667                         return value;
 668                 }
 669
 670                 void setNAME_ATT(CCDBGroup &dbGroup, uint32 stringId, bool forceSending = false)
 671                 {
 672                         _setProp(dbGroup.Database, _NAME_ATT, stringId, forceSending);
 673                 }
 674                 uint32 getNAME_ATT_id(const CCDBGroup &dbGroup)
 675                 {
 676                         uint32 value;
 677                         _getProp(dbGroup.Database, _NAME_ATT, value);
 678
 679                         return value;
 680                 }
 681
 682                 ICDBStructNode *getNAME_ATTCDBNode()
 683                 {
 684                         return _NAME_ATT;
 685                 }
 686
 687         };
 688
 689         class TSQUAD_SPAWN_ZONE
 690         {
 691         public:
 692
 693         class TArray
 694         {
 695         public:
 696
 697
 698         private:
 699                 ICDBStructNode  *_BranchNode;
 700
 701                 ICDBStructNode  *_X;
 702                 ICDBStructNode  *_Y;
 703
 704
 705         public:
 706                 void init(ICDBStructNode *parent, uint index);
 707
 708                 // accessor to branch node
 709                 ICDBStructNode *getCDBNode()
 710                 {
 711                         return _BranchNode;
 712                 }
 713
 714
 715                 void setX(CCDBGroup &dbGroup, sint32 value, bool forceSending = false)
 716                 {
 717
 718
 719                         _setProp(dbGroup.Database, _X, value, forceSending);
 720                 }
 721
 722                 sint32 getX(const CCDBGroup &dbGroup)
 723                 {
 724                         sint32 value;
 725                         _getProp(dbGroup.Database, _X, value);
 726
 727                         return value;
 728                 }
 729
 730                 ICDBStructNode *getXCDBNode()
 731                 {
 732                         return _X;
 733                 }
 734
 735                 void setY(CCDBGroup &dbGroup, sint32 value, bool forceSending = false)
 736                 {
 737
 738
 739                         _setProp(dbGroup.Database, _Y, value, forceSending);
 740                 }
 741
 742                 sint32 getY(const CCDBGroup &dbGroup)
 743                 {
 744                         sint32 value;
 745                         _getProp(dbGroup.Database, _Y, value);
 746
 747                         return value;
 748                 }
 749
 750                 ICDBStructNode *getYCDBNode()
 751                 {
 752                         return _Y;
 753                 }
 754
 755         };
 756
 757
 758         private:
 759                 ICDBStructNode  *_BranchNode;
 760
 761                 TArray _Array[16];
 762
 763
 764         public:
 765                 void init(ICDBStructNode *parent);
 766
 767                 // accessor to branch node
 768                 ICDBStructNode *getCDBNode()
 769                 {
 770                         return _BranchNode;
 771                 }
 772
 773                 TArray &getArray(uint32 index)
 774                 {
 775                         nlassert(index < 16);
 776                         return _Array[index];
 777                 }
 778
 779         };
 780
 781         class TSQUAD_SHOP
 782         {
 783         public:
 784
 785         class TArray
 786         {
 787         public:
 788
 789
 790         private:
 791                 ICDBStructNode  *_BranchNode;
 792
 793                 ICDBStructNode  *_SHEET;
 794
 795
 796         public:
 797                 void init(ICDBStructNode *parent, uint index);
 798
 799                 // accessor to branch node
 800                 ICDBStructNode *getCDBNode()
 801                 {
 802                         return _BranchNode;
 803                 }
 804
 805
 806                 void setSHEET(CCDBGroup &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
 807                 {
 808
 809
 810                         _setProp(dbGroup.Database, _SHEET, value, forceSending);
 811                 }
 812
 813                 NLMISC::CSheetId getSHEET(const CCDBGroup &dbGroup)
 814                 {
 815                         NLMISC::CSheetId value;
 816                         _getProp(dbGroup.Database, _SHEET, value);
 817
 818                         return value;
 819                 }
 820
 821                 ICDBStructNode *getSHEETCDBNode()
 822                 {
 823                         return _SHEET;
 824                 }
 825
 826         };
 827
 828
 829         private:
 830                 ICDBStructNode  *_BranchNode;
 831
 832                 TArray _Array[16];
 833
 834
 835         public:
 836                 void init(ICDBStructNode *parent);
 837
 838                 // accessor to branch node
 839                 ICDBStructNode *getCDBNode()
 840                 {
 841                         return _BranchNode;
 842                 }
 843
 844                 TArray &getArray(uint32 index)
 845                 {
 846                         nlassert(index < 16);
 847                         return _Array[index];
 848                 }
 849
 850         };
 851
 852         class TSQUADS
 853         {
 854         public:
 855
 856         class TSP
 857         {
 858         public:
 859
 860
 861         private:
 862                 ICDBStructNode  *_BranchNode;
 863
 864                 ICDBStructNode  *_SHEET;
 865
 866
 867         public:
 868                 void init(ICDBStructNode *parent, uint index);
 869
 870                 // accessor to branch node
 871                 ICDBStructNode *getCDBNode()
 872                 {
 873                         return _BranchNode;
 874                 }
 875
 876
 877                 void setSHEET(CCDBGroup &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
 878                 {
 879
 880
 881                         _setProp(dbGroup.Database, _SHEET, value, forceSending);
 882                 }
 883
 884                 NLMISC::CSheetId getSHEET(const CCDBGroup &dbGroup)
 885                 {
 886                         NLMISC::CSheetId value;
 887                         _getProp(dbGroup.Database, _SHEET, value);
 888
 889                         return value;
 890                 }
 891
 892                 ICDBStructNode *getSHEETCDBNode()
 893                 {
 894                         return _SHEET;
 895                 }
 896
 897         };
 898
 899         class TT
 900         {
 901         public:
 902
 903
 904         private:
 905                 ICDBStructNode  *_BranchNode;
 906
 907                 ICDBStructNode  *_SHEET;
 908                 ICDBStructNode  *_SPAWN;
 909
 910
 911         public:
 912                 void init(ICDBStructNode *parent, uint index);
 913
 914                 // accessor to branch node
 915                 ICDBStructNode *getCDBNode()
 916                 {
 917                         return _BranchNode;
 918                 }
 919
 920
 921                 void setSHEET(CCDBGroup &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
 922                 {
 923
 924
 925                         _setProp(dbGroup.Database, _SHEET, value, forceSending);
 926                 }
 927
 928                 NLMISC::CSheetId getSHEET(const CCDBGroup &dbGroup)
 929                 {
 930                         NLMISC::CSheetId value;
 931                         _getProp(dbGroup.Database, _SHEET, value);
 932
 933                         return value;
 934                 }
 935
 936                 ICDBStructNode *getSHEETCDBNode()
 937                 {
 938                         return _SHEET;
 939                 }
 940
 941                 void setSPAWN(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
 942                 {
 943
 944                         // Check that the value is not out of database precision
 945                         STOP_IF(value > (1<<4)-1, "setSPAWN : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
 946
 947
 948                         _setProp(dbGroup.Database, _SPAWN, value, forceSending);
 949                 }
 950
 951                 uint8 getSPAWN(const CCDBGroup &dbGroup)
 952                 {
 953                         uint8 value;
 954                         _getProp(dbGroup.Database, _SPAWN, value);
 955
 956                         return value;
 957                 }
 958
 959                 ICDBStructNode *getSPAWNCDBNode()
 960                 {
 961                         return _SPAWN;
 962                 }
 963
 964         };
 965
 966
 967         private:
 968                 ICDBStructNode  *_BranchNode;
 969
 970                 TSP _SP[24];
 971                 TT _T[24];
 972
 973
 974         public:
 975                 void init(ICDBStructNode *parent);
 976
 977                 // accessor to branch node
 978                 ICDBStructNode *getCDBNode()
 979                 {
 980                         return _BranchNode;
 981                 }
 982
 983                 TSP &getSP(uint32 index)
 984                 {
 985                         nlassert(index < 24);
 986                         return _SP[index];
 987                 }
 988                 TT &getT(uint32 index)
 989                 {
 990                         nlassert(index < 24);
 991                         return _T[index];
 992                 }
 993
 994         };
 995
 996         class TBUILDINGS
 997         {
 998         public:
 999
1000         class TArray
1001         {
1002         public:
1003
1004
1005         private:
1006                 ICDBStructNode  *_BranchNode;
1007
1008                 ICDBStructNode  *_SHEET;
1009
1010
1011         public:
1012                 void init(ICDBStructNode *parent, uint index);
1013
1014                 // accessor to branch node
1015                 ICDBStructNode *getCDBNode()
1016                 {
1017                         return _BranchNode;
1018                 }
1019
1020
1021                 void setSHEET(CCDBGroup &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
1022                 {
1023
1024
1025                         _setProp(dbGroup.Database, _SHEET, value, forceSending);
1026                 }
1027
1028                 NLMISC::CSheetId getSHEET(const CCDBGroup &dbGroup)
1029                 {
1030                         NLMISC::CSheetId value;
1031                         _getProp(dbGroup.Database, _SHEET, value);
1032
1033                         return value;
1034                 }
1035
1036                 ICDBStructNode *getSHEETCDBNode()
1037                 {
1038                         return _SHEET;
1039                 }
1040
1041         };
1042
1043
1044         private:
1045                 ICDBStructNode  *_BranchNode;
1046
1047                 TArray _Array[4];
1048
1049
1050         public:
1051                 void init(ICDBStructNode *parent);
1052
1053                 // accessor to branch node
1054                 ICDBStructNode *getCDBNode()
1055                 {
1056                         return _BranchNode;
1057                 }
1058
1059                 TArray &getArray(uint32 index)
1060                 {
1061                         nlassert(index < 4);
1062                         return _Array[index];
1063                 }
1064
1065         };
1066
1067
1068         private:
1069                 ICDBStructNode  *_BranchNode;
1070
1071                 ICDBStructNode  *_OWNED;
1072                 ICDBStructNode  *_SHEET;
1073                 ICDBStructNode  *_LEVEL;
1074                 ICDBStructNode  *_STATUS;
1075                 ICDBStructNode  *_STATE_END_DATE;
1076                 ICDBStructNode  *_DISPLAY_CRASH;
1077                 ICDBStructNode  *_WARCOST;
1078                 ICDBStructNode  *_ROUND_LVL_THRESHOLD;
1079                 ICDBStructNode  *_ROUND_LVL_MAX_ATT;
1080                 ICDBStructNode  *_ROUND_LVL_MAX_DEF;
1081                 ICDBStructNode  *_ROUND_LVL_CUR;
1082                 ICDBStructNode  *_ROUND_ID_CUR;
1083                 ICDBStructNode  *_ROUND_ID_MAX;
1084                 ICDBStructNode  *_TIME_RANGE_DEF_WANTED;
1085                 ICDBStructNode  *_TIME_RANGE_DEF;
1086                 ICDBStructNode  *_TIME_RANGE_ATT;
1087                 ICDBStructNode  *_TIME_RANGE_LENGTH;
1088                 ICDBStructNode  *_SQUAD_CAPITAL;
1089                 TGUILD  _GUILD;
1090                 TSQUAD_SPAWN_ZONE       _SQUAD_SPAWN_ZONE;
1091                 TSQUAD_SHOP     _SQUAD_SHOP;
1092                 TSQUADS _SQUADS;
1093                 TBUILDINGS      _BUILDINGS;
1094
1095
1096         public:
1097                 void init(ICDBStructNode *parent, uint index);
1098
1099                 // accessor to branch node
1100                 ICDBStructNode *getCDBNode()
1101                 {
1102                         return _BranchNode;
1103                 }
1104
1105
1106                 void setOWNED(CCDBGroup &dbGroup, bool value, bool forceSending = false)
1107                 {
1108
1109
1110                         _setProp(dbGroup.Database, _OWNED, value, forceSending);
1111                 }
1112
1113                 bool getOWNED(const CCDBGroup &dbGroup)
1114                 {
1115                         bool value;
1116                         _getProp(dbGroup.Database, _OWNED, value);
1117
1118                         return value;
1119                 }
1120
1121                 ICDBStructNode *getOWNEDCDBNode()
1122                 {
1123                         return _OWNED;
1124                 }
1125
1126                 void setSHEET(CCDBGroup &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
1127                 {
1128
1129
1130                         _setProp(dbGroup.Database, _SHEET, value, forceSending);
1131                 }
1132
1133                 NLMISC::CSheetId getSHEET(const CCDBGroup &dbGroup)
1134                 {
1135                         NLMISC::CSheetId value;
1136                         _getProp(dbGroup.Database, _SHEET, value);
1137
1138                         return value;
1139                 }
1140
1141                 ICDBStructNode *getSHEETCDBNode()
1142                 {
1143                         return _SHEET;
1144                 }
1145
1146                 void setLEVEL(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
1147                 {
1148
1149
1150                         _setProp(dbGroup.Database, _LEVEL, value, forceSending);
1151                 }
1152
1153                 uint8 getLEVEL(const CCDBGroup &dbGroup)
1154                 {
1155                         uint8 value;
1156                         _getProp(dbGroup.Database, _LEVEL, value);
1157
1158                         return value;
1159                 }
1160
1161                 ICDBStructNode *getLEVELCDBNode()
1162                 {
1163                         return _LEVEL;
1164                 }
1165
1166                 void setSTATUS(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
1167                 {
1168
1169                         // Check that the value is not out of database precision
1170                         STOP_IF(value > (1<<4)-1, "setSTATUS : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
1171
1172
1173                         _setProp(dbGroup.Database, _STATUS, value, forceSending);
1174                 }
1175
1176                 uint8 getSTATUS(const CCDBGroup &dbGroup)
1177                 {
1178                         uint8 value;
1179                         _getProp(dbGroup.Database, _STATUS, value);
1180
1181                         return value;
1182                 }
1183
1184                 ICDBStructNode *getSTATUSCDBNode()
1185                 {
1186                         return _STATUS;
1187                 }
1188
1189                 void setSTATE_END_DATE(CCDBGroup &dbGroup, uint32 value, bool forceSending = false)
1190                 {
1191
1192
1193                         _setProp(dbGroup.Database, _STATE_END_DATE, value, forceSending);
1194                 }
1195
1196                 uint32 getSTATE_END_DATE(const CCDBGroup &dbGroup)
1197                 {
1198                         uint32 value;
1199                         _getProp(dbGroup.Database, _STATE_END_DATE, value);
1200
1201                         return value;
1202                 }
1203
1204                 ICDBStructNode *getSTATE_END_DATECDBNode()
1205                 {
1206                         return _STATE_END_DATE;
1207                 }
1208
1209                 void setDISPLAY_CRASH(CCDBGroup &dbGroup, bool value, bool forceSending = false)
1210                 {
1211
1212
1213                         _setProp(dbGroup.Database, _DISPLAY_CRASH, value, forceSending);
1214                 }
1215
1216                 bool getDISPLAY_CRASH(const CCDBGroup &dbGroup)
1217                 {
1218                         bool value;
1219                         _getProp(dbGroup.Database, _DISPLAY_CRASH, value);
1220
1221                         return value;
1222                 }
1223
1224                 ICDBStructNode *getDISPLAY_CRASHCDBNode()
1225                 {
1226                         return _DISPLAY_CRASH;
1227                 }
1228
1229                 void setWARCOST(CCDBGroup &dbGroup, uint32 value, bool forceSending = false)
1230                 {
1231
1232
1233                         _setProp(dbGroup.Database, _WARCOST, value, forceSending);
1234                 }
1235
1236                 uint32 getWARCOST(const CCDBGroup &dbGroup)
1237                 {
1238                         uint32 value;
1239                         _getProp(dbGroup.Database, _WARCOST, value);
1240
1241                         return value;
1242                 }
1243
1244                 ICDBStructNode *getWARCOSTCDBNode()
1245                 {
1246                         return _WARCOST;
1247                 }
1248
1249                 void setROUND_LVL_THRESHOLD(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
1250                 {
1251
1252
1253                         _setProp(dbGroup.Database, _ROUND_LVL_THRESHOLD, value, forceSending);
1254                 }
1255
1256                 uint8 getROUND_LVL_THRESHOLD(const CCDBGroup &dbGroup)
1257                 {
1258                         uint8 value;
1259                         _getProp(dbGroup.Database, _ROUND_LVL_THRESHOLD, value);
1260
1261                         return value;
1262                 }
1263
1264                 ICDBStructNode *getROUND_LVL_THRESHOLDCDBNode()
1265                 {
1266                         return _ROUND_LVL_THRESHOLD;
1267                 }
1268
1269                 void setROUND_LVL_MAX_ATT(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
1270                 {
1271
1272
1273                         _setProp(dbGroup.Database, _ROUND_LVL_MAX_ATT, value, forceSending);
1274                 }
1275
1276                 uint8 getROUND_LVL_MAX_ATT(const CCDBGroup &dbGroup)
1277                 {
1278                         uint8 value;
1279                         _getProp(dbGroup.Database, _ROUND_LVL_MAX_ATT, value);
1280
1281                         return value;
1282                 }
1283
1284                 ICDBStructNode *getROUND_LVL_MAX_ATTCDBNode()
1285                 {
1286                         return _ROUND_LVL_MAX_ATT;
1287                 }
1288
1289                 void setROUND_LVL_MAX_DEF(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
1290                 {
1291
1292
1293                         _setProp(dbGroup.Database, _ROUND_LVL_MAX_DEF, value, forceSending);
1294                 }
1295
1296                 uint8 getROUND_LVL_MAX_DEF(const CCDBGroup &dbGroup)
1297                 {
1298                         uint8 value;
1299                         _getProp(dbGroup.Database, _ROUND_LVL_MAX_DEF, value);
1300
1301                         return value;
1302                 }
1303
1304                 ICDBStructNode *getROUND_LVL_MAX_DEFCDBNode()
1305                 {
1306                         return _ROUND_LVL_MAX_DEF;
1307                 }
1308
1309                 void setROUND_LVL_CUR(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
1310                 {
1311
1312
1313                         _setProp(dbGroup.Database, _ROUND_LVL_CUR, value, forceSending);
1314                 }
1315
1316                 uint8 getROUND_LVL_CUR(const CCDBGroup &dbGroup)
1317                 {
1318                         uint8 value;
1319                         _getProp(dbGroup.Database, _ROUND_LVL_CUR, value);
1320
1321                         return value;
1322                 }
1323
1324                 ICDBStructNode *getROUND_LVL_CURCDBNode()
1325                 {
1326                         return _ROUND_LVL_CUR;
1327                 }
1328
1329                 void setROUND_ID_CUR(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
1330                 {
1331
1332
1333                         _setProp(dbGroup.Database, _ROUND_ID_CUR, value, forceSending);
1334                 }
1335
1336                 uint8 getROUND_ID_CUR(const CCDBGroup &dbGroup)
1337                 {
1338                         uint8 value;
1339                         _getProp(dbGroup.Database, _ROUND_ID_CUR, value);
1340
1341                         return value;
1342                 }
1343
1344                 ICDBStructNode *getROUND_ID_CURCDBNode()
1345                 {
1346                         return _ROUND_ID_CUR;
1347                 }
1348
1349                 void setROUND_ID_MAX(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
1350                 {
1351
1352
1353                         _setProp(dbGroup.Database, _ROUND_ID_MAX, value, forceSending);
1354                 }
1355
1356                 uint8 getROUND_ID_MAX(const CCDBGroup &dbGroup)
1357                 {
1358                         uint8 value;
1359                         _getProp(dbGroup.Database, _ROUND_ID_MAX, value);
1360
1361                         return value;
1362                 }
1363
1364                 ICDBStructNode *getROUND_ID_MAXCDBNode()
1365                 {
1366                         return _ROUND_ID_MAX;
1367                 }
1368
1369                 void setTIME_RANGE_DEF_WANTED(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
1370                 {
1371
1372                         // Check that the value is not out of database precision
1373                         STOP_IF(value > (1<<5)-1, "setTIME_RANGE_DEF_WANTED : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 5 bits");
1374
1375
1376                         _setProp(dbGroup.Database, _TIME_RANGE_DEF_WANTED, value, forceSending);
1377                 }
1378
1379                 uint8 getTIME_RANGE_DEF_WANTED(const CCDBGroup &dbGroup)
1380                 {
1381                         uint8 value;
1382                         _getProp(dbGroup.Database, _TIME_RANGE_DEF_WANTED, value);
1383
1384                         return value;
1385                 }
1386
1387                 ICDBStructNode *getTIME_RANGE_DEF_WANTEDCDBNode()
1388                 {
1389                         return _TIME_RANGE_DEF_WANTED;
1390                 }
1391
1392                 void setTIME_RANGE_DEF(CCDBGroup &dbGroup, uint32 value, bool forceSending = false)
1393                 {
1394
1395
1396                         _setProp(dbGroup.Database, _TIME_RANGE_DEF, value, forceSending);
1397                 }
1398
1399                 uint32 getTIME_RANGE_DEF(const CCDBGroup &dbGroup)
1400                 {
1401                         uint32 value;
1402                         _getProp(dbGroup.Database, _TIME_RANGE_DEF, value);
1403
1404                         return value;
1405                 }
1406
1407                 ICDBStructNode *getTIME_RANGE_DEFCDBNode()
1408                 {
1409                         return _TIME_RANGE_DEF;
1410                 }
1411
1412                 void setTIME_RANGE_ATT(CCDBGroup &dbGroup, uint32 value, bool forceSending = false)
1413                 {
1414
1415
1416                         _setProp(dbGroup.Database, _TIME_RANGE_ATT, value, forceSending);
1417                 }
1418
1419                 uint32 getTIME_RANGE_ATT(const CCDBGroup &dbGroup)
1420                 {
1421                         uint32 value;
1422                         _getProp(dbGroup.Database, _TIME_RANGE_ATT, value);
1423
1424                         return value;
1425                 }
1426
1427                 ICDBStructNode *getTIME_RANGE_ATTCDBNode()
1428                 {
1429                         return _TIME_RANGE_ATT;
1430                 }
1431
1432                 void setTIME_RANGE_LENGTH(CCDBGroup &dbGroup, uint16 value, bool forceSending = false)
1433                 {
1434
1435
1436                         _setProp(dbGroup.Database, _TIME_RANGE_LENGTH, value, forceSending);
1437                 }
1438
1439                 uint16 getTIME_RANGE_LENGTH(const CCDBGroup &dbGroup)
1440                 {
1441                         uint16 value;
1442                         _getProp(dbGroup.Database, _TIME_RANGE_LENGTH, value);
1443
1444                         return value;
1445                 }
1446
1447                 ICDBStructNode *getTIME_RANGE_LENGTHCDBNode()
1448                 {
1449                         return _TIME_RANGE_LENGTH;
1450                 }
1451
1452                 void setSQUAD_CAPITAL(CCDBGroup &dbGroup, uint32 value, bool forceSending = false)
1453                 {
1454
1455
1456                         _setProp(dbGroup.Database, _SQUAD_CAPITAL, value, forceSending);
1457                 }
1458
1459                 uint32 getSQUAD_CAPITAL(const CCDBGroup &dbGroup)
1460                 {
1461                         uint32 value;
1462                         _getProp(dbGroup.Database, _SQUAD_CAPITAL, value);
1463
1464                         return value;
1465                 }
1466
1467                 ICDBStructNode *getSQUAD_CAPITALCDBNode()
1468                 {
1469                         return _SQUAD_CAPITAL;
1470                 }
1471         TGUILD &getGUILD()
1472                 {
1473                         return _GUILD;
1474                 }
1475                 TSQUAD_SPAWN_ZONE &getSQUAD_SPAWN_ZONE()
1476                 {
1477                         return _SQUAD_SPAWN_ZONE;
1478                 }
1479                 TSQUAD_SHOP &getSQUAD_SHOP()
1480                 {
1481                         return _SQUAD_SHOP;
1482                 }
1483                 TSQUADS &getSQUADS()
1484                 {
1485                         return _SQUADS;
1486                 }
1487                 TBUILDINGS &getBUILDINGS()
1488                 {
1489                         return _BUILDINGS;
1490                 }
1491
1492         };
1493
1494
1495         private:
1496                 ICDBStructNode  *_BranchNode;
1497
1498                 ICDBStructNode  *_CANDEL;
1499                 TO _O[16];
1500
1501
1502         public:
1503                 void init(ICDBStructNode *parent);
1504
1505                 // accessor to branch node
1506                 ICDBStructNode *getCDBNode()
1507                 {
1508                         return _BranchNode;
1509                 }
1510
1511
1512                 void setCANDEL(CCDBGroup &dbGroup, bool value, bool forceSending = false)
1513                 {
1514
1515
1516                         _setProp(dbGroup.Database, _CANDEL, value, forceSending);
1517                 }
1518
1519                 bool getCANDEL(const CCDBGroup &dbGroup)
1520                 {
1521                         bool value;
1522                         _getProp(dbGroup.Database, _CANDEL, value);
1523
1524                         return value;
1525                 }
1526
1527                 ICDBStructNode *getCANDELCDBNode()
1528                 {
1529                         return _CANDEL;
1530                 }
1531         TO &getO(uint32 index)
1532                 {
1533                         nlassert(index < 16);
1534                         return _O[index];
1535                 }
1536
1537         };
1538
1539
1540         private:
1541                 ICDBStructNode  *_BranchNode;
1542
1543                 ICDBStructNode  *_COUNTER;
1544                 ICDBStructNode  *_PROXY;
1545                 ICDBStructNode  *_NAME;
1546                 ICDBStructNode  *_DESCRIPTION;
1547                 ICDBStructNode  *_ICON;
1548                 ICDBStructNode  *_XP;
1549                 ICDBStructNode  *_CHARGE_POINTS;
1550                 ICDBStructNode  *_VILLAGE;
1551                 ICDBStructNode  *_PEOPLE;
1552                 ICDBStructNode  *_CREATION_DATE;
1553                 TFAME   _FAME;
1554                 TMEMBERS        _MEMBERS;
1555                 TINVENTORY      _INVENTORY;
1556                 TOUTPOST        _OUTPOST;
1557
1558
1559         public:
1560                 void init(ICDBStructNode *parent);
1561
1562                 // accessor to branch node
1563                 ICDBStructNode *getCDBNode()
1564                 {
1565                         return _BranchNode;
1566                 }
1567
1568
1569                 void setCOUNTER(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
1570                 {
1571
1572
1573                         _setProp(dbGroup.Database, _COUNTER, value, forceSending);
1574                 }
1575
1576                 uint8 getCOUNTER(const CCDBGroup &dbGroup)
1577                 {
1578                         uint8 value;
1579                         _getProp(dbGroup.Database, _COUNTER, value);
1580
1581                         return value;
1582                 }
1583
1584                 ICDBStructNode *getCOUNTERCDBNode()
1585                 {
1586                         return _COUNTER;
1587                 }
1588
1589                 void setPROXY(CCDBGroup &dbGroup, bool value, bool forceSending = false)
1590                 {
1591
1592
1593                         _setProp(dbGroup.Database, _PROXY, value, forceSending);
1594                 }
1595
1596                 bool getPROXY(const CCDBGroup &dbGroup)
1597                 {
1598                         bool value;
1599                         _getProp(dbGroup.Database, _PROXY, value);
1600
1601                         return value;
1602                 }
1603
1604                 ICDBStructNode *getPROXYCDBNode()
1605                 {
1606                         return _PROXY;
1607                 }
1608
1609                 void setNAME(CCDBGroup &dbGroup, ucstring value, bool forceSending = false)
1610                 {
1611
1612
1613                         _setProp(dbGroup.Database, _NAME, value, forceSending);
1614                 }
1615
1616                 ucstring getNAME(const CCDBGroup &dbGroup)
1617                 {
1618                         ucstring value;
1619                         _getProp(dbGroup.Database, _NAME, value);
1620
1621                         return value;
1622                 }
1623
1624                 void setNAME(CCDBGroup &dbGroup, uint32 stringId, bool forceSending = false)
1625                 {
1626                         _setProp(dbGroup.Database, _NAME, stringId, forceSending);
1627                 }
1628                 uint32 getNAME_id(const CCDBGroup &dbGroup)
1629                 {
1630                         uint32 value;
1631                         _getProp(dbGroup.Database, _NAME, value);
1632
1633                         return value;
1634                 }
1635
1636                 ICDBStructNode *getNAMECDBNode()
1637                 {
1638                         return _NAME;
1639                 }
1640
1641                 void setDESCRIPTION(CCDBGroup &dbGroup, ucstring value, bool forceSending = false)
1642                 {
1643
1644
1645                         _setProp(dbGroup.Database, _DESCRIPTION, value, forceSending);
1646                 }
1647
1648                 ucstring getDESCRIPTION(const CCDBGroup &dbGroup)
1649                 {
1650                         ucstring value;
1651                         _getProp(dbGroup.Database, _DESCRIPTION, value);
1652
1653                         return value;
1654                 }
1655
1656                 void setDESCRIPTION(CCDBGroup &dbGroup, uint32 stringId, bool forceSending = false)
1657                 {
1658                         _setProp(dbGroup.Database, _DESCRIPTION, stringId, forceSending);
1659                 }
1660                 uint32 getDESCRIPTION_id(const CCDBGroup &dbGroup)
1661                 {
1662                         uint32 value;
1663                         _getProp(dbGroup.Database, _DESCRIPTION, value);
1664
1665                         return value;
1666                 }
1667
1668                 ICDBStructNode *getDESCRIPTIONCDBNode()
1669                 {
1670                         return _DESCRIPTION;
1671                 }
1672
1673                 void setICON(CCDBGroup &dbGroup, uint64 value, bool forceSending = false)
1674                 {
1675
1676
1677                         _setProp(dbGroup.Database, _ICON, value, forceSending);
1678                 }
1679
1680                 uint64 getICON(const CCDBGroup &dbGroup)
1681                 {
1682                         uint64 value;
1683                         _getProp(dbGroup.Database, _ICON, value);
1684
1685                         return value;
1686                 }
1687
1688                 ICDBStructNode *getICONCDBNode()
1689                 {
1690                         return _ICON;
1691                 }
1692
1693                 void setXP(CCDBGroup &dbGroup, uint32 value, bool forceSending = false)
1694                 {
1695
1696
1697                         _setProp(dbGroup.Database, _XP, value, forceSending);
1698                 }
1699
1700                 uint32 getXP(const CCDBGroup &dbGroup)
1701                 {
1702                         uint32 value;
1703                         _getProp(dbGroup.Database, _XP, value);
1704
1705                         return value;
1706                 }
1707
1708                 ICDBStructNode *getXPCDBNode()
1709                 {
1710                         return _XP;
1711                 }
1712
1713                 void setCHARGE_POINTS(CCDBGroup &dbGroup, uint32 value, bool forceSending = false)
1714                 {
1715
1716
1717                         _setProp(dbGroup.Database, _CHARGE_POINTS, value, forceSending);
1718                 }
1719
1720                 uint32 getCHARGE_POINTS(const CCDBGroup &dbGroup)
1721                 {
1722                         uint32 value;
1723                         _getProp(dbGroup.Database, _CHARGE_POINTS, value);
1724
1725                         return value;
1726                 }
1727
1728                 ICDBStructNode *getCHARGE_POINTSCDBNode()
1729                 {
1730                         return _CHARGE_POINTS;
1731                 }
1732
1733                 void setVILLAGE(CCDBGroup &dbGroup, ucstring value, bool forceSending = false)
1734                 {
1735
1736
1737                         _setProp(dbGroup.Database, _VILLAGE, value, forceSending);
1738                 }
1739
1740                 ucstring getVILLAGE(const CCDBGroup &dbGroup)
1741                 {
1742                         ucstring value;
1743                         _getProp(dbGroup.Database, _VILLAGE, value);
1744
1745                         return value;
1746                 }
1747
1748                 void setVILLAGE(CCDBGroup &dbGroup, uint32 stringId, bool forceSending = false)
1749                 {
1750                         _setProp(dbGroup.Database, _VILLAGE, stringId, forceSending);
1751                 }
1752                 uint32 getVILLAGE_id(const CCDBGroup &dbGroup)
1753                 {
1754                         uint32 value;
1755                         _getProp(dbGroup.Database, _VILLAGE, value);
1756
1757                         return value;
1758                 }
1759
1760                 ICDBStructNode *getVILLAGECDBNode()
1761                 {
1762                         return _VILLAGE;
1763                 }
1764
1765                 void setPEOPLE(CCDBGroup &dbGroup, uint8 value, bool forceSending = false)
1766                 {
1767
1768
1769                         _setProp(dbGroup.Database, _PEOPLE, value, forceSending);
1770                 }
1771
1772                 uint8 getPEOPLE(const CCDBGroup &dbGroup)
1773                 {
1774                         uint8 value;
1775                         _getProp(dbGroup.Database, _PEOPLE, value);
1776
1777                         return value;
1778                 }
1779
1780                 ICDBStructNode *getPEOPLECDBNode()
1781                 {
1782                         return _PEOPLE;
1783                 }
1784
1785                 void setCREATION_DATE(CCDBGroup &dbGroup, uint32 value, bool forceSending = false)
1786                 {
1787
1788
1789                         _setProp(dbGroup.Database, _CREATION_DATE, value, forceSending);
1790                 }
1791
1792                 uint32 getCREATION_DATE(const CCDBGroup &dbGroup)
1793                 {
1794                         uint32 value;
1795                         _getProp(dbGroup.Database, _CREATION_DATE, value);
1796
1797                         return value;
1798                 }
1799
1800                 ICDBStructNode *getCREATION_DATECDBNode()
1801                 {
1802                         return _CREATION_DATE;
1803                 }
1804         TFAME &getFAME()
1805                 {
1806                         return _FAME;
1807                 }
1808                 TMEMBERS &getMEMBERS()
1809                 {
1810                         return _MEMBERS;
1811                 }
1812                 TINVENTORY &getINVENTORY()
1813                 {
1814                         return _INVENTORY;
1815                 }
1816                 TOUTPOST &getOUTPOST()
1817                 {
1818                         return _OUTPOST;
1819                 }
1820
1821         };
1822
1823                 static TGUILD   _GUILD;
1824
1825
1826         public:
1827
1828                 // Constructor
1829                 CBankAccessor_GUILD()
1830                 {
1831                         // make sure the static tree is initialised (some kind of lazy initialisation)
1832                         init();
1833
1834                         // init the base class
1835                         CCDBGroup::init(BankTag);
1836                 }
1837
1838
1839                 static void init();
1840
1841                 static TGUILD &getGUILD()
1842                 {
1843                         return _GUILD;
1844                 }
1845
1846
1847         };
1848
1849
1850 #endif // INCLUDED_DATABASE_database_GUILD_H