?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add infos into target window
[ryzomcore.git] / ryzom / server / src / entities_game_service / guild_pd.cpp
blobf045a8c217a173999022acd5828eb68c9acf1ef5
1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
2 // Copyright (C) 2010 Winch Gate Property Limited
3 //
4 // This program is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU Affero General Public License as
6 // published by the Free Software Foundation, either version 3 of the
7 // License, or (at your option) any later version.
8 //
9 // This program is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU Affero General Public License for more details.
13 //
14 // You should have received a copy of the GNU Affero General Public License
15 // along with this program. If not, see <http://www.gnu.org/licenses/>.
16
17
18 #include "stdpch.h"
19 #include "egs_pd.h"
20
21 namespace EGSPD
22 {
23
24 /* -----------------------------------------
25 * Static Implementation of CGuildPD
26 * ----------------------------------------- */
27 TGuildId CGuildPD::getId() const
28 {
29 return _Id;
30 }
31 uint64 CGuildPD::getMoney() const
32 {
33 return _Money;
34 }
35 void CGuildPD::setMoney(uint64 __v, bool forceWrite)
36 {
37 if ((_Money != __v) || forceWrite)
38 {
39 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(1), __v);
40 }
41 _Money = __v;
42 }
43 uint32 CGuildPD::getCreationDate() const
44 {
45 return _CreationDate;
46 }
47 void CGuildPD::setCreationDate(uint32 __v, bool forceWrite)
48 {
49 if ((_CreationDate != __v) || forceWrite)
50 {
51 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(2), __v);
52 }
53 _CreationDate = __v;
54 }
55 uint32 CGuildPD::getXP() const
56 {
57 return _XP;
58 }
59 void CGuildPD::setXP(uint32 __v, bool forceWrite)
60 {
61 if ((_XP != __v) || forceWrite)
62 {
63 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(3), __v);
64 }
65 _XP = __v;
66 }
67 uint32 CGuildPD::getChargesPoints() const
68 {
69 return _ChargesPoints;
70 }
71 void CGuildPD::setChargesPoints(uint32 __v, bool forceWrite)
72 {
73 if ((_ChargesPoints != __v) || forceWrite)
74 {
75 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(4), __v);
76 }
77 _ChargesPoints = __v;
78 }
79 CPeople::TPeople CGuildPD::getRace() const
80 {
81 return _Race;
82 }
83 void CGuildPD::setRace(CPeople::TPeople __v, bool forceWrite)
84 {
85 nlassert(__v<CPeople::___TPeople_useSize);
86 if ((_Race != __v) || forceWrite)
87 {
88 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(5), (uint32)__v);
89 }
90 _Race = __v;
91 }
92 uint64 CGuildPD::getIcon() const
93 {
94 return _Icon;
95 }
96 void CGuildPD::setIcon(uint64 __v, bool forceWrite)
97 {
98 if ((_Icon != __v) || forceWrite)
99 {
100 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(6), __v);
101 }
102 _Icon = __v;
103 }
104 uint32 CGuildPD::getBuilding() const
105 {
106 return _Building;
107 }
108 void CGuildPD::setBuilding(uint32 __v, bool forceWrite)
109 {
110 if ((_Building != __v) || forceWrite)
111 {
112 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(7), __v);
113 }
114 _Building = __v;
115 }
116 uint32 CGuildPD::getVersion() const
117 {
118 return _Version;
119 }
120 void CGuildPD::setVersion(uint32 __v, bool forceWrite)
121 {
122 if ((_Version != __v) || forceWrite)
123 {
124 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(8), __v);
125 }
126 _Version = __v;
127 }
128 CGuildMemberPD* CGuildPD::getMembers(const TCharacterId& __k)
129 {
130 std::map<TCharacterId, CGuildMemberPD*>::iterator _it = _Members.find(__k);
131 return (_it==_Members.end() ? NULL : (*_it).second);
132 }
133 const CGuildMemberPD* CGuildPD::getMembers(const TCharacterId& __k) const
134 {
135 std::map<TCharacterId, CGuildMemberPD*>::const_iterator _it = _Members.find(__k);
136 return (_it==_Members.end() ? NULL : (*_it).second);
137 }
138 std::map<TCharacterId, CGuildMemberPD*>::iterator CGuildPD::getMembersBegin()
139 {
140 return _Members.begin();
141 }
142 std::map<TCharacterId, CGuildMemberPD*>::iterator CGuildPD::getMembersEnd()
143 {
144 return _Members.end();
145 }
146 std::map<TCharacterId, CGuildMemberPD*>::const_iterator CGuildPD::getMembersBegin() const
147 {
148 return _Members.begin();
149 }
150 std::map<TCharacterId, CGuildMemberPD*>::const_iterator CGuildPD::getMembersEnd() const
151 {
152 return _Members.end();
153 }
154 const std::map<TCharacterId, CGuildMemberPD*> & CGuildPD::getMembers() const
155 {
156 return _Members;
157 }
158 void CGuildPD::setMembers(CGuildMemberPD* __v)
159 {
160 if (__v == NULL) return;
161 TCharacterId __k = __v->getId();
162 std::map<TCharacterId, CGuildMemberPD*>::iterator _it = _Members.find(__k);
163 if (_it != _Members.end())
164 {
165 CGuildMemberPD* __prev = (*_it).second;
166 if (__prev == __v) return;
167 __prev->pds__setParent(NULL);
168 __prev->pds__unregister();
169 __prev->pds__destroy();
170 delete __prev;
171 }
172 __v->pds__setParent(this);
173 _Members[__k] = __v;
174 {
175 // callback the manager
176 IGuildManager::getInstance().guildMemberListChanged(this);
177 }
178 }
179 void CGuildPD::deleteFromMembers(const TCharacterId &__k)
180 {
181 std::map<TCharacterId, CGuildMemberPD*>::iterator __it = _Members.find(__k);
182 if (__it == _Members.end()) return;
183 CGuildMemberPD* __o = (*__it).second;
184 __o->pds__unregister();
185 __o->pds__destroy();
186 delete __o;
187 {
188 // callback the manager
189 IGuildManager::getInstance().guildMemberListChanged(this);
190 }
191 }
192 CGuildFameContainerPD* CGuildPD::getFameContainer()
193 {
194 return _FameContainer;
195 }
196 const CGuildFameContainerPD* CGuildPD::getFameContainer() const
197 {
198 return _FameContainer;
199 }
200 void CGuildPD::setFameContainer(CGuildFameContainerPD* __v)
201 {
202 if (_FameContainer != NULL)
203 {
204 _FameContainer->pds__setParent(NULL);
205 }
206 __v->pds__setParent(this);
207 _FameContainer = __v;
208 }
209 CGuildContainerPD* CGuildPD::getParent()
210 {
211 return _Parent;
212 }
213 const CGuildContainerPD* CGuildPD::getParent() const
214 {
215 return _Parent;
216 }
217 void CGuildPD::clear()
218 {
219 _Money = (uint64)0;
220 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(1), (uint64)0);
221 _CreationDate = 0;
222 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(2), 0);
223 _XP = 0;
224 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(3), 0);
225 _ChargesPoints = 0;
226 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(4), 0);
227 _Race = (CPeople::TPeople)0;
228 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(5), (uint32)(CPeople::TPeople)0);
229 _Icon = (uint64)0;
230 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(6), (uint64)0);
231 _Building = 0;
232 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(7), 0);
233 _Version = 0;
234 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(8), 0);
235 for (std::map<TCharacterId, CGuildMemberPD*>::iterator __it=_Members.begin(); __it!=_Members.end(); )
236 {
237 std::map<TCharacterId, CGuildMemberPD*>::iterator __itr=__it++;
238 CGuildMemberPD* __o = (*__itr).second;
239 __o->pds__unregister();
240 __o->pds__destroy();
241 delete __o;
242 }
243 _Members.clear();
244 CGuildFameContainerPD* __o = _FameContainer;
245 __o->pds__unregister();
246 __o->pds__destroy();
247 delete __o;
248 }
249 CGuildPD* CGuildPD::cast(RY_PDS::IPDBaseData* obj)
250 {
251 return (obj->getTable() == 4) ? static_cast<CGuildPD*>(obj) : NULL;
252 }
253 const CGuildPD* CGuildPD::cast(const RY_PDS::IPDBaseData* obj)
254 {
255 return (obj->getTable() == 4) ? static_cast<const CGuildPD*>(obj) : NULL;
256 }
257 void CGuildPD::setFactory(RY_PDS::TPDFactory userFactory)
258 {
259 pds_static__setFactory(userFactory);
260 }
261 CGuildPD* CGuildPD::create(const TGuildId &Id)
262 {
263 CGuildPD *__o = static_cast<CGuildPD*>(PDSLib.create(4));
264 __o->pds__init(Id);
265 __o->pds__register();
266 __o->pds__notifyInit();
267 return __o;
268 }
269 void CGuildPD::apply(CPersistentDataRecord &__pdr)
270 {
271 uint16 __Tok_MapKey = __pdr.addString("__Key__");
272 uint16 __Tok_MapVal = __pdr.addString("__Val__");
273 uint16 __Tok_ClassName = __pdr.addString("__Class__");
274 uint16 __TokId = __pdr.addString("Id");
275 uint16 __TokMoney = __pdr.addString("Money");
276 uint16 __TokCreationDate = __pdr.addString("CreationDate");
277 uint16 __TokXP = __pdr.addString("XP");
278 uint16 __TokChargesPoints = __pdr.addString("ChargesPoints");
279 uint16 __TokRace = __pdr.addString("Race");
280 uint16 __TokIcon = __pdr.addString("Icon");
281 uint16 __TokBuilding = __pdr.addString("Building");
282 uint16 __TokVersion = __pdr.addString("Version");
283 uint16 __TokMembers = __pdr.addString("Members");
284 uint16 __TokFameContainer = __pdr.addString("FameContainer");
285 _Parent = NULL;
286 while (!__pdr.isEndOfStruct())
287 {
288 if (false) {}
289 else if (__pdr.peekNextToken() == __TokId)
290 {
291 __pdr.pop(__TokId, _Id);
292 }
293 else if (__pdr.peekNextToken() == __TokMoney)
294 {
295 __pdr.pop(__TokMoney, _Money);
296 }
297 else if (__pdr.peekNextToken() == __TokCreationDate)
298 {
299 __pdr.pop(__TokCreationDate, _CreationDate);
300 }
301 else if (__pdr.peekNextToken() == __TokXP)
302 {
303 __pdr.pop(__TokXP, _XP);
304 }
305 else if (__pdr.peekNextToken() == __TokChargesPoints)
306 {
307 __pdr.pop(__TokChargesPoints, _ChargesPoints);
308 }
309 else if (__pdr.peekNextToken() == __TokRace)
310 {
311 {
312 std::string valuename;
313 __pdr.pop(__TokRace, valuename);
314 _Race = CPeople::fromString(valuename);
315 }
316 }
317 else if (__pdr.peekNextToken() == __TokIcon)
318 {
319 __pdr.pop(__TokIcon, _Icon);
320 }
321 else if (__pdr.peekNextToken() == __TokBuilding)
322 {
323 __pdr.pop(__TokBuilding, _Building);
324 }
325 else if (__pdr.peekNextToken() == __TokVersion)
326 {
327 __pdr.pop(__TokVersion, _Version);
328 }
329 // apply Members
330 else if (__pdr.peekNextToken() == __TokMembers)
331 {
332 __pdr.popStructBegin(__TokMembers);
333 while (!__pdr.isEndOfStruct())
334 {
335 TCharacterId key;
336 __pdr.pop(__Tok_MapKey, key);
337 __pdr.popStructBegin(__Tok_MapVal);
338 CGuildMemberPD* obj;
339 obj = NULL;
340 if (__pdr.peekNextToken() == __Tok_ClassName)
341 {
342 std::string __className;
343 __pdr.pop(__Tok_ClassName, __className);
344 obj = CGuildMemberPD::cast(PDSLib.create(__className));
345 if (obj != NULL)
346 {
347 __pdr.popStructBegin(__TokMembers);
348 obj->apply(__pdr);
349 obj->pds__setParentUnnotified(this);
350 __pdr.popStructEnd(__TokMembers);
351 }
352 else
353 {
354 __pdr.skipStruct();
355 }
356 }
357 if (obj != NULL)
358 {
359 _Members[key] = obj;
360 }
361 __pdr.popStructEnd(__Tok_MapVal);
362 }
363 __pdr.popStructEnd(__TokMembers);
364 }
365 // end of apply Members
366 // apply FameContainer
367 else if (__pdr.peekNextToken() == __TokFameContainer)
368 {
369 __pdr.popStructBegin(__TokFameContainer);
370 _FameContainer = NULL;
371 if (__pdr.peekNextToken() == __Tok_ClassName)
372 {
373 std::string __className;
374 __pdr.pop(__Tok_ClassName, __className);
375 _FameContainer = CGuildFameContainerPD::cast(PDSLib.create(__className));
376 if (_FameContainer != NULL)
377 {
378 __pdr.popStructBegin(__TokFameContainer);
379 _FameContainer->apply(__pdr);
380 _FameContainer->pds__setParentUnnotified(this);
381 __pdr.popStructEnd(__TokFameContainer);
382 }
383 else
384 {
385 __pdr.skipStruct();
386 }
387 }
388 __pdr.popStructEnd(__TokFameContainer);
389 }
390 else
391 {
392 nlwarning("Skipping unrecognised token: %s", __pdr.peekNextTokenName().c_str());
393 __pdr.skipData();
394 }
395 }
396 }
397 void CGuildPD::store(CPersistentDataRecord &__pdr) const
398 {
399 uint16 __Tok_MapKey = __pdr.addString("__Key__");
400 uint16 __Tok_MapVal = __pdr.addString("__Val__");
401 uint16 __Tok_ClassName = __pdr.addString("__Class__");
402 uint16 __TokId = __pdr.addString("Id");
403 uint16 __TokMoney = __pdr.addString("Money");
404 uint16 __TokCreationDate = __pdr.addString("CreationDate");
405 uint16 __TokXP = __pdr.addString("XP");
406 uint16 __TokChargesPoints = __pdr.addString("ChargesPoints");
407 uint16 __TokRace = __pdr.addString("Race");
408 uint16 __TokIcon = __pdr.addString("Icon");
409 uint16 __TokBuilding = __pdr.addString("Building");
410 uint16 __TokVersion = __pdr.addString("Version");
411 uint16 __TokMembers = __pdr.addString("Members");
412 uint16 __TokFameContainer = __pdr.addString("FameContainer");
413 __pdr.push(__TokId, _Id);
414 __pdr.push(__TokMoney, _Money);
415 __pdr.push(__TokCreationDate, _CreationDate);
416 __pdr.push(__TokXP, _XP);
417 __pdr.push(__TokChargesPoints, _ChargesPoints);
418 {
419 std::string valuename = CPeople::toString(_Race);
420 __pdr.push(__TokRace, valuename);
421 }
422 __pdr.push(__TokIcon, _Icon);
423 __pdr.push(__TokBuilding, _Building);
424 __pdr.push(__TokVersion, _Version);
425 // store Members
426 __pdr.pushStructBegin(__TokMembers);
427 for (std::map<TCharacterId, CGuildMemberPD*>::const_iterator it=_Members.begin(); it!=_Members.end(); ++it)
428 {
429 TCharacterId key = (*it).first;
430 __pdr.push(__Tok_MapKey, key);
431 __pdr.pushStructBegin(__Tok_MapVal);
432 if ((*it).second != NULL)
433 {
434 std::string __className = PDSLib.getClassName((*it).second);
435 __pdr.push(__Tok_ClassName, __className);
436 __pdr.pushStructBegin(__TokMembers);
437 (*it).second->store(__pdr);
438 __pdr.pushStructEnd(__TokMembers);
439 }
440 __pdr.pushStructEnd(__Tok_MapVal);
441 }
442 __pdr.pushStructEnd(__TokMembers);
443 // end of store Members
444 // store FameContainer
445 __pdr.pushStructBegin(__TokFameContainer);
446 if (_FameContainer != NULL)
447 {
448 std::string __className = PDSLib.getClassName(_FameContainer);
449 __pdr.push(__Tok_ClassName, __className);
450 __pdr.pushStructBegin(__TokFameContainer);
451 _FameContainer->store(__pdr);
452 __pdr.pushStructEnd(__TokFameContainer);
453 }
454 __pdr.pushStructEnd(__TokFameContainer);
455 }
456 void CGuildPD::init()
457 {
458 }
459 void CGuildPD::release()
460 {
461 }
462 void CGuildPD::pds__init(const TGuildId &Id)
463 {
464 _Id = Id;
465 _Money = (uint64)0;
466 _CreationDate = 0;
467 _XP = 0;
468 _ChargesPoints = 0;
469 _Race = (CPeople::TPeople)0;
470 _Icon = (uint64)0;
471 _Building = 0;
472 _Version = 0;
473 _FameContainer = NULL;
474 _Parent = NULL;
475 }
476 void CGuildPD::pds__destroy()
477 {
478 for (std::map<TCharacterId, CGuildMemberPD*>::iterator __it=_Members.begin(); __it!=_Members.end(); )
479 {
480 std::map<TCharacterId, CGuildMemberPD*>::iterator __itr=__it++;
481 CGuildMemberPD* __o = ((*__itr).second);
482 if (__o != NULL)
483 {
484 __o->pds__destroy();
485 delete __o;
486 }
487 }
488 _Members.clear();
489 if (_FameContainer != NULL)
490 {
491 CGuildFameContainerPD* __o = _FameContainer;
492 __o->pds__destroy();
493 delete __o;
494 }
495 }
496 void CGuildPD::pds__fetch(RY_PDS::CPData &data)
497 {
498 data.serial(_Id);
499 data.serial(_Money);
500 data.serial(_CreationDate);
501 data.serial(_XP);
502 data.serial(_ChargesPoints);
503 data.serialEnum(_Race);
504 data.serial(_Icon);
505 data.serial(_Building);
506 data.serial(_Version);
507 RY_PDS::TTableIndex tableIndex;
508 RY_PDS::TRowIndex rowIndex;
509 do
510 {
511 // read table and row, create an object, affect to the ref, and fetch it
512 data.serial(tableIndex, rowIndex);
513 if (rowIndex == RY_PDS::INVALID_ROW_INDEX || tableIndex == RY_PDS::INVALID_TABLE_INDEX) break;
514 TCharacterId __k;
515 data.serial(__k);
516 CGuildMemberPD* __o = static_cast<CGuildMemberPD*>(PDSLib.create(tableIndex));
517 _Members.insert(std::make_pair(__k, __o));
518 PDSLib.setRowIndex(rowIndex, __o);
519 __o->pds__fetch(data);
520 __o->pds__setParentUnnotified(this);
521 }
522 while (true);
523 // read table and row, create an object, affect to the ref, and fetch it
524 _FameContainer = NULL;
525 data.serial(tableIndex, rowIndex);
526 if (rowIndex != RY_PDS::INVALID_ROW_INDEX && tableIndex != RY_PDS::INVALID_TABLE_INDEX)
527 {
528 _FameContainer = static_cast<CGuildFameContainerPD*>(PDSLib.create(tableIndex));
529 PDSLib.setRowIndex(rowIndex, _FameContainer);
530 _FameContainer->pds__fetch(data);
531 _FameContainer->pds__setParentUnnotified(this);
532 }
533 _Parent = NULL;
534 }
535 void CGuildPD::pds__register()
536 {
537 __BaseRow = _IndexAllocator.allocate();
538 PDSLib.allocateRow(4, __BaseRow, 0);
539 pds__registerAttributes();
540 }
541 void CGuildPD::pds__registerAttributes()
542 {
543 if (RY_PDS::PDVerbose) nldebug("CGuildPD: registerAttributes %u:%u", 4, __BaseRow);
544 PDSLib.set(4, __BaseRow, (RY_PDS::TColumnIndex)(0), _Id);
545 }
546 void CGuildPD::pds__unregister()
547 {
548 pds__unregisterAttributes();
549 PDSLib.deallocateRow(4, __BaseRow);
550 _IndexAllocator.deallocate(__BaseRow);
551 }
552 void CGuildPD::pds__unregisterAttributes()
553 {
554 if (RY_PDS::PDVerbose) nldebug("CGuildPD: unregisterAttributes %u:%u", 4, __BaseRow);
555 pds__setParent(NULL);
556 for (std::map<TCharacterId, CGuildMemberPD*>::iterator __it=_Members.begin(); __it!=_Members.end(); )
557 {
558 std::map<TCharacterId, CGuildMemberPD*>::iterator __itr=__it++;
559 CGuildMemberPD* __o = (*__itr).second;
560 __o->pds__unregister();
561 __o->pds__destroy();
562 delete __o;
563 }
564 if (_FameContainer != NULL)
565 {
566 CGuildFameContainerPD* __o = _FameContainer;
567 __o->pds__unregister();
568 __o->pds__destroy();
569 delete __o;
570 }
571 }
572 void CGuildPD::pds__setParent(CGuildContainerPD* __parent)
573 {
574 if (_Parent != NULL)
575 {
576 _Parent->pds__unlinkGuilds(_Id);
577 }
578 _Parent = __parent;
579 PDSLib.setParent(4, getRow(), (RY_PDS::TColumnIndex)(11), (__parent != NULL ? RY_PDS::CObjectIndex(5, __parent->getRow()) : RY_PDS::CObjectIndex::null()));
580 }
581 void CGuildPD::pds__setParentUnnotified(CGuildContainerPD* __parent)
582 {
583 _Parent = __parent;
584 }
585 void CGuildPD::pds__notifyInit()
586 {
587 init();
588 for (std::map<TCharacterId, CGuildMemberPD*>::iterator __it=_Members.begin(); __it!=_Members.end(); )
589 {
590 std::map<TCharacterId, CGuildMemberPD*>::iterator __itr=__it++;
591 (*__itr).second->pds__notifyInit();
592 }
593 if (_FameContainer != NULL)
594 {
595 _FameContainer->pds__notifyInit();
596 }
597 }
598 void CGuildPD::pds__notifyRelease()
599 {
600 release();
601 PDSLib.release(4, __BaseRow);
602 for (std::map<TCharacterId, CGuildMemberPD*>::iterator __it=_Members.begin(); __it!=_Members.end(); )
603 {
604 std::map<TCharacterId, CGuildMemberPD*>::iterator __itr=__it++;
605 (*__itr).second->pds__notifyRelease();
606 }
607 if (_FameContainer != NULL)
608 {
609 _FameContainer->pds__notifyRelease();
610 }
611 }
612 void CGuildPD::pds__unlinkMembers(TCharacterId __k)
613 {
614 _Members.erase(__k);
615 }
616 void CGuildPD::pds__unlinkFameContainer(NLMISC::CEntityId dummy)
617 {
618 {
619 _FameContainer = NULL;
620 }
621 }
622 void CGuildPD::pds_static__init()
623 {
624 PDSLib.setIndexAllocator(4, _IndexAllocator);
625 nlassertex(_FactoryInitialised, ("User Factory for class CGuildPD not set!"));
626 // factory must have been set by user before database init called!
627 // You must provide a factory for the class CGuildPD as it is marked as derived
628 // Call EGSPD::CGuildPD::setFactory() with a factory before any call to EGSPD::init()!
629 }
630 void CGuildPD::pds_static__setFactory(RY_PDS::TPDFactory userFactory)
631 {
632 if (!_FactoryInitialised)
633 {
634 PDSLib.registerClass(4, userFactory, pds_static__fetch, NULL);
635 _FactoryInitialised = true;
636 }
637 }
638 bool CGuildPD::_FactoryInitialised;
639 RY_PDS::CIndexAllocator CGuildPD::_IndexAllocator;
640 void CGuildPD::pds_static__fetch(RY_PDS::IPDBaseData *object, RY_PDS::CPData &data)
641 {
642 CGuildPD *__o = static_cast<CGuildPD*>(object);
643 __o->pds__fetch(data);
644 __o->pds__notifyInit();
645 }
646 // End of static implementation of CGuildPD
647
648
649 } // End of EGSPD