← Back to branch summary

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

« back to all changes in this revision

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