Atlas  0.7.0
Networking protocol for the Worldforge system.
RootOperationChildren2.cpp
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 #include <Atlas/Objects/Operation.h>
9 
11 using Atlas::Message::MapType;
12 
13 namespace Atlas { namespace Objects { namespace Operation {
14 
15 Allocator<MoveData> MoveData::allocator;
16 
17 
18 
20 {
21  allocator.free(this);
22 }
23 
24 
25 
27 {
29 }
30 
32 {
33  return copyInstance<MoveData>(*this);
34 }
35 
36 bool MoveData::instanceOf(int classNo) const
37 {
38  if(MOVE_NO == classNo) return true;
39  return SetData::instanceOf(classNo);
40 }
41 
42 void MoveData::fillDefaultObjectInstance(MoveData& data, std::map<std::string, uint32_t>& attr_data)
43 {
44  data.attr_objtype = default_objtype;
45  data.attr_serialno = 0;
46  data.attr_refno = 0;
47  data.attr_seconds = 0.0;
48  data.attr_future_seconds = 0.0;
49  data.attr_stamp = 0.0;
50  data.attr_parent = default_parent;
51 }
52 
53 Allocator<WieldData> WieldData::allocator;
54 
55 
56 
58 {
59  allocator.free(this);
60 }
61 
62 
63 
65 {
67 }
68 
70 {
71  return copyInstance<WieldData>(*this);
72 }
73 
74 bool WieldData::instanceOf(int classNo) const
75 {
76  if(WIELD_NO == classNo) return true;
77  return SetData::instanceOf(classNo);
78 }
79 
80 void WieldData::fillDefaultObjectInstance(WieldData& data, std::map<std::string, uint32_t>& attr_data)
81 {
82  data.attr_objtype = default_objtype;
83  data.attr_serialno = 0;
84  data.attr_refno = 0;
85  data.attr_seconds = 0.0;
86  data.attr_future_seconds = 0.0;
87  data.attr_stamp = 0.0;
88  data.attr_parent = default_parent;
89 }
90 
91 Allocator<GetData> GetData::allocator;
92 
93 
94 
96 {
97  allocator.free(this);
98 }
99 
100 
101 
103 {
105 }
106 
108 {
109  return copyInstance<GetData>(*this);
110 }
111 
112 bool GetData::instanceOf(int classNo) const
113 {
114  if(GET_NO == classNo) return true;
115  return ActionData::instanceOf(classNo);
116 }
117 
118 void GetData::fillDefaultObjectInstance(GetData& data, std::map<std::string, uint32_t>& attr_data)
119 {
120  data.attr_objtype = default_objtype;
121  data.attr_serialno = 0;
122  data.attr_refno = 0;
123  data.attr_seconds = 0.0;
124  data.attr_future_seconds = 0.0;
125  data.attr_stamp = 0.0;
126  data.attr_parent = default_parent;
127 }
128 
129 Allocator<PerceiveData> PerceiveData::allocator;
130 
131 
132 
134 {
135  allocator.free(this);
136 }
137 
138 
139 
141 {
142  GetData::reset();
143 }
144 
146 {
147  return copyInstance<PerceiveData>(*this);
148 }
149 
150 bool PerceiveData::instanceOf(int classNo) const
151 {
152  if(PERCEIVE_NO == classNo) return true;
153  return GetData::instanceOf(classNo);
154 }
155 
156 void PerceiveData::fillDefaultObjectInstance(PerceiveData& data, std::map<std::string, uint32_t>& attr_data)
157 {
158  data.attr_objtype = default_objtype;
159  data.attr_serialno = 0;
160  data.attr_refno = 0;
161  data.attr_seconds = 0.0;
162  data.attr_future_seconds = 0.0;
163  data.attr_stamp = 0.0;
164  data.attr_parent = default_parent;
165 }
166 
167 Allocator<LookData> LookData::allocator;
168 
169 
170 
172 {
173  allocator.free(this);
174 }
175 
176 
177 
179 {
181 }
182 
184 {
185  return copyInstance<LookData>(*this);
186 }
187 
188 bool LookData::instanceOf(int classNo) const
189 {
190  if(LOOK_NO == classNo) return true;
191  return PerceiveData::instanceOf(classNo);
192 }
193 
194 void LookData::fillDefaultObjectInstance(LookData& data, std::map<std::string, uint32_t>& attr_data)
195 {
196  data.attr_objtype = default_objtype;
197  data.attr_serialno = 0;
198  data.attr_refno = 0;
199  data.attr_seconds = 0.0;
200  data.attr_future_seconds = 0.0;
201  data.attr_stamp = 0.0;
202  data.attr_parent = default_parent;
203 }
204 
205 Allocator<ListenData> ListenData::allocator;
206 
207 
208 
210 {
211  allocator.free(this);
212 }
213 
214 
215 
217 {
219 }
220 
222 {
223  return copyInstance<ListenData>(*this);
224 }
225 
226 bool ListenData::instanceOf(int classNo) const
227 {
228  if(LISTEN_NO == classNo) return true;
229  return PerceiveData::instanceOf(classNo);
230 }
231 
232 void ListenData::fillDefaultObjectInstance(ListenData& data, std::map<std::string, uint32_t>& attr_data)
233 {
234  data.attr_objtype = default_objtype;
235  data.attr_serialno = 0;
236  data.attr_refno = 0;
237  data.attr_seconds = 0.0;
238  data.attr_future_seconds = 0.0;
239  data.attr_stamp = 0.0;
240  data.attr_parent = default_parent;
241 }
242 
243 } } } // namespace Atlas::Objects::Operation
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.
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 * copy() const override
Copy this object.
bool instanceOf(int classNo) const override
Is this instance of some class?
ListenData * 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.
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.
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?
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.
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.
bool instanceOf(int classNo) const override
Is this instance of some class?
double attr_future_seconds
Time in seconds to add current time.
std::int64_t attr_refno
Reference to serial number.
std::int64_t attr_serialno
Serial number.
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?
Attach a tool to the character entity at a pre-defined location so that the character can use it....
Definition: Operation.h:480
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 * copy() const override
Copy this object.
void free() override
Free an instance of this class, returning it to the memory pool.
std::string attr_objtype
What kind of object this is.
Definition: Root.h:129
std::string attr_parent
The object this inherits attributes from.
Definition: Root.h:125
double attr_stamp
Last time this object was modified.
Definition: Root.h:127
Definition: Bridge.h:20