?  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 / mission_pd.h
blob9d8baf07e864628a74aea0f9e35a73bb9867a73b
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 #ifndef MISSION_PD_H
19 #define MISSION_PD_H
20
21 #include <nel/misc/types_nl.h>
22 #include <nel/misc/debug.h>
23 #include <nel/misc/common.h>
24 #include <nel/misc/entity_id.h>
25 #include <nel/misc/sheet_id.h>
26 #include <vector>
27 #include <map>
28 #include <pd_lib/pd_lib.h>
29 #include <game_share/persistent_data.h>
30
31 // User #includes
32 #include "mission_manager/mission_base_behaviour.h"
33
34 namespace EGSPD
35 {
36
37 //
38 // Forward declarations
39 //
40
41
42
43 //
44 // Typedefs & Enums
45 //
46
47 /** CActiveStepStatePD
48 * defined at entities_game_service/pd_scripts/mission.pds:6
49 */
50 class CActiveStepStatePD : public RY_PDS::IPDBaseData
51 {
52
53 public:
54
55 /// \name Accessors and Mutators methods
56 // @{
57
58 /**
59 * Use these methods to change a value, add or delete elements.
60 */
61
62 uint32 getIndex() const;
63
64 uint32 getState() const;
65 void setState(uint32 __v, bool forceWrite=false);
66
67 CActiveStepPD* getStep();
68 const CActiveStepPD* getStep() const;
69
70 // @}
71
72
73 public:
74
75 /// \name Public Management methods
76 // @{
77
78 /**
79 * Use these methods to create, load, unload and get
80 * an object from database.
81 */
82
83
84 /**
85 * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
86 */
87 void clear();
88
89 /**
90 * Cast base object to CActiveStepStatePD
91 */
92 static CActiveStepStatePD* cast(RY_PDS::IPDBaseData* obj);
93
94 /**
95 * Cast base object to const CActiveStepStatePD
96 */
97 static const CActiveStepStatePD* cast(const RY_PDS::IPDBaseData* obj);
98
99 // @}
100
101
102 public:
103
104 /// \name Public constructor
105 // @{
106
107 /**
108 * This constructor is public to allow direct instanciation of the class
109 */
110
111 CActiveStepStatePD();
112 ~CActiveStepStatePD();
113
114 // @}
115
116
117 public:
118
119 /// \name Persistent methods declaration
120 // @{
121
122 void apply(CPersistentDataRecord &__pdr);
123 void store(CPersistentDataRecord &__pdr) const;
124
125 // @}
126
127
128 protected:
129
130 /// \name Attributes
131 // @{
132
133 /**
134 * Don't modify those value manually, use accessors and mutators above
135 */
136
137 uint32 _Index;
138 uint32 _State;
139 CActiveStepPD* _Step;
140
141 // @}
142
143
144 protected:
145
146 /// \name Internal Management methods
147 // @{
148
149 void pds__init(const uint32 &Index);
150 void pds__destroy();
151 void pds__fetch(RY_PDS::CPData &data);
152 void pds__register();
153 void pds__registerAttributes();
154 void pds__unregister();
155 void pds__unregisterAttributes();
156 void pds__setParent(CActiveStepPD* __parent);
157 void pds__setParentUnnotified(CActiveStepPD* __parent);
158 void pds__notifyInit();
159 void pds__notifyRelease();
160 static void pds_static__init();
161
162 // @}
163
164
165 protected:
166
167 /// \name Default Factory and Fetch methods
168 // @{
169
170 static RY_PDS::CIndexAllocator _IndexAllocator;
171
172 // @}
173
174
175 protected:
176
177 friend class CActiveStepPD;
178 friend class CMissionContainerPD;
179 friend class CMissionPD;
180 friend class RY_PDS::CPDSLib;
181 friend void EGSPD::init(uint32);
182 };
183
184 /** CActiveStepPD
185 * defined at entities_game_service/pd_scripts/mission.pds:13
186 */
187 class CActiveStepPD : public RY_PDS::IPDBaseData
188 {
189
190 public:
191
192 /// \name Accessors and Mutators methods
193 // @{
194
195 /**
196 * Use these methods to change a value, add or delete elements.
197 */
198
199 uint32 getIndexInTemplate() const;
200
201 CActiveStepStatePD* getStates(const uint32& __k);
202 const CActiveStepStatePD* getStates(const uint32& __k) const;
203 std::map<uint32, CActiveStepStatePD>::iterator getStatesBegin();
204 std::map<uint32, CActiveStepStatePD>::iterator getStatesEnd();
205 std::map<uint32, CActiveStepStatePD>::const_iterator getStatesBegin() const;
206 std::map<uint32, CActiveStepStatePD>::const_iterator getStatesEnd() const;
207 const std::map<uint32, CActiveStepStatePD> & getStates() const;
208 CActiveStepStatePD* addToStates(const uint32 &__k);
209 void deleteFromStates(const uint32 &__k);
210
211 CMissionPD* getMission();
212 const CMissionPD* getMission() const;
213
214 // @}
215
216
217 public:
218
219 /// \name Public Management methods
220 // @{
221
222 /**
223 * Use these methods to create, load, unload and get
224 * an object from database.
225 */
226
227
228 /**
229 * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
230 */
231 void clear();
232
233 /**
234 * Cast base object to CActiveStepPD
235 */
236 static CActiveStepPD* cast(RY_PDS::IPDBaseData* obj);
237
238 /**
239 * Cast base object to const CActiveStepPD
240 */
241 static const CActiveStepPD* cast(const RY_PDS::IPDBaseData* obj);
242
243 // @}
244
245
246 public:
247
248 /// \name Public constructor
249 // @{
250
251 /**
252 * This constructor is public to allow direct instanciation of the class
253 */
254
255 CActiveStepPD();
256 ~CActiveStepPD();
257
258 // @}
259
260
261 public:
262
263 /// \name Persistent methods declaration
264 // @{
265
266 void apply(CPersistentDataRecord &__pdr);
267 void store(CPersistentDataRecord &__pdr) const;
268
269 // @}
270
271
272 protected:
273
274 /// \name Attributes
275 // @{
276
277 /**
278 * Don't modify those value manually, use accessors and mutators above
279 */
280
281 uint32 _IndexInTemplate;
282 std::map<uint32, CActiveStepStatePD> _States;
283 CMissionPD* _Mission;
284
285 // @}
286
287
288 protected:
289
290 /// \name Internal Management methods
291 // @{
292
293 void pds__init(const uint32 &IndexInTemplate);
294 void pds__destroy();
295 void pds__fetch(RY_PDS::CPData &data);
296 void pds__register();
297 void pds__registerAttributes();
298 void pds__unregister();
299 void pds__unregisterAttributes();
300 void pds__setParent(CMissionPD* __parent);
301 void pds__setParentUnnotified(CMissionPD* __parent);
302 void pds__notifyInit();
303 void pds__notifyRelease();
304 static void pds_static__init();
305
306 // @}
307
308
309 protected:
310
311 /// \name Default Factory and Fetch methods
312 // @{
313
314 static RY_PDS::CIndexAllocator _IndexAllocator;
315
316 // @}
317
318
319 protected:
320
321 friend class CMissionContainerPD;
322 friend class CMissionPD;
323 friend class CActiveStepStatePD;
324 friend class RY_PDS::CPDSLib;
325 friend void EGSPD::init(uint32);
326 };
327
328 /** CDoneStepPD
329 * defined at entities_game_service/pd_scripts/mission.pds:20
330 */
331 class CDoneStepPD : public RY_PDS::IPDBaseData
332 {
333
334 public:
335
336 /// \name Accessors and Mutators methods
337 // @{
338
339 /**
340 * Use these methods to change a value, add or delete elements.
341 */
342
343 uint32 getIndex() const;
344
345 CMissionPD* getMission();
346 const CMissionPD* getMission() const;
347
348 // @}
349
350
351 public:
352
353 /// \name Public Management methods
354 // @{
355
356 /**
357 * Use these methods to create, load, unload and get
358 * an object from database.
359 */
360
361
362 /**
363 * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
364 */
365 void clear();
366
367 /**
368 * Cast base object to CDoneStepPD
369 */
370 static CDoneStepPD* cast(RY_PDS::IPDBaseData* obj);
371
372 /**
373 * Cast base object to const CDoneStepPD
374 */
375 static const CDoneStepPD* cast(const RY_PDS::IPDBaseData* obj);
376
377 // @}
378
379
380 public:
381
382 /// \name Public constructor
383 // @{
384
385 /**
386 * This constructor is public to allow direct instanciation of the class
387 */
388
389 CDoneStepPD();
390 ~CDoneStepPD();
391
392 // @}
393
394
395 public:
396
397 /// \name Persistent methods declaration
398 // @{
399
400 void apply(CPersistentDataRecord &__pdr);
401 void store(CPersistentDataRecord &__pdr) const;
402
403 // @}
404
405
406 protected:
407
408 /// \name Attributes
409 // @{
410
411 /**
412 * Don't modify those value manually, use accessors and mutators above
413 */
414
415 uint32 _Index;
416 CMissionPD* _Mission;
417
418 // @}
419
420
421 protected:
422
423 /// \name Internal Management methods
424 // @{
425
426 void pds__init(const uint32 &Index);
427 void pds__destroy();
428 void pds__fetch(RY_PDS::CPData &data);
429 void pds__register();
430 void pds__registerAttributes();
431 void pds__unregister();
432 void pds__unregisterAttributes();
433 void pds__setParent(CMissionPD* __parent);
434 void pds__setParentUnnotified(CMissionPD* __parent);
435 void pds__notifyInit();
436 void pds__notifyRelease();
437 static void pds_static__init();
438
439 // @}
440
441
442 protected:
443
444 /// \name Default Factory and Fetch methods
445 // @{
446
447 static RY_PDS::CIndexAllocator _IndexAllocator;
448
449 // @}
450
451
452 protected:
453
454 friend class CMissionContainerPD;
455 friend class CMissionPD;
456 friend class RY_PDS::CPDSLib;
457 friend void EGSPD::init(uint32);
458 };
459
460 /** CMissionCompassPD
461 * defined at entities_game_service/pd_scripts/mission.pds:27
462 */
463 class CMissionCompassPD : public RY_PDS::IPDBaseData
464 {
465
466 public:
467
468 /// \name Accessors and Mutators methods
469 // @{
470
471 /**
472 * Use these methods to change a value, add or delete elements.
473 */
474
475 uint32 getIndex() const;
476
477 uint32 getPlace() const;
478 void setPlace(uint32 __v, bool forceWrite=false);
479
480 uint32 getBotId() const;
481 void setBotId(uint32 __v, bool forceWrite=false);
482
483 CMissionPD* getMission();
484 const CMissionPD* getMission() const;
485
486 // @}
487
488
489 public:
490
491 /// \name Public Management methods
492 // @{
493
494 /**
495 * Use these methods to create, load, unload and get
496 * an object from database.
497 */
498
499
500 /**
501 * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
502 */
503 void clear();
504
505 /**
506 * Cast base object to CMissionCompassPD
507 */
508 static CMissionCompassPD* cast(RY_PDS::IPDBaseData* obj);
509
510 /**
511 * Cast base object to const CMissionCompassPD
512 */
513 static const CMissionCompassPD* cast(const RY_PDS::IPDBaseData* obj);
514
515 // @}
516
517
518 public:
519
520 /// \name User defined attributes and methods
521 // @{
522
523 /**
524 * This code was verbatim copied from source file
525 */
526
527 // User code appended in mission.pds
528 uint32 NameStringId;
529 std::string NameString;
530 // @}
531
532
533 public:
534
535 /// \name Public constructor
536 // @{
537
538 /**
539 * This constructor is public to allow direct instanciation of the class
540 */
541
542 CMissionCompassPD();
543 ~CMissionCompassPD();
544
545 // @}
546
547
548 public:
549
550 /// \name Persistent methods declaration
551 // @{
552
553 void apply(CPersistentDataRecord &__pdr);
554 void store(CPersistentDataRecord &__pdr) const;
555
556 // @}
557
558
559 protected:
560
561 /// \name Attributes
562 // @{
563
564 /**
565 * Don't modify those value manually, use accessors and mutators above
566 */
567
568 uint32 _Index;
569 uint32 _Place;
570 uint32 _BotId;
571 CMissionPD* _Mission;
572
573 // @}
574
575
576 protected:
577
578 /// \name Internal Management methods
579 // @{
580
581 void pds__init(const uint32 &Index);
582 void pds__destroy();
583 void pds__fetch(RY_PDS::CPData &data);
584 void pds__register();
585 void pds__registerAttributes();
586 void pds__unregister();
587 void pds__unregisterAttributes();
588 void pds__setParent(CMissionPD* __parent);
589 void pds__setParentUnnotified(CMissionPD* __parent);
590 void pds__notifyInit();
591 void pds__notifyRelease();
592 static void pds_static__init();
593
594 // @}
595
596
597 protected:
598
599 /// \name Default Factory and Fetch methods
600 // @{
601
602 static RY_PDS::CIndexAllocator _IndexAllocator;
603
604 // @}
605
606
607 protected:
608
609 friend class CMissionContainerPD;
610 friend class CMissionPD;
611 friend class RY_PDS::CPDSLib;
612 friend void EGSPD::init(uint32);
613 };
614
615 /** CMissionTeleportPD
616 * defined at entities_game_service/pd_scripts/mission.pds:49
617 */
618 class CMissionTeleportPD : public RY_PDS::IPDBaseData
619 {
620
621 public:
622
623 /// \name Accessors and Mutators methods
624 // @{
625
626 /**
627 * Use these methods to change a value, add or delete elements.
628 */
629
630 uint32 getIndex() const;
631
632 CMissionPD* getMission();
633 const CMissionPD* getMission() const;
634
635 // @}
636
637
638 public:
639
640 /// \name Public Management methods
641 // @{
642
643 /**
644 * Use these methods to create, load, unload and get
645 * an object from database.
646 */
647
648
649 /**
650 * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
651 */
652 void clear();
653
654 /**
655 * Cast base object to CMissionTeleportPD
656 */
657 static CMissionTeleportPD* cast(RY_PDS::IPDBaseData* obj);
658
659 /**
660 * Cast base object to const CMissionTeleportPD
661 */
662 static const CMissionTeleportPD* cast(const RY_PDS::IPDBaseData* obj);
663
664 // @}
665
666
667 public:
668
669 /// \name Public constructor
670 // @{
671
672 /**
673 * This constructor is public to allow direct instanciation of the class
674 */
675
676 CMissionTeleportPD();
677 ~CMissionTeleportPD();
678
679 // @}
680
681
682 public:
683
684 /// \name Persistent methods declaration
685 // @{
686
687 void apply(CPersistentDataRecord &__pdr);
688 void store(CPersistentDataRecord &__pdr) const;
689
690 // @}
691
692
693 protected:
694
695 /// \name Attributes
696 // @{
697
698 /**
699 * Don't modify those value manually, use accessors and mutators above
700 */
701
702 uint32 _Index;
703 CMissionPD* _Mission;
704
705 // @}
706
707
708 protected:
709
710 /// \name Internal Management methods
711 // @{
712
713 void pds__init(const uint32 &Index);
714 void pds__destroy();
715 void pds__fetch(RY_PDS::CPData &data);
716 void pds__register();
717 void pds__registerAttributes();
718 void pds__unregister();
719 void pds__unregisterAttributes();
720 void pds__setParent(CMissionPD* __parent);
721 void pds__setParentUnnotified(CMissionPD* __parent);
722 void pds__notifyInit();
723 void pds__notifyRelease();
724 static void pds_static__init();
725
726 // @}
727
728
729 protected:
730
731 /// \name Default Factory and Fetch methods
732 // @{
733
734 static RY_PDS::CIndexAllocator _IndexAllocator;
735
736 // @}
737
738
739 protected:
740
741 friend class CMissionContainerPD;
742 friend class CMissionPD;
743 friend class RY_PDS::CPDSLib;
744 friend void EGSPD::init(uint32);
745 };
746
747 /** CMissionInsidePlacePD
748 * defined at entities_game_service/pd_scripts/mission.pds:55
749 */
750 class CMissionInsidePlacePD : public RY_PDS::IPDBaseData
751 {
752
753 public:
754
755 /// \name Accessors and Mutators methods
756 // @{
757
758 /**
759 * Use these methods to change a value, add or delete elements.
760 */
761
762 uint32 getAlias() const;
763
764 uint32 getDelay() const;
765 void setDelay(uint32 __v, bool forceWrite=false);
766
767 CMissionPD* getMission();
768 const CMissionPD* getMission() const;
769
770 // @}
771
772
773 public:
774
775 /// \name Public Management methods
776 // @{
777
778 /**
779 * Use these methods to create, load, unload and get
780 * an object from database.
781 */
782
783
784 /**
785 * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
786 */
787 void clear();
788
789 /**
790 * Cast base object to CMissionInsidePlacePD
791 */
792 static CMissionInsidePlacePD* cast(RY_PDS::IPDBaseData* obj);
793
794 /**
795 * Cast base object to const CMissionInsidePlacePD
796 */
797 static const CMissionInsidePlacePD* cast(const RY_PDS::IPDBaseData* obj);
798
799 // @}
800
801
802 public:
803
804 /// \name Public constructor
805 // @{
806
807 /**
808 * This constructor is public to allow direct instanciation of the class
809 */
810
811 CMissionInsidePlacePD();
812 ~CMissionInsidePlacePD();
813
814 // @}
815
816
817 public:
818
819 /// \name Persistent methods declaration
820 // @{
821
822 void apply(CPersistentDataRecord &__pdr);
823 void store(CPersistentDataRecord &__pdr) const;
824
825 // @}
826
827
828 protected:
829
830 /// \name Attributes
831 // @{
832
833 /**
834 * Don't modify those value manually, use accessors and mutators above
835 */
836
837 uint32 _Alias;
838 uint32 _Delay;
839 CMissionPD* _Mission;
840
841 // @}
842
843
844 protected:
845
846 /// \name Internal Management methods
847 // @{
848
849 void pds__init(const uint32 &Alias);
850 void pds__destroy();
851 void pds__fetch(RY_PDS::CPData &data);
852 void pds__register();
853 void pds__registerAttributes();
854 void pds__unregister();
855 void pds__unregisterAttributes();
856 void pds__setParent(CMissionPD* __parent);
857 void pds__setParentUnnotified(CMissionPD* __parent);
858 void pds__notifyInit();
859 void pds__notifyRelease();
860 static void pds_static__init();
861
862 // @}
863
864
865 protected:
866
867 /// \name Default Factory and Fetch methods
868 // @{
869
870 static RY_PDS::CIndexAllocator _IndexAllocator;
871
872 // @}
873
874
875 protected:
876
877 friend class CMissionContainerPD;
878 friend class CMissionPD;
879 friend class RY_PDS::CPDSLib;
880 friend void EGSPD::init(uint32);
881 };
882
883 /** CMissionOutsidePlacePD
884 * defined at entities_game_service/pd_scripts/mission.pds:61
885 */
886 class CMissionOutsidePlacePD : public RY_PDS::IPDBaseData
887 {
888
889 public:
890
891 /// \name Accessors and Mutators methods
892 // @{
893
894 /**
895 * Use these methods to change a value, add or delete elements.
896 */
897
898 uint32 getAlias() const;
899
900 uint32 getDelay() const;
901 void setDelay(uint32 __v, bool forceWrite=false);
902
903 CMissionPD* getMission();
904 const CMissionPD* getMission() const;
905
906 // @}
907
908
909 public:
910
911 /// \name Public Management methods
912 // @{
913
914 /**
915 * Use these methods to create, load, unload and get
916 * an object from database.
917 */
918
919
920 /**
921 * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
922 */
923 void clear();
924
925 /**
926 * Cast base object to CMissionOutsidePlacePD
927 */
928 static CMissionOutsidePlacePD* cast(RY_PDS::IPDBaseData* obj);
929
930 /**
931 * Cast base object to const CMissionOutsidePlacePD
932 */
933 static const CMissionOutsidePlacePD* cast(const RY_PDS::IPDBaseData* obj);
934
935 // @}
936
937
938 public:
939
940 /// \name Public constructor
941 // @{
942
943 /**
944 * This constructor is public to allow direct instanciation of the class
945 */
946
947 CMissionOutsidePlacePD();
948 ~CMissionOutsidePlacePD();
949
950 // @}
951
952
953 public:
954
955 /// \name Persistent methods declaration
956 // @{
957
958 void apply(CPersistentDataRecord &__pdr);
959 void store(CPersistentDataRecord &__pdr) const;
960
961 // @}
962
963
964 protected:
965
966 /// \name Attributes
967 // @{
968
969 /**
970 * Don't modify those value manually, use accessors and mutators above
971 */
972
973 uint32 _Alias;
974 uint32 _Delay;
975 CMissionPD* _Mission;
976
977 // @}
978
979
980 protected:
981
982 /// \name Internal Management methods
983 // @{
984
985 void pds__init(const uint32 &Alias);
986 void pds__destroy();
987 void pds__fetch(RY_PDS::CPData &data);
988 void pds__register();
989 void pds__registerAttributes();
990 void pds__unregister();
991 void pds__unregisterAttributes();
992 void pds__setParent(CMissionPD* __parent);
993 void pds__setParentUnnotified(CMissionPD* __parent);
994 void pds__notifyInit();
995 void pds__notifyRelease();
996 static void pds_static__init();
997
998 // @}
999
1000
1001 protected:
1002
1003 /// \name Default Factory and Fetch methods
1004 // @{
1005
1006 static RY_PDS::CIndexAllocator _IndexAllocator;
1007
1008 // @}
1009
1010
1011 protected:
1012
1013 friend class CMissionContainerPD;
1014 friend class CMissionPD;
1015 friend class RY_PDS::CPDSLib;
1016 friend void EGSPD::init(uint32);
1017 };
1018
1019 /** CHandledAIGroupPD
1020 * defined at entities_game_service/pd_scripts/mission.pds:68
1021 */
1022 class CHandledAIGroupPD : public RY_PDS::IPDBaseData
1023 {
1024
1025 public:
1026
1027 /// \name Accessors and Mutators methods
1028 // @{
1029
1030 /**
1031 * Use these methods to change a value, add or delete elements.
1032 */
1033
1034 uint32 getGroupAlias() const;
1035
1036 uint32 getDespawnTime() const;
1037 void setDespawnTime(uint32 __v, bool forceWrite=false);
1038
1039 CMissionPD* getMission();
1040 const CMissionPD* getMission() const;
1041
1042 // @}
1043
1044
1045 public:
1046
1047 /// \name Public Management methods
1048 // @{
1049
1050 /**
1051 * Use these methods to create, load, unload and get
1052 * an object from database.
1053 */
1054
1055
1056 /**
1057 * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
1058 */
1059 void clear();
1060
1061 /**
1062 * Cast base object to CHandledAIGroupPD
1063 */
1064 static CHandledAIGroupPD* cast(RY_PDS::IPDBaseData* obj);
1065
1066 /**
1067 * Cast base object to const CHandledAIGroupPD
1068 */
1069 static const CHandledAIGroupPD* cast(const RY_PDS::IPDBaseData* obj);
1070
1071 // @}
1072
1073
1074 public:
1075
1076 /// \name Public constructor
1077 // @{
1078
1079 /**
1080 * This constructor is public to allow direct instanciation of the class
1081 */
1082
1083 CHandledAIGroupPD();
1084 ~CHandledAIGroupPD();
1085
1086 // @}
1087
1088
1089 public:
1090
1091 /// \name Persistent methods declaration
1092 // @{
1093
1094 void apply(CPersistentDataRecord &__pdr);
1095 void store(CPersistentDataRecord &__pdr) const;
1096
1097 // @}
1098
1099
1100 protected:
1101
1102 /// \name Attributes
1103 // @{
1104
1105 /**
1106 * Don't modify those value manually, use accessors and mutators above
1107 */
1108
1109 uint32 _GroupAlias;
1110 uint32 _DespawnTime;
1111 CMissionPD* _Mission;
1112
1113 // @}
1114
1115
1116 protected:
1117
1118 /// \name Internal Management methods
1119 // @{
1120
1121 void pds__init(const uint32 &GroupAlias);
1122 void pds__destroy();
1123 void pds__fetch(RY_PDS::CPData &data);
1124 void pds__register();
1125 void pds__registerAttributes();
1126 void pds__unregister();
1127 void pds__unregisterAttributes();
1128 void pds__setParent(CMissionPD* __parent);
1129 void pds__setParentUnnotified(CMissionPD* __parent);
1130 void pds__notifyInit();
1131 void pds__notifyRelease();
1132 static void pds_static__init();
1133
1134 // @}
1135
1136
1137 protected:
1138
1139 /// \name Default Factory and Fetch methods
1140 // @{
1141
1142 static RY_PDS::CIndexAllocator _IndexAllocator;
1143
1144 // @}
1145
1146
1147 protected:
1148
1149 friend class CMissionContainerPD;
1150 friend class CMissionPD;
1151 friend class RY_PDS::CPDSLib;
1152 friend void EGSPD::init(uint32);
1153 };
1154
1155 /** CMissionPD
1156 * defined at entities_game_service/pd_scripts/mission.pds:75
1157 */
1158 class CMissionPD : public RY_PDS::IPDBaseData, public CMissionBaseBehaviour
1159 {
1160
1161 public:
1162
1163 /// \name Accessors and Mutators methods
1164 // @{
1165
1166 /**
1167 * Use these methods to change a value, add or delete elements.
1168 */
1169
1170 uint32 getTemplateId() const;
1171
1172 uint32 getMainMissionTemplateId() const;
1173 void setMainMissionTemplateId(uint32 __v, bool forceWrite=false);
1174
1175 uint32 getGiver() const;
1176 void setGiver(uint32 __v, bool forceWrite=false);
1177
1178 float getHourLowerBound() const;
1179 void setHourLowerBound(float __v, bool forceWrite=false);
1180
1181 float getHourUpperBound() const;
1182 void setHourUpperBound(float __v, bool forceWrite=false);
1183
1184 CSeason::TSeason getSeason() const;
1185 void setSeason(CSeason::TSeason __v, bool forceWrite=false);
1186
1187 uint32 getMonoEndDate() const;
1188 void setMonoEndDate(uint32 __v, bool forceWrite=false);
1189
1190 uint32 getEndDate() const;
1191 void setEndDate(uint32 __v, bool forceWrite=false);
1192
1193 uint32 getCriticalPartEndDate() const;
1194 void setCriticalPartEndDate(uint32 __v, bool forceWrite=false);
1195
1196 uint32 getBeginDate() const;
1197 void setBeginDate(uint32 __v, bool forceWrite=false);
1198
1199 uint32 getFailureIndex() const;
1200 void setFailureIndex(uint32 __v, bool forceWrite=false);
1201
1202 uint32 getCrashHandlerIndex() const;
1203 void setCrashHandlerIndex(uint32 __v, bool forceWrite=false);
1204
1205 uint32 getPlayerReconnectHandlerIndex() const;
1206 void setPlayerReconnectHandlerIndex(uint32 __v, bool forceWrite=false);
1207
1208 bool getFinished() const;
1209 void setFinished(bool __v, bool forceWrite=false);
1210
1211 bool getMissionSuccess() const;
1212 void setMissionSuccess(bool __v, bool forceWrite=false);
1213
1214 uint32 getDescIndex() const;
1215 void setDescIndex(uint32 __v, bool forceWrite=false);
1216
1217 uint32 getWaitingQueueId() const;
1218 void setWaitingQueueId(uint32 __v, bool forceWrite=false);
1219
1220 CActiveStepPD* getSteps(const uint32& __k);
1221 const CActiveStepPD* getSteps(const uint32& __k) const;
1222 std::map<uint32, CActiveStepPD>::iterator getStepsBegin();
1223 std::map<uint32, CActiveStepPD>::iterator getStepsEnd();
1224 std::map<uint32, CActiveStepPD>::const_iterator getStepsBegin() const;
1225 std::map<uint32, CActiveStepPD>::const_iterator getStepsEnd() const;
1226 const std::map<uint32, CActiveStepPD> & getSteps() const;
1227 CActiveStepPD* addToSteps(const uint32 &__k);
1228 void deleteFromSteps(const uint32 &__k);
1229
1230 CMissionCompassPD* getCompass(const uint32& __k);
1231 const CMissionCompassPD* getCompass(const uint32& __k) const;
1232 std::map<uint32, CMissionCompassPD>::iterator getCompassBegin();
1233 std::map<uint32, CMissionCompassPD>::iterator getCompassEnd();
1234 std::map<uint32, CMissionCompassPD>::const_iterator getCompassBegin() const;
1235 std::map<uint32, CMissionCompassPD>::const_iterator getCompassEnd() const;
1236 const std::map<uint32, CMissionCompassPD> & getCompass() const;
1237 CMissionCompassPD* addToCompass(const uint32 &__k);
1238 void deleteFromCompass(const uint32 &__k);
1239
1240 CDoneStepPD* getStepsDone(const uint32& __k);
1241 const CDoneStepPD* getStepsDone(const uint32& __k) const;
1242 std::map<uint32, CDoneStepPD>::iterator getStepsDoneBegin();
1243 std::map<uint32, CDoneStepPD>::iterator getStepsDoneEnd();
1244 std::map<uint32, CDoneStepPD>::const_iterator getStepsDoneBegin() const;
1245 std::map<uint32, CDoneStepPD>::const_iterator getStepsDoneEnd() const;
1246 const std::map<uint32, CDoneStepPD> & getStepsDone() const;
1247 CDoneStepPD* addToStepsDone(const uint32 &__k);
1248 void deleteFromStepsDone(const uint32 &__k);
1249
1250 CMissionTeleportPD* getTeleports(const uint32& __k);
1251 const CMissionTeleportPD* getTeleports(const uint32& __k) const;
1252 std::map<uint32, CMissionTeleportPD>::iterator getTeleportsBegin();
1253 std::map<uint32, CMissionTeleportPD>::iterator getTeleportsEnd();
1254 std::map<uint32, CMissionTeleportPD>::const_iterator getTeleportsBegin() const;
1255 std::map<uint32, CMissionTeleportPD>::const_iterator getTeleportsEnd() const;
1256 const std::map<uint32, CMissionTeleportPD> & getTeleports() const;
1257 CMissionTeleportPD* addToTeleports(const uint32 &__k);
1258 void deleteFromTeleports(const uint32 &__k);
1259
1260 CMissionInsidePlacePD* getInsidePlaces(const uint32& __k);
1261 const CMissionInsidePlacePD* getInsidePlaces(const uint32& __k) const;
1262 std::map<uint32, CMissionInsidePlacePD>::iterator getInsidePlacesBegin();
1263 std::map<uint32, CMissionInsidePlacePD>::iterator getInsidePlacesEnd();
1264 std::map<uint32, CMissionInsidePlacePD>::const_iterator getInsidePlacesBegin() const;
1265 std::map<uint32, CMissionInsidePlacePD>::const_iterator getInsidePlacesEnd() const;
1266 const std::map<uint32, CMissionInsidePlacePD> & getInsidePlaces() const;
1267 CMissionInsidePlacePD* addToInsidePlaces(const uint32 &__k);
1268 void deleteFromInsidePlaces(const uint32 &__k);
1269
1270 CMissionOutsidePlacePD* getOutsidePlaces(const uint32& __k);
1271 const CMissionOutsidePlacePD* getOutsidePlaces(const uint32& __k) const;
1272 std::map<uint32, CMissionOutsidePlacePD>::iterator getOutsidePlacesBegin();
1273 std::map<uint32, CMissionOutsidePlacePD>::iterator getOutsidePlacesEnd();
1274 std::map<uint32, CMissionOutsidePlacePD>::const_iterator getOutsidePlacesBegin() const;
1275 std::map<uint32, CMissionOutsidePlacePD>::const_iterator getOutsidePlacesEnd() const;
1276 const std::map<uint32, CMissionOutsidePlacePD> & getOutsidePlaces() const;
1277 CMissionOutsidePlacePD* addToOutsidePlaces(const uint32 &__k);
1278 void deleteFromOutsidePlaces(const uint32 &__k);
1279
1280 CHandledAIGroupPD* getHandledAIGroups(const uint32& __k);
1281 const CHandledAIGroupPD* getHandledAIGroups(const uint32& __k) const;
1282 std::map<uint32, CHandledAIGroupPD>::iterator getHandledAIGroupsBegin();
1283 std::map<uint32, CHandledAIGroupPD>::iterator getHandledAIGroupsEnd();
1284 std::map<uint32, CHandledAIGroupPD>::const_iterator getHandledAIGroupsBegin() const;
1285 std::map<uint32, CHandledAIGroupPD>::const_iterator getHandledAIGroupsEnd() const;
1286 const std::map<uint32, CHandledAIGroupPD> & getHandledAIGroups() const;
1287 CHandledAIGroupPD* addToHandledAIGroups(const uint32 &__k);
1288 void deleteFromHandledAIGroups(const uint32 &__k);
1289
1290 CMissionContainerPD* getContainer();
1291 const CMissionContainerPD* getContainer() const;
1292
1293 // @}
1294
1295
1296 public:
1297
1298 /// \name Public Management methods
1299 // @{
1300
1301 /**
1302 * Use these methods to create, load, unload and get
1303 * an object from database.
1304 */
1305
1306
1307 /**
1308 * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
1309 */
1310 virtual void clear();
1311
1312 /**
1313 * Cast base object to CMissionPD
1314 */
1315 static CMissionPD* cast(RY_PDS::IPDBaseData* obj);
1316
1317 /**
1318 * Cast base object to const CMissionPD
1319 */
1320 static const CMissionPD* cast(const RY_PDS::IPDBaseData* obj);
1321
1322 /**
1323 * Set user factory for this class (as class is indicated as derived, a home made constructor must be provided)
1324 */
1325 static void setFactory(RY_PDS::TPDFactory userFactory);
1326
1327 /**
1328 * Create an object of the CMissionPD class, and declare it to the PDS.
1329 */
1330 static CMissionPD* create(const uint32 &TemplateId);
1331
1332 // @}
1333
1334
1335 public:
1336
1337 /// \name Public constructor
1338 // @{
1339
1340 /**
1341 * This constructor is public to allow direct instanciation of the class
1342 */
1343
1344 CMissionPD();
1345 virtual ~CMissionPD();
1346
1347 // @}
1348
1349
1350 public:
1351
1352 /// \name Persistent methods declaration
1353 // @{
1354
1355 virtual void apply(CPersistentDataRecord &__pdr);
1356 virtual void store(CPersistentDataRecord &__pdr) const;
1357
1358 // @}
1359
1360
1361 protected:
1362
1363 /// \name User defined init and release methods
1364 // @{
1365
1366 /**
1367 * Overload those methods to implement init and release behaviours
1368 */
1369
1370 virtual void init();
1371 virtual void release();
1372
1373 // @}
1374
1375
1376 protected:
1377
1378 /// \name Attributes
1379 // @{
1380
1381 /**
1382 * Don't modify those value manually, use accessors and mutators above
1383 */
1384
1385 uint32 _TemplateId;
1386 uint32 _MainMissionTemplateId;
1387 uint32 _Giver;
1388 float _HourLowerBound;
1389 float _HourUpperBound;
1390 CSeason::TSeason _Season;
1391 uint32 _MonoEndDate;
1392 uint32 _EndDate;
1393 uint32 _CriticalPartEndDate;
1394 uint32 _BeginDate;
1395 uint32 _FailureIndex;
1396 uint32 _CrashHandlerIndex;
1397 uint32 _PlayerReconnectHandlerIndex;
1398 bool _Finished;
1399 bool _MissionSuccess;
1400 uint32 _DescIndex;
1401 uint32 _WaitingQueueId;
1402 std::map<uint32, CActiveStepPD> _Steps;
1403 std::map<uint32, CMissionCompassPD> _Compass;
1404 std::map<uint32, CDoneStepPD> _StepsDone;
1405 std::map<uint32, CMissionTeleportPD> _Teleports;
1406 std::map<uint32, CMissionInsidePlacePD> _InsidePlaces;
1407 std::map<uint32, CMissionOutsidePlacePD> _OutsidePlaces;
1408 std::map<uint32, CHandledAIGroupPD> _HandledAIGroups;
1409 CMissionContainerPD* _Container;
1410
1411 // @}
1412
1413
1414 protected:
1415
1416 /// \name Internal Management methods
1417 // @{
1418
1419 virtual void pds__init(const uint32 &TemplateId);
1420 virtual void pds__destroy();
1421 virtual void pds__fetch(RY_PDS::CPData &data);
1422 virtual void pds__register();
1423 virtual void pds__registerAttributes();
1424 virtual void pds__unregister();
1425 virtual void pds__unregisterAttributes();
1426 void pds__setParent(CMissionContainerPD* __parent);
1427 void pds__setParentUnnotified(CMissionContainerPD* __parent);
1428 virtual void pds__notifyInit();
1429 virtual void pds__notifyRelease();
1430 static void pds_static__init();
1431
1432 // @}
1433
1434
1435 protected:
1436
1437 /// \name Default Factory and Fetch methods
1438 // @{
1439
1440 static void pds_static__setFactory(RY_PDS::TPDFactory userFactory);
1441 static bool _FactoryInitialised;
1442 static RY_PDS::CIndexAllocator _IndexAllocator;
1443 static void pds_static__fetch(RY_PDS::IPDBaseData *object, RY_PDS::CPData &data);
1444
1445 // @}
1446
1447
1448 protected:
1449
1450 friend class CMissionContainerPD;
1451 friend class CActiveStepPD;
1452 friend class CDoneStepPD;
1453 friend class CHandledAIGroupPD;
1454 friend class CMissionCompassPD;
1455 friend class CMissionInsidePlacePD;
1456 friend class CMissionOutsidePlacePD;
1457 friend class CMissionTeleportPD;
1458 friend class RY_PDS::CPDSLib;
1459 friend void EGSPD::init(uint32);
1460 };
1461
1462 /** CMissionGuildPD
1463 * defined at entities_game_service/pd_scripts/mission.pds:135
1464 */
1465 class CMissionGuildPD : public CMissionPD
1466 {
1467
1468 public:
1469
1470 /// \name Public Management methods
1471 // @{
1472
1473 /**
1474 * Use these methods to create, load, unload and get
1475 * an object from database.
1476 */
1477
1478
1479 /**
1480 * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
1481 */
1482 virtual void clear();
1483
1484 /**
1485 * Cast base object to CMissionGuildPD
1486 */
1487 static CMissionGuildPD* cast(RY_PDS::IPDBaseData* obj);
1488
1489 /**
1490 * Cast base object to const CMissionGuildPD
1491 */
1492 static const CMissionGuildPD* cast(const RY_PDS::IPDBaseData* obj);
1493
1494 /**
1495 * Set user factory for this class (as class is indicated as derived, a home made constructor must be provided)
1496 */
1497 static void setFactory(RY_PDS::TPDFactory userFactory);
1498
1499 /**
1500 * Create an object of the CMissionGuildPD class, and declare it to the PDS.
1501 */
1502 static CMissionGuildPD* create(const uint32 &TemplateId);
1503
1504 // @}
1505
1506
1507 public:
1508
1509 /// \name Public constructor
1510 // @{
1511
1512 /**
1513 * This constructor is public to allow direct instanciation of the class
1514 */
1515
1516 CMissionGuildPD();
1517 virtual ~CMissionGuildPD();
1518
1519 // @}
1520
1521
1522 public:
1523
1524 /// \name Persistent methods declaration
1525 // @{
1526
1527 virtual void apply(CPersistentDataRecord &__pdr);
1528 virtual void store(CPersistentDataRecord &__pdr) const;
1529
1530 // @}
1531
1532
1533 protected:
1534
1535 /// \name User defined init and release methods
1536 // @{
1537
1538 /**
1539 * Overload those methods to implement init and release behaviours
1540 */
1541
1542 virtual void init();
1543 virtual void release();
1544
1545 // @}
1546
1547
1548 protected:
1549
1550 /// \name Internal Management methods
1551 // @{
1552
1553 virtual void pds__init(const uint32 &TemplateId);
1554 virtual void pds__destroy();
1555 virtual void pds__fetch(RY_PDS::CPData &data);
1556 virtual void pds__register();
1557 virtual void pds__registerAttributes();
1558 virtual void pds__unregister();
1559 virtual void pds__unregisterAttributes();
1560 virtual void pds__notifyInit();
1561 virtual void pds__notifyRelease();
1562 static void pds_static__init();
1563
1564 // @}
1565
1566
1567 protected:
1568
1569 /// \name Default Factory and Fetch methods
1570 // @{
1571
1572 static void pds_static__setFactory(RY_PDS::TPDFactory userFactory);
1573 static bool _FactoryInitialised;
1574 static RY_PDS::CIndexAllocator _IndexAllocator;
1575
1576 // @}
1577
1578
1579 protected:
1580
1581 friend class RY_PDS::CPDSLib;
1582 friend void EGSPD::init(uint32);
1583 };
1584
1585 /** CMissionTeamPD
1586 * defined at entities_game_service/pd_scripts/mission.pds:139
1587 */
1588 class CMissionTeamPD : public CMissionPD
1589 {
1590
1591 public:
1592
1593 /// \name Public Management methods
1594 // @{
1595
1596 /**
1597 * Use these methods to create, load, unload and get
1598 * an object from database.
1599 */
1600
1601
1602 /**
1603 * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
1604 */
1605 virtual void clear();
1606
1607 /**
1608 * Cast base object to CMissionTeamPD
1609 */
1610 static CMissionTeamPD* cast(RY_PDS::IPDBaseData* obj);
1611
1612 /**
1613 * Cast base object to const CMissionTeamPD
1614 */
1615 static const CMissionTeamPD* cast(const RY_PDS::IPDBaseData* obj);
1616
1617 /**
1618 * Set user factory for this class (as class is indicated as derived, a home made constructor must be provided)
1619 */
1620 static void setFactory(RY_PDS::TPDFactory userFactory);
1621
1622 /**
1623 * Create an object of the CMissionTeamPD class, and declare it to the PDS.
1624 */
1625 static CMissionTeamPD* create(const uint32 &TemplateId);
1626
1627 // @}
1628
1629
1630 public:
1631
1632 /// \name Public constructor
1633 // @{
1634
1635 /**
1636 * This constructor is public to allow direct instanciation of the class
1637 */
1638
1639 CMissionTeamPD();
1640 virtual ~CMissionTeamPD();
1641
1642 // @}
1643
1644
1645 public:
1646
1647 /// \name Persistent methods declaration
1648 // @{
1649
1650 virtual void apply(CPersistentDataRecord &__pdr);
1651 virtual void store(CPersistentDataRecord &__pdr) const;
1652
1653 // @}
1654
1655
1656 protected:
1657
1658 /// \name User defined init and release methods
1659 // @{
1660
1661 /**
1662 * Overload those methods to implement init and release behaviours
1663 */
1664
1665 virtual void init();
1666 virtual void release();
1667
1668 // @}
1669
1670
1671 protected:
1672
1673 /// \name Internal Management methods
1674 // @{
1675
1676 virtual void pds__init(const uint32 &TemplateId);
1677 virtual void pds__destroy();
1678 virtual void pds__fetch(RY_PDS::CPData &data);
1679 virtual void pds__register();
1680 virtual void pds__registerAttributes();
1681 virtual void pds__unregister();
1682 virtual void pds__unregisterAttributes();
1683 virtual void pds__notifyInit();
1684 virtual void pds__notifyRelease();
1685 static void pds_static__init();
1686
1687 // @}
1688
1689
1690 protected:
1691
1692 /// \name Default Factory and Fetch methods
1693 // @{
1694
1695 static void pds_static__setFactory(RY_PDS::TPDFactory userFactory);
1696 static bool _FactoryInitialised;
1697 static RY_PDS::CIndexAllocator _IndexAllocator;
1698
1699 // @}
1700
1701
1702 protected:
1703
1704 friend class RY_PDS::CPDSLib;
1705 friend void EGSPD::init(uint32);
1706 };
1707
1708 /** CMissionSoloPD
1709 * defined at entities_game_service/pd_scripts/mission.pds:144
1710 */
1711 class CMissionSoloPD : public CMissionPD
1712 {
1713
1714 public:
1715
1716 /// \name Public Management methods
1717 // @{
1718
1719 /**
1720 * Use these methods to create, load, unload and get
1721 * an object from database.
1722 */
1723
1724
1725 /**
1726 * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
1727 */
1728 virtual void clear();
1729
1730 /**
1731 * Cast base object to CMissionSoloPD
1732 */
1733 static CMissionSoloPD* cast(RY_PDS::IPDBaseData* obj);
1734
1735 /**
1736 * Cast base object to const CMissionSoloPD
1737 */
1738 static const CMissionSoloPD* cast(const RY_PDS::IPDBaseData* obj);
1739
1740 /**
1741 * Set user factory for this class (as class is indicated as derived, a home made constructor must be provided)
1742 */
1743 static void setFactory(RY_PDS::TPDFactory userFactory);
1744
1745 /**
1746 * Create an object of the CMissionSoloPD class, and declare it to the PDS.
1747 */
1748 static CMissionSoloPD* create(const uint32 &TemplateId);
1749
1750 // @}
1751
1752
1753 public:
1754
1755 /// \name Public constructor
1756 // @{
1757
1758 /**
1759 * This constructor is public to allow direct instanciation of the class
1760 */
1761
1762 CMissionSoloPD();
1763 virtual ~CMissionSoloPD();
1764
1765 // @}
1766
1767
1768 public:
1769
1770 /// \name Persistent methods declaration
1771 // @{
1772
1773 virtual void apply(CPersistentDataRecord &__pdr);
1774 virtual void store(CPersistentDataRecord &__pdr) const;
1775
1776 // @}
1777
1778
1779 protected:
1780
1781 /// \name User defined init and release methods
1782 // @{
1783
1784 /**
1785 * Overload those methods to implement init and release behaviours
1786 */
1787
1788 virtual void init();
1789 virtual void release();
1790
1791 // @}
1792
1793
1794 protected:
1795
1796 /// \name Internal Management methods
1797 // @{
1798
1799 virtual void pds__init(const uint32 &TemplateId);
1800 virtual void pds__destroy();
1801 virtual void pds__fetch(RY_PDS::CPData &data);
1802 virtual void pds__register();
1803 virtual void pds__registerAttributes();
1804 virtual void pds__unregister();
1805 virtual void pds__unregisterAttributes();
1806 virtual void pds__notifyInit();
1807 virtual void pds__notifyRelease();
1808 static void pds_static__init();
1809
1810 // @}
1811
1812
1813 protected:
1814
1815 /// \name Default Factory and Fetch methods
1816 // @{
1817
1818 static void pds_static__setFactory(RY_PDS::TPDFactory userFactory);
1819 static bool _FactoryInitialised;
1820 static RY_PDS::CIndexAllocator _IndexAllocator;
1821
1822 // @}
1823
1824
1825 protected:
1826
1827 friend class RY_PDS::CPDSLib;
1828 friend void EGSPD::init(uint32);
1829 };
1830
1831 /** CMissionContainerPD
1832 * defined at entities_game_service/pd_scripts/mission.pds:148
1833 */
1834 class CMissionContainerPD : public RY_PDS::IPDBaseData
1835 {
1836
1837 public:
1838
1839 /// \name Accessors and Mutators methods
1840 // @{
1841
1842 /**
1843 * Use these methods to change a value, add or delete elements.
1844 */
1845
1846 NLMISC::CEntityId getCharId() const;
1847
1848 CMissionPD* getMissions(const uint32& __k);
1849 const CMissionPD* getMissions(const uint32& __k) const;
1850 std::map<uint32, CMissionPD*>::iterator getMissionsBegin();
1851 std::map<uint32, CMissionPD*>::iterator getMissionsEnd();
1852 std::map<uint32, CMissionPD*>::const_iterator getMissionsBegin() const;
1853 std::map<uint32, CMissionPD*>::const_iterator getMissionsEnd() const;
1854 const std::map<uint32, CMissionPD*> & getMissions() const;
1855 void setMissions(CMissionPD* __v);
1856 void deleteFromMissions(const uint32 &__k);
1857
1858 // @}
1859
1860
1861 public:
1862
1863 /// \name Public Management methods
1864 // @{
1865
1866 /**
1867 * Use these methods to create, load, unload and get
1868 * an object from database.
1869 */
1870
1871
1872 /**
1873 * Clear whole object content but key (delete subobjects if there are, key is left unmodified), default clear value is 0.
1874 */
1875 void clear();
1876
1877 /**
1878 * Cast base object to CMissionContainerPD
1879 */
1880 static CMissionContainerPD* cast(RY_PDS::IPDBaseData* obj);
1881
1882 /**
1883 * Cast base object to const CMissionContainerPD
1884 */
1885 static const CMissionContainerPD* cast(const RY_PDS::IPDBaseData* obj);
1886
1887 /**
1888 * Create an object of the CMissionContainerPD class, and declare it to the PDS.
1889 */
1890 static CMissionContainerPD* create(const NLMISC::CEntityId &CharId);
1891
1892 /**
1893 * Destroy an object from the PDS. Caution! Object will no longer exist in database.
1894 * Also children (that is objects that belong to this object) are also destroyed.
1895 */
1896 static void remove(const NLMISC::CEntityId& CharId);
1897
1898 /**
1899 * Retrieve an object from the database.
1900 * Data are sent asynchronously, so the load callback is called when data are ready.
1901 * Use get() to access to the loaded object.
1902 */
1903 static void load(const NLMISC::CEntityId& CharId);
1904
1905 /**
1906 * Setup load callback so client is warned that load succeded or failed.
1907 */
1908 static void setLoadCallback(void (*callback)(const NLMISC::CEntityId& key, CMissionContainerPD* object));
1909
1910 /**
1911 * Unload an object from the client memory. Object still exists in database and can be retrieved again using load.
1912 */
1913 static void unload(const NLMISC::CEntityId &CharId);
1914
1915 /**
1916 * Get an object in client. Object must have been previously loaded from database with a load.
1917 */
1918 static CMissionContainerPD* get(const NLMISC::CEntityId &CharId);
1919
1920 /**
1921 * Return the begin iterator of the global map of CMissionContainerPD
1922 */
1923 static std::map<NLMISC::CEntityId, CMissionContainerPD*>::iterator begin();
1924
1925 /**
1926 * Return the end iterator of the global map of CMissionContainerPD
1927 */
1928 static std::map<NLMISC::CEntityId, CMissionContainerPD*>::iterator end();
1929
1930 // @}
1931
1932
1933 public:
1934
1935 /// \name Public constructor
1936 // @{
1937
1938 /**
1939 * This constructor is public to allow direct instanciation of the class
1940 */
1941
1942 CMissionContainerPD();
1943 ~CMissionContainerPD();
1944
1945 // @}
1946
1947
1948 public:
1949
1950 /// \name Persistent methods declaration
1951 // @{
1952
1953 void apply(CPersistentDataRecord &__pdr);
1954 void store(CPersistentDataRecord &__pdr) const;
1955
1956 // @}
1957
1958
1959 protected:
1960
1961 /// \name Attributes
1962 // @{
1963
1964 /**
1965 * Don't modify those value manually, use accessors and mutators above
1966 */
1967
1968 NLMISC::CEntityId _CharId;
1969 std::map<uint32, CMissionPD*> _Missions;
1970
1971 // @}
1972
1973
1974 protected:
1975
1976 /// \name Internal Management methods
1977 // @{
1978
1979 void pds__init(const NLMISC::CEntityId &CharId);
1980 void pds__destroy();
1981 void pds__fetch(RY_PDS::CPData &data);
1982 void pds__register();
1983 void pds__registerAttributes();
1984 void pds__unregister();
1985 void pds__unregisterAttributes();
1986 void pds__notifyInit();
1987 void pds__notifyRelease();
1988 void pds__unlinkMissions(uint32 __k);
1989 static void pds_static__init();
1990
1991 // @}
1992
1993
1994 protected:
1995
1996 static std::map<NLMISC::CEntityId,CMissionContainerPD*> _Map;
1997
1998 protected:
1999
2000 /// \name Default Factory and Fetch methods
2001 // @{
2002
2003 static void pds_static__setFactory(RY_PDS::TPDFactory userFactory);
2004 static bool _FactoryInitialised;
2005 static void pds_static__notifyFailure(uint64 key);
2006 static void (*__pds__LoadCallback)(const NLMISC::CEntityId& key, CMissionContainerPD* object);
2007 static RY_PDS::CIndexAllocator _IndexAllocator;
2008 static RY_PDS::IPDBaseData* pds_static__factory();
2009 static void pds_static__fetch(RY_PDS::IPDBaseData *object, RY_PDS::CPData &data);
2010
2011 // @}
2012
2013
2014 protected:
2015
2016 friend class CMissionPD;
2017 friend class RY_PDS::CPDSLib;
2018 friend void EGSPD::init(uint32);
2019 };
2020
2021
2022 } // End of EGSPD
2023
2024 #endif