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