src/DB/Generated/FieldImpls.h

   1 /***************************************************************************
   2  *   Copyright (C) 2008 by Sverre Rabbelier                                *
   3  *   sverre@rabbelier.nl                                                   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 3 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 /* NOTE: This file was generated automatically. Do not edit. */
  22
  23 #pragma once
  24
  25 /**
  26  * @file FieldImpls.h
  27  * This file contains the generated FieldImpl classes.
  28  *
  29  * @see FieldImpl
  30  */
  31
  32 #include "Types.h"
  33 #include "TableImpl.h"
  34
  35 namespace db
  36 {
  37         /**
  38          * This is a generated class that contains all FieldImpls for the Accounts table.
  39          */
  40         class Accounts : public TableImpl
  41         {
  42         public:
  43                 KeyImplPtr ACCOUNTID; /**< FieldImplPtr for the accountid field. */
  44                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
  45                 FieldImplPtr PASSWORD; /**< FieldImplPtr for the password field. */
  46
  47         private:
  48                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
  49                 Accounts(): TableImpl("Accounts") { }
  50
  51                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
  52                 ~Accounts() { }
  53
  54                 /** Hide the copy constructor. */
  55                 Accounts(const Accounts& rhs);
  56
  57                 /** Hide the assignment operator. */
  58                 Accounts operator=(const Accounts& rhs);
  59
  60                 /** Initialize the table's fields. */
  61                 void Initialize();
  62
  63                 friend class TableImpls;
  64                 friend SmartPtrDelete(Accounts);
  65         };
  66
  67         /**
  68          * This is a generated class that contains all FieldImpls for the Areas table.
  69          */
  70         class Areas : public TableImpl
  71         {
  72         public:
  73                 KeyImplPtr AREAID; /**< FieldImplPtr for the areaid field. */
  74                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
  75                 FieldImplPtr DESCRIPTION; /**< FieldImplPtr for the description field. */
  76                 FieldImplPtr HEIGHT; /**< FieldImplPtr for the height field. */
  77                 FieldImplPtr WIDTH; /**< FieldImplPtr for the width field. */
  78                 FieldImplPtr LENGTH; /**< FieldImplPtr for the length field. */
  79
  80         private:
  81                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
  82                 Areas(): TableImpl("Areas") { }
  83
  84                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
  85                 ~Areas() { }
  86
  87                 /** Hide the copy constructor. */
  88                 Areas(const Areas& rhs);
  89
  90                 /** Hide the assignment operator. */
  91                 Areas operator=(const Areas& rhs);
  92
  93                 /** Initialize the table's fields. */
  94                 void Initialize();
  95
  96                 friend class TableImpls;
  97                 friend SmartPtrDelete(Areas);
  98         };
  99
 100         /**
 101          * This is a generated class that contains all FieldImpls for the Branches table.
 102          */
 103         class Branches : public TableImpl
 104         {
 105         public:
 106                 KeyImplPtr BRANCHID; /**< FieldImplPtr for the branchid field. */
 107                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
 108                 KeyImplPtr FKTREES; /**< FieldImplPtr for the fkTrees field. */
 109                 KeyImplPtr FKSTATSPRIMARY; /**< FieldImplPtr for the fkStatsPrimary field. */
 110                 KeyImplPtr FKSTATSSECONDARY; /**< FieldImplPtr for the fkStatsSecondary field. */
 111
 112         private:
 113                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 114                 Branches(): TableImpl("Branches") { }
 115
 116                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 117                 ~Branches() { }
 118
 119                 /** Hide the copy constructor. */
 120                 Branches(const Branches& rhs);
 121
 122                 /** Hide the assignment operator. */
 123                 Branches operator=(const Branches& rhs);
 124
 125                 /** Initialize the table's fields. */
 126                 void Initialize();
 127
 128                 friend class TableImpls;
 129                 friend SmartPtrDelete(Branches);
 130         };
 131
 132         /**
 133          * This is a generated class that contains all FieldImpls for the Channels table.
 134          */
 135         class Channels : public TableImpl
 136         {
 137         public:
 138                 KeyImplPtr CHANNELID; /**< FieldImplPtr for the channelid field. */
 139                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
 140                 FieldImplPtr DESCRIPTION; /**< FieldImplPtr for the description field. */
 141                 FieldImplPtr NEEDLOGIN; /**< FieldImplPtr for the needLogin field. */
 142
 143         private:
 144                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 145                 Channels(): TableImpl("Channels") { }
 146
 147                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 148                 ~Channels() { }
 149
 150                 /** Hide the copy constructor. */
 151                 Channels(const Channels& rhs);
 152
 153                 /** Hide the assignment operator. */
 154                 Channels operator=(const Channels& rhs);
 155
 156                 /** Initialize the table's fields. */
 157                 void Initialize();
 158
 159                 friend class TableImpls;
 160                 friend SmartPtrDelete(Channels);
 161         };
 162
 163         /**
 164          * This is a generated class that contains all FieldImpls for the ChannelLogs table.
 165          */
 166         class ChannelLogs : public TableImpl
 167         {
 168         public:
 169                 KeyImplPtr CHANNELLOGID; /**< FieldImplPtr for the channellogid field. */
 170                 KeyImplPtr FKCHANNELS; /**< FieldImplPtr for the fkChannels field. */
 171                 KeyImplPtr FKACCOUNTS; /**< FieldImplPtr for the fkAccounts field. */
 172                 FieldImplPtr TIME; /**< FieldImplPtr for the time field. */
 173                 FieldImplPtr CONTENT; /**< FieldImplPtr for the content field. */
 174
 175         private:
 176                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 177                 ChannelLogs(): TableImpl("ChannelLogs") { }
 178
 179                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 180                 ~ChannelLogs() { }
 181
 182                 /** Hide the copy constructor. */
 183                 ChannelLogs(const ChannelLogs& rhs);
 184
 185                 /** Hide the assignment operator. */
 186                 ChannelLogs operator=(const ChannelLogs& rhs);
 187
 188                 /** Initialize the table's fields. */
 189                 void Initialize();
 190
 191                 friend class TableImpls;
 192                 friend SmartPtrDelete(ChannelLogs);
 193         };
 194
 195         /**
 196          * This is a generated class that contains all FieldImpls for the CharacterAccount table.
 197          */
 198         class CharacterAccount : public TableImpl
 199         {
 200         public:
 201                 KeyImplPtr FKENTITIES; /**< FieldImplPtr for the fkEntities field. */
 202                 KeyImplPtr FKACCOUNTS; /**< FieldImplPtr for the fkAccounts field. */
 203
 204         private:
 205                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 206                 CharacterAccount(): TableImpl("CharacterAccount") { }
 207
 208                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 209                 ~CharacterAccount() { }
 210
 211                 /** Hide the copy constructor. */
 212                 CharacterAccount(const CharacterAccount& rhs);
 213
 214                 /** Hide the assignment operator. */
 215                 CharacterAccount operator=(const CharacterAccount& rhs);
 216
 217                 /** Initialize the table's fields. */
 218                 void Initialize();
 219
 220                 friend class TableImpls;
 221                 friend SmartPtrDelete(CharacterAccount);
 222         };
 223
 224         /**
 225          * This is a generated class that contains all FieldImpls for the CharacterBranch table.
 226          */
 227         class CharacterBranch : public TableImpl
 228         {
 229         public:
 230                 KeyImplPtr FKENTITIES; /**< FieldImplPtr for the fkEntities field. */
 231                 KeyImplPtr FKBRANCHES; /**< FieldImplPtr for the fkBranches field. */
 232                 FieldImplPtr XP; /**< FieldImplPtr for the xp field. */
 233
 234         private:
 235                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 236                 CharacterBranch(): TableImpl("CharacterBranch") { }
 237
 238                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 239                 ~CharacterBranch() { }
 240
 241                 /** Hide the copy constructor. */
 242                 CharacterBranch(const CharacterBranch& rhs);
 243
 244                 /** Hide the assignment operator. */
 245                 CharacterBranch operator=(const CharacterBranch& rhs);
 246
 247                 /** Initialize the table's fields. */
 248                 void Initialize();
 249
 250                 friend class TableImpls;
 251                 friend SmartPtrDelete(CharacterBranch);
 252         };
 253
 254         /**
 255          * This is a generated class that contains all FieldImpls for the CharacterCluster table.
 256          */
 257         class CharacterCluster : public TableImpl
 258         {
 259         public:
 260                 KeyImplPtr FKENTITIES; /**< FieldImplPtr for the fkEntities field. */
 261                 KeyImplPtr FKCLUSTERS; /**< FieldImplPtr for the fkClusters field. */
 262                 FieldImplPtr XP; /**< FieldImplPtr for the xp field. */
 263
 264         private:
 265                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 266                 CharacterCluster(): TableImpl("CharacterCluster") { }
 267
 268                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 269                 ~CharacterCluster() { }
 270
 271                 /** Hide the copy constructor. */
 272                 CharacterCluster(const CharacterCluster& rhs);
 273
 274                 /** Hide the assignment operator. */
 275                 CharacterCluster operator=(const CharacterCluster& rhs);
 276
 277                 /** Initialize the table's fields. */
 278                 void Initialize();
 279
 280                 friend class TableImpls;
 281                 friend SmartPtrDelete(CharacterCluster);
 282         };
 283
 284         /**
 285          * This is a generated class that contains all FieldImpls for the CharacterSkill table.
 286          */
 287         class CharacterSkill : public TableImpl
 288         {
 289         public:
 290                 KeyImplPtr FKENTITIES; /**< FieldImplPtr for the fkEntities field. */
 291                 KeyImplPtr FKBRANCHES; /**< FieldImplPtr for the fkBranches field. */
 292                 FieldImplPtr XP; /**< FieldImplPtr for the xp field. */
 293
 294         private:
 295                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 296                 CharacterSkill(): TableImpl("CharacterSkill") { }
 297
 298                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 299                 ~CharacterSkill() { }
 300
 301                 /** Hide the copy constructor. */
 302                 CharacterSkill(const CharacterSkill& rhs);
 303
 304                 /** Hide the assignment operator. */
 305                 CharacterSkill operator=(const CharacterSkill& rhs);
 306
 307                 /** Initialize the table's fields. */
 308                 void Initialize();
 309
 310                 friend class TableImpls;
 311                 friend SmartPtrDelete(CharacterSkill);
 312         };
 313
 314         /**
 315          * This is a generated class that contains all FieldImpls for the CharacterStat table.
 316          */
 317         class CharacterStat : public TableImpl
 318         {
 319         public:
 320                 KeyImplPtr FKENTITIES; /**< FieldImplPtr for the fkEntities field. */
 321                 KeyImplPtr FKSTATS; /**< FieldImplPtr for the fkStats field. */
 322                 FieldImplPtr XP; /**< FieldImplPtr for the xp field. */
 323
 324         private:
 325                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 326                 CharacterStat(): TableImpl("CharacterStat") { }
 327
 328                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 329                 ~CharacterStat() { }
 330
 331                 /** Hide the copy constructor. */
 332                 CharacterStat(const CharacterStat& rhs);
 333
 334                 /** Hide the assignment operator. */
 335                 CharacterStat operator=(const CharacterStat& rhs);
 336
 337                 /** Initialize the table's fields. */
 338                 void Initialize();
 339
 340                 friend class TableImpls;
 341                 friend SmartPtrDelete(CharacterStat);
 342         };
 343
 344         /**
 345          * This is a generated class that contains all FieldImpls for the CharacterTree table.
 346          */
 347         class CharacterTree : public TableImpl
 348         {
 349         public:
 350                 KeyImplPtr FKENTITIES; /**< FieldImplPtr for the fkEntities field. */
 351                 KeyImplPtr FKTREES; /**< FieldImplPtr for the fkTrees field. */
 352                 FieldImplPtr XP; /**< FieldImplPtr for the xp field. */
 353
 354         private:
 355                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 356                 CharacterTree(): TableImpl("CharacterTree") { }
 357
 358                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 359                 ~CharacterTree() { }
 360
 361                 /** Hide the copy constructor. */
 362                 CharacterTree(const CharacterTree& rhs);
 363
 364                 /** Hide the assignment operator. */
 365                 CharacterTree operator=(const CharacterTree& rhs);
 366
 367                 /** Initialize the table's fields. */
 368                 void Initialize();
 369
 370                 friend class TableImpls;
 371                 friend SmartPtrDelete(CharacterTree);
 372         };
 373
 374         /**
 375          * This is a generated class that contains all FieldImpls for the Clusters table.
 376          */
 377         class Clusters : public TableImpl
 378         {
 379         public:
 380                 KeyImplPtr CLUSTERID; /**< FieldImplPtr for the clusterid field. */
 381                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
 382                 FieldImplPtr DESCRIPTION; /**< FieldImplPtr for the description field. */
 383                 KeyImplPtr FKAREAS; /**< FieldImplPtr for the fkAreas field. */
 384
 385         private:
 386                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 387                 Clusters(): TableImpl("Clusters") { }
 388
 389                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 390                 ~Clusters() { }
 391
 392                 /** Hide the copy constructor. */
 393                 Clusters(const Clusters& rhs);
 394
 395                 /** Hide the assignment operator. */
 396                 Clusters operator=(const Clusters& rhs);
 397
 398                 /** Initialize the table's fields. */
 399                 void Initialize();
 400
 401                 friend class TableImpls;
 402                 friend SmartPtrDelete(Clusters);
 403         };
 404
 405         /**
 406          * This is a generated class that contains all FieldImpls for the Chunks table.
 407          */
 408         class Chunks : public TableImpl
 409         {
 410         public:
 411                 KeyImplPtr CHUNKID; /**< FieldImplPtr for the chunkid field. */
 412                 KeyImplPtr FKROOMS; /**< FieldImplPtr for the fkRooms field. */
 413                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
 414                 FieldImplPtr DESCRIPTION; /**< FieldImplPtr for the description field. */
 415                 FieldImplPtr TAGS; /**< FieldImplPtr for the tags field. */
 416
 417         private:
 418                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 419                 Chunks(): TableImpl("Chunks") { }
 420
 421                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 422                 ~Chunks() { }
 423
 424                 /** Hide the copy constructor. */
 425                 Chunks(const Chunks& rhs);
 426
 427                 /** Hide the assignment operator. */
 428                 Chunks operator=(const Chunks& rhs);
 429
 430                 /** Initialize the table's fields. */
 431                 void Initialize();
 432
 433                 friend class TableImpls;
 434                 friend SmartPtrDelete(Chunks);
 435         };
 436
 437         /**
 438          * This is a generated class that contains all FieldImpls for the Colours table.
 439          */
 440         class Colours : public TableImpl
 441         {
 442         public:
 443                 KeyImplPtr COLOURID; /**< FieldImplPtr for the colourid field. */
 444                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
 445                 FieldImplPtr CODE; /**< FieldImplPtr for the code field. */
 446                 FieldImplPtr COLOURSTRING; /**< FieldImplPtr for the colourstring field. */
 447                 FieldImplPtr ANSI; /**< FieldImplPtr for the ansi field. */
 448
 449         private:
 450                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 451                 Colours(): TableImpl("Colours") { }
 452
 453                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 454                 ~Colours() { }
 455
 456                 /** Hide the copy constructor. */
 457                 Colours(const Colours& rhs);
 458
 459                 /** Hide the assignment operator. */
 460                 Colours operator=(const Colours& rhs);
 461
 462                 /** Initialize the table's fields. */
 463                 void Initialize();
 464
 465                 friend class TableImpls;
 466                 friend SmartPtrDelete(Colours);
 467         };
 468
 469         /**
 470          * This is a generated class that contains all FieldImpls for the Commands table.
 471          */
 472         class Commands : public TableImpl
 473         {
 474         public:
 475                 KeyImplPtr COMMANDID; /**< FieldImplPtr for the commandid field. */
 476                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
 477                 FieldImplPtr GRANTGROUP; /**< FieldImplPtr for the grantgroup field. */
 478                 FieldImplPtr HIGHFORCE; /**< FieldImplPtr for the highforce field. */
 479                 FieldImplPtr FORCE; /**< FieldImplPtr for the force field. */
 480                 FieldImplPtr LOWFORCE; /**< FieldImplPtr for the lowforce field. */
 481                 FieldImplPtr HELP; /**< FieldImplPtr for the help field. */
 482
 483         private:
 484                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 485                 Commands(): TableImpl("Commands") { }
 486
 487                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 488                 ~Commands() { }
 489
 490                 /** Hide the copy constructor. */
 491                 Commands(const Commands& rhs);
 492
 493                 /** Hide the assignment operator. */
 494                 Commands operator=(const Commands& rhs);
 495
 496                 /** Initialize the table's fields. */
 497                 void Initialize();
 498
 499                 friend class TableImpls;
 500                 friend SmartPtrDelete(Commands);
 501         };
 502
 503         /**
 504          * This is a generated class that contains all FieldImpls for the Details table.
 505          */
 506         class Details : public TableImpl
 507         {
 508         public:
 509                 KeyImplPtr DETAILID; /**< FieldImplPtr for the detailid field. */
 510                 FieldImplPtr KEY; /**< FieldImplPtr for the key field. */
 511                 FieldImplPtr DESCRIPTION; /**< FieldImplPtr for the description field. */
 512
 513         private:
 514                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 515                 Details(): TableImpl("Details") { }
 516
 517                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 518                 ~Details() { }
 519
 520                 /** Hide the copy constructor. */
 521                 Details(const Details& rhs);
 522
 523                 /** Hide the assignment operator. */
 524                 Details operator=(const Details& rhs);
 525
 526                 /** Initialize the table's fields. */
 527                 void Initialize();
 528
 529                 friend class TableImpls;
 530                 friend SmartPtrDelete(Details);
 531         };
 532
 533         /**
 534          * This is a generated class that contains all FieldImpls for the DetailArea table.
 535          */
 536         class DetailArea : public TableImpl
 537         {
 538         public:
 539                 KeyImplPtr FKDETAILS; /**< FieldImplPtr for the fkDetails field. */
 540                 KeyImplPtr FKAREAS; /**< FieldImplPtr for the fkAreas field. */
 541
 542         private:
 543                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 544                 DetailArea(): TableImpl("DetailArea") { }
 545
 546                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 547                 ~DetailArea() { }
 548
 549                 /** Hide the copy constructor. */
 550                 DetailArea(const DetailArea& rhs);
 551
 552                 /** Hide the assignment operator. */
 553                 DetailArea operator=(const DetailArea& rhs);
 554
 555                 /** Initialize the table's fields. */
 556                 void Initialize();
 557
 558                 friend class TableImpls;
 559                 friend SmartPtrDelete(DetailArea);
 560         };
 561
 562         /**
 563          * This is a generated class that contains all FieldImpls for the DetailRoom table.
 564          */
 565         class DetailRoom : public TableImpl
 566         {
 567         public:
 568                 KeyImplPtr FKDETAILS; /**< FieldImplPtr for the fkDetails field. */
 569                 KeyImplPtr FKROOMS; /**< FieldImplPtr for the fkRooms field. */
 570
 571         private:
 572                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 573                 DetailRoom(): TableImpl("DetailRoom") { }
 574
 575                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 576                 ~DetailRoom() { }
 577
 578                 /** Hide the copy constructor. */
 579                 DetailRoom(const DetailRoom& rhs);
 580
 581                 /** Hide the assignment operator. */
 582                 DetailRoom operator=(const DetailRoom& rhs);
 583
 584                 /** Initialize the table's fields. */
 585                 void Initialize();
 586
 587                 friend class TableImpls;
 588                 friend SmartPtrDelete(DetailRoom);
 589         };
 590
 591         /**
 592          * This is a generated class that contains all FieldImpls for the DetailChunk table.
 593          */
 594         class DetailChunk : public TableImpl
 595         {
 596         public:
 597                 KeyImplPtr FKDETAILS; /**< FieldImplPtr for the fkDetails field. */
 598                 KeyImplPtr FKCHUNKS; /**< FieldImplPtr for the fkChunks field. */
 599
 600         private:
 601                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 602                 DetailChunk(): TableImpl("DetailChunk") { }
 603
 604                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 605                 ~DetailChunk() { }
 606
 607                 /** Hide the copy constructor. */
 608                 DetailChunk(const DetailChunk& rhs);
 609
 610                 /** Hide the assignment operator. */
 611                 DetailChunk operator=(const DetailChunk& rhs);
 612
 613                 /** Initialize the table's fields. */
 614                 void Initialize();
 615
 616                 friend class TableImpls;
 617                 friend SmartPtrDelete(DetailChunk);
 618         };
 619
 620         /**
 621          * This is a generated class that contains all FieldImpls for the DetailCharacter table.
 622          */
 623         class DetailCharacter : public TableImpl
 624         {
 625         public:
 626                 KeyImplPtr FKDETAILS; /**< FieldImplPtr for the fkDetails field. */
 627                 KeyImplPtr FKENTITIES; /**< FieldImplPtr for the fkEntities field. */
 628
 629         private:
 630                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 631                 DetailCharacter(): TableImpl("DetailCharacter") { }
 632
 633                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 634                 ~DetailCharacter() { }
 635
 636                 /** Hide the copy constructor. */
 637                 DetailCharacter(const DetailCharacter& rhs);
 638
 639                 /** Hide the assignment operator. */
 640                 DetailCharacter operator=(const DetailCharacter& rhs);
 641
 642                 /** Initialize the table's fields. */
 643                 void Initialize();
 644
 645                 friend class TableImpls;
 646                 friend SmartPtrDelete(DetailCharacter);
 647         };
 648
 649         /**
 650          * This is a generated class that contains all FieldImpls for the DetailDetail table.
 651          */
 652         class DetailDetail : public TableImpl
 653         {
 654         public:
 655                 KeyImplPtr FKDETAILSPRIMARY; /**< FieldImplPtr for the fkDetailsPrimary field. */
 656                 KeyImplPtr FKDETAILSSECONDARY; /**< FieldImplPtr for the fkDetailsSecondary field. */
 657
 658         private:
 659                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 660                 DetailDetail(): TableImpl("DetailDetail") { }
 661
 662                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 663                 ~DetailDetail() { }
 664
 665                 /** Hide the copy constructor. */
 666                 DetailDetail(const DetailDetail& rhs);
 667
 668                 /** Hide the assignment operator. */
 669                 DetailDetail operator=(const DetailDetail& rhs);
 670
 671                 /** Initialize the table's fields. */
 672                 void Initialize();
 673
 674                 friend class TableImpls;
 675                 friend SmartPtrDelete(DetailDetail);
 676         };
 677
 678         /**
 679          * This is a generated class that contains all FieldImpls for the Echos table.
 680          */
 681         class Echos : public TableImpl
 682         {
 683         public:
 684                 KeyImplPtr ECHOID; /**< FieldImplPtr for the echoid field. */
 685                 FieldImplPtr MESSAGE; /**< FieldImplPtr for the message field. */
 686                 FieldImplPtr VISIBILITY; /**< FieldImplPtr for the visibility field. */
 687                 FieldImplPtr AUDIBILITY; /**< FieldImplPtr for the audibility field. */
 688
 689         private:
 690                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 691                 Echos(): TableImpl("Echos") { }
 692
 693                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 694                 ~Echos() { }
 695
 696                 /** Hide the copy constructor. */
 697                 Echos(const Echos& rhs);
 698
 699                 /** Hide the assignment operator. */
 700                 Echos operator=(const Echos& rhs);
 701
 702                 /** Initialize the table's fields. */
 703                 void Initialize();
 704
 705                 friend class TableImpls;
 706                 friend SmartPtrDelete(Echos);
 707         };
 708
 709         /**
 710          * This is a generated class that contains all FieldImpls for the Entities table.
 711          */
 712         class Entities : public TableImpl
 713         {
 714         public:
 715                 KeyImplPtr ENTITYID; /**< FieldImplPtr for the entityid field. */
 716                 KeyImplPtr FKRACES; /**< FieldImplPtr for the fkRaces field. */
 717                 KeyImplPtr FKCHUNKS; /**< FieldImplPtr for the fkChunks field. */
 718                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
 719                 FieldImplPtr DESCRIPTION; /**< FieldImplPtr for the description field. */
 720
 721         private:
 722                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 723                 Entities(): TableImpl("Entities") { }
 724
 725                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 726                 ~Entities() { }
 727
 728                 /** Hide the copy constructor. */
 729                 Entities(const Entities& rhs);
 730
 731                 /** Hide the assignment operator. */
 732                 Entities operator=(const Entities& rhs);
 733
 734                 /** Initialize the table's fields. */
 735                 void Initialize();
 736
 737                 friend class TableImpls;
 738                 friend SmartPtrDelete(Entities);
 739         };
 740
 741         /**
 742          * This is a generated class that contains all FieldImpls for the Exits table.
 743          */
 744         class Exits : public TableImpl
 745         {
 746         public:
 747                 KeyImplPtr EXITID; /**< FieldImplPtr for the exitid field. */
 748                 KeyImplPtr FKCHUNKSFROM; /**< FieldImplPtr for the fkChunksfrom field. */
 749                 KeyImplPtr FKCHUNKSTO; /**< FieldImplPtr for the fkChunksto field. */
 750                 FieldImplPtr X; /**< FieldImplPtr for the x field. */
 751                 FieldImplPtr Y; /**< FieldImplPtr for the y field. */
 752                 FieldImplPtr Z; /**< FieldImplPtr for the z field. */
 753
 754         private:
 755                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 756                 Exits(): TableImpl("Exits") { }
 757
 758                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 759                 ~Exits() { }
 760
 761                 /** Hide the copy constructor. */
 762                 Exits(const Exits& rhs);
 763
 764                 /** Hide the assignment operator. */
 765                 Exits operator=(const Exits& rhs);
 766
 767                 /** Initialize the table's fields. */
 768                 void Initialize();
 769
 770                 friend class TableImpls;
 771                 friend SmartPtrDelete(Exits);
 772         };
 773
 774         /**
 775          * This is a generated class that contains all FieldImpls for the GrantGroups table.
 776          */
 777         class GrantGroups : public TableImpl
 778         {
 779         public:
 780                 KeyImplPtr GRANTGROUPID; /**< FieldImplPtr for the grantgroupid field. */
 781                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
 782                 FieldImplPtr DEFAULTGRANT; /**< FieldImplPtr for the defaultgrant field. */
 783                 FieldImplPtr DEFAULTLOG; /**< FieldImplPtr for the defaultlog field. */
 784                 FieldImplPtr IMPLIES; /**< FieldImplPtr for the implies field. */
 785
 786         private:
 787                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 788                 GrantGroups(): TableImpl("GrantGroups") { }
 789
 790                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 791                 ~GrantGroups() { }
 792
 793                 /** Hide the copy constructor. */
 794                 GrantGroups(const GrantGroups& rhs);
 795
 796                 /** Hide the assignment operator. */
 797                 GrantGroups operator=(const GrantGroups& rhs);
 798
 799                 /** Initialize the table's fields. */
 800                 void Initialize();
 801
 802                 friend class TableImpls;
 803                 friend SmartPtrDelete(GrantGroups);
 804         };
 805
 806         /**
 807          * This is a generated class that contains all FieldImpls for the Logs table.
 808          */
 809         class Logs : public TableImpl
 810         {
 811         public:
 812                 KeyImplPtr LOGID; /**< FieldImplPtr for the logid field. */
 813                 FieldImplPtr TYPE; /**< FieldImplPtr for the type field. */
 814                 FieldImplPtr TIME; /**< FieldImplPtr for the time field. */
 815                 FieldImplPtr CONTENT; /**< FieldImplPtr for the content field. */
 816
 817         private:
 818                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 819                 Logs(): TableImpl("Logs") { }
 820
 821                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 822                 ~Logs() { }
 823
 824                 /** Hide the copy constructor. */
 825                 Logs(const Logs& rhs);
 826
 827                 /** Hide the assignment operator. */
 828                 Logs operator=(const Logs& rhs);
 829
 830                 /** Initialize the table's fields. */
 831                 void Initialize();
 832
 833                 friend class TableImpls;
 834                 friend SmartPtrDelete(Logs);
 835         };
 836
 837         /**
 838          * This is a generated class that contains all FieldImpls for the Permissions table.
 839          */
 840         class Permissions : public TableImpl
 841         {
 842         public:
 843                 KeyImplPtr FKACCOUNTS; /**< FieldImplPtr for the fkAccounts field. */
 844                 KeyImplPtr FKGRANTGROUPS; /**< FieldImplPtr for the fkGrantGroups field. */
 845                 FieldImplPtr GRANT; /**< FieldImplPtr for the grant field. */
 846                 FieldImplPtr LOG; /**< FieldImplPtr for the log field. */
 847
 848         private:
 849                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 850                 Permissions(): TableImpl("Permissions") { }
 851
 852                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 853                 ~Permissions() { }
 854
 855                 /** Hide the copy constructor. */
 856                 Permissions(const Permissions& rhs);
 857
 858                 /** Hide the assignment operator. */
 859                 Permissions operator=(const Permissions& rhs);
 860
 861                 /** Initialize the table's fields. */
 862                 void Initialize();
 863
 864                 friend class TableImpls;
 865                 friend SmartPtrDelete(Permissions);
 866         };
 867
 868         /**
 869          * This is a generated class that contains all FieldImpls for the Races table.
 870          */
 871         class Races : public TableImpl
 872         {
 873         public:
 874                 KeyImplPtr RACEID; /**< FieldImplPtr for the raceid field. */
 875                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
 876
 877         private:
 878                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 879                 Races(): TableImpl("Races") { }
 880
 881                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 882                 ~Races() { }
 883
 884                 /** Hide the copy constructor. */
 885                 Races(const Races& rhs);
 886
 887                 /** Hide the assignment operator. */
 888                 Races operator=(const Races& rhs);
 889
 890                 /** Initialize the table's fields. */
 891                 void Initialize();
 892
 893                 friend class TableImpls;
 894                 friend SmartPtrDelete(Races);
 895         };
 896
 897         /**
 898          * This is a generated class that contains all FieldImpls for the Rooms table.
 899          */
 900         class Rooms : public TableImpl
 901         {
 902         public:
 903                 KeyImplPtr ROOMID; /**< FieldImplPtr for the roomid field. */
 904                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
 905                 FieldImplPtr DESCRIPTION; /**< FieldImplPtr for the description field. */
 906                 KeyImplPtr FKCLUSTERS; /**< FieldImplPtr for the fkClusters field. */
 907                 KeyImplPtr FKSECTORS; /**< FieldImplPtr for the fkSectors field. */
 908                 FieldImplPtr WIDTH; /**< FieldImplPtr for the width field. */
 909                 FieldImplPtr LENGTH; /**< FieldImplPtr for the length field. */
 910                 FieldImplPtr HEIGHT; /**< FieldImplPtr for the height field. */
 911
 912         private:
 913                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 914                 Rooms(): TableImpl("Rooms") { }
 915
 916                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 917                 ~Rooms() { }
 918
 919                 /** Hide the copy constructor. */
 920                 Rooms(const Rooms& rhs);
 921
 922                 /** Hide the assignment operator. */
 923                 Rooms operator=(const Rooms& rhs);
 924
 925                 /** Initialize the table's fields. */
 926                 void Initialize();
 927
 928                 friend class TableImpls;
 929                 friend SmartPtrDelete(Rooms);
 930         };
 931
 932         /**
 933          * This is a generated class that contains all FieldImpls for the Sectors table.
 934          */
 935         class Sectors : public TableImpl
 936         {
 937         public:
 938                 KeyImplPtr SECTORID; /**< FieldImplPtr for the sectorid field. */
 939                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
 940                 FieldImplPtr SYMBOL; /**< FieldImplPtr for the symbol field. */
 941                 FieldImplPtr MOVECOST; /**< FieldImplPtr for the movecost field. */
 942                 FieldImplPtr WATER; /**< FieldImplPtr for the water field. */
 943
 944         private:
 945                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 946                 Sectors(): TableImpl("Sectors") { }
 947
 948                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 949                 ~Sectors() { }
 950
 951                 /** Hide the copy constructor. */
 952                 Sectors(const Sectors& rhs);
 953
 954                 /** Hide the assignment operator. */
 955                 Sectors operator=(const Sectors& rhs);
 956
 957                 /** Initialize the table's fields. */
 958                 void Initialize();
 959
 960                 friend class TableImpls;
 961                 friend SmartPtrDelete(Sectors);
 962         };
 963
 964         /**
 965          * This is a generated class that contains all FieldImpls for the Skills table.
 966          */
 967         class Skills : public TableImpl
 968         {
 969         public:
 970                 KeyImplPtr SKILLID; /**< FieldImplPtr for the skillid field. */
 971                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
 972                 KeyImplPtr FKBRANCHES; /**< FieldImplPtr for the fkBranches field. */
 973
 974         private:
 975                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
 976                 Skills(): TableImpl("Skills") { }
 977
 978                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
 979                 ~Skills() { }
 980
 981                 /** Hide the copy constructor. */
 982                 Skills(const Skills& rhs);
 983
 984                 /** Hide the assignment operator. */
 985                 Skills operator=(const Skills& rhs);
 986
 987                 /** Initialize the table's fields. */
 988                 void Initialize();
 989
 990                 friend class TableImpls;
 991                 friend SmartPtrDelete(Skills);
 992         };
 993
 994         /**
 995          * This is a generated class that contains all FieldImpls for the Stats table.
 996          */
 997         class Stats : public TableImpl
 998         {
 999         public:
1000                 KeyImplPtr STATID; /**< FieldImplPtr for the statid field. */
1001                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
1002                 FieldImplPtr SHORTNAME; /**< FieldImplPtr for the shortname field. */
1003
1004         private:
1005                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
1006                 Stats(): TableImpl("Stats") { }
1007
1008                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
1009                 ~Stats() { }
1010
1011                 /** Hide the copy constructor. */
1012                 Stats(const Stats& rhs);
1013
1014                 /** Hide the assignment operator. */
1015                 Stats operator=(const Stats& rhs);
1016
1017                 /** Initialize the table's fields. */
1018                 void Initialize();
1019
1020                 friend class TableImpls;
1021                 friend SmartPtrDelete(Stats);
1022         };
1023
1024         /**
1025          * This is a generated class that contains all FieldImpls for the Traces table.
1026          */
1027         class Traces : public TableImpl
1028         {
1029         public:
1030                 KeyImplPtr TRACEID; /**< FieldImplPtr for the traceid field. */
1031                 KeyImplPtr FKACCOUNTS; /**< FieldImplPtr for the fkAccounts field. */
1032                 FieldImplPtr TIME; /**< FieldImplPtr for the time field. */
1033                 FieldImplPtr DESCRIPTION; /**< FieldImplPtr for the description field. */
1034                 FieldImplPtr DIFF; /**< FieldImplPtr for the diff field. */
1035
1036         private:
1037                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
1038                 Traces(): TableImpl("Traces") { }
1039
1040                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
1041                 ~Traces() { }
1042
1043                 /** Hide the copy constructor. */
1044                 Traces(const Traces& rhs);
1045
1046                 /** Hide the assignment operator. */
1047                 Traces operator=(const Traces& rhs);
1048
1049                 /** Initialize the table's fields. */
1050                 void Initialize();
1051
1052                 friend class TableImpls;
1053                 friend SmartPtrDelete(Traces);
1054         };
1055
1056         /**
1057          * This is a generated class that contains all FieldImpls for the TraceChunk table.
1058          */
1059         class TraceChunk : public TableImpl
1060         {
1061         public:
1062                 KeyImplPtr FKTRACES; /**< FieldImplPtr for the fkTraces field. */
1063                 KeyImplPtr FKCHUNKS; /**< FieldImplPtr for the fkChunks field. */
1064
1065         private:
1066                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
1067                 TraceChunk(): TableImpl("TraceChunk") { }
1068
1069                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
1070                 ~TraceChunk() { }
1071
1072                 /** Hide the copy constructor. */
1073                 TraceChunk(const TraceChunk& rhs);
1074
1075                 /** Hide the assignment operator. */
1076                 TraceChunk operator=(const TraceChunk& rhs);
1077
1078                 /** Initialize the table's fields. */
1079                 void Initialize();
1080
1081                 friend class TableImpls;
1082                 friend SmartPtrDelete(TraceChunk);
1083         };
1084
1085         /**
1086          * This is a generated class that contains all FieldImpls for the TraceDetail table.
1087          */
1088         class TraceDetail : public TableImpl
1089         {
1090         public:
1091                 KeyImplPtr FKTRACES; /**< FieldImplPtr for the fkTraces field. */
1092                 KeyImplPtr FKDETAILS; /**< FieldImplPtr for the fkDetails field. */
1093
1094         private:
1095                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
1096                 TraceDetail(): TableImpl("TraceDetail") { }
1097
1098                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
1099                 ~TraceDetail() { }
1100
1101                 /** Hide the copy constructor. */
1102                 TraceDetail(const TraceDetail& rhs);
1103
1104                 /** Hide the assignment operator. */
1105                 TraceDetail operator=(const TraceDetail& rhs);
1106
1107                 /** Initialize the table's fields. */
1108                 void Initialize();
1109
1110                 friend class TableImpls;
1111                 friend SmartPtrDelete(TraceDetail);
1112         };
1113
1114         /**
1115          * This is a generated class that contains all FieldImpls for the TraceEntity table.
1116          */
1117         class TraceEntity : public TableImpl
1118         {
1119         public:
1120                 KeyImplPtr FKTRACES; /**< FieldImplPtr for the fkTraces field. */
1121                 KeyImplPtr FKENTITIES; /**< FieldImplPtr for the fkEntities field. */
1122
1123         private:
1124                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
1125                 TraceEntity(): TableImpl("TraceEntity") { }
1126
1127                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
1128                 ~TraceEntity() { }
1129
1130                 /** Hide the copy constructor. */
1131                 TraceEntity(const TraceEntity& rhs);
1132
1133                 /** Hide the assignment operator. */
1134                 TraceEntity operator=(const TraceEntity& rhs);
1135
1136                 /** Initialize the table's fields. */
1137                 void Initialize();
1138
1139                 friend class TableImpls;
1140                 friend SmartPtrDelete(TraceEntity);
1141         };
1142
1143         /**
1144          * This is a generated class that contains all FieldImpls for the TraceRoom table.
1145          */
1146         class TraceRoom : public TableImpl
1147         {
1148         public:
1149                 KeyImplPtr FKTRACES; /**< FieldImplPtr for the fkTraces field. */
1150                 KeyImplPtr FKROOMS; /**< FieldImplPtr for the fkRooms field. */
1151
1152         private:
1153                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
1154                 TraceRoom(): TableImpl("TraceRoom") { }
1155
1156                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
1157                 ~TraceRoom() { }
1158
1159                 /** Hide the copy constructor. */
1160                 TraceRoom(const TraceRoom& rhs);
1161
1162                 /** Hide the assignment operator. */
1163                 TraceRoom operator=(const TraceRoom& rhs);
1164
1165                 /** Initialize the table's fields. */
1166                 void Initialize();
1167
1168                 friend class TableImpls;
1169                 friend SmartPtrDelete(TraceRoom);
1170         };
1171
1172         /**
1173          * This is a generated class that contains all FieldImpls for the Trees table.
1174          */
1175         class Trees : public TableImpl
1176         {
1177         public:
1178                 KeyImplPtr TREEID; /**< FieldImplPtr for the treeid field. */
1179                 FieldImplPtr NAME; /**< FieldImplPtr for the name field. */
1180                 KeyImplPtr FKCLUSTERS; /**< FieldImplPtr for the fkClusters field. */
1181                 KeyImplPtr FKSTATSPRIMARY; /**< FieldImplPtr for the fkStatsPrimary field. */
1182                 KeyImplPtr FKSTATSSECONDARY; /**< FieldImplPtr for the fkStatsSecondary field. */
1183
1184         private:
1185                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
1186                 Trees(): TableImpl("Trees") { }
1187
1188                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
1189                 ~Trees() { }
1190
1191                 /** Hide the copy constructor. */
1192                 Trees(const Trees& rhs);
1193
1194                 /** Hide the assignment operator. */
1195                 Trees operator=(const Trees& rhs);
1196
1197                 /** Initialize the table's fields. */
1198                 void Initialize();
1199
1200                 friend class TableImpls;
1201                 friend SmartPtrDelete(Trees);
1202         };
1203
1204         /**
1205          * This is a generated class that contains all FieldImpls for the Version table.
1206          */
1207         class Version : public TableImpl
1208         {
1209         public:
1210                 KeyImplPtr VERSIONID; /**< FieldImplPtr for the versionid field. */
1211                 FieldImplPtr VERSIONTEXT; /**< FieldImplPtr for the versiontext field. */
1212                 FieldImplPtr MAJOR; /**< FieldImplPtr for the major field. */
1213                 FieldImplPtr MINOR; /**< FieldImplPtr for the minor field. */
1214                 FieldImplPtr MICRO; /**< FieldImplPtr for the micro field. */
1215
1216         private:
1217                 /** This is a managed class, use <code>TableImpls</code> to get an instance. */
1218                 Version(): TableImpl("Version") { }
1219
1220                 /** This is a managed class, free <code>TableImpls</code> to free the instance. */
1221                 ~Version() { }
1222
1223                 /** Hide the copy constructor. */
1224                 Version(const Version& rhs);
1225
1226                 /** Hide the assignment operator. */
1227                 Version operator=(const Version& rhs);
1228
1229                 /** Initialize the table's fields. */
1230                 void Initialize();
1231
1232                 friend class TableImpls;
1233                 friend SmartPtrDelete(Version);
1234         };
1235
1236 } // end of namespace
1237
1238