1 // This file may be redistributed and modified only under the terms of
2 // the GNU Lesser General Public License (See COPYING for details).
3 // Copyright 2000-2001 Stefanus Du Toit and Aloril.
4 // Copyright 2001-2005 Alistair Riddoch.
5 // Automatically generated using gen_cpp.py.
6 
7 #include <Atlas/Objects/Entity.h>
8 
9 using Atlas::Message::Element;
10 using Atlas::Message::MapType;
11 
12 namespace Atlas { namespace Objects { namespace Entity {
13 
~AdminEntityData()14 AdminEntityData::~AdminEntityData()
15 {
16 }
17 
copy() const18 AdminEntityData * AdminEntityData::copy() const
19 {
20     AdminEntityData * copied = AdminEntityData::alloc();
21     *copied = *this;
22     copied->m_refCount = 0;
23     return copied;
24 }
25 
instanceOf(int classNo) const26 bool AdminEntityData::instanceOf(int classNo) const
27 {
28     if(ADMIN_ENTITY_NO == classNo) return true;
29     return RootEntityData::instanceOf(classNo);
30 }
31 
32 //freelist related methods specific to this class
33 AdminEntityData *AdminEntityData::defaults_AdminEntityData = 0;
34 AdminEntityData *AdminEntityData::begin_AdminEntityData = 0;
35 
alloc()36 AdminEntityData *AdminEntityData::alloc()
37 {
38     if(begin_AdminEntityData) {
39         AdminEntityData *res = begin_AdminEntityData;
40         assert( res->m_refCount == 0 );
41         res->m_attrFlags = 0;
42         res->m_attributes.clear();
43         begin_AdminEntityData = (AdminEntityData *)begin_AdminEntityData->m_next;
44         return res;
45     }
46     return new AdminEntityData(AdminEntityData::getDefaultObjectInstance());
47 }
48 
free()49 void AdminEntityData::free()
50 {
51     m_next = begin_AdminEntityData;
52     begin_AdminEntityData = this;
53 }
54 
55 
getDefaultObjectInstance()56 AdminEntityData *AdminEntityData::getDefaultObjectInstance()
57 {
58     if (defaults_AdminEntityData == 0) {
59         defaults_AdminEntityData = new AdminEntityData;
60         defaults_AdminEntityData->attr_objtype = "obj";
61         defaults_AdminEntityData->attr_pos.clear();
62         defaults_AdminEntityData->attr_pos.push_back(0.0);
63         defaults_AdminEntityData->attr_pos.push_back(0.0);
64         defaults_AdminEntityData->attr_pos.push_back(0.0);
65         defaults_AdminEntityData->attr_velocity.clear();
66         defaults_AdminEntityData->attr_velocity.push_back(0.0);
67         defaults_AdminEntityData->attr_velocity.push_back(0.0);
68         defaults_AdminEntityData->attr_velocity.push_back(0.0);
69         defaults_AdminEntityData->attr_stamp_contains = 0.0;
70         defaults_AdminEntityData->attr_stamp = 0.0;
71         defaults_AdminEntityData->attr_parents = std::list<std::string>(1, "admin_entity");
72         RootEntityData::getDefaultObjectInstance();
73     }
74     return defaults_AdminEntityData;
75 }
76 
getDefaultObject()77 AdminEntityData *AdminEntityData::getDefaultObject()
78 {
79     return AdminEntityData::getDefaultObjectInstance();
80 }
81 
82 const std::string USERNAME_ATTR = "username";
83 const std::string PASSWORD_ATTR = "password";
84 const std::string CHARACTERS_ATTR = "characters";
85 
getAttrClass(const std::string & name) const86 int AccountData::getAttrClass(const std::string& name) const
87 {
88     if (attr_flags_AccountData->find(name) != attr_flags_AccountData->end()) {
89         return ACCOUNT_NO;
90     }
91     return AdminEntityData::getAttrClass(name);
92 }
93 
getAttrFlag(const std::string & name) const94 int AccountData::getAttrFlag(const std::string& name) const
95 {
96     std::map<std::string, int>::const_iterator I = attr_flags_AccountData->find(name);
97     if (I != attr_flags_AccountData->end()) {
98         return I->second;
99     }
100     return AdminEntityData::getAttrFlag(name);
101 }
102 
copyAttr(const std::string & name,Element & attr) const103 int AccountData::copyAttr(const std::string& name, Element & attr) const
104 {
105     if (name == USERNAME_ATTR) { attr = getUsername(); return 0; }
106     if (name == PASSWORD_ATTR) { attr = getPassword(); return 0; }
107     if (name == CHARACTERS_ATTR) { attr = getCharactersAsList(); return 0; }
108     return AdminEntityData::copyAttr(name, attr);
109 }
110 
setAttr(const std::string & name,const Element & attr)111 void AccountData::setAttr(const std::string& name, const Element& attr)
112 {
113     if (name == USERNAME_ATTR) { setUsername(attr.asString()); return; }
114     if (name == PASSWORD_ATTR) { setPassword(attr.asString()); return; }
115     if (name == CHARACTERS_ATTR) { setCharactersAsList(attr.asList()); return; }
116     AdminEntityData::setAttr(name, attr);
117 }
118 
removeAttr(const std::string & name)119 void AccountData::removeAttr(const std::string& name)
120 {
121     if (name == USERNAME_ATTR)
122         { m_attrFlags &= ~USERNAME_FLAG; return;}
123     if (name == PASSWORD_ATTR)
124         { m_attrFlags &= ~PASSWORD_FLAG; return;}
125     if (name == CHARACTERS_ATTR)
126         { m_attrFlags &= ~CHARACTERS_FLAG; return;}
127     AdminEntityData::removeAttr(name);
128 }
129 
sendUsername(Atlas::Bridge & b) const130 inline void AccountData::sendUsername(Atlas::Bridge & b) const
131 {
132     if(m_attrFlags & USERNAME_FLAG) {
133         b.mapStringItem(USERNAME_ATTR, attr_username);
134     }
135 }
136 
sendPassword(Atlas::Bridge & b) const137 inline void AccountData::sendPassword(Atlas::Bridge & b) const
138 {
139     if(m_attrFlags & PASSWORD_FLAG) {
140         b.mapStringItem(PASSWORD_ATTR, attr_password);
141     }
142 }
143 
sendCharacters(Atlas::Bridge & b) const144 inline void AccountData::sendCharacters(Atlas::Bridge & b) const
145 {
146     if(m_attrFlags & CHARACTERS_FLAG) {
147         b.mapListItem(CHARACTERS_ATTR);
148         const std::list<std::string> & l = attr_characters;
149         std::list<std::string>::const_iterator I = l.begin();
150         for(; I != l.end(); ++I) {
151             b.listStringItem(*I);
152         }
153         b.listEnd();
154     }
155 }
156 
sendContents(Bridge & b) const157 void AccountData::sendContents(Bridge & b) const
158 {
159     sendUsername(b);
160     sendPassword(b);
161     sendCharacters(b);
162     AdminEntityData::sendContents(b);
163 }
164 
addToMessage(MapType & m) const165 void AccountData::addToMessage(MapType & m) const
166 {
167     AdminEntityData::addToMessage(m);
168     if(m_attrFlags & USERNAME_FLAG)
169         m[USERNAME_ATTR] = attr_username;
170     if(m_attrFlags & PASSWORD_FLAG)
171         m[PASSWORD_ATTR] = attr_password;
172     if(m_attrFlags & CHARACTERS_FLAG)
173         m[CHARACTERS_ATTR] = getCharactersAsList();
174     return;
175 }
176 
iterate(int & current_class,std::string & attr) const177 void AccountData::iterate(int& current_class, std::string& attr) const
178 {
179     // If we've already finished this class, chain to the parent
180     if(current_class >= 0 && current_class != ACCOUNT_NO) {
181         AdminEntityData::iterate(current_class, attr);
182         return;
183     }
184 
185     static const char *attr_list[] = {"username","password","characters",};
186     static const unsigned n_attr = sizeof(attr_list) / sizeof(const char*);
187 
188     unsigned next_attr = n_attr; // so we chain to the parent if we don't find attr
189 
190     if(attr.empty()) // just staring on this class
191         next_attr = 0;
192     else {
193       for(unsigned i = 0; i < n_attr; ++i) {
194          if(attr == attr_list[i]) {
195              next_attr = i + 1;
196              break;
197          }
198       }
199     }
200 
201     if(next_attr == n_attr) { // last one on the list
202         current_class = -1;
203         attr = "";
204         AdminEntityData::iterate(current_class, attr); // chain to parent
205     }
206     else {
207         current_class = ACCOUNT_NO;
208         attr = attr_list[next_attr];
209     }
210 }
211 
~AccountData()212 AccountData::~AccountData()
213 {
214 }
215 
copy() const216 AccountData * AccountData::copy() const
217 {
218     AccountData * copied = AccountData::alloc();
219     *copied = *this;
220     copied->m_refCount = 0;
221     return copied;
222 }
223 
instanceOf(int classNo) const224 bool AccountData::instanceOf(int classNo) const
225 {
226     if(ACCOUNT_NO == classNo) return true;
227     return AdminEntityData::instanceOf(classNo);
228 }
229 
230 //freelist related methods specific to this class
231 AccountData *AccountData::defaults_AccountData = 0;
232 AccountData *AccountData::begin_AccountData = 0;
233 
alloc()234 AccountData *AccountData::alloc()
235 {
236     if(begin_AccountData) {
237         AccountData *res = begin_AccountData;
238         assert( res->m_refCount == 0 );
239         res->m_attrFlags = 0;
240         res->m_attributes.clear();
241         begin_AccountData = (AccountData *)begin_AccountData->m_next;
242         return res;
243     }
244     return new AccountData(AccountData::getDefaultObjectInstance());
245 }
246 
free()247 void AccountData::free()
248 {
249     m_next = begin_AccountData;
250     begin_AccountData = this;
251 }
252 
253 std::map<std::string, int> * AccountData::attr_flags_AccountData = 0;
254 
getDefaultObjectInstance()255 AccountData *AccountData::getDefaultObjectInstance()
256 {
257     if (defaults_AccountData == 0) {
258         defaults_AccountData = new AccountData;
259         defaults_AccountData->attr_objtype = "obj";
260         defaults_AccountData->attr_pos.clear();
261         defaults_AccountData->attr_pos.push_back(0.0);
262         defaults_AccountData->attr_pos.push_back(0.0);
263         defaults_AccountData->attr_pos.push_back(0.0);
264         defaults_AccountData->attr_velocity.clear();
265         defaults_AccountData->attr_velocity.push_back(0.0);
266         defaults_AccountData->attr_velocity.push_back(0.0);
267         defaults_AccountData->attr_velocity.push_back(0.0);
268         defaults_AccountData->attr_stamp_contains = 0.0;
269         defaults_AccountData->attr_stamp = 0.0;
270         defaults_AccountData->attr_parents = std::list<std::string>(1, "account");
271         attr_flags_AccountData = new std::map<std::string, int>;
272         (*attr_flags_AccountData)[USERNAME_ATTR] = USERNAME_FLAG;
273         (*attr_flags_AccountData)[PASSWORD_ATTR] = PASSWORD_FLAG;
274         (*attr_flags_AccountData)[CHARACTERS_ATTR] = CHARACTERS_FLAG;
275         AdminEntityData::getDefaultObjectInstance();
276     }
277     return defaults_AccountData;
278 }
279 
getDefaultObject()280 AccountData *AccountData::getDefaultObject()
281 {
282     return AccountData::getDefaultObjectInstance();
283 }
284 
~PlayerData()285 PlayerData::~PlayerData()
286 {
287 }
288 
copy() const289 PlayerData * PlayerData::copy() const
290 {
291     PlayerData * copied = PlayerData::alloc();
292     *copied = *this;
293     copied->m_refCount = 0;
294     return copied;
295 }
296 
instanceOf(int classNo) const297 bool PlayerData::instanceOf(int classNo) const
298 {
299     if(PLAYER_NO == classNo) return true;
300     return AccountData::instanceOf(classNo);
301 }
302 
303 //freelist related methods specific to this class
304 PlayerData *PlayerData::defaults_PlayerData = 0;
305 PlayerData *PlayerData::begin_PlayerData = 0;
306 
alloc()307 PlayerData *PlayerData::alloc()
308 {
309     if(begin_PlayerData) {
310         PlayerData *res = begin_PlayerData;
311         assert( res->m_refCount == 0 );
312         res->m_attrFlags = 0;
313         res->m_attributes.clear();
314         begin_PlayerData = (PlayerData *)begin_PlayerData->m_next;
315         return res;
316     }
317     return new PlayerData(PlayerData::getDefaultObjectInstance());
318 }
319 
free()320 void PlayerData::free()
321 {
322     m_next = begin_PlayerData;
323     begin_PlayerData = this;
324 }
325 
326 
getDefaultObjectInstance()327 PlayerData *PlayerData::getDefaultObjectInstance()
328 {
329     if (defaults_PlayerData == 0) {
330         defaults_PlayerData = new PlayerData;
331         defaults_PlayerData->attr_objtype = "obj";
332         defaults_PlayerData->attr_pos.clear();
333         defaults_PlayerData->attr_pos.push_back(0.0);
334         defaults_PlayerData->attr_pos.push_back(0.0);
335         defaults_PlayerData->attr_pos.push_back(0.0);
336         defaults_PlayerData->attr_velocity.clear();
337         defaults_PlayerData->attr_velocity.push_back(0.0);
338         defaults_PlayerData->attr_velocity.push_back(0.0);
339         defaults_PlayerData->attr_velocity.push_back(0.0);
340         defaults_PlayerData->attr_stamp_contains = 0.0;
341         defaults_PlayerData->attr_stamp = 0.0;
342         defaults_PlayerData->attr_parents = std::list<std::string>(1, "player");
343         AccountData::getDefaultObjectInstance();
344     }
345     return defaults_PlayerData;
346 }
347 
getDefaultObject()348 PlayerData *PlayerData::getDefaultObject()
349 {
350     return PlayerData::getDefaultObjectInstance();
351 }
352 
~AdminData()353 AdminData::~AdminData()
354 {
355 }
356 
copy() const357 AdminData * AdminData::copy() const
358 {
359     AdminData * copied = AdminData::alloc();
360     *copied = *this;
361     copied->m_refCount = 0;
362     return copied;
363 }
364 
instanceOf(int classNo) const365 bool AdminData::instanceOf(int classNo) const
366 {
367     if(ADMIN_NO == classNo) return true;
368     return AccountData::instanceOf(classNo);
369 }
370 
371 //freelist related methods specific to this class
372 AdminData *AdminData::defaults_AdminData = 0;
373 AdminData *AdminData::begin_AdminData = 0;
374 
alloc()375 AdminData *AdminData::alloc()
376 {
377     if(begin_AdminData) {
378         AdminData *res = begin_AdminData;
379         assert( res->m_refCount == 0 );
380         res->m_attrFlags = 0;
381         res->m_attributes.clear();
382         begin_AdminData = (AdminData *)begin_AdminData->m_next;
383         return res;
384     }
385     return new AdminData(AdminData::getDefaultObjectInstance());
386 }
387 
free()388 void AdminData::free()
389 {
390     m_next = begin_AdminData;
391     begin_AdminData = this;
392 }
393 
394 
getDefaultObjectInstance()395 AdminData *AdminData::getDefaultObjectInstance()
396 {
397     if (defaults_AdminData == 0) {
398         defaults_AdminData = new AdminData;
399         defaults_AdminData->attr_objtype = "obj";
400         defaults_AdminData->attr_pos.clear();
401         defaults_AdminData->attr_pos.push_back(0.0);
402         defaults_AdminData->attr_pos.push_back(0.0);
403         defaults_AdminData->attr_pos.push_back(0.0);
404         defaults_AdminData->attr_velocity.clear();
405         defaults_AdminData->attr_velocity.push_back(0.0);
406         defaults_AdminData->attr_velocity.push_back(0.0);
407         defaults_AdminData->attr_velocity.push_back(0.0);
408         defaults_AdminData->attr_stamp_contains = 0.0;
409         defaults_AdminData->attr_stamp = 0.0;
410         defaults_AdminData->attr_parents = std::list<std::string>(1, "admin");
411         AccountData::getDefaultObjectInstance();
412     }
413     return defaults_AdminData;
414 }
415 
getDefaultObject()416 AdminData *AdminData::getDefaultObject()
417 {
418     return AdminData::getDefaultObjectInstance();
419 }
420 
~GameData()421 GameData::~GameData()
422 {
423 }
424 
copy() const425 GameData * GameData::copy() const
426 {
427     GameData * copied = GameData::alloc();
428     *copied = *this;
429     copied->m_refCount = 0;
430     return copied;
431 }
432 
instanceOf(int classNo) const433 bool GameData::instanceOf(int classNo) const
434 {
435     if(GAME_NO == classNo) return true;
436     return AdminEntityData::instanceOf(classNo);
437 }
438 
439 //freelist related methods specific to this class
440 GameData *GameData::defaults_GameData = 0;
441 GameData *GameData::begin_GameData = 0;
442 
alloc()443 GameData *GameData::alloc()
444 {
445     if(begin_GameData) {
446         GameData *res = begin_GameData;
447         assert( res->m_refCount == 0 );
448         res->m_attrFlags = 0;
449         res->m_attributes.clear();
450         begin_GameData = (GameData *)begin_GameData->m_next;
451         return res;
452     }
453     return new GameData(GameData::getDefaultObjectInstance());
454 }
455 
free()456 void GameData::free()
457 {
458     m_next = begin_GameData;
459     begin_GameData = this;
460 }
461 
462 
getDefaultObjectInstance()463 GameData *GameData::getDefaultObjectInstance()
464 {
465     if (defaults_GameData == 0) {
466         defaults_GameData = new GameData;
467         defaults_GameData->attr_objtype = "obj";
468         defaults_GameData->attr_pos.clear();
469         defaults_GameData->attr_pos.push_back(0.0);
470         defaults_GameData->attr_pos.push_back(0.0);
471         defaults_GameData->attr_pos.push_back(0.0);
472         defaults_GameData->attr_velocity.clear();
473         defaults_GameData->attr_velocity.push_back(0.0);
474         defaults_GameData->attr_velocity.push_back(0.0);
475         defaults_GameData->attr_velocity.push_back(0.0);
476         defaults_GameData->attr_stamp_contains = 0.0;
477         defaults_GameData->attr_stamp = 0.0;
478         defaults_GameData->attr_parents = std::list<std::string>(1, "game");
479         AdminEntityData::getDefaultObjectInstance();
480     }
481     return defaults_GameData;
482 }
483 
getDefaultObject()484 GameData *GameData::getDefaultObject()
485 {
486     return GameData::getDefaultObjectInstance();
487 }
488 
~GameEntityData()489 GameEntityData::~GameEntityData()
490 {
491 }
492 
copy() const493 GameEntityData * GameEntityData::copy() const
494 {
495     GameEntityData * copied = GameEntityData::alloc();
496     *copied = *this;
497     copied->m_refCount = 0;
498     return copied;
499 }
500 
instanceOf(int classNo) const501 bool GameEntityData::instanceOf(int classNo) const
502 {
503     if(GAME_ENTITY_NO == classNo) return true;
504     return RootEntityData::instanceOf(classNo);
505 }
506 
507 //freelist related methods specific to this class
508 GameEntityData *GameEntityData::defaults_GameEntityData = 0;
509 GameEntityData *GameEntityData::begin_GameEntityData = 0;
510 
alloc()511 GameEntityData *GameEntityData::alloc()
512 {
513     if(begin_GameEntityData) {
514         GameEntityData *res = begin_GameEntityData;
515         assert( res->m_refCount == 0 );
516         res->m_attrFlags = 0;
517         res->m_attributes.clear();
518         begin_GameEntityData = (GameEntityData *)begin_GameEntityData->m_next;
519         return res;
520     }
521     return new GameEntityData(GameEntityData::getDefaultObjectInstance());
522 }
523 
free()524 void GameEntityData::free()
525 {
526     m_next = begin_GameEntityData;
527     begin_GameEntityData = this;
528 }
529 
530 
getDefaultObjectInstance()531 GameEntityData *GameEntityData::getDefaultObjectInstance()
532 {
533     if (defaults_GameEntityData == 0) {
534         defaults_GameEntityData = new GameEntityData;
535         defaults_GameEntityData->attr_objtype = "obj";
536         defaults_GameEntityData->attr_pos.clear();
537         defaults_GameEntityData->attr_pos.push_back(0.0);
538         defaults_GameEntityData->attr_pos.push_back(0.0);
539         defaults_GameEntityData->attr_pos.push_back(0.0);
540         defaults_GameEntityData->attr_velocity.clear();
541         defaults_GameEntityData->attr_velocity.push_back(0.0);
542         defaults_GameEntityData->attr_velocity.push_back(0.0);
543         defaults_GameEntityData->attr_velocity.push_back(0.0);
544         defaults_GameEntityData->attr_stamp_contains = 0.0;
545         defaults_GameEntityData->attr_stamp = 0.0;
546         defaults_GameEntityData->attr_parents = std::list<std::string>(1, "game_entity");
547         RootEntityData::getDefaultObjectInstance();
548     }
549     return defaults_GameEntityData;
550 }
551 
getDefaultObject()552 GameEntityData *GameEntityData::getDefaultObject()
553 {
554     return GameEntityData::getDefaultObjectInstance();
555 }
556 
557 } } } // namespace Atlas::Objects::Entity
558