Main Page | Modules | Namespace List | Class Hierarchy | Class List | Directories | File List | Class Members | Related Pages

Entity.h

00001 // This file may be redistributed and modified only under the terms of
00002 // the GNU Lesser General Public License (See COPYING for details).
00003 // Copyright 2000-2001 Stefanus Du Toit and Aloril.
00004 // Copyright 2001-2004 Al Riddoch.
00005 // Automatically generated using gen_cpp.py.
00006 
00007 #ifndef ATLAS_OBJECTS_ENTITY_ENTITY_H
00008 #define ATLAS_OBJECTS_ENTITY_ENTITY_H
00009 
00010 #include <Atlas/Objects/RootEntity.h>
00011 #include <Atlas/Objects/Anonymous.h>
00012 
00013 
00014 namespace Atlas { namespace Objects { namespace Entity { 
00015 
00022 class AdminEntityData;
00023 typedef SmartPtr<AdminEntityData> AdminEntity;
00024 
00025 static const int ADMIN_ENTITY_NO = 3;
00026 
00029 
00031 class AdminEntityData : public RootEntityData
00032 {
00033 protected:
00035     AdminEntityData(AdminEntityData *defaults = NULL) : 
00036         RootEntityData((RootEntityData*)defaults)
00037     {
00038         m_class_no = ADMIN_ENTITY_NO;
00039     }
00041     virtual ~AdminEntityData();
00042 
00043 public:
00045     virtual AdminEntityData * copy() const;
00046 
00048     virtual bool instanceOf(int classNo) const;
00049 
00050 
00051     virtual void iterate(int& current_class, std::string& attr) const
00052         {if(current_class == ADMIN_ENTITY_NO) current_class = -1; RootEntityData::iterate(current_class, attr);}
00053 
00054     //freelist related things
00055 public:
00056     static AdminEntityData *alloc();
00057     virtual void free();
00058 
00063     virtual AdminEntityData *getDefaultObject();
00064 
00069     static AdminEntityData *getDefaultObjectInstance();
00070 private:
00071     static AdminEntityData *defaults_AdminEntityData;
00072     static AdminEntityData *begin_AdminEntityData;
00073 };
00074 
00075 
00082 class AccountData;
00083 typedef SmartPtr<AccountData> Account;
00084 
00085 static const int ACCOUNT_NO = 4;
00086 
00089 
00091 class AccountData : public AdminEntityData
00092 {
00093 protected:
00095     AccountData(AccountData *defaults = NULL) : 
00096         AdminEntityData((AdminEntityData*)defaults)
00097     {
00098         m_class_no = ACCOUNT_NO;
00099     }
00101     virtual ~AccountData();
00102 
00103 public:
00105     virtual AccountData * copy() const;
00106 
00108     virtual bool instanceOf(int classNo) const;
00109 
00112     virtual int copyAttr(const std::string& name, Atlas::Message::Element & attr) const;
00114     virtual void setAttr(const std::string& name,
00115                          const Atlas::Message::Element& attr);
00117     virtual void removeAttr(const std::string& name);
00118 
00120     virtual void sendContents(Atlas::Bridge & b) const;
00121 
00123     virtual void addToMessage(Atlas::Message::MapType &) const;
00124 
00126     inline void setUsername(const std::string& val);
00128     inline void setPassword(const std::string& val);
00130     inline void setCharacters(const std::list<std::string>& val);
00132     inline void setCharactersAsList(const Atlas::Message::ListType& val);
00133 
00135     inline const std::string& getUsername() const;
00137     inline std::string& modifyUsername();
00139     inline const std::string& getPassword() const;
00141     inline std::string& modifyPassword();
00143     inline const std::list<std::string>& getCharacters() const;
00145     inline std::list<std::string>& modifyCharacters();
00147     inline const Atlas::Message::ListType getCharactersAsList() const;
00148 
00150     inline bool isDefaultUsername() const;
00152     inline bool isDefaultPassword() const;
00154     inline bool isDefaultCharacters() const;
00155 
00156 protected:
00158     virtual int getAttrClass(const std::string& name)const;
00160     virtual int getAttrFlag(const std::string& name)const;
00162     std::string attr_username;
00164     std::string attr_password;
00166     std::list<std::string> attr_characters;
00167 
00169     void sendUsername(Atlas::Bridge&) const;
00171     void sendPassword(Atlas::Bridge&) const;
00173     void sendCharacters(Atlas::Bridge&) const;
00174 
00175     virtual void iterate(int& current_class, std::string& attr) const;
00176 
00177     //freelist related things
00178 public:
00179     static AccountData *alloc();
00180     virtual void free();
00181 
00186     virtual AccountData *getDefaultObject();
00187 
00192     static AccountData *getDefaultObjectInstance();
00193 private:
00194     static AccountData *defaults_AccountData;
00195     static AccountData *begin_AccountData;
00196 
00197     static std::map<std::string, int> * attr_flags_AccountData;
00198 };
00199 
00200 //
00201 // Inlined member functions follow.
00202 //
00203 
00204 const int USERNAME_FLAG = 1 << 11;
00205 void AccountData::setUsername(const std::string& val)
00206 {
00207     attr_username = val;
00208     m_attrFlags |= USERNAME_FLAG;
00209 }
00210 
00211 const int PASSWORD_FLAG = 1 << 12;
00212 void AccountData::setPassword(const std::string& val)
00213 {
00214     attr_password = val;
00215     m_attrFlags |= PASSWORD_FLAG;
00216 }
00217 
00218 const int CHARACTERS_FLAG = 1 << 13;
00219 void AccountData::setCharacters(const std::list<std::string>& val)
00220 {
00221     attr_characters = val;
00222     m_attrFlags |= CHARACTERS_FLAG;
00223 }
00224 
00225 void AccountData::setCharactersAsList(const Atlas::Message::ListType& val)
00226 {
00227     m_attrFlags |= CHARACTERS_FLAG;
00228     attr_characters.resize(0);
00229     for(Atlas::Message::ListType::const_iterator I = val.begin();
00230         I != val.end();
00231         I++)
00232     {
00233         if((*I).isString()) {
00234             attr_characters.push_back((*I).asString());
00235         }
00236     }
00237 }
00238 
00239 const std::string& AccountData::getUsername() const
00240 {
00241     if(m_attrFlags & USERNAME_FLAG)
00242         return attr_username;
00243     else
00244         return ((AccountData*)m_defaults)->attr_username;
00245 }
00246 
00247 std::string& AccountData::modifyUsername()
00248 {
00249     if(!(m_attrFlags & USERNAME_FLAG))
00250         setUsername(((AccountData*)m_defaults)->attr_username);
00251     return attr_username;
00252 }
00253 
00254 const std::string& AccountData::getPassword() const
00255 {
00256     if(m_attrFlags & PASSWORD_FLAG)
00257         return attr_password;
00258     else
00259         return ((AccountData*)m_defaults)->attr_password;
00260 }
00261 
00262 std::string& AccountData::modifyPassword()
00263 {
00264     if(!(m_attrFlags & PASSWORD_FLAG))
00265         setPassword(((AccountData*)m_defaults)->attr_password);
00266     return attr_password;
00267 }
00268 
00269 const std::list<std::string>& AccountData::getCharacters() const
00270 {
00271     if(m_attrFlags & CHARACTERS_FLAG)
00272         return attr_characters;
00273     else
00274         return ((AccountData*)m_defaults)->attr_characters;
00275 }
00276 
00277 std::list<std::string>& AccountData::modifyCharacters()
00278 {
00279     if(!(m_attrFlags & CHARACTERS_FLAG))
00280         setCharacters(((AccountData*)m_defaults)->attr_characters);
00281     return attr_characters;
00282 }
00283 
00284 const Atlas::Message::ListType AccountData::getCharactersAsList() const
00285 {
00286     const std::list<std::string>& lst_in = getCharacters();
00287     Atlas::Message::ListType lst_out;
00288     for(std::list<std::string>::const_iterator I = lst_in.begin();
00289         I != lst_in.end();
00290         I++)
00291     {
00292         lst_out.push_back(std::string(*I));
00293     }
00294     return lst_out;
00295 }
00296 
00297 bool AccountData::isDefaultUsername() const
00298 {
00299     return (m_attrFlags & USERNAME_FLAG) == 0;
00300 }
00301 
00302 bool AccountData::isDefaultPassword() const
00303 {
00304     return (m_attrFlags & PASSWORD_FLAG) == 0;
00305 }
00306 
00307 bool AccountData::isDefaultCharacters() const
00308 {
00309     return (m_attrFlags & CHARACTERS_FLAG) == 0;
00310 }
00311 
00312 
00313 
00320 class PlayerData;
00321 typedef SmartPtr<PlayerData> Player;
00322 
00323 static const int PLAYER_NO = 5;
00324 
00327 
00329 class PlayerData : public AccountData
00330 {
00331 protected:
00333     PlayerData(PlayerData *defaults = NULL) : 
00334         AccountData((AccountData*)defaults)
00335     {
00336         m_class_no = PLAYER_NO;
00337     }
00339     virtual ~PlayerData();
00340 
00341 public:
00343     virtual PlayerData * copy() const;
00344 
00346     virtual bool instanceOf(int classNo) const;
00347 
00348 
00349     virtual void iterate(int& current_class, std::string& attr) const
00350         {if(current_class == PLAYER_NO) current_class = -1; AccountData::iterate(current_class, attr);}
00351 
00352     //freelist related things
00353 public:
00354     static PlayerData *alloc();
00355     virtual void free();
00356 
00361     virtual PlayerData *getDefaultObject();
00362 
00367     static PlayerData *getDefaultObjectInstance();
00368 private:
00369     static PlayerData *defaults_PlayerData;
00370     static PlayerData *begin_PlayerData;
00371 };
00372 
00373 
00380 class AdminData;
00381 typedef SmartPtr<AdminData> Admin;
00382 
00383 static const int ADMIN_NO = 6;
00384 
00387 
00389 class AdminData : public AccountData
00390 {
00391 protected:
00393     AdminData(AdminData *defaults = NULL) : 
00394         AccountData((AccountData*)defaults)
00395     {
00396         m_class_no = ADMIN_NO;
00397     }
00399     virtual ~AdminData();
00400 
00401 public:
00403     virtual AdminData * copy() const;
00404 
00406     virtual bool instanceOf(int classNo) const;
00407 
00408 
00409     virtual void iterate(int& current_class, std::string& attr) const
00410         {if(current_class == ADMIN_NO) current_class = -1; AccountData::iterate(current_class, attr);}
00411 
00412     //freelist related things
00413 public:
00414     static AdminData *alloc();
00415     virtual void free();
00416 
00421     virtual AdminData *getDefaultObject();
00422 
00427     static AdminData *getDefaultObjectInstance();
00428 private:
00429     static AdminData *defaults_AdminData;
00430     static AdminData *begin_AdminData;
00431 };
00432 
00433 
00440 class GameData;
00441 typedef SmartPtr<GameData> Game;
00442 
00443 static const int GAME_NO = 7;
00444 
00447 
00449 class GameData : public AdminEntityData
00450 {
00451 protected:
00453     GameData(GameData *defaults = NULL) : 
00454         AdminEntityData((AdminEntityData*)defaults)
00455     {
00456         m_class_no = GAME_NO;
00457     }
00459     virtual ~GameData();
00460 
00461 public:
00463     virtual GameData * copy() const;
00464 
00466     virtual bool instanceOf(int classNo) const;
00467 
00468 
00469     virtual void iterate(int& current_class, std::string& attr) const
00470         {if(current_class == GAME_NO) current_class = -1; AdminEntityData::iterate(current_class, attr);}
00471 
00472     //freelist related things
00473 public:
00474     static GameData *alloc();
00475     virtual void free();
00476 
00481     virtual GameData *getDefaultObject();
00482 
00487     static GameData *getDefaultObjectInstance();
00488 private:
00489     static GameData *defaults_GameData;
00490     static GameData *begin_GameData;
00491 };
00492 
00493 
00500 class GameEntityData;
00501 typedef SmartPtr<GameEntityData> GameEntity;
00502 
00503 static const int GAME_ENTITY_NO = 8;
00504 
00507 
00509 class GameEntityData : public RootEntityData
00510 {
00511 protected:
00513     GameEntityData(GameEntityData *defaults = NULL) : 
00514         RootEntityData((RootEntityData*)defaults)
00515     {
00516         m_class_no = GAME_ENTITY_NO;
00517     }
00519     virtual ~GameEntityData();
00520 
00521 public:
00523     virtual GameEntityData * copy() const;
00524 
00526     virtual bool instanceOf(int classNo) const;
00527 
00528 
00529     virtual void iterate(int& current_class, std::string& attr) const
00530         {if(current_class == GAME_ENTITY_NO) current_class = -1; RootEntityData::iterate(current_class, attr);}
00531 
00532     //freelist related things
00533 public:
00534     static GameEntityData *alloc();
00535     virtual void free();
00536 
00541     virtual GameEntityData *getDefaultObject();
00542 
00547     static GameEntityData *getDefaultObjectInstance();
00548 private:
00549     static GameEntityData *defaults_GameEntityData;
00550     static GameEntityData *begin_GameEntityData;
00551 };
00552 
00553 } } } // namespace Atlas::Objects::Entity
00554 
00555 #endif // ATLAS_OBJECTS_ENTITY_ENTITY_H

Copyright 2000-2004 the respective authors.

This document can be licensed under the terms of the GNU Free Documentation License or the GNU General Public License and may be freely distributed under the terms given by one of these licenses.