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 // Automatically generated using gen_cpp.py.
6 
7 #include <Atlas/Objects/Operation.h>
8 
9 using Atlas::Message::Element;
10 using Atlas::Message::MapType;
11 
12 namespace Atlas { namespace Objects { namespace Operation {
13 
~DeleteData()14 DeleteData::~DeleteData()
15 {
16 }
17 
copy() const18 DeleteData * DeleteData::copy() const
19 {
20     DeleteData * copied = DeleteData::alloc();
21     *copied = *this;
22     copied->m_refCount = 0;
23     return copied;
24 }
25 
instanceOf(int classNo) const26 bool DeleteData::instanceOf(int classNo) const
27 {
28     if(DELETE_NO == classNo) return true;
29     return ActionData::instanceOf(classNo);
30 }
31 
32 //freelist related methods specific to this class
33 DeleteData *DeleteData::defaults_DeleteData = 0;
34 DeleteData *DeleteData::begin_DeleteData = 0;
35 
alloc()36 DeleteData *DeleteData::alloc()
37 {
38     if(begin_DeleteData) {
39         DeleteData *res = begin_DeleteData;
40         assert( res->m_refCount == 0 );
41         res->m_attrFlags = 0;
42         res->m_attributes.clear();
43         begin_DeleteData = (DeleteData *)begin_DeleteData->m_next;
44         return res;
45     }
46     return new DeleteData(DeleteData::getDefaultObjectInstance());
47 }
48 
free()49 void DeleteData::free()
50 {
51     m_next = begin_DeleteData;
52     begin_DeleteData = this;
53 }
54 
55 
getDefaultObjectInstance()56 DeleteData *DeleteData::getDefaultObjectInstance()
57 {
58     if (defaults_DeleteData == 0) {
59         defaults_DeleteData = new DeleteData;
60         defaults_DeleteData->attr_objtype = "op";
61         defaults_DeleteData->attr_serialno = 0;
62         defaults_DeleteData->attr_refno = 0;
63         defaults_DeleteData->attr_seconds = 0.0;
64         defaults_DeleteData->attr_future_seconds = 0.0;
65         defaults_DeleteData->attr_stamp = 0.0;
66         defaults_DeleteData->attr_parents = std::list<std::string>(1, "delete");
67         ActionData::getDefaultObjectInstance();
68     }
69     return defaults_DeleteData;
70 }
71 
getDefaultObject()72 DeleteData *DeleteData::getDefaultObject()
73 {
74     return DeleteData::getDefaultObjectInstance();
75 }
76 
~SetData()77 SetData::~SetData()
78 {
79 }
80 
copy() const81 SetData * SetData::copy() const
82 {
83     SetData * copied = SetData::alloc();
84     *copied = *this;
85     copied->m_refCount = 0;
86     return copied;
87 }
88 
instanceOf(int classNo) const89 bool SetData::instanceOf(int classNo) const
90 {
91     if(SET_NO == classNo) return true;
92     return ActionData::instanceOf(classNo);
93 }
94 
95 //freelist related methods specific to this class
96 SetData *SetData::defaults_SetData = 0;
97 SetData *SetData::begin_SetData = 0;
98 
alloc()99 SetData *SetData::alloc()
100 {
101     if(begin_SetData) {
102         SetData *res = begin_SetData;
103         assert( res->m_refCount == 0 );
104         res->m_attrFlags = 0;
105         res->m_attributes.clear();
106         begin_SetData = (SetData *)begin_SetData->m_next;
107         return res;
108     }
109     return new SetData(SetData::getDefaultObjectInstance());
110 }
111 
free()112 void SetData::free()
113 {
114     m_next = begin_SetData;
115     begin_SetData = this;
116 }
117 
118 
getDefaultObjectInstance()119 SetData *SetData::getDefaultObjectInstance()
120 {
121     if (defaults_SetData == 0) {
122         defaults_SetData = new SetData;
123         defaults_SetData->attr_objtype = "op";
124         defaults_SetData->attr_serialno = 0;
125         defaults_SetData->attr_refno = 0;
126         defaults_SetData->attr_seconds = 0.0;
127         defaults_SetData->attr_future_seconds = 0.0;
128         defaults_SetData->attr_stamp = 0.0;
129         defaults_SetData->attr_parents = std::list<std::string>(1, "set");
130         ActionData::getDefaultObjectInstance();
131     }
132     return defaults_SetData;
133 }
134 
getDefaultObject()135 SetData *SetData::getDefaultObject()
136 {
137     return SetData::getDefaultObjectInstance();
138 }
139 
~AffectData()140 AffectData::~AffectData()
141 {
142 }
143 
copy() const144 AffectData * AffectData::copy() const
145 {
146     AffectData * copied = AffectData::alloc();
147     *copied = *this;
148     copied->m_refCount = 0;
149     return copied;
150 }
151 
instanceOf(int classNo) const152 bool AffectData::instanceOf(int classNo) const
153 {
154     if(AFFECT_NO == classNo) return true;
155     return SetData::instanceOf(classNo);
156 }
157 
158 //freelist related methods specific to this class
159 AffectData *AffectData::defaults_AffectData = 0;
160 AffectData *AffectData::begin_AffectData = 0;
161 
alloc()162 AffectData *AffectData::alloc()
163 {
164     if(begin_AffectData) {
165         AffectData *res = begin_AffectData;
166         assert( res->m_refCount == 0 );
167         res->m_attrFlags = 0;
168         res->m_attributes.clear();
169         begin_AffectData = (AffectData *)begin_AffectData->m_next;
170         return res;
171     }
172     return new AffectData(AffectData::getDefaultObjectInstance());
173 }
174 
free()175 void AffectData::free()
176 {
177     m_next = begin_AffectData;
178     begin_AffectData = this;
179 }
180 
181 
getDefaultObjectInstance()182 AffectData *AffectData::getDefaultObjectInstance()
183 {
184     if (defaults_AffectData == 0) {
185         defaults_AffectData = new AffectData;
186         defaults_AffectData->attr_objtype = "op";
187         defaults_AffectData->attr_serialno = 0;
188         defaults_AffectData->attr_refno = 0;
189         defaults_AffectData->attr_seconds = 0.0;
190         defaults_AffectData->attr_future_seconds = 0.0;
191         defaults_AffectData->attr_stamp = 0.0;
192         defaults_AffectData->attr_parents = std::list<std::string>(1, "affect");
193         SetData::getDefaultObjectInstance();
194     }
195     return defaults_AffectData;
196 }
197 
getDefaultObject()198 AffectData *AffectData::getDefaultObject()
199 {
200     return AffectData::getDefaultObjectInstance();
201 }
202 
~MoveData()203 MoveData::~MoveData()
204 {
205 }
206 
copy() const207 MoveData * MoveData::copy() const
208 {
209     MoveData * copied = MoveData::alloc();
210     *copied = *this;
211     copied->m_refCount = 0;
212     return copied;
213 }
214 
instanceOf(int classNo) const215 bool MoveData::instanceOf(int classNo) const
216 {
217     if(MOVE_NO == classNo) return true;
218     return SetData::instanceOf(classNo);
219 }
220 
221 //freelist related methods specific to this class
222 MoveData *MoveData::defaults_MoveData = 0;
223 MoveData *MoveData::begin_MoveData = 0;
224 
alloc()225 MoveData *MoveData::alloc()
226 {
227     if(begin_MoveData) {
228         MoveData *res = begin_MoveData;
229         assert( res->m_refCount == 0 );
230         res->m_attrFlags = 0;
231         res->m_attributes.clear();
232         begin_MoveData = (MoveData *)begin_MoveData->m_next;
233         return res;
234     }
235     return new MoveData(MoveData::getDefaultObjectInstance());
236 }
237 
free()238 void MoveData::free()
239 {
240     m_next = begin_MoveData;
241     begin_MoveData = this;
242 }
243 
244 
getDefaultObjectInstance()245 MoveData *MoveData::getDefaultObjectInstance()
246 {
247     if (defaults_MoveData == 0) {
248         defaults_MoveData = new MoveData;
249         defaults_MoveData->attr_objtype = "op";
250         defaults_MoveData->attr_serialno = 0;
251         defaults_MoveData->attr_refno = 0;
252         defaults_MoveData->attr_seconds = 0.0;
253         defaults_MoveData->attr_future_seconds = 0.0;
254         defaults_MoveData->attr_stamp = 0.0;
255         defaults_MoveData->attr_parents = std::list<std::string>(1, "move");
256         SetData::getDefaultObjectInstance();
257     }
258     return defaults_MoveData;
259 }
260 
getDefaultObject()261 MoveData *MoveData::getDefaultObject()
262 {
263     return MoveData::getDefaultObjectInstance();
264 }
265 
~WieldData()266 WieldData::~WieldData()
267 {
268 }
269 
copy() const270 WieldData * WieldData::copy() const
271 {
272     WieldData * copied = WieldData::alloc();
273     *copied = *this;
274     copied->m_refCount = 0;
275     return copied;
276 }
277 
instanceOf(int classNo) const278 bool WieldData::instanceOf(int classNo) const
279 {
280     if(WIELD_NO == classNo) return true;
281     return SetData::instanceOf(classNo);
282 }
283 
284 //freelist related methods specific to this class
285 WieldData *WieldData::defaults_WieldData = 0;
286 WieldData *WieldData::begin_WieldData = 0;
287 
alloc()288 WieldData *WieldData::alloc()
289 {
290     if(begin_WieldData) {
291         WieldData *res = begin_WieldData;
292         assert( res->m_refCount == 0 );
293         res->m_attrFlags = 0;
294         res->m_attributes.clear();
295         begin_WieldData = (WieldData *)begin_WieldData->m_next;
296         return res;
297     }
298     return new WieldData(WieldData::getDefaultObjectInstance());
299 }
300 
free()301 void WieldData::free()
302 {
303     m_next = begin_WieldData;
304     begin_WieldData = this;
305 }
306 
307 
getDefaultObjectInstance()308 WieldData *WieldData::getDefaultObjectInstance()
309 {
310     if (defaults_WieldData == 0) {
311         defaults_WieldData = new WieldData;
312         defaults_WieldData->attr_objtype = "op";
313         defaults_WieldData->attr_serialno = 0;
314         defaults_WieldData->attr_refno = 0;
315         defaults_WieldData->attr_seconds = 0.0;
316         defaults_WieldData->attr_future_seconds = 0.0;
317         defaults_WieldData->attr_stamp = 0.0;
318         defaults_WieldData->attr_parents = std::list<std::string>(1, "wield");
319         SetData::getDefaultObjectInstance();
320     }
321     return defaults_WieldData;
322 }
323 
getDefaultObject()324 WieldData *WieldData::getDefaultObject()
325 {
326     return WieldData::getDefaultObjectInstance();
327 }
328 
~GetData()329 GetData::~GetData()
330 {
331 }
332 
copy() const333 GetData * GetData::copy() const
334 {
335     GetData * copied = GetData::alloc();
336     *copied = *this;
337     copied->m_refCount = 0;
338     return copied;
339 }
340 
instanceOf(int classNo) const341 bool GetData::instanceOf(int classNo) const
342 {
343     if(GET_NO == classNo) return true;
344     return ActionData::instanceOf(classNo);
345 }
346 
347 //freelist related methods specific to this class
348 GetData *GetData::defaults_GetData = 0;
349 GetData *GetData::begin_GetData = 0;
350 
alloc()351 GetData *GetData::alloc()
352 {
353     if(begin_GetData) {
354         GetData *res = begin_GetData;
355         assert( res->m_refCount == 0 );
356         res->m_attrFlags = 0;
357         res->m_attributes.clear();
358         begin_GetData = (GetData *)begin_GetData->m_next;
359         return res;
360     }
361     return new GetData(GetData::getDefaultObjectInstance());
362 }
363 
free()364 void GetData::free()
365 {
366     m_next = begin_GetData;
367     begin_GetData = this;
368 }
369 
370 
getDefaultObjectInstance()371 GetData *GetData::getDefaultObjectInstance()
372 {
373     if (defaults_GetData == 0) {
374         defaults_GetData = new GetData;
375         defaults_GetData->attr_objtype = "op";
376         defaults_GetData->attr_serialno = 0;
377         defaults_GetData->attr_refno = 0;
378         defaults_GetData->attr_seconds = 0.0;
379         defaults_GetData->attr_future_seconds = 0.0;
380         defaults_GetData->attr_stamp = 0.0;
381         defaults_GetData->attr_parents = std::list<std::string>(1, "get");
382         ActionData::getDefaultObjectInstance();
383     }
384     return defaults_GetData;
385 }
386 
getDefaultObject()387 GetData *GetData::getDefaultObject()
388 {
389     return GetData::getDefaultObjectInstance();
390 }
391 
392 } } } // namespace Atlas::Objects::Operation
393