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 
15 namespace Atlas { namespace Objects { namespace Operation {
16 
27 class ActionData;
28 typedef SmartPtr<ActionData> Action;
29 
30 static const int ACTION_NO = 10;
31 
34 
41 {
42 protected:
44  explicit ActionData(ActionData *defaults = nullptr) :
46  {
47  m_class_no = ACTION_NO;
48  }
50  ~ActionData() override = default;
51 
52 public:
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 
66 public:
67  template <typename>
68  friend class ::Atlas::Objects::Allocator;
69  static Allocator<ActionData> allocator;
70 
71 protected:
73  void reset() override;
74  void free() override;
75 
76 private:
77 
78  static void fillDefaultObjectInstance(ActionData& data, std::map<std::string, uint32_t>& attr_data);
79 };
80 
81 
88 class CreateData;
90 
91 static const int CREATE_NO = 11;
92 
95 
97 class CreateData : public ActionData
98 {
99 protected:
101  explicit CreateData(CreateData *defaults = nullptr) :
102  ActionData((ActionData*)defaults)
103  {
104  m_class_no = CREATE_NO;
105  }
107  ~CreateData() override = default;
108 
109 public:
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 
123 public:
124  template <typename>
125  friend class ::Atlas::Objects::Allocator;
126  static Allocator<CreateData> allocator;
127 
128 protected:
130  void reset() override;
131  void free() override;
132 
133 private:
134 
135  static void fillDefaultObjectInstance(CreateData& data, std::map<std::string, uint32_t>& attr_data);
136 };
137 
138 
149 class DeleteData;
151 
152 static const int DELETE_NO = 12;
153 
156 
162 class DeleteData : public ActionData
163 {
164 protected:
166  explicit DeleteData(DeleteData *defaults = nullptr) :
167  ActionData((ActionData*)defaults)
168  {
169  m_class_no = DELETE_NO;
170  }
172  ~DeleteData() override = default;
173 
174 public:
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 
188 public:
189  template <typename>
190  friend class ::Atlas::Objects::Allocator;
191  static Allocator<DeleteData> allocator;
192 
193 protected:
195  void reset() override;
196  void free() override;
197 
198 private:
199 
200  static void fillDefaultObjectInstance(DeleteData& data, std::map<std::string, uint32_t>& attr_data);
201 };
202 
203 
214 class SetData;
215 typedef SmartPtr<SetData> Set;
216 
217 static const int SET_NO = 13;
218 
221 
227 class SetData : public ActionData
228 {
229 protected:
231  explicit SetData(SetData *defaults = nullptr) :
232  ActionData((ActionData*)defaults)
233  {
234  m_class_no = SET_NO;
235  }
237  ~SetData() override = default;
238 
239 public:
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 
253 public:
254  template <typename>
255  friend class ::Atlas::Objects::Allocator;
256  static Allocator<SetData> allocator;
257 
258 protected:
260  void reset() override;
261  void free() override;
262 
263 private:
264 
265  static void fillDefaultObjectInstance(SetData& data, std::map<std::string, uint32_t>& attr_data);
266 };
267 
268 
279 class AffectData;
281 
282 static const int AFFECT_NO = 14;
283 
286 
292 class AffectData : public SetData
293 {
294 protected:
296  explicit AffectData(AffectData *defaults = nullptr) :
297  SetData((SetData*)defaults)
298  {
299  m_class_no = AFFECT_NO;
300  }
302  ~AffectData() override = default;
303 
304 public:
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 
318 public:
319  template <typename>
320  friend class ::Atlas::Objects::Allocator;
321  static Allocator<AffectData> allocator;
322 
323 protected:
325  void reset() override;
326  void free() override;
327 
328 private:
329 
330  static void fillDefaultObjectInstance(AffectData& data, std::map<std::string, uint32_t>& attr_data);
331 };
332 
333 
344 class HitData;
345 typedef SmartPtr<HitData> Hit;
346 
347 static const int HIT_NO = 15;
348 
351 
357 class HitData : public AffectData
358 {
359 protected:
361  explicit HitData(HitData *defaults = nullptr) :
362  AffectData((AffectData*)defaults)
363  {
364  m_class_no = HIT_NO;
365  }
367  ~HitData() override = default;
368 
369 public:
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 
383 public:
384  template <typename>
385  friend class ::Atlas::Objects::Allocator;
386  static Allocator<HitData> allocator;
387 
388 protected:
390  void reset() override;
391  void free() override;
392 
393 private:
394 
395  static void fillDefaultObjectInstance(HitData& data, std::map<std::string, uint32_t>& attr_data);
396 };
397 
398 
405 class MoveData;
406 typedef SmartPtr<MoveData> Move;
407 
408 static const int MOVE_NO = 16;
409 
412 
414 class MoveData : public SetData
415 {
416 protected:
418  explicit MoveData(MoveData *defaults = nullptr) :
419  SetData((SetData*)defaults)
420  {
421  m_class_no = MOVE_NO;
422  }
424  ~MoveData() override = default;
425 
426 public:
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 
440 public:
441  template <typename>
442  friend class ::Atlas::Objects::Allocator;
443  static Allocator<MoveData> allocator;
444 
445 protected:
447  void reset() override;
448  void free() override;
449 
450 private:
451 
452  static void fillDefaultObjectInstance(MoveData& data, std::map<std::string, uint32_t>& attr_data);
453 };
454 
455 
466 class WieldData;
467 typedef SmartPtr<WieldData> Wield;
468 
469 static const int WIELD_NO = 17;
470 
473 
479 class WieldData : public SetData
480 {
481 protected:
483  explicit WieldData(WieldData *defaults = nullptr) :
484  SetData((SetData*)defaults)
485  {
486  m_class_no = WIELD_NO;
487  }
489  ~WieldData() override = default;
490 
491 public:
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 
505 public:
506  template <typename>
507  friend class ::Atlas::Objects::Allocator;
508  static Allocator<WieldData> allocator;
509 
510 protected:
512  void reset() override;
513  void free() override;
514 
515 private:
516 
517  static void fillDefaultObjectInstance(WieldData& data, std::map<std::string, uint32_t>& attr_data);
518 };
519 
520 
531 class GetData;
532 typedef SmartPtr<GetData> Get;
533 
534 static const int GET_NO = 18;
535 
538 
544 class GetData : public ActionData
545 {
546 protected:
548  explicit GetData(GetData *defaults = nullptr) :
549  ActionData((ActionData*)defaults)
550  {
551  m_class_no = GET_NO;
552  }
554  ~GetData() override = default;
555 
556 public:
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 
570 public:
571  template <typename>
572  friend class ::Atlas::Objects::Allocator;
573  static Allocator<GetData> allocator;
574 
575 protected:
577  void reset() override;
578  void free() override;
579 
580 private:
581 
582  static void fillDefaultObjectInstance(GetData& data, std::map<std::string, uint32_t>& attr_data);
583 };
584 
585 
596 class PerceiveData;
598 
599 static const int PERCEIVE_NO = 19;
600 
603 
609 class PerceiveData : public GetData
610 {
611 protected:
613  explicit PerceiveData(PerceiveData *defaults = nullptr) :
614  GetData((GetData*)defaults)
615  {
616  m_class_no = PERCEIVE_NO;
617  }
619  ~PerceiveData() override = default;
620 
621 public:
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 
635 public:
636  template <typename>
637  friend class ::Atlas::Objects::Allocator;
638  static Allocator<PerceiveData> allocator;
639 
640 protected:
642  void reset() override;
643  void free() override;
644 
645 private:
646 
647  static void fillDefaultObjectInstance(PerceiveData& data, std::map<std::string, uint32_t>& attr_data);
648 };
649 
650 
661 class LookData;
662 typedef SmartPtr<LookData> Look;
663 
664 static const int LOOK_NO = 20;
665 
668 
674 class LookData : public PerceiveData
675 {
676 protected:
678  explicit LookData(LookData *defaults = nullptr) :
679  PerceiveData((PerceiveData*)defaults)
680  {
681  m_class_no = LOOK_NO;
682  }
684  ~LookData() override = default;
685 
686 public:
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 
700 public:
701  template <typename>
702  friend class ::Atlas::Objects::Allocator;
703  static Allocator<LookData> allocator;
704 
705 protected:
707  void reset() override;
708  void free() override;
709 
710 private:
711 
712  static void fillDefaultObjectInstance(LookData& data, std::map<std::string, uint32_t>& attr_data);
713 };
714 
715 
726 class ListenData;
728 
729 static const int LISTEN_NO = 21;
730 
733 
739 class ListenData : public PerceiveData
740 {
741 protected:
743  explicit ListenData(ListenData *defaults = nullptr) :
744  PerceiveData((PerceiveData*)defaults)
745  {
746  m_class_no = LISTEN_NO;
747  }
749  ~ListenData() override = default;
750 
751 public:
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 
765 public:
766  template <typename>
767  friend class ::Atlas::Objects::Allocator;
768  static Allocator<ListenData> allocator;
769 
770 protected:
772  void reset() override;
773  void free() override;
774 
775 private:
776 
777  static void fillDefaultObjectInstance(ListenData& data, std::map<std::string, uint32_t>& attr_data);
778 };
779 
780 
791 class SniffData;
792 typedef SmartPtr<SniffData> Sniff;
793 
794 static const int SNIFF_NO = 22;
795 
798 
804 class SniffData : public PerceiveData
805 {
806 protected:
808  explicit SniffData(SniffData *defaults = nullptr) :
809  PerceiveData((PerceiveData*)defaults)
810  {
811  m_class_no = SNIFF_NO;
812  }
814  ~SniffData() override = default;
815 
816 public:
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 
830 public:
831  template <typename>
832  friend class ::Atlas::Objects::Allocator;
833  static Allocator<SniffData> allocator;
834 
835 protected:
837  void reset() override;
838  void free() override;
839 
840 private:
841 
842  static void fillDefaultObjectInstance(SniffData& data, std::map<std::string, uint32_t>& attr_data);
843 };
844 
845 
856 class TouchData;
857 typedef SmartPtr<TouchData> Touch;
858 
859 static const int TOUCH_NO = 23;
860 
863 
869 class TouchData : public PerceiveData
870 {
871 protected:
873  explicit TouchData(TouchData *defaults = nullptr) :
874  PerceiveData((PerceiveData*)defaults)
875  {
876  m_class_no = TOUCH_NO;
877  }
879  ~TouchData() override = default;
880 
881 public:
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 
895 public:
896  template <typename>
897  friend class ::Atlas::Objects::Allocator;
898  static Allocator<TouchData> allocator;
899 
900 protected:
902  void reset() override;
903  void free() override;
904 
905 private:
906 
907  static void fillDefaultObjectInstance(TouchData& data, std::map<std::string, uint32_t>& attr_data);
908 };
909 
910 
917 class LoginData;
918 typedef SmartPtr<LoginData> Login;
919 
920 static const int LOGIN_NO = 24;
921 
924 
926 class LoginData : public GetData
927 {
928 protected:
930  explicit LoginData(LoginData *defaults = nullptr) :
931  GetData((GetData*)defaults)
932  {
933  m_class_no = LOGIN_NO;
934  }
936  ~LoginData() override = default;
937 
938 public:
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 
952 public:
953  template <typename>
954  friend class ::Atlas::Objects::Allocator;
955  static Allocator<LoginData> allocator;
956 
957 protected:
959  void reset() override;
960  void free() override;
961 
962 private:
963 
964  static void fillDefaultObjectInstance(LoginData& data, std::map<std::string, uint32_t>& attr_data);
965 };
966 
967 
974 class LogoutData;
976 
977 static const int LOGOUT_NO = 25;
978 
981 
983 class LogoutData : public LoginData
984 {
985 protected:
987  explicit LogoutData(LogoutData *defaults = nullptr) :
988  LoginData((LoginData*)defaults)
989  {
990  m_class_no = LOGOUT_NO;
991  }
993  ~LogoutData() override = default;
994 
995 public:
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 
1009 public:
1010  template <typename>
1011  friend class ::Atlas::Objects::Allocator;
1012  static Allocator<LogoutData> allocator;
1013 
1014 protected:
1016  void reset() override;
1017  void free() override;
1018 
1019 private:
1020 
1021  static void fillDefaultObjectInstance(LogoutData& data, std::map<std::string, uint32_t>& attr_data);
1022 };
1023 
1024 
1035 class CommunicateData;
1037 
1038 static const int COMMUNICATE_NO = 26;
1039 
1042 
1049 {
1050 protected:
1052  explicit CommunicateData(CommunicateData *defaults = nullptr) :
1053  ActionData((ActionData*)defaults)
1054  {
1055  m_class_no = COMMUNICATE_NO;
1056  }
1058  ~CommunicateData() override = default;
1059 
1060 public:
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 
1074 public:
1075  template <typename>
1076  friend class ::Atlas::Objects::Allocator;
1077  static Allocator<CommunicateData> allocator;
1078 
1079 protected:
1081  void reset() override;
1082  void free() override;
1083 
1084 private:
1085 
1086  static void fillDefaultObjectInstance(CommunicateData& data, std::map<std::string, uint32_t>& attr_data);
1087 };
1088 
1089 
1096 class TalkData;
1097 typedef SmartPtr<TalkData> Talk;
1098 
1099 static const int TALK_NO = 27;
1100 
1103 
1106 {
1107 protected:
1109  explicit TalkData(TalkData *defaults = nullptr) :
1110  CommunicateData((CommunicateData*)defaults)
1111  {
1112  m_class_no = TALK_NO;
1113  }
1115  ~TalkData() override = default;
1116 
1117 public:
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 
1131 public:
1132  template <typename>
1133  friend class ::Atlas::Objects::Allocator;
1134  static Allocator<TalkData> allocator;
1135 
1136 protected:
1138  void reset() override;
1139  void free() override;
1140 
1141 private:
1142 
1143  static void fillDefaultObjectInstance(TalkData& data, std::map<std::string, uint32_t>& attr_data);
1144 };
1145 
1146 
1157 class ImaginaryData;
1159 
1160 static const int IMAGINARY_NO = 28;
1161 
1164 
1171 {
1172 protected:
1174  explicit ImaginaryData(ImaginaryData *defaults = nullptr) :
1175  ActionData((ActionData*)defaults)
1176  {
1177  m_class_no = IMAGINARY_NO;
1178  }
1180  ~ImaginaryData() override = default;
1181 
1182 public:
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 
1196 public:
1197  template <typename>
1198  friend class ::Atlas::Objects::Allocator;
1199  static Allocator<ImaginaryData> allocator;
1200 
1201 protected:
1203  void reset() override;
1204  void free() override;
1205 
1206 private:
1207 
1208  static void fillDefaultObjectInstance(ImaginaryData& data, std::map<std::string, uint32_t>& attr_data);
1209 };
1210 
1211 
1222 class UseData;
1223 typedef SmartPtr<UseData> Use;
1224 
1225 static const int USE_NO = 29;
1226 
1229 
1235 class UseData : public ActionData
1236 {
1237 protected:
1239  explicit UseData(UseData *defaults = nullptr) :
1240  ActionData((ActionData*)defaults)
1241  {
1242  m_class_no = USE_NO;
1243  }
1245  ~UseData() override = default;
1246 
1247 public:
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 
1261 public:
1262  template <typename>
1263  friend class ::Atlas::Objects::Allocator;
1264  static Allocator<UseData> allocator;
1265 
1266 protected:
1268  void reset() override;
1269  void free() override;
1270 
1271 private:
1272 
1273  static void fillDefaultObjectInstance(UseData& data, std::map<std::string, uint32_t>& attr_data);
1274 };
1275 
1276 
1287 class ActivityData;
1289 
1290 static const int ACTIVITY_NO = 30;
1291 
1294 
1300 class ActivityData : public ActionData
1301 {
1302 protected:
1304  explicit ActivityData(ActivityData *defaults = nullptr) :
1305  ActionData((ActionData*)defaults)
1306  {
1307  m_class_no = ACTIVITY_NO;
1308  }
1310  ~ActivityData() override = default;
1311 
1312 public:
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 
1326 public:
1327  template <typename>
1328  friend class ::Atlas::Objects::Allocator;
1329  static Allocator<ActivityData> allocator;
1330 
1331 protected:
1333  void reset() override;
1334  void free() override;
1335 
1336 private:
1337 
1338  static void fillDefaultObjectInstance(ActivityData& data, std::map<std::string, uint32_t>& attr_data);
1339 };
1340 
1341 
1352 class InfoData;
1353 typedef SmartPtr<InfoData> Info;
1354 
1355 static const int INFO_NO = 31;
1356 
1359 
1366 {
1367 protected:
1369  explicit InfoData(InfoData *defaults = nullptr) :
1371  {
1372  m_class_no = INFO_NO;
1373  }
1375  ~InfoData() override = default;
1376 
1377 public:
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 
1391 public:
1392  template <typename>
1393  friend class ::Atlas::Objects::Allocator;
1394  static Allocator<InfoData> allocator;
1395 
1396 protected:
1398  void reset() override;
1399  void free() override;
1400 
1401 private:
1402 
1403  static void fillDefaultObjectInstance(InfoData& data, std::map<std::string, uint32_t>& attr_data);
1404 };
1405 
1406 
1413 class PerceptionData;
1415 
1416 static const int PERCEPTION_NO = 32;
1417 
1420 
1422 class PerceptionData : public InfoData
1423 {
1424 protected:
1426  explicit PerceptionData(PerceptionData *defaults = nullptr) :
1427  InfoData((InfoData*)defaults)
1428  {
1429  m_class_no = PERCEPTION_NO;
1430  }
1432  ~PerceptionData() override = default;
1433 
1434 public:
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 
1448 public:
1449  template <typename>
1450  friend class ::Atlas::Objects::Allocator;
1451  static Allocator<PerceptionData> allocator;
1452 
1453 protected:
1455  void reset() override;
1456  void free() override;
1457 
1458 private:
1459 
1460  static void fillDefaultObjectInstance(PerceptionData& data, std::map<std::string, uint32_t>& attr_data);
1461 };
1462 
1463 
1470 class UnseenData;
1472 
1473 static const int UNSEEN_NO = 33;
1474 
1477 
1480 {
1481 protected:
1483  explicit UnseenData(UnseenData *defaults = nullptr) :
1484  PerceptionData((PerceptionData*)defaults)
1485  {
1486  m_class_no = UNSEEN_NO;
1487  }
1489  ~UnseenData() override = default;
1490 
1491 public:
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 
1505 public:
1506  template <typename>
1507  friend class ::Atlas::Objects::Allocator;
1508  static Allocator<UnseenData> allocator;
1509 
1510 protected:
1512  void reset() override;
1513  void free() override;
1514 
1515 private:
1516 
1517  static void fillDefaultObjectInstance(UnseenData& data, std::map<std::string, uint32_t>& attr_data);
1518 };
1519 
1520 
1527 class SightData;
1528 typedef SmartPtr<SightData> Sight;
1529 
1530 static const int SIGHT_NO = 34;
1531 
1534 
1537 {
1538 protected:
1540  explicit SightData(SightData *defaults = nullptr) :
1541  PerceptionData((PerceptionData*)defaults)
1542  {
1543  m_class_no = SIGHT_NO;
1544  }
1546  ~SightData() override = default;
1547 
1548 public:
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 
1562 public:
1563  template <typename>
1564  friend class ::Atlas::Objects::Allocator;
1565  static Allocator<SightData> allocator;
1566 
1567 protected:
1569  void reset() override;
1570  void free() override;
1571 
1572 private:
1573 
1574  static void fillDefaultObjectInstance(SightData& data, std::map<std::string, uint32_t>& attr_data);
1575 };
1576 
1577 
1584 class AppearanceData;
1586 
1587 static const int APPEARANCE_NO = 35;
1588 
1591 
1594 {
1595 protected:
1597  explicit AppearanceData(AppearanceData *defaults = nullptr) :
1598  SightData((SightData*)defaults)
1599  {
1600  m_class_no = APPEARANCE_NO;
1601  }
1603  ~AppearanceData() override = default;
1604 
1605 public:
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 
1619 public:
1620  template <typename>
1621  friend class ::Atlas::Objects::Allocator;
1622  static Allocator<AppearanceData> allocator;
1623 
1624 protected:
1626  void reset() override;
1627  void free() override;
1628 
1629 private:
1630 
1631  static void fillDefaultObjectInstance(AppearanceData& data, std::map<std::string, uint32_t>& attr_data);
1632 };
1633 
1634 
1641 class DisappearanceData;
1643 
1644 static const int DISAPPEARANCE_NO = 36;
1645 
1648 
1651 {
1652 protected:
1654  explicit DisappearanceData(DisappearanceData *defaults = nullptr) :
1655  SightData((SightData*)defaults)
1656  {
1657  m_class_no = DISAPPEARANCE_NO;
1658  }
1660  ~DisappearanceData() override = default;
1661 
1662 public:
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 
1676 public:
1677  template <typename>
1678  friend class ::Atlas::Objects::Allocator;
1679  static Allocator<DisappearanceData> allocator;
1680 
1681 protected:
1683  void reset() override;
1684  void free() override;
1685 
1686 private:
1687 
1688  static void fillDefaultObjectInstance(DisappearanceData& data, std::map<std::string, uint32_t>& attr_data);
1689 };
1690 
1691 
1698 class SoundData;
1699 typedef SmartPtr<SoundData> Sound;
1700 
1701 static const int SOUND_NO = 37;
1702 
1705 
1708 {
1709 protected:
1711  explicit SoundData(SoundData *defaults = nullptr) :
1712  PerceptionData((PerceptionData*)defaults)
1713  {
1714  m_class_no = SOUND_NO;
1715  }
1717  ~SoundData() override = default;
1718 
1719 public:
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 
1733 public:
1734  template <typename>
1735  friend class ::Atlas::Objects::Allocator;
1736  static Allocator<SoundData> allocator;
1737 
1738 protected:
1740  void reset() override;
1741  void free() override;
1742 
1743 private:
1744 
1745  static void fillDefaultObjectInstance(SoundData& data, std::map<std::string, uint32_t>& attr_data);
1746 };
1747 
1748 
1755 class SmellData;
1756 typedef SmartPtr<SmellData> Smell;
1757 
1758 static const int SMELL_NO = 38;
1759 
1762 
1765 {
1766 protected:
1768  explicit SmellData(SmellData *defaults = nullptr) :
1769  PerceptionData((PerceptionData*)defaults)
1770  {
1771  m_class_no = SMELL_NO;
1772  }
1774  ~SmellData() override = default;
1775 
1776 public:
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 
1790 public:
1791  template <typename>
1792  friend class ::Atlas::Objects::Allocator;
1793  static Allocator<SmellData> allocator;
1794 
1795 protected:
1797  void reset() override;
1798  void free() override;
1799 
1800 private:
1801 
1802  static void fillDefaultObjectInstance(SmellData& data, std::map<std::string, uint32_t>& attr_data);
1803 };
1804 
1805 
1812 class FeelData;
1813 typedef SmartPtr<FeelData> Feel;
1814 
1815 static const int FEEL_NO = 39;
1816 
1819 
1821 class FeelData : public PerceptionData
1822 {
1823 protected:
1825  explicit FeelData(FeelData *defaults = nullptr) :
1826  PerceptionData((PerceptionData*)defaults)
1827  {
1828  m_class_no = FEEL_NO;
1829  }
1831  ~FeelData() override = default;
1832 
1833 public:
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 
1847 public:
1848  template <typename>
1849  friend class ::Atlas::Objects::Allocator;
1850  static Allocator<FeelData> allocator;
1851 
1852 protected:
1854  void reset() override;
1855  void free() override;
1856 
1857 private:
1858 
1859  static void fillDefaultObjectInstance(FeelData& data, std::map<std::string, uint32_t>& attr_data);
1860 };
1861 
1862 
1873 class ErrorData;
1874 typedef SmartPtr<ErrorData> Error;
1875 
1876 static const int ERROR_NO = 40;
1877 
1880 
1886 class ErrorData : public InfoData
1887 {
1888 protected:
1890  explicit ErrorData(ErrorData *defaults = nullptr) :
1891  InfoData((InfoData*)defaults)
1892  {
1893  m_class_no = ERROR_NO;
1894  }
1896  ~ErrorData() override = default;
1897 
1898 public:
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 
1912 public:
1913  template <typename>
1914  friend class ::Atlas::Objects::Allocator;
1915  static Allocator<ErrorData> allocator;
1916 
1917 protected:
1919  void reset() override;
1920  void free() override;
1921 
1922 private:
1923 
1924  static void fillDefaultObjectInstance(ErrorData& data, std::map<std::string, uint32_t>& attr_data);
1925 };
1926 
1927 
1938 class ChangeData;
1940 
1941 static const int CHANGE_NO = 41;
1942 
1945 
1951 class ChangeData : public InfoData
1952 {
1953 protected:
1955  explicit ChangeData(ChangeData *defaults = nullptr) :
1956  InfoData((InfoData*)defaults)
1957  {
1958  m_class_no = CHANGE_NO;
1959  }
1961  ~ChangeData() override = default;
1962 
1963 public:
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 
1977 public:
1978  template <typename>
1979  friend class ::Atlas::Objects::Allocator;
1980  static Allocator<ChangeData> allocator;
1981 
1982 protected:
1984  void reset() override;
1985  void free() override;
1986 
1987 private:
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
DisappearanceData(DisappearanceData *defaults=nullptr)
Construct a DisappearanceData class definition.
Definition: Operation.h:1654
PerceptionData(PerceptionData *defaults=nullptr)
Construct a PerceptionData class definition.
Definition: Operation.h:1426
Character sees something appearing: it literally appears or has it come in visible range...
Definition: Operation.h:1593
DeleteData(DeleteData *defaults=nullptr)
Construct a DeleteData class definition.
Definition: Operation.h:166
TouchData(TouchData *defaults=nullptr)
Construct a TouchData class definition.
Definition: Operation.h:873
Character smells something.
Definition: Operation.h:1764
Character hears something.
Definition: Operation.h:1707
ActionData(ActionData *defaults=nullptr)
Construct a ActionData class definition.
Definition: Operation.h:44
ImaginaryData(ImaginaryData *defaults=nullptr)
Construct a ImaginaryData class definition.
Definition: Operation.h:1174
GetData(GetData *defaults=nullptr)
Construct a GetData class definition.
Definition: Operation.h:548
WieldData(WieldData *defaults=nullptr)
Construct a WieldData class definition.
Definition: Operation.h:483
MoveData(MoveData *defaults=nullptr)
Construct a MoveData class definition.
Definition: Operation.h:418
~ActionData() override=default
Default destructor.
Character sees something.
Definition: Operation.h:1536
SightData(SightData *defaults=nullptr)
Construct a SightData class definition.
Definition: Operation.h:1540
TalkData(TalkData *defaults=nullptr)
Construct a TalkData class definition.
Definition: Operation.h:1109
Use a currently wielded tool..
Definition: Operation.h:1235
LoginData(LoginData *defaults=nullptr)
Construct a LoginData class definition.
Definition: Operation.h:930
AffectData(AffectData *defaults=nullptr)
Construct a AffectData class definition.
Definition: Operation.h:296
ActivityData(ActivityData *defaults=nullptr)
Construct a ActivityData class definition.
Definition: Operation.h:1304
SoundData(SoundData *defaults=nullptr)
Construct a SoundData class definition.
Definition: Operation.h:1711
Generic operation for getting info about things..
Definition: Operation.h:544
Sets attributes for existing entity..
Definition: Operation.h:292
Operation for logging into server.
Definition: Operation.h:926
LogoutData(LogoutData *defaults=nullptr)
Construct a LogoutData class definition.
Definition: Operation.h:987
ChangeData(ChangeData *defaults=nullptr)
Construct a ChangeData class definition.
Definition: Operation.h:1955
ActionData * copy() const override
Copy this object.
Generic base operation for perceiving things by eyes, ears, etc....
Definition: Operation.h:609
CreateData(CreateData *defaults=nullptr)
Construct a CreateData class definition.
Definition: Operation.h:101
AppearanceData(AppearanceData *defaults=nullptr)
Construct a AppearanceData class definition.
Definition: Operation.h:1597
Base operation for all operators.
Definition: RootOperation.h:41
CommunicateData(CommunicateData *defaults=nullptr)
Construct a CommunicateData class definition.
Definition: Operation.h:1052
SetData(SetData *defaults=nullptr)
Construct a SetData class definition.
Definition: Operation.h:231
SmellData(SmellData *defaults=nullptr)
Construct a SmellData class definition.
Definition: Operation.h:1768
FeelData(FeelData *defaults=nullptr)
Construct a FeelData class definition.
Definition: Operation.h:1825
void free() override
Free an instance of this class, returning it to the memory pool.
When something is not yet implemented in server, then character can pretend to do something ;-)...
Definition: Operation.h:1170
Activities performed by entities. This is mainly meant for actions that should be communicated to oth...
Definition: Operation.h:1300
Looking at something.
Definition: Operation.h:674
ListenData(ListenData *defaults=nullptr)
Construct a ListenData class definition.
Definition: Operation.h:743
Character perceives something..
Definition: Operation.h:1422
Operation for logging out.
Definition: Operation.h:983
UseData(UseData *defaults=nullptr)
Construct a UseData class definition.
Definition: Operation.h:1239
Sets attributes for existing entity..
Definition: Operation.h:227
PerceiveData(PerceiveData *defaults=nullptr)
Construct a PerceiveData class definition.
Definition: Operation.h:613
Operation for when one entity hits another..
Definition: Operation.h:357
This is base operator for operations that might have effects..
Definition: Operation.h:40
Character feels something (with fingers usually).
Definition: Operation.h:1821
void reset() override
Resets the object as it&#39;s returned to the pool.
An operation used to signal to clients when things such as types have changed..
Definition: Operation.h:1951
HitData(HitData *defaults=nullptr)
Construct a HitData class definition.
Definition: Operation.h:361
InfoData(InfoData *defaults=nullptr)
Construct a InfoData class definition.
Definition: Operation.h:1369
SniffData(SniffData *defaults=nullptr)
Construct a SniffData class definition.
Definition: Operation.h:808
UnseenData(UnseenData *defaults=nullptr)
Construct a UnseenData class definition.
Definition: Operation.h:1483
Base operator for all kind of communication..
Definition: Operation.h:1048
LookData(LookData *defaults=nullptr)
Construct a LookData class definition.
Definition: Operation.h:678
This is base operator for operations that tell you info about objects or events.. ...
Definition: Operation.h:1365
Create new things from nothing using this operator..
Definition: Operation.h:97
Character sees something disappearing: it literally disappears or has it gone too far to be visible...
Definition: Operation.h:1650
bool instanceOf(int classNo) const override
Is this instance of some class?
Character failed to interact with another entity because it does not exist..
Definition: Operation.h:1479
Definition: Bridge.h:20
ErrorData(ErrorData *defaults=nullptr)
Construct a ErrorData class definition.
Definition: Operation.h:1890
Attach a tool to the character entity at a pre-defined location so that the character can use it...
Definition: Operation.h:479