Atlas-C++
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-2005 Alistair 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 // Attribute name strings follow.
00202 //
00203 
00204 extern const std::string USERNAME_ATTR;
00205 extern const std::string PASSWORD_ATTR;
00206 extern const std::string CHARACTERS_ATTR;
00207 
00208 //
00209 // Inlined member functions follow.
00210 //
00211 
00212 const int USERNAME_FLAG = 1 << 11;
00213 
00214 void AccountData::setUsername(const std::string& val)
00215 {
00216     attr_username = val;
00217     m_attrFlags |= USERNAME_FLAG;
00218 }
00219 
00220 const int PASSWORD_FLAG = 1 << 12;
00221 
00222 void AccountData::setPassword(const std::string& val)
00223 {
00224     attr_password = val;
00225     m_attrFlags |= PASSWORD_FLAG;
00226 }
00227 
00228 const int CHARACTERS_FLAG = 1 << 13;
00229 
00230 void AccountData::setCharacters(const std::list<std::string>& val)
00231 {
00232     attr_characters = val;
00233     m_attrFlags |= CHARACTERS_FLAG;
00234 }
00235 
00236 void AccountData::setCharactersAsList(const Atlas::Message::ListType& val)
00237 {
00238     m_attrFlags |= CHARACTERS_FLAG;
00239     attr_characters.resize(0);
00240     for(Atlas::Message::ListType::const_iterator I = val.begin();
00241         I != val.end();
00242         I++)
00243     {
00244         if((*I).isString()) {
00245             attr_characters.push_back((*I).asString());
00246         }
00247     }
00248 }
00249 
00250 const std::string& AccountData::getUsername() const
00251 {
00252     if(m_attrFlags & USERNAME_FLAG)
00253         return attr_username;
00254     else
00255         return ((AccountData*)m_defaults)->attr_username;
00256 }
00257 
00258 std::string& AccountData::modifyUsername()
00259 {
00260     if(!(m_attrFlags & USERNAME_FLAG))
00261         setUsername(((AccountData*)m_defaults)->attr_username);
00262     return attr_username;
00263 }
00264 
00265 const std::string& AccountData::getPassword() const
00266 {
00267     if(m_attrFlags & PASSWORD_FLAG)
00268         return attr_password;
00269     else
00270         return ((AccountData*)m_defaults)->attr_password;
00271 }
00272 
00273 std::string& AccountData::modifyPassword()
00274 {
00275     if(!(m_attrFlags & PASSWORD_FLAG))
00276         setPassword(((AccountData*)m_defaults)->attr_password);
00277     return attr_password;
00278 }
00279 
00280 const std::list<std::string>& AccountData::getCharacters() const
00281 {
00282     if(m_attrFlags & CHARACTERS_FLAG)
00283         return attr_characters;
00284     else
00285         return ((AccountData*)m_defaults)->attr_characters;
00286 }
00287 
00288 std::list<std::string>& AccountData::modifyCharacters()
00289 {
00290     if(!(m_attrFlags & CHARACTERS_FLAG))
00291         setCharacters(((AccountData*)m_defaults)->attr_characters);
00292     return attr_characters;
00293 }
00294 
00295 const Atlas::Message::ListType AccountData::getCharactersAsList() const
00296 {
00297     const std::list<std::string>& lst_in = getCharacters();
00298     Atlas::Message::ListType lst_out;
00299     for(std::list<std::string>::const_iterator I = lst_in.begin();
00300         I != lst_in.end();
00301         I++)
00302     {
00303         lst_out.push_back(std::string(*I));
00304     }
00305     return lst_out;
00306 }
00307 
00308 bool AccountData::isDefaultUsername() const
00309 {
00310     return (m_attrFlags & USERNAME_FLAG) == 0;
00311 }
00312 
00313 bool AccountData::isDefaultPassword() const
00314 {
00315     return (m_attrFlags & PASSWORD_FLAG) == 0;
00316 }
00317 
00318 bool AccountData::isDefaultCharacters() const
00319 {
00320     return (m_attrFlags & CHARACTERS_FLAG) == 0;
00321 }
00322 
00323 
00324 
00331 class PlayerData;
00332 typedef SmartPtr<PlayerData> Player;
00333 
00334 static const int PLAYER_NO = 5;
00335 
00338 
00340 class PlayerData : public AccountData
00341 {
00342 protected:
00344     PlayerData(PlayerData *defaults = NULL) : 
00345         AccountData((AccountData*)defaults)
00346     {
00347         m_class_no = PLAYER_NO;
00348     }
00350     virtual ~PlayerData();
00351 
00352 public:
00354     virtual PlayerData * copy() const;
00355 
00357     virtual bool instanceOf(int classNo) const;
00358 
00359 
00360     virtual void iterate(int& current_class, std::string& attr) const
00361         {if(current_class == PLAYER_NO) current_class = -1; AccountData::iterate(current_class, attr);}
00362 
00363     //freelist related things
00364 public:
00365     static PlayerData *alloc();
00366     virtual void free();
00367 
00372     virtual PlayerData *getDefaultObject();
00373 
00378     static PlayerData *getDefaultObjectInstance();
00379 private:
00380     static PlayerData *defaults_PlayerData;
00381     static PlayerData *begin_PlayerData;
00382 };
00383 
00384 
00391 class AdminData;
00392 typedef SmartPtr<AdminData> Admin;
00393 
00394 static const int ADMIN_NO = 6;
00395 
00398 
00400 class AdminData : public AccountData
00401 {
00402 protected:
00404     AdminData(AdminData *defaults = NULL) : 
00405         AccountData((AccountData*)defaults)
00406     {
00407         m_class_no = ADMIN_NO;
00408     }
00410     virtual ~AdminData();
00411 
00412 public:
00414     virtual AdminData * copy() const;
00415 
00417     virtual bool instanceOf(int classNo) const;
00418 
00419 
00420     virtual void iterate(int& current_class, std::string& attr) const
00421         {if(current_class == ADMIN_NO) current_class = -1; AccountData::iterate(current_class, attr);}
00422 
00423     //freelist related things
00424 public:
00425     static AdminData *alloc();
00426     virtual void free();
00427 
00432     virtual AdminData *getDefaultObject();
00433 
00438     static AdminData *getDefaultObjectInstance();
00439 private:
00440     static AdminData *defaults_AdminData;
00441     static AdminData *begin_AdminData;
00442 };
00443 
00444 
00451 class GameData;
00452 typedef SmartPtr<GameData> Game;
00453 
00454 static const int GAME_NO = 7;
00455 
00458 
00460 class GameData : public AdminEntityData
00461 {
00462 protected:
00464     GameData(GameData *defaults = NULL) : 
00465         AdminEntityData((AdminEntityData*)defaults)
00466     {
00467         m_class_no = GAME_NO;
00468     }
00470     virtual ~GameData();
00471 
00472 public:
00474     virtual GameData * copy() const;
00475 
00477     virtual bool instanceOf(int classNo) const;
00478 
00479 
00480     virtual void iterate(int& current_class, std::string& attr) const
00481         {if(current_class == GAME_NO) current_class = -1; AdminEntityData::iterate(current_class, attr);}
00482 
00483     //freelist related things
00484 public:
00485     static GameData *alloc();
00486     virtual void free();
00487 
00492     virtual GameData *getDefaultObject();
00493 
00498     static GameData *getDefaultObjectInstance();
00499 private:
00500     static GameData *defaults_GameData;
00501     static GameData *begin_GameData;
00502 };
00503 
00504 
00511 class GameEntityData;
00512 typedef SmartPtr<GameEntityData> GameEntity;
00513 
00514 static const int GAME_ENTITY_NO = 8;
00515 
00518 
00520 class GameEntityData : public RootEntityData
00521 {
00522 protected:
00524     GameEntityData(GameEntityData *defaults = NULL) : 
00525         RootEntityData((RootEntityData*)defaults)
00526     {
00527         m_class_no = GAME_ENTITY_NO;
00528     }
00530     virtual ~GameEntityData();
00531 
00532 public:
00534     virtual GameEntityData * copy() const;
00535 
00537     virtual bool instanceOf(int classNo) const;
00538 
00539 
00540     virtual void iterate(int& current_class, std::string& attr) const
00541         {if(current_class == GAME_ENTITY_NO) current_class = -1; RootEntityData::iterate(current_class, attr);}
00542 
00543     //freelist related things
00544 public:
00545     static GameEntityData *alloc();
00546     virtual void free();
00547 
00552     virtual GameEntityData *getDefaultObject();
00553 
00558     static GameEntityData *getDefaultObjectInstance();
00559 private:
00560     static GameEntityData *defaults_GameEntityData;
00561     static GameEntityData *begin_GameEntityData;
00562 };
00563 
00564 } } } // namespace Atlas::Objects::Entity
00565 
00566 #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.