← Back to branch summary

~ubuntu-branches/ubuntu/breezy/atlas-cpp/breezy

« back to all changes in this revision

Viewing changes to Atlas/Objects/RootOperationChildren2.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michael Koch
  • Date: 2005-10-02 11:41:44 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051002114144-8qmn4d1cdn9g27ta
Tags: 0.5.98-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
Atlas/Objects/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-2004 Al 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
 
 
14
DeleteData::~DeleteData()
 
15
{
 
16
}
 
17
 
 
18
DeleteData * DeleteData::copy() const
 
19
{
 
20
    DeleteData * copied = DeleteData::alloc();
 
21
    *copied = *this;
 
22
    copied->m_refCount = 0;
 
23
    return copied;
 
24
}
 
25
 
 
26
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
 
 
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
 
 
49
void DeleteData::free()
 
50
{
 
51
    m_next = begin_DeleteData;
 
52
    begin_DeleteData = this;
 
53
}
 
54
 
 
55
 
 
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
 
 
72
DeleteData *DeleteData::getDefaultObject()
 
73
{
 
74
    return DeleteData::getDefaultObjectInstance();
 
75
}
 
76
 
 
77
SetData::~SetData()
 
78
{
 
79
}
 
80
 
 
81
SetData * SetData::copy() const
 
82
{
 
83
    SetData * copied = SetData::alloc();
 
84
    *copied = *this;
 
85
    copied->m_refCount = 0;
 
86
    return copied;
 
87
}
 
88
 
 
89
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
 
 
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
 
 
112
void SetData::free()
 
113
{
 
114
    m_next = begin_SetData;
 
115
    begin_SetData = this;
 
116
}
 
117
 
 
118
 
 
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
 
 
135
SetData *SetData::getDefaultObject()
 
136
{
 
137
    return SetData::getDefaultObjectInstance();
 
138
}
 
139
 
 
140
AffectData::~AffectData()
 
141
{
 
142
}
 
143
 
 
144
AffectData * AffectData::copy() const
 
145
{
 
146
    AffectData * copied = AffectData::alloc();
 
147
    *copied = *this;
 
148
    copied->m_refCount = 0;
 
149
    return copied;
 
150
}
 
151
 
 
152
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
 
 
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
 
 
175
void AffectData::free()
 
176
{
 
177
    m_next = begin_AffectData;
 
178
    begin_AffectData = this;
 
179
}
 
180
 
 
181
 
 
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
 
 
198
AffectData *AffectData::getDefaultObject()
 
199
{
 
200
    return AffectData::getDefaultObjectInstance();
 
201
}
 
202
 
 
203
MoveData::~MoveData()
 
204
{
 
205
}
 
206
 
 
207
MoveData * MoveData::copy() const
 
208
{
 
209
    MoveData * copied = MoveData::alloc();
 
210
    *copied = *this;
 
211
    copied->m_refCount = 0;
 
212
    return copied;
 
213
}
 
214
 
 
215
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
 
 
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
 
 
238
void MoveData::free()
 
239
{
 
240
    m_next = begin_MoveData;
 
241
    begin_MoveData = this;
 
242
}
 
243
 
 
244
 
 
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
 
 
261
MoveData *MoveData::getDefaultObject()
 
262
{
 
263
    return MoveData::getDefaultObjectInstance();
 
264
}
 
265
 
 
266
WieldData::~WieldData()
 
267
{
 
268
}
 
269
 
 
270
WieldData * WieldData::copy() const
 
271
{
 
272
    WieldData * copied = WieldData::alloc();
 
273
    *copied = *this;
 
274
    copied->m_refCount = 0;
 
275
    return copied;
 
276
}
 
277
 
 
278
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
 
 
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
 
 
301
void WieldData::free()
 
302
{
 
303
    m_next = begin_WieldData;
 
304
    begin_WieldData = this;
 
305
}
 
306
 
 
307
 
 
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
 
 
324
WieldData *WieldData::getDefaultObject()
 
325
{
 
326
    return WieldData::getDefaultObjectInstance();
 
327
}
 
328
 
 
329
GetData::~GetData()
 
330
{
 
331
}
 
332
 
 
333
GetData * GetData::copy() const
 
334
{
 
335
    GetData * copied = GetData::alloc();
 
336
    *copied = *this;
 
337
    copied->m_refCount = 0;
 
338
    return copied;
 
339
}
 
340
 
 
341
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
 
 
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
 
 
364
void GetData::free()
 
365
{
 
366
    m_next = begin_GetData;
 
367
    begin_GetData = this;
 
368
}
 
369
 
 
370
 
 
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
 
 
387
GetData *GetData::getDefaultObject()
 
388
{
 
389
    return GetData::getDefaultObjectInstance();
 
390
}
 
391
 
 
392
} } } // namespace Atlas::Objects::Operation