Atlas 0.7.0
Networking protocol for the Worldforge system.
Operation.h
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// Copyright 2011-2020 Erik Ogenvik.
6// Automatically generated using gen_cpp.py. Don't edit directly.
7
8#ifndef ATLAS_OBJECTS_OPERATION_OPERATION_H
9#define ATLAS_OBJECTS_OPERATION_OPERATION_H
10
11#include <Atlas/Objects/RootOperation.h>
12#include <Atlas/Objects/Generic.h>
13
14
15namespace Atlas { namespace Objects { namespace Operation {
16
27class ActionData;
28typedef SmartPtr<ActionData> Action;
29
30static const int ACTION_NO = 10;
31
34
41{
42protected:
44 explicit ActionData(ActionData *defaults = nullptr) :
46 {
47 m_class_no = ACTION_NO;
48 }
50 ~ActionData() override = default;
51
52public:
53 // The parent type for this object's superclass
54 static constexpr const char* super_parent = "root_operation";
55 // The default parent type for this object
56 static constexpr const char* default_parent = "action";
57 // The default objtype for this object
58 static constexpr const char* default_objtype = "op";
60 ActionData * copy() const override;
61
63 bool instanceOf(int classNo) const override;
64
65
66public:
67 template <typename>
68 friend class ::Atlas::Objects::Allocator;
69 static Allocator<ActionData> allocator;
70
71protected:
73 void reset() override;
74 void free() override;
75
76private:
77
78 static void fillDefaultObjectInstance(ActionData& data, std::map<std::string, uint32_t>& attr_data);
79};
80
81
88class CreateData;
90
91static const int CREATE_NO = 11;
92
95
97class CreateData : public ActionData
98{
99protected:
101 explicit CreateData(CreateData *defaults = nullptr) :
102 ActionData((ActionData*)defaults)
103 {
104 m_class_no = CREATE_NO;
105 }
107 ~CreateData() override = default;
108
109public:
110 // The parent type for this object's superclass
111 static constexpr const char* super_parent = "action";
112 // The default parent type for this object
113 static constexpr const char* default_parent = "create";
114 // The default objtype for this object
115 static constexpr const char* default_objtype = "op";
117 CreateData * copy() const override;
118
120 bool instanceOf(int classNo) const override;
121
122
123public:
124 template <typename>
125 friend class ::Atlas::Objects::Allocator;
126 static Allocator<CreateData> allocator;
127
128protected:
130 void reset() override;
131 void free() override;
132
133private:
134
135 static void fillDefaultObjectInstance(CreateData& data, std::map<std::string, uint32_t>& attr_data);
136};
137
138
149class DeleteData;
151
152static const int DELETE_NO = 12;
153
156
162class DeleteData : public ActionData
163{
164protected:
166 explicit DeleteData(DeleteData *defaults = nullptr) :
167 ActionData((ActionData*)defaults)
168 {
169 m_class_no = DELETE_NO;
170 }
172 ~DeleteData() override = default;
173
174public:
175 // The parent type for this object's superclass
176 static constexpr const char* super_parent = "action";
177 // The default parent type for this object
178 static constexpr const char* default_parent = "delete";
179 // The default objtype for this object
180 static constexpr const char* default_objtype = "op";
182 DeleteData * copy() const override;
183
185 bool instanceOf(int classNo) const override;
186
187
188public:
189 template <typename>
190 friend class ::Atlas::Objects::Allocator;
191 static Allocator<DeleteData> allocator;
192
193protected:
195 void reset() override;
196 void free() override;
197
198private:
199
200 static void fillDefaultObjectInstance(DeleteData& data, std::map<std::string, uint32_t>& attr_data);
201};
202
203
214class SetData;
215typedef SmartPtr<SetData> Set;
216
217static const int SET_NO = 13;
218
221
227class SetData : public ActionData
228{
229protected:
231 explicit SetData(SetData *defaults = nullptr) :
232 ActionData((ActionData*)defaults)
233 {
234 m_class_no = SET_NO;
235 }
237 ~SetData() override = default;
238
239public:
240 // The parent type for this object's superclass
241 static constexpr const char* super_parent = "action";
242 // The default parent type for this object
243 static constexpr const char* default_parent = "set";
244 // The default objtype for this object
245 static constexpr const char* default_objtype = "op";
247 SetData * copy() const override;
248
250 bool instanceOf(int classNo) const override;
251
252
253public:
254 template <typename>
255 friend class ::Atlas::Objects::Allocator;
256 static Allocator<SetData> allocator;
257
258protected:
260 void reset() override;
261 void free() override;
262
263private:
264
265 static void fillDefaultObjectInstance(SetData& data, std::map<std::string, uint32_t>& attr_data);
266};
267
268
279class AffectData;
281
282static const int AFFECT_NO = 14;
283
286
292class AffectData : public SetData
293{
294protected:
296 explicit AffectData(AffectData *defaults = nullptr) :
297 SetData((SetData*)defaults)
298 {
299 m_class_no = AFFECT_NO;
300 }
302 ~AffectData() override = default;
303
304public:
305 // The parent type for this object's superclass
306 static constexpr const char* super_parent = "set";
307 // The default parent type for this object
308 static constexpr const char* default_parent = "affect";
309 // The default objtype for this object
310 static constexpr const char* default_objtype = "op";
312 AffectData * copy() const override;
313
315 bool instanceOf(int classNo) const override;
316
317
318public:
319 template <typename>
320 friend class ::Atlas::Objects::Allocator;
321 static Allocator<AffectData> allocator;
322
323protected:
325 void reset() override;
326 void free() override;
327
328private:
329
330 static void fillDefaultObjectInstance(AffectData& data, std::map<std::string, uint32_t>& attr_data);
331};
332
333
344class HitData;
345typedef SmartPtr<HitData> Hit;
346
347static const int HIT_NO = 15;
348
351
357class HitData : public AffectData
358{
359protected:
361 explicit HitData(HitData *defaults = nullptr) :
362 AffectData((AffectData*)defaults)
363 {
364 m_class_no = HIT_NO;
365 }
367 ~HitData() override = default;
368
369public:
370 // The parent type for this object's superclass
371 static constexpr const char* super_parent = "affect";
372 // The default parent type for this object
373 static constexpr const char* default_parent = "hit";
374 // The default objtype for this object
375 static constexpr const char* default_objtype = "op";
377 HitData * copy() const override;
378
380 bool instanceOf(int classNo) const override;
381
382
383public:
384 template <typename>
385 friend class ::Atlas::Objects::Allocator;
386 static Allocator<HitData> allocator;
387
388protected:
390 void reset() override;
391 void free() override;
392
393private:
394
395 static void fillDefaultObjectInstance(HitData& data, std::map<std::string, uint32_t>& attr_data);
396};
397
398
405class MoveData;
407
408static const int MOVE_NO = 16;
409
412
414class MoveData : public SetData
415{
416protected:
418 explicit MoveData(MoveData *defaults = nullptr) :
419 SetData((SetData*)defaults)
420 {
421 m_class_no = MOVE_NO;
422 }
424 ~MoveData() override = default;
425
426public:
427 // The parent type for this object's superclass
428 static constexpr const char* super_parent = "set";
429 // The default parent type for this object
430 static constexpr const char* default_parent = "move";
431 // The default objtype for this object
432 static constexpr const char* default_objtype = "op";
434 MoveData * copy() const override;
435
437 bool instanceOf(int classNo) const override;
438
439
440public:
441 template <typename>
442 friend class ::Atlas::Objects::Allocator;
443 static Allocator<MoveData> allocator;
444
445protected:
447 void reset() override;
448 void free() override;
449
450private:
451
452 static void fillDefaultObjectInstance(MoveData& data, std::map<std::string, uint32_t>& attr_data);
453};
454
455
466class WieldData;
468
469static const int WIELD_NO = 17;
470
473
479class WieldData : public SetData
480{
481protected:
483 explicit WieldData(WieldData *defaults = nullptr) :
484 SetData((SetData*)defaults)
485 {
486 m_class_no = WIELD_NO;
487 }
489 ~WieldData() override = default;
490
491public:
492 // The parent type for this object's superclass
493 static constexpr const char* super_parent = "set";
494 // The default parent type for this object
495 static constexpr const char* default_parent = "wield";
496 // The default objtype for this object
497 static constexpr const char* default_objtype = "op";
499 WieldData * copy() const override;
500
502 bool instanceOf(int classNo) const override;
503
504
505public:
506 template <typename>
507 friend class ::Atlas::Objects::Allocator;
508 static Allocator<WieldData> allocator;
509
510protected:
512 void reset() override;
513 void free() override;
514
515private:
516
517 static void fillDefaultObjectInstance(WieldData& data, std::map<std::string, uint32_t>& attr_data);
518};
519
520
531class GetData;
532typedef SmartPtr<GetData> Get;
533
534static const int GET_NO = 18;
535
538
544class GetData : public ActionData
545{
546protected:
548 explicit GetData(GetData *defaults = nullptr) :
549 ActionData((ActionData*)defaults)
550 {
551 m_class_no = GET_NO;
552 }
554 ~GetData() override = default;
555
556public:
557 // The parent type for this object's superclass
558 static constexpr const char* super_parent = "action";
559 // The default parent type for this object
560 static constexpr const char* default_parent = "get";
561 // The default objtype for this object
562 static constexpr const char* default_objtype = "op";
564 GetData * copy() const override;
565
567 bool instanceOf(int classNo) const override;
568
569
570public:
571 template <typename>
572 friend class ::Atlas::Objects::Allocator;
573 static Allocator<GetData> allocator;
574
575protected:
577 void reset() override;
578 void free() override;
579
580private:
581
582 static void fillDefaultObjectInstance(GetData& data, std::map<std::string, uint32_t>& attr_data);
583};
584
585
596class PerceiveData;
598
599static const int PERCEIVE_NO = 19;
600
603
609class PerceiveData : public GetData
610{
611protected:
613 explicit PerceiveData(PerceiveData *defaults = nullptr) :
614 GetData((GetData*)defaults)
615 {
616 m_class_no = PERCEIVE_NO;
617 }
619 ~PerceiveData() override = default;
620
621public:
622 // The parent type for this object's superclass
623 static constexpr const char* super_parent = "get";
624 // The default parent type for this object
625 static constexpr const char* default_parent = "perceive";
626 // The default objtype for this object
627 static constexpr const char* default_objtype = "op";
629 PerceiveData * copy() const override;
630
632 bool instanceOf(int classNo) const override;
633
634
635public:
636 template <typename>
637 friend class ::Atlas::Objects::Allocator;
638 static Allocator<PerceiveData> allocator;
639
640protected:
642 void reset() override;
643 void free() override;
644
645private:
646
647 static void fillDefaultObjectInstance(PerceiveData& data, std::map<std::string, uint32_t>& attr_data);
648};
649
650
661class LookData;
663
664static const int LOOK_NO = 20;
665
668
674class LookData : public PerceiveData
675{
676protected:
678 explicit LookData(LookData *defaults = nullptr) :
679 PerceiveData((PerceiveData*)defaults)
680 {
681 m_class_no = LOOK_NO;
682 }
684 ~LookData() override = default;
685
686public:
687 // The parent type for this object's superclass
688 static constexpr const char* super_parent = "perceive";
689 // The default parent type for this object
690 static constexpr const char* default_parent = "look";
691 // The default objtype for this object
692 static constexpr const char* default_objtype = "op";
694 LookData * copy() const override;
695
697 bool instanceOf(int classNo) const override;
698
699
700public:
701 template <typename>
702 friend class ::Atlas::Objects::Allocator;
703 static Allocator<LookData> allocator;
704
705protected:
707 void reset() override;
708 void free() override;
709
710private:
711
712 static void fillDefaultObjectInstance(LookData& data, std::map<std::string, uint32_t>& attr_data);
713};
714
715
726class ListenData;
728
729static const int LISTEN_NO = 21;
730
733
740{
741protected:
743 explicit ListenData(ListenData *defaults = nullptr) :
744 PerceiveData((PerceiveData*)defaults)
745 {
746 m_class_no = LISTEN_NO;
747 }
749 ~ListenData() override = default;
750
751public:
752 // The parent type for this object's superclass
753 static constexpr const char* super_parent = "perceive";
754 // The default parent type for this object
755 static constexpr const char* default_parent = "listen";
756 // The default objtype for this object
757 static constexpr const char* default_objtype = "op";
759 ListenData * copy() const override;
760
762 bool instanceOf(int classNo) const override;
763
764
765public:
766 template <typename>
767 friend class ::Atlas::Objects::Allocator;
768 static Allocator<ListenData> allocator;
769
770protected:
772 void reset() override;
773 void free() override;
774
775private:
776
777 static void fillDefaultObjectInstance(ListenData& data, std::map<std::string, uint32_t>& attr_data);
778};
779
780
791class SniffData;
793
794static const int SNIFF_NO = 22;
795
798
805{
806protected:
808 explicit SniffData(SniffData *defaults = nullptr) :
809 PerceiveData((PerceiveData*)defaults)
810 {
811 m_class_no = SNIFF_NO;
812 }
814 ~SniffData() override = default;
815
816public:
817 // The parent type for this object's superclass
818 static constexpr const char* super_parent = "perceive";
819 // The default parent type for this object
820 static constexpr const char* default_parent = "sniff";
821 // The default objtype for this object
822 static constexpr const char* default_objtype = "op";
824 SniffData * copy() const override;
825
827 bool instanceOf(int classNo) const override;
828
829
830public:
831 template <typename>
832 friend class ::Atlas::Objects::Allocator;
833 static Allocator<SniffData> allocator;
834
835protected:
837 void reset() override;
838 void free() override;
839
840private:
841
842 static void fillDefaultObjectInstance(SniffData& data, std::map<std::string, uint32_t>& attr_data);
843};
844
845
856class TouchData;
858
859static const int TOUCH_NO = 23;
860
863
870{
871protected:
873 explicit TouchData(TouchData *defaults = nullptr) :
874 PerceiveData((PerceiveData*)defaults)
875 {
876 m_class_no = TOUCH_NO;
877 }
879 ~TouchData() override = default;
880
881public:
882 // The parent type for this object's superclass
883 static constexpr const char* super_parent = "perceive";
884 // The default parent type for this object
885 static constexpr const char* default_parent = "touch";
886 // The default objtype for this object
887 static constexpr const char* default_objtype = "op";
889 TouchData * copy() const override;
890
892 bool instanceOf(int classNo) const override;
893
894
895public:
896 template <typename>
897 friend class ::Atlas::Objects::Allocator;
898 static Allocator<TouchData> allocator;
899
900protected:
902 void reset() override;
903 void free() override;
904
905private:
906
907 static void fillDefaultObjectInstance(TouchData& data, std::map<std::string, uint32_t>& attr_data);
908};
909
910
917class LoginData;
919
920static const int LOGIN_NO = 24;
921
924
926class LoginData : public GetData
927{
928protected:
930 explicit LoginData(LoginData *defaults = nullptr) :
931 GetData((GetData*)defaults)
932 {
933 m_class_no = LOGIN_NO;
934 }
936 ~LoginData() override = default;
937
938public:
939 // The parent type for this object's superclass
940 static constexpr const char* super_parent = "get";
941 // The default parent type for this object
942 static constexpr const char* default_parent = "login";
943 // The default objtype for this object
944 static constexpr const char* default_objtype = "op";
946 LoginData * copy() const override;
947
949 bool instanceOf(int classNo) const override;
950
951
952public:
953 template <typename>
954 friend class ::Atlas::Objects::Allocator;
955 static Allocator<LoginData> allocator;
956
957protected:
959 void reset() override;
960 void free() override;
961
962private:
963
964 static void fillDefaultObjectInstance(LoginData& data, std::map<std::string, uint32_t>& attr_data);
965};
966
967
974class LogoutData;
976
977static const int LOGOUT_NO = 25;
978
981
983class LogoutData : public LoginData
984{
985protected:
987 explicit LogoutData(LogoutData *defaults = nullptr) :
988 LoginData((LoginData*)defaults)
989 {
990 m_class_no = LOGOUT_NO;
991 }
993 ~LogoutData() override = default;
994
995public:
996 // The parent type for this object's superclass
997 static constexpr const char* super_parent = "login";
998 // The default parent type for this object
999 static constexpr const char* default_parent = "logout";
1000 // The default objtype for this object
1001 static constexpr const char* default_objtype = "op";
1003 LogoutData * copy() const override;
1004
1006 bool instanceOf(int classNo) const override;
1007
1008
1009public:
1010 template <typename>
1011 friend class ::Atlas::Objects::Allocator;
1012 static Allocator<LogoutData> allocator;
1013
1014protected:
1016 void reset() override;
1017 void free() override;
1018
1019private:
1020
1021 static void fillDefaultObjectInstance(LogoutData& data, std::map<std::string, uint32_t>& attr_data);
1022};
1023
1024
1035class CommunicateData;
1037
1038static const int COMMUNICATE_NO = 26;
1039
1042
1049{
1050protected:
1052 explicit CommunicateData(CommunicateData *defaults = nullptr) :
1053 ActionData((ActionData*)defaults)
1054 {
1055 m_class_no = COMMUNICATE_NO;
1056 }
1058 ~CommunicateData() override = default;
1059
1060public:
1061 // The parent type for this object's superclass
1062 static constexpr const char* super_parent = "action";
1063 // The default parent type for this object
1064 static constexpr const char* default_parent = "communicate";
1065 // The default objtype for this object
1066 static constexpr const char* default_objtype = "op";
1068 CommunicateData * copy() const override;
1069
1071 bool instanceOf(int classNo) const override;
1072
1073
1074public:
1075 template <typename>
1076 friend class ::Atlas::Objects::Allocator;
1077 static Allocator<CommunicateData> allocator;
1078
1079protected:
1081 void reset() override;
1082 void free() override;
1083
1084private:
1085
1086 static void fillDefaultObjectInstance(CommunicateData& data, std::map<std::string, uint32_t>& attr_data);
1087};
1088
1089
1096class TalkData;
1097typedef SmartPtr<TalkData> Talk;
1098
1099static const int TALK_NO = 27;
1100
1103
1106{
1107protected:
1109 explicit TalkData(TalkData *defaults = nullptr) :
1111 {
1112 m_class_no = TALK_NO;
1113 }
1115 ~TalkData() override = default;
1116
1117public:
1118 // The parent type for this object's superclass
1119 static constexpr const char* super_parent = "communicate";
1120 // The default parent type for this object
1121 static constexpr const char* default_parent = "talk";
1122 // The default objtype for this object
1123 static constexpr const char* default_objtype = "op";
1125 TalkData * copy() const override;
1126
1128 bool instanceOf(int classNo) const override;
1129
1130
1131public:
1132 template <typename>
1133 friend class ::Atlas::Objects::Allocator;
1134 static Allocator<TalkData> allocator;
1135
1136protected:
1138 void reset() override;
1139 void free() override;
1140
1141private:
1142
1143 static void fillDefaultObjectInstance(TalkData& data, std::map<std::string, uint32_t>& attr_data);
1144};
1145
1146
1157class ImaginaryData;
1159
1160static const int IMAGINARY_NO = 28;
1161
1164
1171{
1172protected:
1174 explicit ImaginaryData(ImaginaryData *defaults = nullptr) :
1175 ActionData((ActionData*)defaults)
1176 {
1177 m_class_no = IMAGINARY_NO;
1178 }
1180 ~ImaginaryData() override = default;
1181
1182public:
1183 // The parent type for this object's superclass
1184 static constexpr const char* super_parent = "action";
1185 // The default parent type for this object
1186 static constexpr const char* default_parent = "imaginary";
1187 // The default objtype for this object
1188 static constexpr const char* default_objtype = "op";
1190 ImaginaryData * copy() const override;
1191
1193 bool instanceOf(int classNo) const override;
1194
1195
1196public:
1197 template <typename>
1198 friend class ::Atlas::Objects::Allocator;
1199 static Allocator<ImaginaryData> allocator;
1200
1201protected:
1203 void reset() override;
1204 void free() override;
1205
1206private:
1207
1208 static void fillDefaultObjectInstance(ImaginaryData& data, std::map<std::string, uint32_t>& attr_data);
1209};
1210
1211
1222class UseData;
1223typedef SmartPtr<UseData> Use;
1224
1225static const int USE_NO = 29;
1226
1229
1235class UseData : public ActionData
1236{
1237protected:
1239 explicit UseData(UseData *defaults = nullptr) :
1240 ActionData((ActionData*)defaults)
1241 {
1242 m_class_no = USE_NO;
1243 }
1245 ~UseData() override = default;
1246
1247public:
1248 // The parent type for this object's superclass
1249 static constexpr const char* super_parent = "action";
1250 // The default parent type for this object
1251 static constexpr const char* default_parent = "use";
1252 // The default objtype for this object
1253 static constexpr const char* default_objtype = "op";
1255 UseData * copy() const override;
1256
1258 bool instanceOf(int classNo) const override;
1259
1260
1261public:
1262 template <typename>
1263 friend class ::Atlas::Objects::Allocator;
1264 static Allocator<UseData> allocator;
1265
1266protected:
1268 void reset() override;
1269 void free() override;
1270
1271private:
1272
1273 static void fillDefaultObjectInstance(UseData& data, std::map<std::string, uint32_t>& attr_data);
1274};
1275
1276
1287class ActivityData;
1289
1290static const int ACTIVITY_NO = 30;
1291
1294
1301{
1302protected:
1304 explicit ActivityData(ActivityData *defaults = nullptr) :
1305 ActionData((ActionData*)defaults)
1306 {
1307 m_class_no = ACTIVITY_NO;
1308 }
1310 ~ActivityData() override = default;
1311
1312public:
1313 // The parent type for this object's superclass
1314 static constexpr const char* super_parent = "action";
1315 // The default parent type for this object
1316 static constexpr const char* default_parent = "activity";
1317 // The default objtype for this object
1318 static constexpr const char* default_objtype = "op";
1320 ActivityData * copy() const override;
1321
1323 bool instanceOf(int classNo) const override;
1324
1325
1326public:
1327 template <typename>
1328 friend class ::Atlas::Objects::Allocator;
1329 static Allocator<ActivityData> allocator;
1330
1331protected:
1333 void reset() override;
1334 void free() override;
1335
1336private:
1337
1338 static void fillDefaultObjectInstance(ActivityData& data, std::map<std::string, uint32_t>& attr_data);
1339};
1340
1341
1352class InfoData;
1353typedef SmartPtr<InfoData> Info;
1354
1355static const int INFO_NO = 31;
1356
1359
1366{
1367protected:
1369 explicit InfoData(InfoData *defaults = nullptr) :
1371 {
1372 m_class_no = INFO_NO;
1373 }
1375 ~InfoData() override = default;
1376
1377public:
1378 // The parent type for this object's superclass
1379 static constexpr const char* super_parent = "root_operation";
1380 // The default parent type for this object
1381 static constexpr const char* default_parent = "info";
1382 // The default objtype for this object
1383 static constexpr const char* default_objtype = "op";
1385 InfoData * copy() const override;
1386
1388 bool instanceOf(int classNo) const override;
1389
1390
1391public:
1392 template <typename>
1393 friend class ::Atlas::Objects::Allocator;
1394 static Allocator<InfoData> allocator;
1395
1396protected:
1398 void reset() override;
1399 void free() override;
1400
1401private:
1402
1403 static void fillDefaultObjectInstance(InfoData& data, std::map<std::string, uint32_t>& attr_data);
1404};
1405
1406
1413class PerceptionData;
1415
1416static const int PERCEPTION_NO = 32;
1417
1420
1423{
1424protected:
1426 explicit PerceptionData(PerceptionData *defaults = nullptr) :
1427 InfoData((InfoData*)defaults)
1428 {
1429 m_class_no = PERCEPTION_NO;
1430 }
1432 ~PerceptionData() override = default;
1433
1434public:
1435 // The parent type for this object's superclass
1436 static constexpr const char* super_parent = "info";
1437 // The default parent type for this object
1438 static constexpr const char* default_parent = "perception";
1439 // The default objtype for this object
1440 static constexpr const char* default_objtype = "op";
1442 PerceptionData * copy() const override;
1443
1445 bool instanceOf(int classNo) const override;
1446
1447
1448public:
1449 template <typename>
1450 friend class ::Atlas::Objects::Allocator;
1451 static Allocator<PerceptionData> allocator;
1452
1453protected:
1455 void reset() override;
1456 void free() override;
1457
1458private:
1459
1460 static void fillDefaultObjectInstance(PerceptionData& data, std::map<std::string, uint32_t>& attr_data);
1461};
1462
1463
1470class UnseenData;
1472
1473static const int UNSEEN_NO = 33;
1474
1477
1480{
1481protected:
1483 explicit UnseenData(UnseenData *defaults = nullptr) :
1484 PerceptionData((PerceptionData*)defaults)
1485 {
1486 m_class_no = UNSEEN_NO;
1487 }
1489 ~UnseenData() override = default;
1490
1491public:
1492 // The parent type for this object's superclass
1493 static constexpr const char* super_parent = "perception";
1494 // The default parent type for this object
1495 static constexpr const char* default_parent = "unseen";
1496 // The default objtype for this object
1497 static constexpr const char* default_objtype = "op";
1499 UnseenData * copy() const override;
1500
1502 bool instanceOf(int classNo) const override;
1503
1504
1505public:
1506 template <typename>
1507 friend class ::Atlas::Objects::Allocator;
1508 static Allocator<UnseenData> allocator;
1509
1510protected:
1512 void reset() override;
1513 void free() override;
1514
1515private:
1516
1517 static void fillDefaultObjectInstance(UnseenData& data, std::map<std::string, uint32_t>& attr_data);
1518};
1519
1520
1527class SightData;
1529
1530static const int SIGHT_NO = 34;
1531
1534
1537{
1538protected:
1540 explicit SightData(SightData *defaults = nullptr) :
1541 PerceptionData((PerceptionData*)defaults)
1542 {
1543 m_class_no = SIGHT_NO;
1544 }
1546 ~SightData() override = default;
1547
1548public:
1549 // The parent type for this object's superclass
1550 static constexpr const char* super_parent = "perception";
1551 // The default parent type for this object
1552 static constexpr const char* default_parent = "sight";
1553 // The default objtype for this object
1554 static constexpr const char* default_objtype = "op";
1556 SightData * copy() const override;
1557
1559 bool instanceOf(int classNo) const override;
1560
1561
1562public:
1563 template <typename>
1564 friend class ::Atlas::Objects::Allocator;
1565 static Allocator<SightData> allocator;
1566
1567protected:
1569 void reset() override;
1570 void free() override;
1571
1572private:
1573
1574 static void fillDefaultObjectInstance(SightData& data, std::map<std::string, uint32_t>& attr_data);
1575};
1576
1577
1584class AppearanceData;
1586
1587static const int APPEARANCE_NO = 35;
1588
1591
1594{
1595protected:
1597 explicit AppearanceData(AppearanceData *defaults = nullptr) :
1598 SightData((SightData*)defaults)
1599 {
1600 m_class_no = APPEARANCE_NO;
1601 }
1603 ~AppearanceData() override = default;
1604
1605public:
1606 // The parent type for this object's superclass
1607 static constexpr const char* super_parent = "sight";
1608 // The default parent type for this object
1609 static constexpr const char* default_parent = "appearance";
1610 // The default objtype for this object
1611 static constexpr const char* default_objtype = "op";
1613 AppearanceData * copy() const override;
1614
1616 bool instanceOf(int classNo) const override;
1617
1618
1619public:
1620 template <typename>
1621 friend class ::Atlas::Objects::Allocator;
1622 static Allocator<AppearanceData> allocator;
1623
1624protected:
1626 void reset() override;
1627 void free() override;
1628
1629private:
1630
1631 static void fillDefaultObjectInstance(AppearanceData& data, std::map<std::string, uint32_t>& attr_data);
1632};
1633
1634
1641class DisappearanceData;
1643
1644static const int DISAPPEARANCE_NO = 36;
1645
1648
1651{
1652protected:
1654 explicit DisappearanceData(DisappearanceData *defaults = nullptr) :
1655 SightData((SightData*)defaults)
1656 {
1657 m_class_no = DISAPPEARANCE_NO;
1658 }
1660 ~DisappearanceData() override = default;
1661
1662public:
1663 // The parent type for this object's superclass
1664 static constexpr const char* super_parent = "sight";
1665 // The default parent type for this object
1666 static constexpr const char* default_parent = "disappearance";
1667 // The default objtype for this object
1668 static constexpr const char* default_objtype = "op";
1670 DisappearanceData * copy() const override;
1671
1673 bool instanceOf(int classNo) const override;
1674
1675
1676public:
1677 template <typename>
1678 friend class ::Atlas::Objects::Allocator;
1679 static Allocator<DisappearanceData> allocator;
1680
1681protected:
1683 void reset() override;
1684 void free() override;
1685
1686private:
1687
1688 static void fillDefaultObjectInstance(DisappearanceData& data, std::map<std::string, uint32_t>& attr_data);
1689};
1690
1691
1698class SoundData;
1700
1701static const int SOUND_NO = 37;
1702
1705
1708{
1709protected:
1711 explicit SoundData(SoundData *defaults = nullptr) :
1712 PerceptionData((PerceptionData*)defaults)
1713 {
1714 m_class_no = SOUND_NO;
1715 }
1717 ~SoundData() override = default;
1718
1719public:
1720 // The parent type for this object's superclass
1721 static constexpr const char* super_parent = "perception";
1722 // The default parent type for this object
1723 static constexpr const char* default_parent = "sound";
1724 // The default objtype for this object
1725 static constexpr const char* default_objtype = "op";
1727 SoundData * copy() const override;
1728
1730 bool instanceOf(int classNo) const override;
1731
1732
1733public:
1734 template <typename>
1735 friend class ::Atlas::Objects::Allocator;
1736 static Allocator<SoundData> allocator;
1737
1738protected:
1740 void reset() override;
1741 void free() override;
1742
1743private:
1744
1745 static void fillDefaultObjectInstance(SoundData& data, std::map<std::string, uint32_t>& attr_data);
1746};
1747
1748
1755class SmellData;
1757
1758static const int SMELL_NO = 38;
1759
1762
1765{
1766protected:
1768 explicit SmellData(SmellData *defaults = nullptr) :
1769 PerceptionData((PerceptionData*)defaults)
1770 {
1771 m_class_no = SMELL_NO;
1772 }
1774 ~SmellData() override = default;
1775
1776public:
1777 // The parent type for this object's superclass
1778 static constexpr const char* super_parent = "perception";
1779 // The default parent type for this object
1780 static constexpr const char* default_parent = "smell";
1781 // The default objtype for this object
1782 static constexpr const char* default_objtype = "op";
1784 SmellData * copy() const override;
1785
1787 bool instanceOf(int classNo) const override;
1788
1789
1790public:
1791 template <typename>
1792 friend class ::Atlas::Objects::Allocator;
1793 static Allocator<SmellData> allocator;
1794
1795protected:
1797 void reset() override;
1798 void free() override;
1799
1800private:
1801
1802 static void fillDefaultObjectInstance(SmellData& data, std::map<std::string, uint32_t>& attr_data);
1803};
1804
1805
1812class FeelData;
1813typedef SmartPtr<FeelData> Feel;
1814
1815static const int FEEL_NO = 39;
1816
1819
1822{
1823protected:
1825 explicit FeelData(FeelData *defaults = nullptr) :
1826 PerceptionData((PerceptionData*)defaults)
1827 {
1828 m_class_no = FEEL_NO;
1829 }
1831 ~FeelData() override = default;
1832
1833public:
1834 // The parent type for this object's superclass
1835 static constexpr const char* super_parent = "perception";
1836 // The default parent type for this object
1837 static constexpr const char* default_parent = "feel";
1838 // The default objtype for this object
1839 static constexpr const char* default_objtype = "op";
1841 FeelData * copy() const override;
1842
1844 bool instanceOf(int classNo) const override;
1845
1846
1847public:
1848 template <typename>
1849 friend class ::Atlas::Objects::Allocator;
1850 static Allocator<FeelData> allocator;
1851
1852protected:
1854 void reset() override;
1855 void free() override;
1856
1857private:
1858
1859 static void fillDefaultObjectInstance(FeelData& data, std::map<std::string, uint32_t>& attr_data);
1860};
1861
1862
1873class ErrorData;
1875
1876static const int ERROR_NO = 40;
1877
1880
1886class ErrorData : public InfoData
1887{
1888protected:
1890 explicit ErrorData(ErrorData *defaults = nullptr) :
1891 InfoData((InfoData*)defaults)
1892 {
1893 m_class_no = ERROR_NO;
1894 }
1896 ~ErrorData() override = default;
1897
1898public:
1899 // The parent type for this object's superclass
1900 static constexpr const char* super_parent = "info";
1901 // The default parent type for this object
1902 static constexpr const char* default_parent = "error";
1903 // The default objtype for this object
1904 static constexpr const char* default_objtype = "op";
1906 ErrorData * copy() const override;
1907
1909 bool instanceOf(int classNo) const override;
1910
1911
1912public:
1913 template <typename>
1914 friend class ::Atlas::Objects::Allocator;
1915 static Allocator<ErrorData> allocator;
1916
1917protected:
1919 void reset() override;
1920 void free() override;
1921
1922private:
1923
1924 static void fillDefaultObjectInstance(ErrorData& data, std::map<std::string, uint32_t>& attr_data);
1925};
1926
1927
1938class ChangeData;
1940
1941static const int CHANGE_NO = 41;
1942
1945
1951class ChangeData : public InfoData
1952{
1953protected:
1955 explicit ChangeData(ChangeData *defaults = nullptr) :
1956 InfoData((InfoData*)defaults)
1957 {
1958 m_class_no = CHANGE_NO;
1959 }
1961 ~ChangeData() override = default;
1962
1963public:
1964 // The parent type for this object's superclass
1965 static constexpr const char* super_parent = "info";
1966 // The default parent type for this object
1967 static constexpr const char* default_parent = "change";
1968 // The default objtype for this object
1969 static constexpr const char* default_objtype = "op";
1971 ChangeData * copy() const override;
1972
1974 bool instanceOf(int classNo) const override;
1975
1976
1977public:
1978 template <typename>
1979 friend class ::Atlas::Objects::Allocator;
1980 static Allocator<ChangeData> allocator;
1981
1982protected:
1984 void reset() override;
1985 void free() override;
1986
1987private:
1988
1989 static void fillDefaultObjectInstance(ChangeData& data, std::map<std::string, uint32_t>& attr_data);
1990};
1991
1992} } } // namespace Atlas::Objects::Operation
1993
1994#endif // ATLAS_OBJECTS_OPERATION_OPERATION_H
This is base operator for operations that might have effects..
Definition: Operation.h:41
bool instanceOf(int classNo) const override
Is this instance of some class?
~ActionData() override=default
Default destructor.
void free() override
Free an instance of this class, returning it to the memory pool.
void reset() override
Resets the object as it's returned to the pool.
ActionData * copy() const override
Copy this object.
ActionData(ActionData *defaults=nullptr)
Construct a ActionData class definition.
Definition: Operation.h:44
Activities performed by entities. This is mainly meant for actions that should be communicated to oth...
Definition: Operation.h:1301
ActivityData(ActivityData *defaults=nullptr)
Construct a ActivityData class definition.
Definition: Operation.h:1304
void reset() override
Resets the object as it's returned to the pool.
bool instanceOf(int classNo) const override
Is this instance of some class?
ActivityData * copy() const override
Copy this object.
void free() override
Free an instance of this class, returning it to the memory pool.
~ActivityData() override=default
Default destructor.
Sets attributes for existing entity..
Definition: Operation.h:293
bool instanceOf(int classNo) const override
Is this instance of some class?
AffectData * copy() const override
Copy this object.
AffectData(AffectData *defaults=nullptr)
Construct a AffectData class definition.
Definition: Operation.h:296
~AffectData() override=default
Default destructor.
void free() override
Free an instance of this class, returning it to the memory pool.
void reset() override
Resets the object as it's returned to the pool.
Character sees something appearing: it literally appears or has it come in visible range.
Definition: Operation.h:1594
void free() override
Free an instance of this class, returning it to the memory pool.
bool instanceOf(int classNo) const override
Is this instance of some class?
AppearanceData * copy() const override
Copy this object.
~AppearanceData() override=default
Default destructor.
AppearanceData(AppearanceData *defaults=nullptr)
Construct a AppearanceData class definition.
Definition: Operation.h:1597
void reset() override
Resets the object as it's returned to the pool.
An operation used to signal to clients when things such as types have changed..
Definition: Operation.h:1952
bool instanceOf(int classNo) const override
Is this instance of some class?
ChangeData(ChangeData *defaults=nullptr)
Construct a ChangeData class definition.
Definition: Operation.h:1955
ChangeData * copy() const override
Copy this object.
void reset() override
Resets the object as it's returned to the pool.
void free() override
Free an instance of this class, returning it to the memory pool.
~ChangeData() override=default
Default destructor.
Base operator for all kind of communication..
Definition: Operation.h:1049
~CommunicateData() override=default
Default destructor.
void reset() override
Resets the object as it's returned to the pool.
CommunicateData(CommunicateData *defaults=nullptr)
Construct a CommunicateData class definition.
Definition: Operation.h:1052
bool instanceOf(int classNo) const override
Is this instance of some class?
CommunicateData * copy() const override
Copy this object.
void free() override
Free an instance of this class, returning it to the memory pool.
Create new things from nothing using this operator..
Definition: Operation.h:98
void free() override
Free an instance of this class, returning it to the memory pool.
~CreateData() override=default
Default destructor.
CreateData * copy() const override
Copy this object.
void reset() override
Resets the object as it's returned to the pool.
bool instanceOf(int classNo) const override
Is this instance of some class?
CreateData(CreateData *defaults=nullptr)
Construct a CreateData class definition.
Definition: Operation.h:101
void reset() override
Resets the object as it's returned to the pool.
DeleteData * copy() const override
Copy this object.
bool instanceOf(int classNo) const override
Is this instance of some class?
void free() override
Free an instance of this class, returning it to the memory pool.
DeleteData(DeleteData *defaults=nullptr)
Construct a DeleteData class definition.
Definition: Operation.h:166
~DeleteData() override=default
Default destructor.
Character sees something disappearing: it literally disappears or has it gone too far to be visible.
Definition: Operation.h:1651
DisappearanceData(DisappearanceData *defaults=nullptr)
Construct a DisappearanceData class definition.
Definition: Operation.h:1654
void reset() override
Resets the object as it's returned to the pool.
DisappearanceData * copy() const override
Copy this object.
~DisappearanceData() override=default
Default destructor.
bool instanceOf(int classNo) const override
Is this instance of some class?
void free() override
Free an instance of this class, returning it to the memory pool.
ErrorData(ErrorData *defaults=nullptr)
Construct a ErrorData class definition.
Definition: Operation.h:1890
void free() override
Free an instance of this class, returning it to the memory pool.
void reset() override
Resets the object as it's returned to the pool.
bool instanceOf(int classNo) const override
Is this instance of some class?
~ErrorData() override=default
Default destructor.
ErrorData * copy() const override
Copy this object.
Character feels something (with fingers usually).
Definition: Operation.h:1822
void free() override
Free an instance of this class, returning it to the memory pool.
~FeelData() override=default
Default destructor.
FeelData * copy() const override
Copy this object.
bool instanceOf(int classNo) const override
Is this instance of some class?
void reset() override
Resets the object as it's returned to the pool.
FeelData(FeelData *defaults=nullptr)
Construct a FeelData class definition.
Definition: Operation.h:1825
Generic operation for getting info about things..
Definition: Operation.h:545
void free() override
Free an instance of this class, returning it to the memory pool.
void reset() override
Resets the object as it's returned to the pool.
bool instanceOf(int classNo) const override
Is this instance of some class?
~GetData() override=default
Default destructor.
GetData * copy() const override
Copy this object.
GetData(GetData *defaults=nullptr)
Construct a GetData class definition.
Definition: Operation.h:548
Operation for when one entity hits another..
Definition: Operation.h:358
bool instanceOf(int classNo) const override
Is this instance of some class?
void free() override
Free an instance of this class, returning it to the memory pool.
void reset() override
Resets the object as it's returned to the pool.
HitData * copy() const override
Copy this object.
HitData(HitData *defaults=nullptr)
Construct a HitData class definition.
Definition: Operation.h:361
~HitData() override=default
Default destructor.
When something is not yet implemented in server, then character can pretend to do something ;-).
Definition: Operation.h:1171
~ImaginaryData() override=default
Default destructor.
ImaginaryData * copy() const override
Copy this object.
void free() override
Free an instance of this class, returning it to the memory pool.
ImaginaryData(ImaginaryData *defaults=nullptr)
Construct a ImaginaryData class definition.
Definition: Operation.h:1174
void reset() override
Resets the object as it's returned to the pool.
bool instanceOf(int classNo) const override
Is this instance of some class?
This is base operator for operations that tell you info about objects or events..
Definition: Operation.h:1366
bool instanceOf(int classNo) const override
Is this instance of some class?
void reset() override
Resets the object as it's returned to the pool.
InfoData(InfoData *defaults=nullptr)
Construct a InfoData class definition.
Definition: Operation.h:1369
InfoData * copy() const override
Copy this object.
void free() override
Free an instance of this class, returning it to the memory pool.
~InfoData() override=default
Default destructor.
~ListenData() override=default
Default destructor.
bool instanceOf(int classNo) const override
Is this instance of some class?
ListenData * copy() const override
Copy this object.
ListenData(ListenData *defaults=nullptr)
Construct a ListenData class definition.
Definition: Operation.h:743
void reset() override
Resets the object as it's returned to the pool.
void free() override
Free an instance of this class, returning it to the memory pool.
Operation for logging into server.
Definition: Operation.h:927
bool instanceOf(int classNo) const override
Is this instance of some class?
void free() override
Free an instance of this class, returning it to the memory pool.
LoginData * copy() const override
Copy this object.
void reset() override
Resets the object as it's returned to the pool.
~LoginData() override=default
Default destructor.
LoginData(LoginData *defaults=nullptr)
Construct a LoginData class definition.
Definition: Operation.h:930
Operation for logging out.
Definition: Operation.h:984
void reset() override
Resets the object as it's returned to the pool.
LogoutData(LogoutData *defaults=nullptr)
Construct a LogoutData class definition.
Definition: Operation.h:987
void free() override
Free an instance of this class, returning it to the memory pool.
~LogoutData() override=default
Default destructor.
LogoutData * copy() const override
Copy this object.
bool instanceOf(int classNo) const override
Is this instance of some class?
LookData(LookData *defaults=nullptr)
Construct a LookData class definition.
Definition: Operation.h:678
void reset() override
Resets the object as it's returned to the pool.
~LookData() override=default
Default destructor.
void free() override
Free an instance of this class, returning it to the memory pool.
bool instanceOf(int classNo) const override
Is this instance of some class?
LookData * copy() const override
Copy this object.
MoveData * copy() const override
Copy this object.
void reset() override
Resets the object as it's returned to the pool.
bool instanceOf(int classNo) const override
Is this instance of some class?
~MoveData() override=default
Default destructor.
MoveData(MoveData *defaults=nullptr)
Construct a MoveData class definition.
Definition: Operation.h:418
void free() override
Free an instance of this class, returning it to the memory pool.
Generic base operation for perceiving things by eyes, ears, etc....
Definition: Operation.h:610
PerceiveData * copy() const override
Copy this object.
PerceiveData(PerceiveData *defaults=nullptr)
Construct a PerceiveData class definition.
Definition: Operation.h:613
void reset() override
Resets the object as it's returned to the pool.
~PerceiveData() override=default
Default destructor.
void free() override
Free an instance of this class, returning it to the memory pool.
bool instanceOf(int classNo) const override
Is this instance of some class?
Character perceives something..
Definition: Operation.h:1423
void free() override
Free an instance of this class, returning it to the memory pool.
PerceptionData(PerceptionData *defaults=nullptr)
Construct a PerceptionData class definition.
Definition: Operation.h:1426
bool instanceOf(int classNo) const override
Is this instance of some class?
~PerceptionData() override=default
Default destructor.
void reset() override
Resets the object as it's returned to the pool.
PerceptionData * copy() const override
Copy this object.
Base operation for all operators.
Definition: RootOperation.h:42
Sets attributes for existing entity..
Definition: Operation.h:228
void free() override
Free an instance of this class, returning it to the memory pool.
void reset() override
Resets the object as it's returned to the pool.
SetData * copy() const override
Copy this object.
SetData(SetData *defaults=nullptr)
Construct a SetData class definition.
Definition: Operation.h:231
bool instanceOf(int classNo) const override
Is this instance of some class?
~SetData() override=default
Default destructor.
Character sees something.
Definition: Operation.h:1537
~SightData() override=default
Default destructor.
SightData * copy() const override
Copy this object.
void free() override
Free an instance of this class, returning it to the memory pool.
SightData(SightData *defaults=nullptr)
Construct a SightData class definition.
Definition: Operation.h:1540
bool instanceOf(int classNo) const override
Is this instance of some class?
void reset() override
Resets the object as it's returned to the pool.
Character smells something.
Definition: Operation.h:1765
SmellData * copy() const override
Copy this object.
bool instanceOf(int classNo) const override
Is this instance of some class?
~SmellData() override=default
Default destructor.
void reset() override
Resets the object as it's returned to the pool.
SmellData(SmellData *defaults=nullptr)
Construct a SmellData class definition.
Definition: Operation.h:1768
void free() override
Free an instance of this class, returning it to the memory pool.
~SniffData() override=default
Default destructor.
bool instanceOf(int classNo) const override
Is this instance of some class?
void free() override
Free an instance of this class, returning it to the memory pool.
SniffData * copy() const override
Copy this object.
void reset() override
Resets the object as it's returned to the pool.
SniffData(SniffData *defaults=nullptr)
Construct a SniffData class definition.
Definition: Operation.h:808
Character hears something.
Definition: Operation.h:1708
void reset() override
Resets the object as it's returned to the pool.
~SoundData() override=default
Default destructor.
bool instanceOf(int classNo) const override
Is this instance of some class?
SoundData * copy() const override
Copy this object.
SoundData(SoundData *defaults=nullptr)
Construct a SoundData class definition.
Definition: Operation.h:1711
void free() override
Free an instance of this class, returning it to the memory pool.
TalkData * copy() const override
Copy this object.
bool instanceOf(int classNo) const override
Is this instance of some class?
void reset() override
Resets the object as it's returned to the pool.
void free() override
Free an instance of this class, returning it to the memory pool.
~TalkData() override=default
Default destructor.
TalkData(TalkData *defaults=nullptr)
Construct a TalkData class definition.
Definition: Operation.h:1109
void reset() override
Resets the object as it's returned to the pool.
void free() override
Free an instance of this class, returning it to the memory pool.
TouchData(TouchData *defaults=nullptr)
Construct a TouchData class definition.
Definition: Operation.h:873
TouchData * copy() const override
Copy this object.
bool instanceOf(int classNo) const override
Is this instance of some class?
~TouchData() override=default
Default destructor.
Character failed to interact with another entity because it does not exist..
Definition: Operation.h:1480
UnseenData * copy() const override
Copy this object.
void free() override
Free an instance of this class, returning it to the memory pool.
void reset() override
Resets the object as it's returned to the pool.
UnseenData(UnseenData *defaults=nullptr)
Construct a UnseenData class definition.
Definition: Operation.h:1483
bool instanceOf(int classNo) const override
Is this instance of some class?
~UnseenData() override=default
Default destructor.
Use a currently wielded tool..
Definition: Operation.h:1236
bool instanceOf(int classNo) const override
Is this instance of some class?
~UseData() override=default
Default destructor.
UseData * copy() const override
Copy this object.
void free() override
Free an instance of this class, returning it to the memory pool.
UseData(UseData *defaults=nullptr)
Construct a UseData class definition.
Definition: Operation.h:1239
void reset() override
Resets the object as it's returned to the pool.
Attach a tool to the character entity at a pre-defined location so that the character can use it....
Definition: Operation.h:480
~WieldData() override=default
Default destructor.
void reset() override
Resets the object as it's returned to the pool.
bool instanceOf(int classNo) const override
Is this instance of some class?
WieldData(WieldData *defaults=nullptr)
Construct a WieldData class definition.
Definition: Operation.h:483
WieldData * copy() const override
Copy this object.
void free() override
Free an instance of this class, returning it to the memory pool.
Definition: Bridge.h:20