Atlas-C++
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 Erik Ogenvik.
6 // Automatically generated using gen_cpp.py.
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  ActionData(ActionData *defaults = nullptr) :
46  {
47  m_class_no = ACTION_NO;
48  }
50  ~ActionData() override = default;
51 
52 public:
54  ActionData * copy() const override;
55 
57  bool instanceOf(int classNo) const override;
58 
59 
60  void iterate(int& current_class, std::string& attr) const override
61  {if(current_class == ACTION_NO) current_class = -1; RootOperationData::iterate(current_class, attr);}
62 
63 public:
64  template <typename>
65  friend class ::Atlas::Objects::Allocator;
66  static Allocator<ActionData> allocator;
67 
68 protected:
70  void reset() override;
71  void free() override;
72 
73 private:
74 
75  static void fillDefaultObjectInstance(ActionData& data, std::map<std::string, int32_t>& attr_data);
76 };
77 
78 
85 class CreateData;
87 
88 static const int CREATE_NO = 11;
89 
92 
94 class CreateData : public ActionData
95 {
96 protected:
98  CreateData(CreateData *defaults = nullptr) :
99  ActionData((ActionData*)defaults)
100  {
101  m_class_no = CREATE_NO;
102  }
104  ~CreateData() override = default;
105 
106 public:
108  CreateData * copy() const override;
109 
111  bool instanceOf(int classNo) const override;
112 
113 
114  void iterate(int& current_class, std::string& attr) const override
115  {if(current_class == CREATE_NO) current_class = -1; ActionData::iterate(current_class, attr);}
116 
117 public:
118  template <typename>
119  friend class ::Atlas::Objects::Allocator;
120  static Allocator<CreateData> allocator;
121 
122 protected:
124  void reset() override;
125  void free() override;
126 
127 private:
128 
129  static void fillDefaultObjectInstance(CreateData& data, std::map<std::string, int32_t>& attr_data);
130 };
131 
132 
139 class CombineData;
141 
142 static const int COMBINE_NO = 12;
143 
146 
148 class CombineData : public CreateData
149 {
150 protected:
152  CombineData(CombineData *defaults = nullptr) :
153  CreateData((CreateData*)defaults)
154  {
155  m_class_no = COMBINE_NO;
156  }
158  ~CombineData() override = default;
159 
160 public:
162  CombineData * copy() const override;
163 
165  bool instanceOf(int classNo) const override;
166 
167 
168  void iterate(int& current_class, std::string& attr) const override
169  {if(current_class == COMBINE_NO) current_class = -1; CreateData::iterate(current_class, attr);}
170 
171 public:
172  template <typename>
173  friend class ::Atlas::Objects::Allocator;
174  static Allocator<CombineData> allocator;
175 
176 protected:
178  void reset() override;
179  void free() override;
180 
181 private:
182 
183  static void fillDefaultObjectInstance(CombineData& data, std::map<std::string, int32_t>& attr_data);
184 };
185 
186 
193 class DivideData;
195 
196 static const int DIVIDE_NO = 13;
197 
200 
202 class DivideData : public CreateData
203 {
204 protected:
206  DivideData(DivideData *defaults = nullptr) :
207  CreateData((CreateData*)defaults)
208  {
209  m_class_no = DIVIDE_NO;
210  }
212  ~DivideData() override = default;
213 
214 public:
216  DivideData * copy() const override;
217 
219  bool instanceOf(int classNo) const override;
220 
221 
222  void iterate(int& current_class, std::string& attr) const override
223  {if(current_class == DIVIDE_NO) current_class = -1; CreateData::iterate(current_class, attr);}
224 
225 public:
226  template <typename>
227  friend class ::Atlas::Objects::Allocator;
228  static Allocator<DivideData> allocator;
229 
230 protected:
232  void reset() override;
233  void free() override;
234 
235 private:
236 
237  static void fillDefaultObjectInstance(DivideData& data, std::map<std::string, int32_t>& attr_data);
238 };
239 
240 
247 class CommunicateData;
249 
250 static const int COMMUNICATE_NO = 14;
251 
254 
257 {
258 protected:
260  CommunicateData(CommunicateData *defaults = nullptr) :
261  CreateData((CreateData*)defaults)
262  {
263  m_class_no = COMMUNICATE_NO;
264  }
266  ~CommunicateData() override = default;
267 
268 public:
270  CommunicateData * copy() const override;
271 
273  bool instanceOf(int classNo) const override;
274 
275 
276  void iterate(int& current_class, std::string& attr) const override
277  {if(current_class == COMMUNICATE_NO) current_class = -1; CreateData::iterate(current_class, attr);}
278 
279 public:
280  template <typename>
281  friend class ::Atlas::Objects::Allocator;
282  static Allocator<CommunicateData> allocator;
283 
284 protected:
286  void reset() override;
287  void free() override;
288 
289 private:
290 
291  static void fillDefaultObjectInstance(CommunicateData& data, std::map<std::string, int32_t>& attr_data);
292 };
293 
294 
301 class TalkData;
302 typedef SmartPtr<TalkData> Talk;
303 
304 static const int TALK_NO = 15;
305 
308 
310 class TalkData : public CommunicateData
311 {
312 protected:
314  TalkData(TalkData *defaults = nullptr) :
315  CommunicateData((CommunicateData*)defaults)
316  {
317  m_class_no = TALK_NO;
318  }
320  ~TalkData() override = default;
321 
322 public:
324  TalkData * copy() const override;
325 
327  bool instanceOf(int classNo) const override;
328 
329 
330  void iterate(int& current_class, std::string& attr) const override
331  {if(current_class == TALK_NO) current_class = -1; CommunicateData::iterate(current_class, attr);}
332 
333 public:
334  template <typename>
335  friend class ::Atlas::Objects::Allocator;
336  static Allocator<TalkData> allocator;
337 
338 protected:
340  void reset() override;
341  void free() override;
342 
343 private:
344 
345  static void fillDefaultObjectInstance(TalkData& data, std::map<std::string, int32_t>& attr_data);
346 };
347 
348 
359 class DeleteData;
361 
362 static const int DELETE_NO = 16;
363 
366 
372 class DeleteData : public ActionData
373 {
374 protected:
376  DeleteData(DeleteData *defaults = nullptr) :
377  ActionData((ActionData*)defaults)
378  {
379  m_class_no = DELETE_NO;
380  }
382  ~DeleteData() override = default;
383 
384 public:
386  DeleteData * copy() const override;
387 
389  bool instanceOf(int classNo) const override;
390 
391 
392  void iterate(int& current_class, std::string& attr) const override
393  {if(current_class == DELETE_NO) current_class = -1; ActionData::iterate(current_class, attr);}
394 
395 public:
396  template <typename>
397  friend class ::Atlas::Objects::Allocator;
398  static Allocator<DeleteData> allocator;
399 
400 protected:
402  void reset() override;
403  void free() override;
404 
405 private:
406 
407  static void fillDefaultObjectInstance(DeleteData& data, std::map<std::string, int32_t>& attr_data);
408 };
409 
410 
421 class SetData;
422 typedef SmartPtr<SetData> Set;
423 
424 static const int SET_NO = 17;
425 
428 
434 class SetData : public ActionData
435 {
436 protected:
438  SetData(SetData *defaults = nullptr) :
439  ActionData((ActionData*)defaults)
440  {
441  m_class_no = SET_NO;
442  }
444  ~SetData() override = default;
445 
446 public:
448  SetData * copy() const override;
449 
451  bool instanceOf(int classNo) const override;
452 
453 
454  void iterate(int& current_class, std::string& attr) const override
455  {if(current_class == SET_NO) current_class = -1; ActionData::iterate(current_class, attr);}
456 
457 public:
458  template <typename>
459  friend class ::Atlas::Objects::Allocator;
460  static Allocator<SetData> allocator;
461 
462 protected:
464  void reset() override;
465  void free() override;
466 
467 private:
468 
469  static void fillDefaultObjectInstance(SetData& data, std::map<std::string, int32_t>& attr_data);
470 };
471 
472 
483 class AffectData;
485 
486 static const int AFFECT_NO = 18;
487 
490 
496 class AffectData : public SetData
497 {
498 protected:
500  AffectData(AffectData *defaults = nullptr) :
501  SetData((SetData*)defaults)
502  {
503  m_class_no = AFFECT_NO;
504  }
506  ~AffectData() override = default;
507 
508 public:
510  AffectData * copy() const override;
511 
513  bool instanceOf(int classNo) const override;
514 
515 
516  void iterate(int& current_class, std::string& attr) const override
517  {if(current_class == AFFECT_NO) current_class = -1; SetData::iterate(current_class, attr);}
518 
519 public:
520  template <typename>
521  friend class ::Atlas::Objects::Allocator;
522  static Allocator<AffectData> allocator;
523 
524 protected:
526  void reset() override;
527  void free() override;
528 
529 private:
530 
531  static void fillDefaultObjectInstance(AffectData& data, std::map<std::string, int32_t>& attr_data);
532 };
533 
534 
541 class MoveData;
542 typedef SmartPtr<MoveData> Move;
543 
544 static const int MOVE_NO = 19;
545 
548 
550 class MoveData : public SetData
551 {
552 protected:
554  MoveData(MoveData *defaults = nullptr) :
555  SetData((SetData*)defaults)
556  {
557  m_class_no = MOVE_NO;
558  }
560  ~MoveData() override = default;
561 
562 public:
564  MoveData * copy() const override;
565 
567  bool instanceOf(int classNo) const override;
568 
569 
570  void iterate(int& current_class, std::string& attr) const override
571  {if(current_class == MOVE_NO) current_class = -1; SetData::iterate(current_class, attr);}
572 
573 public:
574  template <typename>
575  friend class ::Atlas::Objects::Allocator;
576  static Allocator<MoveData> allocator;
577 
578 protected:
580  void reset() override;
581  void free() override;
582 
583 private:
584 
585  static void fillDefaultObjectInstance(MoveData& data, std::map<std::string, int32_t>& attr_data);
586 };
587 
588 
599 class WieldData;
600 typedef SmartPtr<WieldData> Wield;
601 
602 static const int WIELD_NO = 20;
603 
606 
612 class WieldData : public SetData
613 {
614 protected:
616  WieldData(WieldData *defaults = nullptr) :
617  SetData((SetData*)defaults)
618  {
619  m_class_no = WIELD_NO;
620  }
622  ~WieldData() override = default;
623 
624 public:
626  WieldData * copy() const override;
627 
629  bool instanceOf(int classNo) const override;
630 
631 
632  void iterate(int& current_class, std::string& attr) const override
633  {if(current_class == WIELD_NO) current_class = -1; SetData::iterate(current_class, attr);}
634 
635 public:
636  template <typename>
637  friend class ::Atlas::Objects::Allocator;
638  static Allocator<WieldData> allocator;
639 
640 protected:
642  void reset() override;
643  void free() override;
644 
645 private:
646 
647  static void fillDefaultObjectInstance(WieldData& data, std::map<std::string, int32_t>& attr_data);
648 };
649 
650 
661 class GetData;
662 typedef SmartPtr<GetData> Get;
663 
664 static const int GET_NO = 21;
665 
668 
674 class GetData : public ActionData
675 {
676 protected:
678  GetData(GetData *defaults = nullptr) :
679  ActionData((ActionData*)defaults)
680  {
681  m_class_no = GET_NO;
682  }
684  ~GetData() override = default;
685 
686 public:
688  GetData * copy() const override;
689 
691  bool instanceOf(int classNo) const override;
692 
693 
694  void iterate(int& current_class, std::string& attr) const override
695  {if(current_class == GET_NO) current_class = -1; ActionData::iterate(current_class, attr);}
696 
697 public:
698  template <typename>
699  friend class ::Atlas::Objects::Allocator;
700  static Allocator<GetData> allocator;
701 
702 protected:
704  void reset() override;
705  void free() override;
706 
707 private:
708 
709  static void fillDefaultObjectInstance(GetData& data, std::map<std::string, int32_t>& attr_data);
710 };
711 
712 
723 class PerceiveData;
725 
726 static const int PERCEIVE_NO = 22;
727 
730 
736 class PerceiveData : public GetData
737 {
738 protected:
740  PerceiveData(PerceiveData *defaults = nullptr) :
741  GetData((GetData*)defaults)
742  {
743  m_class_no = PERCEIVE_NO;
744  }
746  ~PerceiveData() override = default;
747 
748 public:
750  PerceiveData * copy() const override;
751 
753  bool instanceOf(int classNo) const override;
754 
755 
756  void iterate(int& current_class, std::string& attr) const override
757  {if(current_class == PERCEIVE_NO) current_class = -1; GetData::iterate(current_class, attr);}
758 
759 public:
760  template <typename>
761  friend class ::Atlas::Objects::Allocator;
762  static Allocator<PerceiveData> allocator;
763 
764 protected:
766  void reset() override;
767  void free() override;
768 
769 private:
770 
771  static void fillDefaultObjectInstance(PerceiveData& data, std::map<std::string, int32_t>& attr_data);
772 };
773 
774 
785 class LookData;
786 typedef SmartPtr<LookData> Look;
787 
788 static const int LOOK_NO = 23;
789 
792 
798 class LookData : public PerceiveData
799 {
800 protected:
802  LookData(LookData *defaults = nullptr) :
803  PerceiveData((PerceiveData*)defaults)
804  {
805  m_class_no = LOOK_NO;
806  }
808  ~LookData() override = default;
809 
810 public:
812  LookData * copy() const override;
813 
815  bool instanceOf(int classNo) const override;
816 
817 
818  void iterate(int& current_class, std::string& attr) const override
819  {if(current_class == LOOK_NO) current_class = -1; PerceiveData::iterate(current_class, attr);}
820 
821 public:
822  template <typename>
823  friend class ::Atlas::Objects::Allocator;
824  static Allocator<LookData> allocator;
825 
826 protected:
828  void reset() override;
829  void free() override;
830 
831 private:
832 
833  static void fillDefaultObjectInstance(LookData& data, std::map<std::string, int32_t>& attr_data);
834 };
835 
836 
847 class ListenData;
849 
850 static const int LISTEN_NO = 24;
851 
854 
860 class ListenData : public PerceiveData
861 {
862 protected:
864  ListenData(ListenData *defaults = nullptr) :
865  PerceiveData((PerceiveData*)defaults)
866  {
867  m_class_no = LISTEN_NO;
868  }
870  ~ListenData() override = default;
871 
872 public:
874  ListenData * copy() const override;
875 
877  bool instanceOf(int classNo) const override;
878 
879 
880  void iterate(int& current_class, std::string& attr) const override
881  {if(current_class == LISTEN_NO) current_class = -1; PerceiveData::iterate(current_class, attr);}
882 
883 public:
884  template <typename>
885  friend class ::Atlas::Objects::Allocator;
886  static Allocator<ListenData> allocator;
887 
888 protected:
890  void reset() override;
891  void free() override;
892 
893 private:
894 
895  static void fillDefaultObjectInstance(ListenData& data, std::map<std::string, int32_t>& attr_data);
896 };
897 
898 
909 class SniffData;
910 typedef SmartPtr<SniffData> Sniff;
911 
912 static const int SNIFF_NO = 25;
913 
916 
922 class SniffData : public PerceiveData
923 {
924 protected:
926  SniffData(SniffData *defaults = nullptr) :
927  PerceiveData((PerceiveData*)defaults)
928  {
929  m_class_no = SNIFF_NO;
930  }
932  ~SniffData() override = default;
933 
934 public:
936  SniffData * copy() const override;
937 
939  bool instanceOf(int classNo) const override;
940 
941 
942  void iterate(int& current_class, std::string& attr) const override
943  {if(current_class == SNIFF_NO) current_class = -1; PerceiveData::iterate(current_class, attr);}
944 
945 public:
946  template <typename>
947  friend class ::Atlas::Objects::Allocator;
948  static Allocator<SniffData> allocator;
949 
950 protected:
952  void reset() override;
953  void free() override;
954 
955 private:
956 
957  static void fillDefaultObjectInstance(SniffData& data, std::map<std::string, int32_t>& attr_data);
958 };
959 
960 
971 class TouchData;
972 typedef SmartPtr<TouchData> Touch;
973 
974 static const int TOUCH_NO = 26;
975 
978 
984 class TouchData : public PerceiveData
985 {
986 protected:
988  TouchData(TouchData *defaults = nullptr) :
989  PerceiveData((PerceiveData*)defaults)
990  {
991  m_class_no = TOUCH_NO;
992  }
994  ~TouchData() override = default;
995 
996 public:
998  TouchData * copy() const override;
999 
1001  bool instanceOf(int classNo) const override;
1002 
1003 
1004  void iterate(int& current_class, std::string& attr) const override
1005  {if(current_class == TOUCH_NO) current_class = -1; PerceiveData::iterate(current_class, attr);}
1006 
1007 public:
1008  template <typename>
1009  friend class ::Atlas::Objects::Allocator;
1010  static Allocator<TouchData> allocator;
1011 
1012 protected:
1014  void reset() override;
1015  void free() override;
1016 
1017 private:
1018 
1019  static void fillDefaultObjectInstance(TouchData& data, std::map<std::string, int32_t>& attr_data);
1020 };
1021 
1022 
1029 class LoginData;
1030 typedef SmartPtr<LoginData> Login;
1031 
1032 static const int LOGIN_NO = 27;
1033 
1036 
1038 class LoginData : public GetData
1039 {
1040 protected:
1042  LoginData(LoginData *defaults = nullptr) :
1043  GetData((GetData*)defaults)
1044  {
1045  m_class_no = LOGIN_NO;
1046  }
1048  ~LoginData() override = default;
1049 
1050 public:
1052  LoginData * copy() const override;
1053 
1055  bool instanceOf(int classNo) const override;
1056 
1057 
1058  void iterate(int& current_class, std::string& attr) const override
1059  {if(current_class == LOGIN_NO) current_class = -1; GetData::iterate(current_class, attr);}
1060 
1061 public:
1062  template <typename>
1063  friend class ::Atlas::Objects::Allocator;
1064  static Allocator<LoginData> allocator;
1065 
1066 protected:
1068  void reset() override;
1069  void free() override;
1070 
1071 private:
1072 
1073  static void fillDefaultObjectInstance(LoginData& data, std::map<std::string, int32_t>& attr_data);
1074 };
1075 
1076 
1083 class LogoutData;
1085 
1086 static const int LOGOUT_NO = 28;
1087 
1090 
1092 class LogoutData : public LoginData
1093 {
1094 protected:
1096  LogoutData(LogoutData *defaults = nullptr) :
1097  LoginData((LoginData*)defaults)
1098  {
1099  m_class_no = LOGOUT_NO;
1100  }
1102  ~LogoutData() override = default;
1103 
1104 public:
1106  LogoutData * copy() const override;
1107 
1109  bool instanceOf(int classNo) const override;
1110 
1111 
1112  void iterate(int& current_class, std::string& attr) const override
1113  {if(current_class == LOGOUT_NO) current_class = -1; LoginData::iterate(current_class, attr);}
1114 
1115 public:
1116  template <typename>
1117  friend class ::Atlas::Objects::Allocator;
1118  static Allocator<LogoutData> allocator;
1119 
1120 protected:
1122  void reset() override;
1123  void free() override;
1124 
1125 private:
1126 
1127  static void fillDefaultObjectInstance(LogoutData& data, std::map<std::string, int32_t>& attr_data);
1128 };
1129 
1130 
1141 class ImaginaryData;
1143 
1144 static const int IMAGINARY_NO = 29;
1145 
1148 
1155 {
1156 protected:
1158  ImaginaryData(ImaginaryData *defaults = nullptr) :
1159  ActionData((ActionData*)defaults)
1160  {
1161  m_class_no = IMAGINARY_NO;
1162  }
1164  ~ImaginaryData() override = default;
1165 
1166 public:
1168  ImaginaryData * copy() const override;
1169 
1171  bool instanceOf(int classNo) const override;
1172 
1173 
1174  void iterate(int& current_class, std::string& attr) const override
1175  {if(current_class == IMAGINARY_NO) current_class = -1; ActionData::iterate(current_class, attr);}
1176 
1177 public:
1178  template <typename>
1179  friend class ::Atlas::Objects::Allocator;
1180  static Allocator<ImaginaryData> allocator;
1181 
1182 protected:
1184  void reset() override;
1185  void free() override;
1186 
1187 private:
1188 
1189  static void fillDefaultObjectInstance(ImaginaryData& data, std::map<std::string, int32_t>& attr_data);
1190 };
1191 
1192 
1203 class UseData;
1204 typedef SmartPtr<UseData> Use;
1205 
1206 static const int USE_NO = 30;
1207 
1210 
1216 class UseData : public ActionData
1217 {
1218 protected:
1220  UseData(UseData *defaults = nullptr) :
1221  ActionData((ActionData*)defaults)
1222  {
1223  m_class_no = USE_NO;
1224  }
1226  ~UseData() override = default;
1227 
1228 public:
1230  UseData * copy() const override;
1231 
1233  bool instanceOf(int classNo) const override;
1234 
1235 
1236  void iterate(int& current_class, std::string& attr) const override
1237  {if(current_class == USE_NO) current_class = -1; ActionData::iterate(current_class, attr);}
1238 
1239 public:
1240  template <typename>
1241  friend class ::Atlas::Objects::Allocator;
1242  static Allocator<UseData> allocator;
1243 
1244 protected:
1246  void reset() override;
1247  void free() override;
1248 
1249 private:
1250 
1251  static void fillDefaultObjectInstance(UseData& data, std::map<std::string, int32_t>& attr_data);
1252 };
1253 
1254 
1265 class InfoData;
1266 typedef SmartPtr<InfoData> Info;
1267 
1268 static const int INFO_NO = 31;
1269 
1272 
1279 {
1280 protected:
1282  InfoData(InfoData *defaults = nullptr) :
1284  {
1285  m_class_no = INFO_NO;
1286  }
1288  ~InfoData() override = default;
1289 
1290 public:
1292  InfoData * copy() const override;
1293 
1295  bool instanceOf(int classNo) const override;
1296 
1297 
1298  void iterate(int& current_class, std::string& attr) const override
1299  {if(current_class == INFO_NO) current_class = -1; RootOperationData::iterate(current_class, attr);}
1300 
1301 public:
1302  template <typename>
1303  friend class ::Atlas::Objects::Allocator;
1304  static Allocator<InfoData> allocator;
1305 
1306 protected:
1308  void reset() override;
1309  void free() override;
1310 
1311 private:
1312 
1313  static void fillDefaultObjectInstance(InfoData& data, std::map<std::string, int32_t>& attr_data);
1314 };
1315 
1316 
1323 class PerceptionData;
1325 
1326 static const int PERCEPTION_NO = 32;
1327 
1330 
1332 class PerceptionData : public InfoData
1333 {
1334 protected:
1336  PerceptionData(PerceptionData *defaults = nullptr) :
1337  InfoData((InfoData*)defaults)
1338  {
1339  m_class_no = PERCEPTION_NO;
1340  }
1342  ~PerceptionData() override = default;
1343 
1344 public:
1346  PerceptionData * copy() const override;
1347 
1349  bool instanceOf(int classNo) const override;
1350 
1351 
1352  void iterate(int& current_class, std::string& attr) const override
1353  {if(current_class == PERCEPTION_NO) current_class = -1; InfoData::iterate(current_class, attr);}
1354 
1355 public:
1356  template <typename>
1357  friend class ::Atlas::Objects::Allocator;
1358  static Allocator<PerceptionData> allocator;
1359 
1360 protected:
1362  void reset() override;
1363  void free() override;
1364 
1365 private:
1366 
1367  static void fillDefaultObjectInstance(PerceptionData& data, std::map<std::string, int32_t>& attr_data);
1368 };
1369 
1370 
1377 class SightData;
1378 typedef SmartPtr<SightData> Sight;
1379 
1380 static const int SIGHT_NO = 33;
1381 
1384 
1387 {
1388 protected:
1390  SightData(SightData *defaults = nullptr) :
1391  PerceptionData((PerceptionData*)defaults)
1392  {
1393  m_class_no = SIGHT_NO;
1394  }
1396  ~SightData() override = default;
1397 
1398 public:
1400  SightData * copy() const override;
1401 
1403  bool instanceOf(int classNo) const override;
1404 
1405 
1406  void iterate(int& current_class, std::string& attr) const override
1407  {if(current_class == SIGHT_NO) current_class = -1; PerceptionData::iterate(current_class, attr);}
1408 
1409 public:
1410  template <typename>
1411  friend class ::Atlas::Objects::Allocator;
1412  static Allocator<SightData> allocator;
1413 
1414 protected:
1416  void reset() override;
1417  void free() override;
1418 
1419 private:
1420 
1421  static void fillDefaultObjectInstance(SightData& data, std::map<std::string, int32_t>& attr_data);
1422 };
1423 
1424 
1431 class AppearanceData;
1433 
1434 static const int APPEARANCE_NO = 34;
1435 
1438 
1441 {
1442 protected:
1444  AppearanceData(AppearanceData *defaults = nullptr) :
1445  SightData((SightData*)defaults)
1446  {
1447  m_class_no = APPEARANCE_NO;
1448  }
1450  ~AppearanceData() override = default;
1451 
1452 public:
1454  AppearanceData * copy() const override;
1455 
1457  bool instanceOf(int classNo) const override;
1458 
1459 
1460  void iterate(int& current_class, std::string& attr) const override
1461  {if(current_class == APPEARANCE_NO) current_class = -1; SightData::iterate(current_class, attr);}
1462 
1463 public:
1464  template <typename>
1465  friend class ::Atlas::Objects::Allocator;
1466  static Allocator<AppearanceData> allocator;
1467 
1468 protected:
1470  void reset() override;
1471  void free() override;
1472 
1473 private:
1474 
1475  static void fillDefaultObjectInstance(AppearanceData& data, std::map<std::string, int32_t>& attr_data);
1476 };
1477 
1478 
1485 class DisappearanceData;
1487 
1488 static const int DISAPPEARANCE_NO = 35;
1489 
1492 
1495 {
1496 protected:
1498  DisappearanceData(DisappearanceData *defaults = nullptr) :
1499  SightData((SightData*)defaults)
1500  {
1501  m_class_no = DISAPPEARANCE_NO;
1502  }
1504  ~DisappearanceData() override = default;
1505 
1506 public:
1508  DisappearanceData * copy() const override;
1509 
1511  bool instanceOf(int classNo) const override;
1512 
1513 
1514  void iterate(int& current_class, std::string& attr) const override
1515  {if(current_class == DISAPPEARANCE_NO) current_class = -1; SightData::iterate(current_class, attr);}
1516 
1517 public:
1518  template <typename>
1519  friend class ::Atlas::Objects::Allocator;
1520  static Allocator<DisappearanceData> allocator;
1521 
1522 protected:
1524  void reset() override;
1525  void free() override;
1526 
1527 private:
1528 
1529  static void fillDefaultObjectInstance(DisappearanceData& data, std::map<std::string, int32_t>& attr_data);
1530 };
1531 
1532 
1539 class SoundData;
1540 typedef SmartPtr<SoundData> Sound;
1541 
1542 static const int SOUND_NO = 36;
1543 
1546 
1549 {
1550 protected:
1552  SoundData(SoundData *defaults = nullptr) :
1553  PerceptionData((PerceptionData*)defaults)
1554  {
1555  m_class_no = SOUND_NO;
1556  }
1558  ~SoundData() override = default;
1559 
1560 public:
1562  SoundData * copy() const override;
1563 
1565  bool instanceOf(int classNo) const override;
1566 
1567 
1568  void iterate(int& current_class, std::string& attr) const override
1569  {if(current_class == SOUND_NO) current_class = -1; PerceptionData::iterate(current_class, attr);}
1570 
1571 public:
1572  template <typename>
1573  friend class ::Atlas::Objects::Allocator;
1574  static Allocator<SoundData> allocator;
1575 
1576 protected:
1578  void reset() override;
1579  void free() override;
1580 
1581 private:
1582 
1583  static void fillDefaultObjectInstance(SoundData& data, std::map<std::string, int32_t>& attr_data);
1584 };
1585 
1586 
1593 class SmellData;
1594 typedef SmartPtr<SmellData> Smell;
1595 
1596 static const int SMELL_NO = 37;
1597 
1600 
1603 {
1604 protected:
1606  SmellData(SmellData *defaults = nullptr) :
1607  PerceptionData((PerceptionData*)defaults)
1608  {
1609  m_class_no = SMELL_NO;
1610  }
1612  ~SmellData() override = default;
1613 
1614 public:
1616  SmellData * copy() const override;
1617 
1619  bool instanceOf(int classNo) const override;
1620 
1621 
1622  void iterate(int& current_class, std::string& attr) const override
1623  {if(current_class == SMELL_NO) current_class = -1; PerceptionData::iterate(current_class, attr);}
1624 
1625 public:
1626  template <typename>
1627  friend class ::Atlas::Objects::Allocator;
1628  static Allocator<SmellData> allocator;
1629 
1630 protected:
1632  void reset() override;
1633  void free() override;
1634 
1635 private:
1636 
1637  static void fillDefaultObjectInstance(SmellData& data, std::map<std::string, int32_t>& attr_data);
1638 };
1639 
1640 
1647 class FeelData;
1648 typedef SmartPtr<FeelData> Feel;
1649 
1650 static const int FEEL_NO = 38;
1651 
1654 
1656 class FeelData : public PerceptionData
1657 {
1658 protected:
1660  FeelData(FeelData *defaults = nullptr) :
1661  PerceptionData((PerceptionData*)defaults)
1662  {
1663  m_class_no = FEEL_NO;
1664  }
1666  ~FeelData() override = default;
1667 
1668 public:
1670  FeelData * copy() const override;
1671 
1673  bool instanceOf(int classNo) const override;
1674 
1675 
1676  void iterate(int& current_class, std::string& attr) const override
1677  {if(current_class == FEEL_NO) current_class = -1; PerceptionData::iterate(current_class, attr);}
1678 
1679 public:
1680  template <typename>
1681  friend class ::Atlas::Objects::Allocator;
1682  static Allocator<FeelData> allocator;
1683 
1684 protected:
1686  void reset() override;
1687  void free() override;
1688 
1689 private:
1690 
1691  static void fillDefaultObjectInstance(FeelData& data, std::map<std::string, int32_t>& attr_data);
1692 };
1693 
1694 
1705 class ErrorData;
1706 typedef SmartPtr<ErrorData> Error;
1707 
1708 static const int ERROR_NO = 39;
1709 
1712 
1718 class ErrorData : public InfoData
1719 {
1720 protected:
1722  ErrorData(ErrorData *defaults = nullptr) :
1723  InfoData((InfoData*)defaults)
1724  {
1725  m_class_no = ERROR_NO;
1726  }
1728  ~ErrorData() override = default;
1729 
1730 public:
1732  ErrorData * copy() const override;
1733 
1735  bool instanceOf(int classNo) const override;
1736 
1737 
1738  void iterate(int& current_class, std::string& attr) const override
1739  {if(current_class == ERROR_NO) current_class = -1; InfoData::iterate(current_class, attr);}
1740 
1741 public:
1742  template <typename>
1743  friend class ::Atlas::Objects::Allocator;
1744  static Allocator<ErrorData> allocator;
1745 
1746 protected:
1748  void reset() override;
1749  void free() override;
1750 
1751 private:
1752 
1753  static void fillDefaultObjectInstance(ErrorData& data, std::map<std::string, int32_t>& attr_data);
1754 };
1755 
1756 } } } // namespace Atlas::Objects::Operation
1757 
1758 #endif // ATLAS_OBJECTS_OPERATION_OPERATION_H
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:392
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:168
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:632
DivideData(DivideData *defaults=nullptr)
Construct a DivideData class definition.
Definition: Operation.h:206
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:818
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:1406
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:60
Base operation for all operators.
Definition: RootOperation.h:41
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:570
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:1236
Something went wrong.
Definition: Operation.h:1718
Operation for logging into server.
Definition: Operation.h:1038
PerceptionData(PerceptionData *defaults=nullptr)
Construct a PerceptionData class definition.
Definition: Operation.h:1336
ActionData * copy() const override
Copy this object.
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:1676
Character smells something.
Definition: Operation.h:1602
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:454
Use a currently wielded tool.
Definition: Operation.h:1216
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:942
AffectData(AffectData *defaults=nullptr)
Construct a AffectData class definition.
Definition: Operation.h:500
LookData(LookData *defaults=nullptr)
Construct a LookData class definition.
Definition: Operation.h:802
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:222
WieldData(WieldData *defaults=nullptr)
Construct a WieldData class definition.
Definition: Operation.h:616
TalkData(TalkData *defaults=nullptr)
Construct a TalkData class definition.
Definition: Operation.h:314
bool instanceOf(int classNo) const override
Is this instance of some class?
This is base operator for operations that might have effects.
Definition: Operation.h:40
CombineData(CombineData *defaults=nullptr)
Construct a CombineData class definition.
Definition: Operation.h:152
Sets attributes for existing entity.
Definition: Operation.h:496
Character hears something.
Definition: Operation.h:1548
used for talking.
Definition: Operation.h:310
LogoutData(LogoutData *defaults=nullptr)
Construct a LogoutData class definition.
Definition: Operation.h:1096
The Atlas namespace.
Definition: Bridge.h:20
ActionData(ActionData *defaults=nullptr)
Construct a ActionData class definition.
Definition: Operation.h:44
CreateData(CreateData *defaults=nullptr)
Construct a CreateData class definition.
Definition: Operation.h:98
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:1352
Sniff something.
Definition: Operation.h:922
Create new things from nothing using this operator.
Definition: Operation.h:94
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:516
SightData(SightData *defaults=nullptr)
Construct a SightData class definition.
Definition: Operation.h:1390
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
LoginData(LoginData *defaults=nullptr)
Construct a LoginData class definition.
Definition: Operation.h:1042
SetData(SetData *defaults=nullptr)
Construct a SetData class definition.
Definition: Operation.h:438
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:1460
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:694
Character sees something disappearing: it literally disappears or has it gone too far to be visible...
Definition: Operation.h:1494
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:1622
ListenData(ListenData *defaults=nullptr)
Construct a ListenData class definition.
Definition: Operation.h:864
Operation for logging out.
Definition: Operation.h:1092
Generic base operation for perceiving things by eyes, ears, etc....
Definition: Operation.h:736
PerceiveData(PerceiveData *defaults=nullptr)
Construct a PerceiveData class definition.
Definition: Operation.h:740
SoundData(SoundData *defaults=nullptr)
Construct a SoundData class definition.
Definition: Operation.h:1552
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:114
GetData(GetData *defaults=nullptr)
Construct a GetData class definition.
Definition: Operation.h:678
ImaginaryData(ImaginaryData *defaults=nullptr)
Construct a ImaginaryData class definition.
Definition: Operation.h:1158
Looking at something.
Definition: Operation.h:798
Listen (something).
Definition: Operation.h:860
Character feels something (with fingers usually).
Definition: Operation.h:1656
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:1514
Character sees something appearing: it literally appears or has it come in visible range...
Definition: Operation.h:1440
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:1112
CommunicateData(CommunicateData *defaults=nullptr)
Construct a CommunicateData class definition.
Definition: Operation.h:260
Character perceives something.
Definition: Operation.h:1332
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:880
~ActionData() override=default
Default destructor.
When something is not yet implemented in server, then character can pretend to do something ;-)...
Definition: Operation.h:1154
SmellData(SmellData *defaults=nullptr)
Construct a SmellData class definition.
Definition: Operation.h:1606
Base operator for all kind of communication.
Definition: Operation.h:256
Touch something.
Definition: Operation.h:984
FeelData(FeelData *defaults=nullptr)
Construct a FeelData class definition.
Definition: Operation.h:1660
DeleteData(DeleteData *defaults=nullptr)
Construct a DeleteData class definition.
Definition: Operation.h:376
Definition: Decoder.h:16
Delete something.
Definition: Operation.h:372
Generic operation for getting info about things.
Definition: Operation.h:674
Trait which handles allocation of instances of BaseObject.
Definition: BaseObject.h:63
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:1568
Combine existing objects into new objects.
Definition: Operation.h:148
MoveData(MoveData *defaults=nullptr)
Construct a MoveData class definition.
Definition: Operation.h:554
Character sees something.
Definition: Operation.h:1386
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:756
InfoData(InfoData *defaults=nullptr)
Construct a InfoData class definition.
Definition: Operation.h:1282
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:330
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:988
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:276
This is base operator for operations that tell you info about objects or events.
Definition: Operation.h:1278
Change position.
Definition: Operation.h:550
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:1004
void reset() override
Resets the object as it&#39;s returned to the pool.
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:1058
ErrorData(ErrorData *defaults=nullptr)
Construct a ErrorData class definition.
Definition: Operation.h:1722
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:1298
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:1738
Divide existing object into pieces.
Definition: Operation.h:202
SniffData(SniffData *defaults=nullptr)
Construct a SniffData class definition.
Definition: Operation.h:926
void iterate(int &current_class, std::string &attr) const override
Iterate over the attributes of this instance.
Definition: Operation.h:1174
Sets attributes for existing entity.
Definition: Operation.h:434
Attach a tool to the character entity at a pre-defined location so that the character can use it...
Definition: Operation.h:612
AppearanceData(AppearanceData *defaults=nullptr)
Construct a AppearanceData class definition.
Definition: Operation.h:1444
UseData(UseData *defaults=nullptr)
Construct a UseData class definition.
Definition: Operation.h:1220
DisappearanceData(DisappearanceData *defaults=nullptr)
Construct a DisappearanceData class definition.
Definition: Operation.h:1498

Copyright 2000-2004 the respective authors.

This document can be licensed under the terms of the GNU Free Documentation License or the GNU General Public License and may be freely distributed under the terms given by one of these licenses.