src/DB/Generated/FieldImpls.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2008 by Sverre Rabbelier                                *
 *   sverre@rabbelier.nl                                                   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 3 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

/* NOTE: This file was generated automatically. Do not edit. */

#pragma once

#include "Types.h"
#include "TableImpl.h"

namespace db
{
        class Accounts : public TableImpl
        {
        public:
                KeyImplPtr ACCOUNTID; 
                FieldImplPtr NAME; 
                FieldImplPtr PASSWORD; 
        private:
                Accounts(): TableImpl("Accounts") { }

                ~Accounts() { }

                Accounts(const Accounts& rhs);

                Accounts operator=(const Accounts& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Accounts);
        };

        class Areas : public TableImpl
        {
        public:
                KeyImplPtr AREAID; 
                FieldImplPtr NAME; 
                FieldImplPtr DESCRIPTION; 
                FieldImplPtr HEIGHT; 
                FieldImplPtr WIDTH; 
                FieldImplPtr LENGTH; 
        private:
                Areas(): TableImpl("Areas") { }

                ~Areas() { }

                Areas(const Areas& rhs);

                Areas operator=(const Areas& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Areas);
        };

        class Branches : public TableImpl
        {
        public:
                KeyImplPtr BRANCHID; 
                FieldImplPtr NAME; 
                KeyImplPtr FKTREES; 
                KeyImplPtr FKSTATSPRIMARY; 
                KeyImplPtr FKSTATSSECONDARY; 
        private:
                Branches(): TableImpl("Branches") { }

                ~Branches() { }

                Branches(const Branches& rhs);

                Branches operator=(const Branches& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Branches);
        };

        class Channels : public TableImpl
        {
        public:
                KeyImplPtr CHANNELID; 
                FieldImplPtr NAME; 
                FieldImplPtr DESCRIPTION; 
                FieldImplPtr NEEDLOGIN; 
        private:
                Channels(): TableImpl("Channels") { }

                ~Channels() { }

                Channels(const Channels& rhs);

                Channels operator=(const Channels& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Channels);
        };

        class ChannelLogs : public TableImpl
        {
        public:
                KeyImplPtr CHANNELLOGID; 
                KeyImplPtr FKCHANNELS; 
                KeyImplPtr FKACCOUNTS; 
                FieldImplPtr TIME; 
                FieldImplPtr CONTENT; 
        private:
                ChannelLogs(): TableImpl("ChannelLogs") { }

                ~ChannelLogs() { }

                ChannelLogs(const ChannelLogs& rhs);

                ChannelLogs operator=(const ChannelLogs& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(ChannelLogs);
        };

        class CharacterAccount : public TableImpl
        {
        public:
                KeyImplPtr FKENTITIES; 
                KeyImplPtr FKACCOUNTS; 
        private:
                CharacterAccount(): TableImpl("CharacterAccount") { }

                ~CharacterAccount() { }

                CharacterAccount(const CharacterAccount& rhs);

                CharacterAccount operator=(const CharacterAccount& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(CharacterAccount);
        };

        class CharacterBranch : public TableImpl
        {
        public:
                KeyImplPtr FKENTITIES; 
                KeyImplPtr FKBRANCHES; 
                FieldImplPtr XP; 
        private:
                CharacterBranch(): TableImpl("CharacterBranch") { }

                ~CharacterBranch() { }

                CharacterBranch(const CharacterBranch& rhs);

                CharacterBranch operator=(const CharacterBranch& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(CharacterBranch);
        };

        class CharacterCluster : public TableImpl
        {
        public:
                KeyImplPtr FKENTITIES; 
                KeyImplPtr FKCLUSTERS; 
                FieldImplPtr XP; 
        private:
                CharacterCluster(): TableImpl("CharacterCluster") { }

                ~CharacterCluster() { }

                CharacterCluster(const CharacterCluster& rhs);

                CharacterCluster operator=(const CharacterCluster& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(CharacterCluster);
        };

        class CharacterSkill : public TableImpl
        {
        public:
                KeyImplPtr FKENTITIES; 
                KeyImplPtr FKBRANCHES; 
                FieldImplPtr XP; 
        private:
                CharacterSkill(): TableImpl("CharacterSkill") { }

                ~CharacterSkill() { }

                CharacterSkill(const CharacterSkill& rhs);

                CharacterSkill operator=(const CharacterSkill& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(CharacterSkill);
        };

        class CharacterStat : public TableImpl
        {
        public:
                KeyImplPtr FKENTITIES; 
                KeyImplPtr FKSTATS; 
                FieldImplPtr XP; 
        private:
                CharacterStat(): TableImpl("CharacterStat") { }

                ~CharacterStat() { }

                CharacterStat(const CharacterStat& rhs);

                CharacterStat operator=(const CharacterStat& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(CharacterStat);
        };

        class CharacterTree : public TableImpl
        {
        public:
                KeyImplPtr FKENTITIES; 
                KeyImplPtr FKTREES; 
                FieldImplPtr XP; 
        private:
                CharacterTree(): TableImpl("CharacterTree") { }

                ~CharacterTree() { }

                CharacterTree(const CharacterTree& rhs);

                CharacterTree operator=(const CharacterTree& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(CharacterTree);
        };

        class Clusters : public TableImpl
        {
        public:
                KeyImplPtr CLUSTERID; 
                FieldImplPtr NAME; 
                FieldImplPtr DESCRIPTION; 
                KeyImplPtr FKAREAS; 
        private:
                Clusters(): TableImpl("Clusters") { }

                ~Clusters() { }

                Clusters(const Clusters& rhs);

                Clusters operator=(const Clusters& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Clusters);
        };

        class Chunks : public TableImpl
        {
        public:
                KeyImplPtr CHUNKID; 
                KeyImplPtr FKROOMS; 
                FieldImplPtr NAME; 
                FieldImplPtr DESCRIPTION; 
                FieldImplPtr TAGS; 
        private:
                Chunks(): TableImpl("Chunks") { }

                ~Chunks() { }

                Chunks(const Chunks& rhs);

                Chunks operator=(const Chunks& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Chunks);
        };

        class Colours : public TableImpl
        {
        public:
                KeyImplPtr COLOURID; 
                FieldImplPtr NAME; 
                FieldImplPtr CODE; 
                FieldImplPtr COLOURSTRING; 
                FieldImplPtr ANSI; 
        private:
                Colours(): TableImpl("Colours") { }

                ~Colours() { }

                Colours(const Colours& rhs);

                Colours operator=(const Colours& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Colours);
        };

        class Commands : public TableImpl
        {
        public:
                KeyImplPtr COMMANDID; 
                FieldImplPtr NAME; 
                FieldImplPtr GRANTGROUP; 
                FieldImplPtr HIGHFORCE; 
                FieldImplPtr FORCE; 
                FieldImplPtr LOWFORCE; 
                FieldImplPtr HELP; 
        private:
                Commands(): TableImpl("Commands") { }

                ~Commands() { }

                Commands(const Commands& rhs);

                Commands operator=(const Commands& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Commands);
        };

        class Details : public TableImpl
        {
        public:
                KeyImplPtr DETAILID; 
                FieldImplPtr KEY; 
                FieldImplPtr DESCRIPTION; 
        private:
                Details(): TableImpl("Details") { }

                ~Details() { }

                Details(const Details& rhs);

                Details operator=(const Details& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Details);
        };

        class DetailArea : public TableImpl
        {
        public:
                KeyImplPtr FKDETAILS; 
                KeyImplPtr FKAREAS; 
        private:
                DetailArea(): TableImpl("DetailArea") { }

                ~DetailArea() { }

                DetailArea(const DetailArea& rhs);

                DetailArea operator=(const DetailArea& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(DetailArea);
        };

        class DetailRoom : public TableImpl
        {
        public:
                KeyImplPtr FKDETAILS; 
                KeyImplPtr FKROOMS; 
        private:
                DetailRoom(): TableImpl("DetailRoom") { }

                ~DetailRoom() { }

                DetailRoom(const DetailRoom& rhs);

                DetailRoom operator=(const DetailRoom& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(DetailRoom);
        };

        class DetailChunk : public TableImpl
        {
        public:
                KeyImplPtr FKDETAILS; 
                KeyImplPtr FKCHUNKS; 
        private:
                DetailChunk(): TableImpl("DetailChunk") { }

                ~DetailChunk() { }

                DetailChunk(const DetailChunk& rhs);

                DetailChunk operator=(const DetailChunk& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(DetailChunk);
        };

        class DetailCharacter : public TableImpl
        {
        public:
                KeyImplPtr FKDETAILS; 
                KeyImplPtr FKENTITIES; 
        private:
                DetailCharacter(): TableImpl("DetailCharacter") { }

                ~DetailCharacter() { }

                DetailCharacter(const DetailCharacter& rhs);

                DetailCharacter operator=(const DetailCharacter& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(DetailCharacter);
        };

        class DetailDetail : public TableImpl
        {
        public:
                KeyImplPtr FKDETAILSPRIMARY; 
                KeyImplPtr FKDETAILSSECONDARY; 
        private:
                DetailDetail(): TableImpl("DetailDetail") { }

                ~DetailDetail() { }

                DetailDetail(const DetailDetail& rhs);

                DetailDetail operator=(const DetailDetail& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(DetailDetail);
        };

        class Echos : public TableImpl
        {
        public:
                KeyImplPtr ECHOID; 
                FieldImplPtr MESSAGE; 
                FieldImplPtr VISIBILITY; 
                FieldImplPtr AUDIBILITY; 
        private:
                Echos(): TableImpl("Echos") { }

                ~Echos() { }

                Echos(const Echos& rhs);

                Echos operator=(const Echos& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Echos);
        };

        class Entities : public TableImpl
        {
        public:
                KeyImplPtr ENTITYID; 
                KeyImplPtr FKRACES; 
                KeyImplPtr FKROOMS; 
                FieldImplPtr NAME; 
                FieldImplPtr DESCRIPTION; 
        private:
                Entities(): TableImpl("Entities") { }

                ~Entities() { }

                Entities(const Entities& rhs);

                Entities operator=(const Entities& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Entities);
        };

        class ExitRoom : public TableImpl
        {
        public:
                KeyImplPtr FKEXITS; 
                KeyImplPtr FKROOMS; 
        private:
                ExitRoom(): TableImpl("ExitRoom") { }

                ~ExitRoom() { }

                ExitRoom(const ExitRoom& rhs);

                ExitRoom operator=(const ExitRoom& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(ExitRoom);
        };

        class Exits : public TableImpl
        {
        public:
                KeyImplPtr EXITID; 
                KeyImplPtr FKROOMS; 
                FieldImplPtr DIR; 
        private:
                Exits(): TableImpl("Exits") { }

                ~Exits() { }

                Exits(const Exits& rhs);

                Exits operator=(const Exits& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Exits);
        };

        class GrantGroups : public TableImpl
        {
        public:
                KeyImplPtr GRANTGROUPID; 
                FieldImplPtr NAME; 
                FieldImplPtr DEFAULTGRANT; 
                FieldImplPtr DEFAULTLOG; 
                FieldImplPtr IMPLIES; 
        private:
                GrantGroups(): TableImpl("GrantGroups") { }

                ~GrantGroups() { }

                GrantGroups(const GrantGroups& rhs);

                GrantGroups operator=(const GrantGroups& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(GrantGroups);
        };

        class Logs : public TableImpl
        {
        public:
                KeyImplPtr LOGID; 
                FieldImplPtr TYPE; 
                FieldImplPtr TIME; 
                FieldImplPtr CONTENT; 
        private:
                Logs(): TableImpl("Logs") { }

                ~Logs() { }

                Logs(const Logs& rhs);

                Logs operator=(const Logs& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Logs);
        };

        class Permissions : public TableImpl
        {
        public:
                KeyImplPtr FKACCOUNTS; 
                KeyImplPtr FKGRANTGROUPS; 
                FieldImplPtr GRANT; 
                FieldImplPtr LOG; 
        private:
                Permissions(): TableImpl("Permissions") { }

                ~Permissions() { }

                Permissions(const Permissions& rhs);

                Permissions operator=(const Permissions& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Permissions);
        };

        class Races : public TableImpl
        {
        public:
                KeyImplPtr RACEID; 
                FieldImplPtr NAME; 
        private:
                Races(): TableImpl("Races") { }

                ~Races() { }

                Races(const Races& rhs);

                Races operator=(const Races& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Races);
        };

        class Rooms : public TableImpl
        {
        public:
                KeyImplPtr ROOMID; 
                FieldImplPtr NAME; 
                FieldImplPtr DESCRIPTION; 
                KeyImplPtr FKCLUSTERS; 
                KeyImplPtr FKSECTORS; 
                FieldImplPtr WIDTH; 
                FieldImplPtr LENGTH; 
                FieldImplPtr HEIGHT; 
        private:
                Rooms(): TableImpl("Rooms") { }

                ~Rooms() { }

                Rooms(const Rooms& rhs);

                Rooms operator=(const Rooms& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Rooms);
        };

        class Sectors : public TableImpl
        {
        public:
                KeyImplPtr SECTORID; 
                FieldImplPtr NAME; 
                FieldImplPtr SYMBOL; 
                FieldImplPtr MOVECOST; 
                FieldImplPtr WATER; 
        private:
                Sectors(): TableImpl("Sectors") { }

                ~Sectors() { }

                Sectors(const Sectors& rhs);

                Sectors operator=(const Sectors& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Sectors);
        };

        class Skills : public TableImpl
        {
        public:
                KeyImplPtr SKILLID; 
                FieldImplPtr NAME; 
                KeyImplPtr FKBRANCHES; 
        private:
                Skills(): TableImpl("Skills") { }

                ~Skills() { }

                Skills(const Skills& rhs);

                Skills operator=(const Skills& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Skills);
        };

        class Stats : public TableImpl
        {
        public:
                KeyImplPtr STATID; 
                FieldImplPtr NAME; 
                FieldImplPtr SHORTNAME; 
        private:
                Stats(): TableImpl("Stats") { }

                ~Stats() { }

                Stats(const Stats& rhs);

                Stats operator=(const Stats& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Stats);
        };

        class Traces : public TableImpl
        {
        public:
                KeyImplPtr TRACEID; 
                KeyImplPtr FKACCOUNTS; 
                FieldImplPtr TIME; 
                FieldImplPtr DESCRIPTION; 
                FieldImplPtr DIFF; 
        private:
                Traces(): TableImpl("Traces") { }

                ~Traces() { }

                Traces(const Traces& rhs);

                Traces operator=(const Traces& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Traces);
        };

        class TraceChunk : public TableImpl
        {
        public:
                KeyImplPtr FKTRACES; 
                KeyImplPtr FKCHUNKS; 
        private:
                TraceChunk(): TableImpl("TraceChunk") { }

                ~TraceChunk() { }

                TraceChunk(const TraceChunk& rhs);

                TraceChunk operator=(const TraceChunk& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(TraceChunk);
        };

        class TraceDetail : public TableImpl
        {
        public:
                KeyImplPtr FKTRACES; 
                KeyImplPtr FKDETAILS; 
        private:
                TraceDetail(): TableImpl("TraceDetail") { }

                ~TraceDetail() { }

                TraceDetail(const TraceDetail& rhs);

                TraceDetail operator=(const TraceDetail& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(TraceDetail);
        };

        class TraceEntity : public TableImpl
        {
        public:
                KeyImplPtr FKTRACES; 
                KeyImplPtr FKENTITIES; 
        private:
                TraceEntity(): TableImpl("TraceEntity") { }

                ~TraceEntity() { }

                TraceEntity(const TraceEntity& rhs);

                TraceEntity operator=(const TraceEntity& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(TraceEntity);
        };

        class TraceRoom : public TableImpl
        {
        public:
                KeyImplPtr FKTRACES; 
                KeyImplPtr FKROOMS; 
        private:
                TraceRoom(): TableImpl("TraceRoom") { }

                ~TraceRoom() { }

                TraceRoom(const TraceRoom& rhs);

                TraceRoom operator=(const TraceRoom& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(TraceRoom);
        };

        class Trees : public TableImpl
        {
        public:
                KeyImplPtr TREEID; 
                FieldImplPtr NAME; 
                KeyImplPtr FKCLUSTERS; 
                KeyImplPtr FKSTATSPRIMARY; 
                KeyImplPtr FKSTATSSECONDARY; 
        private:
                Trees(): TableImpl("Trees") { }

                ~Trees() { }

                Trees(const Trees& rhs);

                Trees operator=(const Trees& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Trees);
        };

        class Version : public TableImpl
        {
        public:
                KeyImplPtr VERSIONID; 
                FieldImplPtr VERSIONTEXT; 
                FieldImplPtr MAJOR; 
                FieldImplPtr MINOR; 
                FieldImplPtr MICRO; 
        private:
                Version(): TableImpl("Version") { }

                ~Version() { }

                Version(const Version& rhs);

                Version operator=(const Version& rhs);

                void Initialize();

                friend class TableImpls;
                friend SmartPtrDelete(Version);
        };

} // end of namespace

---