← Back to branch summary

~ubuntu-branches/debian/sid/ember/sid

« back to all changes in this revision

Viewing changes to src/framework/bindings/lua/atlas/lua_Atlas.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michael Koch
  • Date: 2009-07-23 07:46:40 UTC
  • Revision ID: james.westby@ubuntu.com-20090723074640-wh0ukzis0kda36qv
Tags: upstream-0.5.6
Import upstream version 0.5.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/framework/bindings/lua/atlas/lua_Atlas.cpp
 
1
/*
 
2
** Lua binding: Atlas
 
3
** Generated automatically by tolua++-1.0.92 on Sat Jul  5 23:48:55 2008.
 
4
*/
 
5
 
 
6
#ifndef __cplusplus
 
7
#include "stdlib.h"
 
8
#endif
 
9
#include "string.h"
 
10
 
 
11
#include "tolua++.h"
 
12
 
 
13
/* Exported function */
 
14
TOLUA_API int  tolua_Atlas_open (lua_State* tolua_S);
 
15
 
 
16
#include "required.h"
 
17
 
 
18
/* function to release collected object via destructor */
 
19
#ifdef __cplusplus
 
20
 
 
21
static int tolua_collect_Atlas__Message__ListType (lua_State* tolua_S)
 
22
{
 
23
 Atlas::Message::ListType* self = (Atlas::Message::ListType*) tolua_tousertype(tolua_S,1,0);
 
24
        delete self;
 
25
        return 0;
 
26
}
 
27
 
 
28
static int tolua_collect_Atlas__Message__MapType (lua_State* tolua_S)
 
29
{
 
30
 Atlas::Message::MapType* self = (Atlas::Message::MapType*) tolua_tousertype(tolua_S,1,0);
 
31
        delete self;
 
32
        return 0;
 
33
}
 
34
 
 
35
static int tolua_collect_Atlas__Message__Element (lua_State* tolua_S)
 
36
{
 
37
 Atlas::Message::Element* self = (Atlas::Message::Element*) tolua_tousertype(tolua_S,1,0);
 
38
        delete self;
 
39
        return 0;
 
40
}
 
41
 
 
42
static int tolua_collect_Atlas__Message__MapType__iterator (lua_State* tolua_S)
 
43
{
 
44
 Atlas::Message::MapType::iterator* self = (Atlas::Message::MapType::iterator*) tolua_tousertype(tolua_S,1,0);
 
45
        delete self;
 
46
        return 0;
 
47
}
 
48
#endif
 
49
 
 
50
 
 
51
/* function to register type */
 
52
static void tolua_reg_types (lua_State* tolua_S)
 
53
{
 
54
 tolua_usertype(tolua_S,"Atlas::Message::MapType::value_type");
 
55
 tolua_usertype(tolua_S,"Atlas::Message::MapType");
 
56
 tolua_usertype(tolua_S,"Atlas::Message::ListType");
 
57
 tolua_usertype(tolua_S,"Atlas::Message::Element");
 
58
 tolua_usertype(tolua_S,"Atlas::Message::MapType::iterator");
 
59
}
 
60
 
 
61
/* method: new of class  Atlas::Message::Element */
 
62
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new00
 
63
static int tolua_Atlas_Atlas_Message_Element_new00(lua_State* tolua_S)
 
64
{
 
65
#ifndef TOLUA_RELEASE
 
66
 tolua_Error tolua_err;
 
67
 if (
 
68
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
69
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
70
 )
 
71
  goto tolua_lerror;
 
72
 else
 
73
#endif
 
74
 {
 
75
  {
 
76
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element();
 
77
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Atlas::Message::Element");
 
78
  }
 
79
 }
 
80
 return 1;
 
81
#ifndef TOLUA_RELEASE
 
82
 tolua_lerror:
 
83
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 
84
 return 0;
 
85
#endif
 
86
}
 
87
#endif //#ifndef TOLUA_DISABLE
 
88
 
 
89
/* method: new_local of class  Atlas::Message::Element */
 
90
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new00_local
 
91
static int tolua_Atlas_Atlas_Message_Element_new00_local(lua_State* tolua_S)
 
92
{
 
93
#ifndef TOLUA_RELEASE
 
94
 tolua_Error tolua_err;
 
95
 if (
 
96
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
97
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
98
 )
 
99
  goto tolua_lerror;
 
100
 else
 
101
#endif
 
102
 {
 
103
  {
 
104
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element();
 
105
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Atlas::Message::Element");
 
106
  }
 
107
 }
 
108
 return 1;
 
109
#ifndef TOLUA_RELEASE
 
110
 tolua_lerror:
 
111
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 
112
 return 0;
 
113
#endif
 
114
}
 
115
#endif //#ifndef TOLUA_DISABLE
 
116
 
 
117
/* method: delete of class  Atlas::Message::Element */
 
118
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_delete00
 
119
static int tolua_Atlas_Atlas_Message_Element_delete00(lua_State* tolua_S)
 
120
{
 
121
#ifndef TOLUA_RELEASE
 
122
 tolua_Error tolua_err;
 
123
 if (
 
124
     !tolua_isusertype(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
125
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
126
 )
 
127
  goto tolua_lerror;
 
128
 else
 
129
#endif
 
130
 {
 
131
  Atlas::Message::Element* self = (Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
132
#ifndef TOLUA_RELEASE
 
133
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
 
134
#endif
 
135
  delete self;
 
136
 }
 
137
 return 0;
 
138
#ifndef TOLUA_RELEASE
 
139
 tolua_lerror:
 
140
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 
141
 return 0;
 
142
#endif
 
143
}
 
144
#endif //#ifndef TOLUA_DISABLE
 
145
 
 
146
/* method: new of class  Atlas::Message::Element */
 
147
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new01
 
148
static int tolua_Atlas_Atlas_Message_Element_new01(lua_State* tolua_S)
 
149
{
 
150
 tolua_Error tolua_err;
 
151
 if (
 
152
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
153
     !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err) ||
 
154
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
155
 )
 
156
  goto tolua_lerror;
 
157
 else
 
158
 {
 
159
  const Atlas::Message::Element* obj = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
 
160
  {
 
161
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(*obj);
 
162
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Atlas::Message::Element");
 
163
  }
 
164
 }
 
165
 return 1;
 
166
tolua_lerror:
 
167
 return tolua_Atlas_Atlas_Message_Element_new00(tolua_S);
 
168
}
 
169
#endif //#ifndef TOLUA_DISABLE
 
170
 
 
171
/* method: new_local of class  Atlas::Message::Element */
 
172
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new01_local
 
173
static int tolua_Atlas_Atlas_Message_Element_new01_local(lua_State* tolua_S)
 
174
{
 
175
 tolua_Error tolua_err;
 
176
 if (
 
177
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
178
     !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err) ||
 
179
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
180
 )
 
181
  goto tolua_lerror;
 
182
 else
 
183
 {
 
184
  const Atlas::Message::Element* obj = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
 
185
  {
 
186
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(*obj);
 
187
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Atlas::Message::Element");
 
188
  }
 
189
 }
 
190
 return 1;
 
191
tolua_lerror:
 
192
 return tolua_Atlas_Atlas_Message_Element_new00_local(tolua_S);
 
193
}
 
194
#endif //#ifndef TOLUA_DISABLE
 
195
 
 
196
/* method: new of class  Atlas::Message::Element */
 
197
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new02
 
198
static int tolua_Atlas_Atlas_Message_Element_new02(lua_State* tolua_S)
 
199
{
 
200
 tolua_Error tolua_err;
 
201
 if (
 
202
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
203
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
204
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
205
 )
 
206
  goto tolua_lerror;
 
207
 else
 
208
 {
 
209
  int v = ((int)  tolua_tonumber(tolua_S,2,0));
 
210
  {
 
211
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
212
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Atlas::Message::Element");
 
213
  }
 
214
 }
 
215
 return 1;
 
216
tolua_lerror:
 
217
 return tolua_Atlas_Atlas_Message_Element_new01(tolua_S);
 
218
}
 
219
#endif //#ifndef TOLUA_DISABLE
 
220
 
 
221
/* method: new_local of class  Atlas::Message::Element */
 
222
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new02_local
 
223
static int tolua_Atlas_Atlas_Message_Element_new02_local(lua_State* tolua_S)
 
224
{
 
225
 tolua_Error tolua_err;
 
226
 if (
 
227
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
228
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
229
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
230
 )
 
231
  goto tolua_lerror;
 
232
 else
 
233
 {
 
234
  int v = ((int)  tolua_tonumber(tolua_S,2,0));
 
235
  {
 
236
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
237
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Atlas::Message::Element");
 
238
  }
 
239
 }
 
240
 return 1;
 
241
tolua_lerror:
 
242
 return tolua_Atlas_Atlas_Message_Element_new01_local(tolua_S);
 
243
}
 
244
#endif //#ifndef TOLUA_DISABLE
 
245
 
 
246
/* method: new of class  Atlas::Message::Element */
 
247
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new03
 
248
static int tolua_Atlas_Atlas_Message_Element_new03(lua_State* tolua_S)
 
249
{
 
250
 tolua_Error tolua_err;
 
251
 if (
 
252
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
253
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 
254
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
255
 )
 
256
  goto tolua_lerror;
 
257
 else
 
258
 {
 
259
  bool v = ((bool)  tolua_toboolean(tolua_S,2,0));
 
260
  {
 
261
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
262
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Atlas::Message::Element");
 
263
  }
 
264
 }
 
265
 return 1;
 
266
tolua_lerror:
 
267
 return tolua_Atlas_Atlas_Message_Element_new02(tolua_S);
 
268
}
 
269
#endif //#ifndef TOLUA_DISABLE
 
270
 
 
271
/* method: new_local of class  Atlas::Message::Element */
 
272
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new03_local
 
273
static int tolua_Atlas_Atlas_Message_Element_new03_local(lua_State* tolua_S)
 
274
{
 
275
 tolua_Error tolua_err;
 
276
 if (
 
277
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
278
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 
279
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
280
 )
 
281
  goto tolua_lerror;
 
282
 else
 
283
 {
 
284
  bool v = ((bool)  tolua_toboolean(tolua_S,2,0));
 
285
  {
 
286
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
287
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Atlas::Message::Element");
 
288
  }
 
289
 }
 
290
 return 1;
 
291
tolua_lerror:
 
292
 return tolua_Atlas_Atlas_Message_Element_new02_local(tolua_S);
 
293
}
 
294
#endif //#ifndef TOLUA_DISABLE
 
295
 
 
296
/* method: new of class  Atlas::Message::Element */
 
297
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new04
 
298
static int tolua_Atlas_Atlas_Message_Element_new04(lua_State* tolua_S)
 
299
{
 
300
 tolua_Error tolua_err;
 
301
 if (
 
302
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
303
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
304
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
305
 )
 
306
  goto tolua_lerror;
 
307
 else
 
308
 {
 
309
  long v = ((long)  tolua_tonumber(tolua_S,2,0));
 
310
  {
 
311
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
312
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Atlas::Message::Element");
 
313
  }
 
314
 }
 
315
 return 1;
 
316
tolua_lerror:
 
317
 return tolua_Atlas_Atlas_Message_Element_new03(tolua_S);
 
318
}
 
319
#endif //#ifndef TOLUA_DISABLE
 
320
 
 
321
/* method: new_local of class  Atlas::Message::Element */
 
322
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new04_local
 
323
static int tolua_Atlas_Atlas_Message_Element_new04_local(lua_State* tolua_S)
 
324
{
 
325
 tolua_Error tolua_err;
 
326
 if (
 
327
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
328
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
329
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
330
 )
 
331
  goto tolua_lerror;
 
332
 else
 
333
 {
 
334
  long v = ((long)  tolua_tonumber(tolua_S,2,0));
 
335
  {
 
336
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
337
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Atlas::Message::Element");
 
338
  }
 
339
 }
 
340
 return 1;
 
341
tolua_lerror:
 
342
 return tolua_Atlas_Atlas_Message_Element_new03_local(tolua_S);
 
343
}
 
344
#endif //#ifndef TOLUA_DISABLE
 
345
 
 
346
/* method: new of class  Atlas::Message::Element */
 
347
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new05
 
348
static int tolua_Atlas_Atlas_Message_Element_new05(lua_State* tolua_S)
 
349
{
 
350
 tolua_Error tolua_err;
 
351
 if (
 
352
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
353
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
354
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
355
 )
 
356
  goto tolua_lerror;
 
357
 else
 
358
 {
 
359
  float v = ((float)  tolua_tonumber(tolua_S,2,0));
 
360
  {
 
361
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
362
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Atlas::Message::Element");
 
363
  }
 
364
 }
 
365
 return 1;
 
366
tolua_lerror:
 
367
 return tolua_Atlas_Atlas_Message_Element_new04(tolua_S);
 
368
}
 
369
#endif //#ifndef TOLUA_DISABLE
 
370
 
 
371
/* method: new_local of class  Atlas::Message::Element */
 
372
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new05_local
 
373
static int tolua_Atlas_Atlas_Message_Element_new05_local(lua_State* tolua_S)
 
374
{
 
375
 tolua_Error tolua_err;
 
376
 if (
 
377
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
378
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
379
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
380
 )
 
381
  goto tolua_lerror;
 
382
 else
 
383
 {
 
384
  float v = ((float)  tolua_tonumber(tolua_S,2,0));
 
385
  {
 
386
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
387
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Atlas::Message::Element");
 
388
  }
 
389
 }
 
390
 return 1;
 
391
tolua_lerror:
 
392
 return tolua_Atlas_Atlas_Message_Element_new04_local(tolua_S);
 
393
}
 
394
#endif //#ifndef TOLUA_DISABLE
 
395
 
 
396
/* method: new of class  Atlas::Message::Element */
 
397
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new06
 
398
static int tolua_Atlas_Atlas_Message_Element_new06(lua_State* tolua_S)
 
399
{
 
400
 tolua_Error tolua_err;
 
401
 if (
 
402
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
403
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
404
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
405
 )
 
406
  goto tolua_lerror;
 
407
 else
 
408
 {
 
409
  double v = ((double)  tolua_tonumber(tolua_S,2,0));
 
410
  {
 
411
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
412
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Atlas::Message::Element");
 
413
  }
 
414
 }
 
415
 return 1;
 
416
tolua_lerror:
 
417
 return tolua_Atlas_Atlas_Message_Element_new05(tolua_S);
 
418
}
 
419
#endif //#ifndef TOLUA_DISABLE
 
420
 
 
421
/* method: new_local of class  Atlas::Message::Element */
 
422
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new06_local
 
423
static int tolua_Atlas_Atlas_Message_Element_new06_local(lua_State* tolua_S)
 
424
{
 
425
 tolua_Error tolua_err;
 
426
 if (
 
427
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
428
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
429
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
430
 )
 
431
  goto tolua_lerror;
 
432
 else
 
433
 {
 
434
  double v = ((double)  tolua_tonumber(tolua_S,2,0));
 
435
  {
 
436
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
437
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Atlas::Message::Element");
 
438
  }
 
439
 }
 
440
 return 1;
 
441
tolua_lerror:
 
442
 return tolua_Atlas_Atlas_Message_Element_new05_local(tolua_S);
 
443
}
 
444
#endif //#ifndef TOLUA_DISABLE
 
445
 
 
446
/* method: new of class  Atlas::Message::Element */
 
447
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new07
 
448
static int tolua_Atlas_Atlas_Message_Element_new07(lua_State* tolua_S)
 
449
{
 
450
 tolua_Error tolua_err;
 
451
 if (
 
452
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
453
     !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
 
454
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
455
 )
 
456
  goto tolua_lerror;
 
457
 else
 
458
 {
 
459
  void* v = ((void*)  tolua_touserdata(tolua_S,2,0));
 
460
  {
 
461
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
462
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Atlas::Message::Element");
 
463
  }
 
464
 }
 
465
 return 1;
 
466
tolua_lerror:
 
467
 return tolua_Atlas_Atlas_Message_Element_new06(tolua_S);
 
468
}
 
469
#endif //#ifndef TOLUA_DISABLE
 
470
 
 
471
/* method: new_local of class  Atlas::Message::Element */
 
472
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new07_local
 
473
static int tolua_Atlas_Atlas_Message_Element_new07_local(lua_State* tolua_S)
 
474
{
 
475
 tolua_Error tolua_err;
 
476
 if (
 
477
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
478
     !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
 
479
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
480
 )
 
481
  goto tolua_lerror;
 
482
 else
 
483
 {
 
484
  void* v = ((void*)  tolua_touserdata(tolua_S,2,0));
 
485
  {
 
486
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
487
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Atlas::Message::Element");
 
488
  }
 
489
 }
 
490
 return 1;
 
491
tolua_lerror:
 
492
 return tolua_Atlas_Atlas_Message_Element_new06_local(tolua_S);
 
493
}
 
494
#endif //#ifndef TOLUA_DISABLE
 
495
 
 
496
/* method: new of class  Atlas::Message::Element */
 
497
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new08
 
498
static int tolua_Atlas_Atlas_Message_Element_new08(lua_State* tolua_S)
 
499
{
 
500
 tolua_Error tolua_err;
 
501
 if (
 
502
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
503
     !tolua_isstring_type(tolua_S,2,0,&tolua_err) ||
 
504
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
505
 )
 
506
  goto tolua_lerror;
 
507
 else
 
508
 {
 
509
  const char* v = ((const char*)  tolua_tostring(tolua_S,2,0));
 
510
  {
 
511
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
512
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Atlas::Message::Element");
 
513
  }
 
514
 }
 
515
 return 1;
 
516
tolua_lerror:
 
517
 return tolua_Atlas_Atlas_Message_Element_new07(tolua_S);
 
518
}
 
519
#endif //#ifndef TOLUA_DISABLE
 
520
 
 
521
/* method: new_local of class  Atlas::Message::Element */
 
522
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new08_local
 
523
static int tolua_Atlas_Atlas_Message_Element_new08_local(lua_State* tolua_S)
 
524
{
 
525
 tolua_Error tolua_err;
 
526
 if (
 
527
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
528
     !tolua_isstring_type(tolua_S,2,0,&tolua_err) ||
 
529
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
530
 )
 
531
  goto tolua_lerror;
 
532
 else
 
533
 {
 
534
  const char* v = ((const char*)  tolua_tostring(tolua_S,2,0));
 
535
  {
 
536
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
537
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Atlas::Message::Element");
 
538
  }
 
539
 }
 
540
 return 1;
 
541
tolua_lerror:
 
542
 return tolua_Atlas_Atlas_Message_Element_new07_local(tolua_S);
 
543
}
 
544
#endif //#ifndef TOLUA_DISABLE
 
545
 
 
546
/* method: new of class  Atlas::Message::Element */
 
547
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new09
 
548
static int tolua_Atlas_Atlas_Message_Element_new09(lua_State* tolua_S)
 
549
{
 
550
 tolua_Error tolua_err;
 
551
 if (
 
552
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
553
     !tolua_iscppstring_type(tolua_S,2,0,&tolua_err) ||
 
554
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
555
 )
 
556
  goto tolua_lerror;
 
557
 else
 
558
 {
 
559
  const std::string v = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
560
  {
 
561
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
562
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Atlas::Message::Element");
 
563
   tolua_pushcppstring(tolua_S,(const char*)v);
 
564
  }
 
565
 }
 
566
 return 2;
 
567
tolua_lerror:
 
568
 return tolua_Atlas_Atlas_Message_Element_new08(tolua_S);
 
569
}
 
570
#endif //#ifndef TOLUA_DISABLE
 
571
 
 
572
/* method: new_local of class  Atlas::Message::Element */
 
573
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new09_local
 
574
static int tolua_Atlas_Atlas_Message_Element_new09_local(lua_State* tolua_S)
 
575
{
 
576
 tolua_Error tolua_err;
 
577
 if (
 
578
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
579
     !tolua_iscppstring_type(tolua_S,2,0,&tolua_err) ||
 
580
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
581
 )
 
582
  goto tolua_lerror;
 
583
 else
 
584
 {
 
585
  const std::string v = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
586
  {
 
587
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(v);
 
588
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Atlas::Message::Element");
 
589
   tolua_pushcppstring(tolua_S,(const char*)v);
 
590
  }
 
591
 }
 
592
 return 2;
 
593
tolua_lerror:
 
594
 return tolua_Atlas_Atlas_Message_Element_new08_local(tolua_S);
 
595
}
 
596
#endif //#ifndef TOLUA_DISABLE
 
597
 
 
598
/* method: new of class  Atlas::Message::Element */
 
599
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new10
 
600
static int tolua_Atlas_Atlas_Message_Element_new10(lua_State* tolua_S)
 
601
{
 
602
 tolua_Error tolua_err;
 
603
 if (
 
604
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
605
     !tolua_isusertype(tolua_S,2,"const Atlas::Message::MapType",0,&tolua_err) ||
 
606
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
607
 )
 
608
  goto tolua_lerror;
 
609
 else
 
610
 {
 
611
  const Atlas::Message::MapType* v = ((const Atlas::Message::MapType*)  tolua_tousertype(tolua_S,2,0));
 
612
  {
 
613
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(*v);
 
614
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Atlas::Message::Element");
 
615
  }
 
616
 }
 
617
 return 1;
 
618
tolua_lerror:
 
619
 return tolua_Atlas_Atlas_Message_Element_new09(tolua_S);
 
620
}
 
621
#endif //#ifndef TOLUA_DISABLE
 
622
 
 
623
/* method: new_local of class  Atlas::Message::Element */
 
624
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new10_local
 
625
static int tolua_Atlas_Atlas_Message_Element_new10_local(lua_State* tolua_S)
 
626
{
 
627
 tolua_Error tolua_err;
 
628
 if (
 
629
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
630
     !tolua_isusertype(tolua_S,2,"const Atlas::Message::MapType",0,&tolua_err) ||
 
631
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
632
 )
 
633
  goto tolua_lerror;
 
634
 else
 
635
 {
 
636
  const Atlas::Message::MapType* v = ((const Atlas::Message::MapType*)  tolua_tousertype(tolua_S,2,0));
 
637
  {
 
638
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(*v);
 
639
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Atlas::Message::Element");
 
640
  }
 
641
 }
 
642
 return 1;
 
643
tolua_lerror:
 
644
 return tolua_Atlas_Atlas_Message_Element_new09_local(tolua_S);
 
645
}
 
646
#endif //#ifndef TOLUA_DISABLE
 
647
 
 
648
/* method: new of class  Atlas::Message::Element */
 
649
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new11
 
650
static int tolua_Atlas_Atlas_Message_Element_new11(lua_State* tolua_S)
 
651
{
 
652
 tolua_Error tolua_err;
 
653
 if (
 
654
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
655
     !tolua_isusertype(tolua_S,2,"const Atlas::Message::ListType",0,&tolua_err) ||
 
656
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
657
 )
 
658
  goto tolua_lerror;
 
659
 else
 
660
 {
 
661
  const Atlas::Message::ListType* v = ((const Atlas::Message::ListType*)  tolua_tousertype(tolua_S,2,0));
 
662
  {
 
663
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(*v);
 
664
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Atlas::Message::Element");
 
665
  }
 
666
 }
 
667
 return 1;
 
668
tolua_lerror:
 
669
 return tolua_Atlas_Atlas_Message_Element_new10(tolua_S);
 
670
}
 
671
#endif //#ifndef TOLUA_DISABLE
 
672
 
 
673
/* method: new_local of class  Atlas::Message::Element */
 
674
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_new11_local
 
675
static int tolua_Atlas_Atlas_Message_Element_new11_local(lua_State* tolua_S)
 
676
{
 
677
 tolua_Error tolua_err;
 
678
 if (
 
679
     !tolua_isusertable(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
680
     !tolua_isusertype(tolua_S,2,"const Atlas::Message::ListType",0,&tolua_err) ||
 
681
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
682
 )
 
683
  goto tolua_lerror;
 
684
 else
 
685
 {
 
686
  const Atlas::Message::ListType* v = ((const Atlas::Message::ListType*)  tolua_tousertype(tolua_S,2,0));
 
687
  {
 
688
   Atlas::Message::Element* tolua_ret = (Atlas::Message::Element*)  new Atlas::Message::Element(*v);
 
689
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Atlas::Message::Element");
 
690
  }
 
691
 }
 
692
 return 1;
 
693
tolua_lerror:
 
694
 return tolua_Atlas_Atlas_Message_Element_new10_local(tolua_S);
 
695
}
 
696
#endif //#ifndef TOLUA_DISABLE
 
697
 
 
698
/* method: operator== of class  Atlas::Message::Element */
 
699
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element__eq00
 
700
static int tolua_Atlas_Atlas_Message_Element__eq00(lua_State* tolua_S)
 
701
{
 
702
#ifndef TOLUA_RELEASE
 
703
 tolua_Error tolua_err;
 
704
 if (
 
705
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
706
     !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err) ||
 
707
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
708
 )
 
709
  goto tolua_lerror;
 
710
 else
 
711
#endif
 
712
 {
 
713
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
714
  const Atlas::Message::Element* o = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
 
715
#ifndef TOLUA_RELEASE
 
716
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
 
717
#endif
 
718
  {
 
719
   bool tolua_ret = (bool)  self->operator==(*o);
 
720
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
721
  }
 
722
 }
 
723
 return 1;
 
724
#ifndef TOLUA_RELEASE
 
725
 tolua_lerror:
 
726
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 
727
 return 0;
 
728
#endif
 
729
}
 
730
#endif //#ifndef TOLUA_DISABLE
 
731
 
 
732
/* method: operator== of class  Atlas::Message::Element */
 
733
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element__eq01
 
734
static int tolua_Atlas_Atlas_Message_Element__eq01(lua_State* tolua_S)
 
735
{
 
736
 tolua_Error tolua_err;
 
737
 if (
 
738
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
739
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
740
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
741
 )
 
742
  goto tolua_lerror;
 
743
 else
 
744
 {
 
745
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
746
  long v = ((long)  tolua_tonumber(tolua_S,2,0));
 
747
#ifndef TOLUA_RELEASE
 
748
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
 
749
#endif
 
750
  {
 
751
   bool tolua_ret = (bool)  self->operator==(v);
 
752
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
753
  }
 
754
 }
 
755
 return 1;
 
756
tolua_lerror:
 
757
 return tolua_Atlas_Atlas_Message_Element__eq00(tolua_S);
 
758
}
 
759
#endif //#ifndef TOLUA_DISABLE
 
760
 
 
761
/* method: operator== of class  Atlas::Message::Element */
 
762
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element__eq02
 
763
static int tolua_Atlas_Atlas_Message_Element__eq02(lua_State* tolua_S)
 
764
{
 
765
 tolua_Error tolua_err;
 
766
 if (
 
767
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
768
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
769
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
770
 )
 
771
  goto tolua_lerror;
 
772
 else
 
773
 {
 
774
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
775
  double v = ((double)  tolua_tonumber(tolua_S,2,0));
 
776
#ifndef TOLUA_RELEASE
 
777
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
 
778
#endif
 
779
  {
 
780
   bool tolua_ret = (bool)  self->operator==(v);
 
781
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
782
  }
 
783
 }
 
784
 return 1;
 
785
tolua_lerror:
 
786
 return tolua_Atlas_Atlas_Message_Element__eq01(tolua_S);
 
787
}
 
788
#endif //#ifndef TOLUA_DISABLE
 
789
 
 
790
/* method: operator== of class  Atlas::Message::Element */
 
791
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element__eq03
 
792
static int tolua_Atlas_Atlas_Message_Element__eq03(lua_State* tolua_S)
 
793
{
 
794
 tolua_Error tolua_err;
 
795
 if (
 
796
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
797
     !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
 
798
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
799
 )
 
800
  goto tolua_lerror;
 
801
 else
 
802
 {
 
803
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
804
  void* v = ((void*)  tolua_touserdata(tolua_S,2,0));
 
805
#ifndef TOLUA_RELEASE
 
806
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
 
807
#endif
 
808
  {
 
809
   bool tolua_ret = (bool)  self->operator==(v);
 
810
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
811
  }
 
812
 }
 
813
 return 1;
 
814
tolua_lerror:
 
815
 return tolua_Atlas_Atlas_Message_Element__eq02(tolua_S);
 
816
}
 
817
#endif //#ifndef TOLUA_DISABLE
 
818
 
 
819
/* method: operator== of class  Atlas::Message::Element */
 
820
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element__eq04
 
821
static int tolua_Atlas_Atlas_Message_Element__eq04(lua_State* tolua_S)
 
822
{
 
823
 tolua_Error tolua_err;
 
824
 if (
 
825
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
826
     !tolua_isstring_type(tolua_S,2,0,&tolua_err) ||
 
827
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
828
 )
 
829
  goto tolua_lerror;
 
830
 else
 
831
 {
 
832
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
833
  const char* v = ((const char*)  tolua_tostring(tolua_S,2,0));
 
834
#ifndef TOLUA_RELEASE
 
835
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
 
836
#endif
 
837
  {
 
838
   bool tolua_ret = (bool)  self->operator==(v);
 
839
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
840
  }
 
841
 }
 
842
 return 1;
 
843
tolua_lerror:
 
844
 return tolua_Atlas_Atlas_Message_Element__eq03(tolua_S);
 
845
}
 
846
#endif //#ifndef TOLUA_DISABLE
 
847
 
 
848
/* method: operator== of class  Atlas::Message::Element */
 
849
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element__eq05
 
850
static int tolua_Atlas_Atlas_Message_Element__eq05(lua_State* tolua_S)
 
851
{
 
852
 tolua_Error tolua_err;
 
853
 if (
 
854
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
855
     !tolua_iscppstring_type(tolua_S,2,0,&tolua_err) ||
 
856
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
857
 )
 
858
  goto tolua_lerror;
 
859
 else
 
860
 {
 
861
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
862
  const std::string v = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
863
#ifndef TOLUA_RELEASE
 
864
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
 
865
#endif
 
866
  {
 
867
   bool tolua_ret = (bool)  self->operator==(v);
 
868
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
869
   tolua_pushcppstring(tolua_S,(const char*)v);
 
870
  }
 
871
 }
 
872
 return 2;
 
873
tolua_lerror:
 
874
 return tolua_Atlas_Atlas_Message_Element__eq04(tolua_S);
 
875
}
 
876
#endif //#ifndef TOLUA_DISABLE
 
877
 
 
878
/* method: operator== of class  Atlas::Message::Element */
 
879
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element__eq06
 
880
static int tolua_Atlas_Atlas_Message_Element__eq06(lua_State* tolua_S)
 
881
{
 
882
 tolua_Error tolua_err;
 
883
 if (
 
884
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
885
     !tolua_isusertype(tolua_S,2,"const Atlas::Message::MapType",0,&tolua_err) ||
 
886
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
887
 )
 
888
  goto tolua_lerror;
 
889
 else
 
890
 {
 
891
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
892
  const Atlas::Message::MapType* v = ((const Atlas::Message::MapType*)  tolua_tousertype(tolua_S,2,0));
 
893
#ifndef TOLUA_RELEASE
 
894
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
 
895
#endif
 
896
  {
 
897
   bool tolua_ret = (bool)  self->operator==(*v);
 
898
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
899
  }
 
900
 }
 
901
 return 1;
 
902
tolua_lerror:
 
903
 return tolua_Atlas_Atlas_Message_Element__eq05(tolua_S);
 
904
}
 
905
#endif //#ifndef TOLUA_DISABLE
 
906
 
 
907
/* method: operator== of class  Atlas::Message::Element */
 
908
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element__eq07
 
909
static int tolua_Atlas_Atlas_Message_Element__eq07(lua_State* tolua_S)
 
910
{
 
911
 tolua_Error tolua_err;
 
912
 if (
 
913
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
914
     !tolua_isusertype(tolua_S,2,"const Atlas::Message::ListType",0,&tolua_err) ||
 
915
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
916
 )
 
917
  goto tolua_lerror;
 
918
 else
 
919
 {
 
920
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
921
  const Atlas::Message::ListType* v = ((const Atlas::Message::ListType*)  tolua_tousertype(tolua_S,2,0));
 
922
#ifndef TOLUA_RELEASE
 
923
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
 
924
#endif
 
925
  {
 
926
   bool tolua_ret = (bool)  self->operator==(*v);
 
927
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
928
  }
 
929
 }
 
930
 return 1;
 
931
tolua_lerror:
 
932
 return tolua_Atlas_Atlas_Message_Element__eq06(tolua_S);
 
933
}
 
934
#endif //#ifndef TOLUA_DISABLE
 
935
 
 
936
/* method: getType of class  Atlas::Message::Element */
 
937
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_getType00
 
938
static int tolua_Atlas_Atlas_Message_Element_getType00(lua_State* tolua_S)
 
939
{
 
940
#ifndef TOLUA_RELEASE
 
941
 tolua_Error tolua_err;
 
942
 if (
 
943
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
944
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
945
 )
 
946
  goto tolua_lerror;
 
947
 else
 
948
#endif
 
949
 {
 
950
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
951
#ifndef TOLUA_RELEASE
 
952
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getType'",NULL);
 
953
#endif
 
954
  {
 
955
   Atlas::Message::Element::Type tolua_ret = (Atlas::Message::Element::Type)  self->getType();
 
956
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 
957
  }
 
958
 }
 
959
 return 1;
 
960
#ifndef TOLUA_RELEASE
 
961
 tolua_lerror:
 
962
 tolua_error(tolua_S,"#ferror in function 'getType'.",&tolua_err);
 
963
 return 0;
 
964
#endif
 
965
}
 
966
#endif //#ifndef TOLUA_DISABLE
 
967
 
 
968
/* method: isNone of class  Atlas::Message::Element */
 
969
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_isNone00
 
970
static int tolua_Atlas_Atlas_Message_Element_isNone00(lua_State* tolua_S)
 
971
{
 
972
#ifndef TOLUA_RELEASE
 
973
 tolua_Error tolua_err;
 
974
 if (
 
975
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
976
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
977
 )
 
978
  goto tolua_lerror;
 
979
 else
 
980
#endif
 
981
 {
 
982
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
983
#ifndef TOLUA_RELEASE
 
984
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isNone'",NULL);
 
985
#endif
 
986
  {
 
987
   bool tolua_ret = (bool)  self->isNone();
 
988
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
989
  }
 
990
 }
 
991
 return 1;
 
992
#ifndef TOLUA_RELEASE
 
993
 tolua_lerror:
 
994
 tolua_error(tolua_S,"#ferror in function 'isNone'.",&tolua_err);
 
995
 return 0;
 
996
#endif
 
997
}
 
998
#endif //#ifndef TOLUA_DISABLE
 
999
 
 
1000
/* method: isInt of class  Atlas::Message::Element */
 
1001
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_isInt00
 
1002
static int tolua_Atlas_Atlas_Message_Element_isInt00(lua_State* tolua_S)
 
1003
{
 
1004
#ifndef TOLUA_RELEASE
 
1005
 tolua_Error tolua_err;
 
1006
 if (
 
1007
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1008
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1009
 )
 
1010
  goto tolua_lerror;
 
1011
 else
 
1012
#endif
 
1013
 {
 
1014
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1015
#ifndef TOLUA_RELEASE
 
1016
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isInt'",NULL);
 
1017
#endif
 
1018
  {
 
1019
   bool tolua_ret = (bool)  self->isInt();
 
1020
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
1021
  }
 
1022
 }
 
1023
 return 1;
 
1024
#ifndef TOLUA_RELEASE
 
1025
 tolua_lerror:
 
1026
 tolua_error(tolua_S,"#ferror in function 'isInt'.",&tolua_err);
 
1027
 return 0;
 
1028
#endif
 
1029
}
 
1030
#endif //#ifndef TOLUA_DISABLE
 
1031
 
 
1032
/* method: isFloat of class  Atlas::Message::Element */
 
1033
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_isFloat00
 
1034
static int tolua_Atlas_Atlas_Message_Element_isFloat00(lua_State* tolua_S)
 
1035
{
 
1036
#ifndef TOLUA_RELEASE
 
1037
 tolua_Error tolua_err;
 
1038
 if (
 
1039
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1040
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1041
 )
 
1042
  goto tolua_lerror;
 
1043
 else
 
1044
#endif
 
1045
 {
 
1046
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1047
#ifndef TOLUA_RELEASE
 
1048
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isFloat'",NULL);
 
1049
#endif
 
1050
  {
 
1051
   bool tolua_ret = (bool)  self->isFloat();
 
1052
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
1053
  }
 
1054
 }
 
1055
 return 1;
 
1056
#ifndef TOLUA_RELEASE
 
1057
 tolua_lerror:
 
1058
 tolua_error(tolua_S,"#ferror in function 'isFloat'.",&tolua_err);
 
1059
 return 0;
 
1060
#endif
 
1061
}
 
1062
#endif //#ifndef TOLUA_DISABLE
 
1063
 
 
1064
/* method: isPtr of class  Atlas::Message::Element */
 
1065
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_isPtr00
 
1066
static int tolua_Atlas_Atlas_Message_Element_isPtr00(lua_State* tolua_S)
 
1067
{
 
1068
#ifndef TOLUA_RELEASE
 
1069
 tolua_Error tolua_err;
 
1070
 if (
 
1071
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1072
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1073
 )
 
1074
  goto tolua_lerror;
 
1075
 else
 
1076
#endif
 
1077
 {
 
1078
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1079
#ifndef TOLUA_RELEASE
 
1080
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isPtr'",NULL);
 
1081
#endif
 
1082
  {
 
1083
   bool tolua_ret = (bool)  self->isPtr();
 
1084
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
1085
  }
 
1086
 }
 
1087
 return 1;
 
1088
#ifndef TOLUA_RELEASE
 
1089
 tolua_lerror:
 
1090
 tolua_error(tolua_S,"#ferror in function 'isPtr'.",&tolua_err);
 
1091
 return 0;
 
1092
#endif
 
1093
}
 
1094
#endif //#ifndef TOLUA_DISABLE
 
1095
 
 
1096
/* method: isNum of class  Atlas::Message::Element */
 
1097
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_isNum00
 
1098
static int tolua_Atlas_Atlas_Message_Element_isNum00(lua_State* tolua_S)
 
1099
{
 
1100
#ifndef TOLUA_RELEASE
 
1101
 tolua_Error tolua_err;
 
1102
 if (
 
1103
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1104
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1105
 )
 
1106
  goto tolua_lerror;
 
1107
 else
 
1108
#endif
 
1109
 {
 
1110
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1111
#ifndef TOLUA_RELEASE
 
1112
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isNum'",NULL);
 
1113
#endif
 
1114
  {
 
1115
   bool tolua_ret = (bool)  self->isNum();
 
1116
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
1117
  }
 
1118
 }
 
1119
 return 1;
 
1120
#ifndef TOLUA_RELEASE
 
1121
 tolua_lerror:
 
1122
 tolua_error(tolua_S,"#ferror in function 'isNum'.",&tolua_err);
 
1123
 return 0;
 
1124
#endif
 
1125
}
 
1126
#endif //#ifndef TOLUA_DISABLE
 
1127
 
 
1128
/* method: isString of class  Atlas::Message::Element */
 
1129
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_isString00
 
1130
static int tolua_Atlas_Atlas_Message_Element_isString00(lua_State* tolua_S)
 
1131
{
 
1132
#ifndef TOLUA_RELEASE
 
1133
 tolua_Error tolua_err;
 
1134
 if (
 
1135
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1136
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1137
 )
 
1138
  goto tolua_lerror;
 
1139
 else
 
1140
#endif
 
1141
 {
 
1142
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1143
#ifndef TOLUA_RELEASE
 
1144
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isString'",NULL);
 
1145
#endif
 
1146
  {
 
1147
   bool tolua_ret = (bool)  self->isString();
 
1148
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
1149
  }
 
1150
 }
 
1151
 return 1;
 
1152
#ifndef TOLUA_RELEASE
 
1153
 tolua_lerror:
 
1154
 tolua_error(tolua_S,"#ferror in function 'isString'.",&tolua_err);
 
1155
 return 0;
 
1156
#endif
 
1157
}
 
1158
#endif //#ifndef TOLUA_DISABLE
 
1159
 
 
1160
/* method: isMap of class  Atlas::Message::Element */
 
1161
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_isMap00
 
1162
static int tolua_Atlas_Atlas_Message_Element_isMap00(lua_State* tolua_S)
 
1163
{
 
1164
#ifndef TOLUA_RELEASE
 
1165
 tolua_Error tolua_err;
 
1166
 if (
 
1167
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1168
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1169
 )
 
1170
  goto tolua_lerror;
 
1171
 else
 
1172
#endif
 
1173
 {
 
1174
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1175
#ifndef TOLUA_RELEASE
 
1176
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isMap'",NULL);
 
1177
#endif
 
1178
  {
 
1179
   bool tolua_ret = (bool)  self->isMap();
 
1180
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
1181
  }
 
1182
 }
 
1183
 return 1;
 
1184
#ifndef TOLUA_RELEASE
 
1185
 tolua_lerror:
 
1186
 tolua_error(tolua_S,"#ferror in function 'isMap'.",&tolua_err);
 
1187
 return 0;
 
1188
#endif
 
1189
}
 
1190
#endif //#ifndef TOLUA_DISABLE
 
1191
 
 
1192
/* method: isList of class  Atlas::Message::Element */
 
1193
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_isList00
 
1194
static int tolua_Atlas_Atlas_Message_Element_isList00(lua_State* tolua_S)
 
1195
{
 
1196
#ifndef TOLUA_RELEASE
 
1197
 tolua_Error tolua_err;
 
1198
 if (
 
1199
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1200
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1201
 )
 
1202
  goto tolua_lerror;
 
1203
 else
 
1204
#endif
 
1205
 {
 
1206
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1207
#ifndef TOLUA_RELEASE
 
1208
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isList'",NULL);
 
1209
#endif
 
1210
  {
 
1211
   bool tolua_ret = (bool)  self->isList();
 
1212
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
1213
  }
 
1214
 }
 
1215
 return 1;
 
1216
#ifndef TOLUA_RELEASE
 
1217
 tolua_lerror:
 
1218
 tolua_error(tolua_S,"#ferror in function 'isList'.",&tolua_err);
 
1219
 return 0;
 
1220
#endif
 
1221
}
 
1222
#endif //#ifndef TOLUA_DISABLE
 
1223
 
 
1224
/* method: asInt of class  Atlas::Message::Element */
 
1225
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_asInt00
 
1226
static int tolua_Atlas_Atlas_Message_Element_asInt00(lua_State* tolua_S)
 
1227
{
 
1228
#ifndef TOLUA_RELEASE
 
1229
 tolua_Error tolua_err;
 
1230
 if (
 
1231
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1232
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1233
 )
 
1234
  goto tolua_lerror;
 
1235
 else
 
1236
#endif
 
1237
 {
 
1238
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1239
#ifndef TOLUA_RELEASE
 
1240
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asInt'",NULL);
 
1241
#endif
 
1242
  {
 
1243
   long tolua_ret = (long)  self->asInt();
 
1244
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 
1245
  }
 
1246
 }
 
1247
 return 1;
 
1248
#ifndef TOLUA_RELEASE
 
1249
 tolua_lerror:
 
1250
 tolua_error(tolua_S,"#ferror in function 'asInt'.",&tolua_err);
 
1251
 return 0;
 
1252
#endif
 
1253
}
 
1254
#endif //#ifndef TOLUA_DISABLE
 
1255
 
 
1256
/* method: Int of class  Atlas::Message::Element */
 
1257
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_Int00
 
1258
static int tolua_Atlas_Atlas_Message_Element_Int00(lua_State* tolua_S)
 
1259
{
 
1260
#ifndef TOLUA_RELEASE
 
1261
 tolua_Error tolua_err;
 
1262
 if (
 
1263
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1264
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1265
 )
 
1266
  goto tolua_lerror;
 
1267
 else
 
1268
#endif
 
1269
 {
 
1270
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1271
#ifndef TOLUA_RELEASE
 
1272
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Int'",NULL);
 
1273
#endif
 
1274
  {
 
1275
   long tolua_ret = (long)  self->Int();
 
1276
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 
1277
  }
 
1278
 }
 
1279
 return 1;
 
1280
#ifndef TOLUA_RELEASE
 
1281
 tolua_lerror:
 
1282
 tolua_error(tolua_S,"#ferror in function 'Int'.",&tolua_err);
 
1283
 return 0;
 
1284
#endif
 
1285
}
 
1286
#endif //#ifndef TOLUA_DISABLE
 
1287
 
 
1288
/* method: asFloat of class  Atlas::Message::Element */
 
1289
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_asFloat00
 
1290
static int tolua_Atlas_Atlas_Message_Element_asFloat00(lua_State* tolua_S)
 
1291
{
 
1292
#ifndef TOLUA_RELEASE
 
1293
 tolua_Error tolua_err;
 
1294
 if (
 
1295
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1296
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1297
 )
 
1298
  goto tolua_lerror;
 
1299
 else
 
1300
#endif
 
1301
 {
 
1302
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1303
#ifndef TOLUA_RELEASE
 
1304
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asFloat'",NULL);
 
1305
#endif
 
1306
  {
 
1307
   double tolua_ret = (double)  self->asFloat();
 
1308
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 
1309
  }
 
1310
 }
 
1311
 return 1;
 
1312
#ifndef TOLUA_RELEASE
 
1313
 tolua_lerror:
 
1314
 tolua_error(tolua_S,"#ferror in function 'asFloat'.",&tolua_err);
 
1315
 return 0;
 
1316
#endif
 
1317
}
 
1318
#endif //#ifndef TOLUA_DISABLE
 
1319
 
 
1320
/* method: Float of class  Atlas::Message::Element */
 
1321
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_Float00
 
1322
static int tolua_Atlas_Atlas_Message_Element_Float00(lua_State* tolua_S)
 
1323
{
 
1324
#ifndef TOLUA_RELEASE
 
1325
 tolua_Error tolua_err;
 
1326
 if (
 
1327
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1328
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1329
 )
 
1330
  goto tolua_lerror;
 
1331
 else
 
1332
#endif
 
1333
 {
 
1334
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1335
#ifndef TOLUA_RELEASE
 
1336
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Float'",NULL);
 
1337
#endif
 
1338
  {
 
1339
   double tolua_ret = (double)  self->Float();
 
1340
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 
1341
  }
 
1342
 }
 
1343
 return 1;
 
1344
#ifndef TOLUA_RELEASE
 
1345
 tolua_lerror:
 
1346
 tolua_error(tolua_S,"#ferror in function 'Float'.",&tolua_err);
 
1347
 return 0;
 
1348
#endif
 
1349
}
 
1350
#endif //#ifndef TOLUA_DISABLE
 
1351
 
 
1352
/* method: asNum of class  Atlas::Message::Element */
 
1353
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_asNum00
 
1354
static int tolua_Atlas_Atlas_Message_Element_asNum00(lua_State* tolua_S)
 
1355
{
 
1356
#ifndef TOLUA_RELEASE
 
1357
 tolua_Error tolua_err;
 
1358
 if (
 
1359
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1360
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1361
 )
 
1362
  goto tolua_lerror;
 
1363
 else
 
1364
#endif
 
1365
 {
 
1366
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1367
#ifndef TOLUA_RELEASE
 
1368
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asNum'",NULL);
 
1369
#endif
 
1370
  {
 
1371
   double tolua_ret = (double)  self->asNum();
 
1372
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 
1373
  }
 
1374
 }
 
1375
 return 1;
 
1376
#ifndef TOLUA_RELEASE
 
1377
 tolua_lerror:
 
1378
 tolua_error(tolua_S,"#ferror in function 'asNum'.",&tolua_err);
 
1379
 return 0;
 
1380
#endif
 
1381
}
 
1382
#endif //#ifndef TOLUA_DISABLE
 
1383
 
 
1384
/* method: asString of class  Atlas::Message::Element */
 
1385
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_asString00
 
1386
static int tolua_Atlas_Atlas_Message_Element_asString00(lua_State* tolua_S)
 
1387
{
 
1388
#ifndef TOLUA_RELEASE
 
1389
 tolua_Error tolua_err;
 
1390
 if (
 
1391
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1392
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1393
 )
 
1394
  goto tolua_lerror;
 
1395
 else
 
1396
#endif
 
1397
 {
 
1398
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1399
#ifndef TOLUA_RELEASE
 
1400
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asString'",NULL);
 
1401
#endif
 
1402
  {
 
1403
   const std::string tolua_ret = (const std::string)  self->asString();
 
1404
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 
1405
  }
 
1406
 }
 
1407
 return 1;
 
1408
#ifndef TOLUA_RELEASE
 
1409
 tolua_lerror:
 
1410
 tolua_error(tolua_S,"#ferror in function 'asString'.",&tolua_err);
 
1411
 return 0;
 
1412
#endif
 
1413
}
 
1414
#endif //#ifndef TOLUA_DISABLE
 
1415
 
 
1416
/* method: asString of class  Atlas::Message::Element */
 
1417
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_asString01
 
1418
static int tolua_Atlas_Atlas_Message_Element_asString01(lua_State* tolua_S)
 
1419
{
 
1420
 tolua_Error tolua_err;
 
1421
 if (
 
1422
     !tolua_isusertype(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
1423
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1424
 )
 
1425
  goto tolua_lerror;
 
1426
 else
 
1427
 {
 
1428
  Atlas::Message::Element* self = (Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1429
#ifndef TOLUA_RELEASE
 
1430
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asString'",NULL);
 
1431
#endif
 
1432
  {
 
1433
   std::string tolua_ret = (std::string)  self->asString();
 
1434
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 
1435
  }
 
1436
 }
 
1437
 return 1;
 
1438
tolua_lerror:
 
1439
 return tolua_Atlas_Atlas_Message_Element_asString00(tolua_S);
 
1440
}
 
1441
#endif //#ifndef TOLUA_DISABLE
 
1442
 
 
1443
/* method: String of class  Atlas::Message::Element */
 
1444
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_String00
 
1445
static int tolua_Atlas_Atlas_Message_Element_String00(lua_State* tolua_S)
 
1446
{
 
1447
#ifndef TOLUA_RELEASE
 
1448
 tolua_Error tolua_err;
 
1449
 if (
 
1450
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1451
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1452
 )
 
1453
  goto tolua_lerror;
 
1454
 else
 
1455
#endif
 
1456
 {
 
1457
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1458
#ifndef TOLUA_RELEASE
 
1459
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'String'",NULL);
 
1460
#endif
 
1461
  {
 
1462
   const std::string tolua_ret = (const std::string)  self->String();
 
1463
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 
1464
  }
 
1465
 }
 
1466
 return 1;
 
1467
#ifndef TOLUA_RELEASE
 
1468
 tolua_lerror:
 
1469
 tolua_error(tolua_S,"#ferror in function 'String'.",&tolua_err);
 
1470
 return 0;
 
1471
#endif
 
1472
}
 
1473
#endif //#ifndef TOLUA_DISABLE
 
1474
 
 
1475
/* method: String of class  Atlas::Message::Element */
 
1476
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_String01
 
1477
static int tolua_Atlas_Atlas_Message_Element_String01(lua_State* tolua_S)
 
1478
{
 
1479
 tolua_Error tolua_err;
 
1480
 if (
 
1481
     !tolua_isusertype(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
1482
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1483
 )
 
1484
  goto tolua_lerror;
 
1485
 else
 
1486
 {
 
1487
  Atlas::Message::Element* self = (Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1488
#ifndef TOLUA_RELEASE
 
1489
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'String'",NULL);
 
1490
#endif
 
1491
  {
 
1492
   std::string tolua_ret = (std::string)  self->String();
 
1493
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 
1494
  }
 
1495
 }
 
1496
 return 1;
 
1497
tolua_lerror:
 
1498
 return tolua_Atlas_Atlas_Message_Element_String00(tolua_S);
 
1499
}
 
1500
#endif //#ifndef TOLUA_DISABLE
 
1501
 
 
1502
/* method: asMap of class  Atlas::Message::Element */
 
1503
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_asMap00
 
1504
static int tolua_Atlas_Atlas_Message_Element_asMap00(lua_State* tolua_S)
 
1505
{
 
1506
#ifndef TOLUA_RELEASE
 
1507
 tolua_Error tolua_err;
 
1508
 if (
 
1509
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1510
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1511
 )
 
1512
  goto tolua_lerror;
 
1513
 else
 
1514
#endif
 
1515
 {
 
1516
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1517
#ifndef TOLUA_RELEASE
 
1518
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asMap'",NULL);
 
1519
#endif
 
1520
  {
 
1521
   const Atlas::Message::MapType& tolua_ret = (const Atlas::Message::MapType&)  self->asMap();
 
1522
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Atlas::Message::MapType");
 
1523
  }
 
1524
 }
 
1525
 return 1;
 
1526
#ifndef TOLUA_RELEASE
 
1527
 tolua_lerror:
 
1528
 tolua_error(tolua_S,"#ferror in function 'asMap'.",&tolua_err);
 
1529
 return 0;
 
1530
#endif
 
1531
}
 
1532
#endif //#ifndef TOLUA_DISABLE
 
1533
 
 
1534
/* method: asMap of class  Atlas::Message::Element */
 
1535
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_asMap01
 
1536
static int tolua_Atlas_Atlas_Message_Element_asMap01(lua_State* tolua_S)
 
1537
{
 
1538
 tolua_Error tolua_err;
 
1539
 if (
 
1540
     !tolua_isusertype(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
1541
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1542
 )
 
1543
  goto tolua_lerror;
 
1544
 else
 
1545
 {
 
1546
  Atlas::Message::Element* self = (Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1547
#ifndef TOLUA_RELEASE
 
1548
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asMap'",NULL);
 
1549
#endif
 
1550
  {
 
1551
   Atlas::Message::MapType& tolua_ret = (Atlas::Message::MapType&)  self->asMap();
 
1552
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Atlas::Message::MapType");
 
1553
  }
 
1554
 }
 
1555
 return 1;
 
1556
tolua_lerror:
 
1557
 return tolua_Atlas_Atlas_Message_Element_asMap00(tolua_S);
 
1558
}
 
1559
#endif //#ifndef TOLUA_DISABLE
 
1560
 
 
1561
/* method: Map of class  Atlas::Message::Element */
 
1562
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_Map00
 
1563
static int tolua_Atlas_Atlas_Message_Element_Map00(lua_State* tolua_S)
 
1564
{
 
1565
#ifndef TOLUA_RELEASE
 
1566
 tolua_Error tolua_err;
 
1567
 if (
 
1568
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1569
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1570
 )
 
1571
  goto tolua_lerror;
 
1572
 else
 
1573
#endif
 
1574
 {
 
1575
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1576
#ifndef TOLUA_RELEASE
 
1577
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Map'",NULL);
 
1578
#endif
 
1579
  {
 
1580
   const Atlas::Message::MapType& tolua_ret = (const Atlas::Message::MapType&)  self->Map();
 
1581
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Atlas::Message::MapType");
 
1582
  }
 
1583
 }
 
1584
 return 1;
 
1585
#ifndef TOLUA_RELEASE
 
1586
 tolua_lerror:
 
1587
 tolua_error(tolua_S,"#ferror in function 'Map'.",&tolua_err);
 
1588
 return 0;
 
1589
#endif
 
1590
}
 
1591
#endif //#ifndef TOLUA_DISABLE
 
1592
 
 
1593
/* method: Map of class  Atlas::Message::Element */
 
1594
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_Map01
 
1595
static int tolua_Atlas_Atlas_Message_Element_Map01(lua_State* tolua_S)
 
1596
{
 
1597
 tolua_Error tolua_err;
 
1598
 if (
 
1599
     !tolua_isusertype(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
1600
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1601
 )
 
1602
  goto tolua_lerror;
 
1603
 else
 
1604
 {
 
1605
  Atlas::Message::Element* self = (Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1606
#ifndef TOLUA_RELEASE
 
1607
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Map'",NULL);
 
1608
#endif
 
1609
  {
 
1610
   Atlas::Message::MapType& tolua_ret = (Atlas::Message::MapType&)  self->Map();
 
1611
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Atlas::Message::MapType");
 
1612
  }
 
1613
 }
 
1614
 return 1;
 
1615
tolua_lerror:
 
1616
 return tolua_Atlas_Atlas_Message_Element_Map00(tolua_S);
 
1617
}
 
1618
#endif //#ifndef TOLUA_DISABLE
 
1619
 
 
1620
/* method: asList of class  Atlas::Message::Element */
 
1621
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_asList00
 
1622
static int tolua_Atlas_Atlas_Message_Element_asList00(lua_State* tolua_S)
 
1623
{
 
1624
#ifndef TOLUA_RELEASE
 
1625
 tolua_Error tolua_err;
 
1626
 if (
 
1627
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1628
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1629
 )
 
1630
  goto tolua_lerror;
 
1631
 else
 
1632
#endif
 
1633
 {
 
1634
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1635
#ifndef TOLUA_RELEASE
 
1636
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asList'",NULL);
 
1637
#endif
 
1638
  {
 
1639
   const Atlas::Message::ListType& tolua_ret = (const Atlas::Message::ListType&)  self->asList();
 
1640
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Atlas::Message::ListType");
 
1641
  }
 
1642
 }
 
1643
 return 1;
 
1644
#ifndef TOLUA_RELEASE
 
1645
 tolua_lerror:
 
1646
 tolua_error(tolua_S,"#ferror in function 'asList'.",&tolua_err);
 
1647
 return 0;
 
1648
#endif
 
1649
}
 
1650
#endif //#ifndef TOLUA_DISABLE
 
1651
 
 
1652
/* method: asList of class  Atlas::Message::Element */
 
1653
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_asList01
 
1654
static int tolua_Atlas_Atlas_Message_Element_asList01(lua_State* tolua_S)
 
1655
{
 
1656
 tolua_Error tolua_err;
 
1657
 if (
 
1658
     !tolua_isusertype(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
1659
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1660
 )
 
1661
  goto tolua_lerror;
 
1662
 else
 
1663
 {
 
1664
  Atlas::Message::Element* self = (Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1665
#ifndef TOLUA_RELEASE
 
1666
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asList'",NULL);
 
1667
#endif
 
1668
  {
 
1669
   Atlas::Message::ListType& tolua_ret = (Atlas::Message::ListType&)  self->asList();
 
1670
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Atlas::Message::ListType");
 
1671
  }
 
1672
 }
 
1673
 return 1;
 
1674
tolua_lerror:
 
1675
 return tolua_Atlas_Atlas_Message_Element_asList00(tolua_S);
 
1676
}
 
1677
#endif //#ifndef TOLUA_DISABLE
 
1678
 
 
1679
/* method: List of class  Atlas::Message::Element */
 
1680
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_List00
 
1681
static int tolua_Atlas_Atlas_Message_Element_List00(lua_State* tolua_S)
 
1682
{
 
1683
#ifndef TOLUA_RELEASE
 
1684
 tolua_Error tolua_err;
 
1685
 if (
 
1686
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::Element",0,&tolua_err) ||
 
1687
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1688
 )
 
1689
  goto tolua_lerror;
 
1690
 else
 
1691
#endif
 
1692
 {
 
1693
  const Atlas::Message::Element* self = (const Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1694
#ifndef TOLUA_RELEASE
 
1695
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'List'",NULL);
 
1696
#endif
 
1697
  {
 
1698
   const Atlas::Message::ListType& tolua_ret = (const Atlas::Message::ListType&)  self->List();
 
1699
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Atlas::Message::ListType");
 
1700
  }
 
1701
 }
 
1702
 return 1;
 
1703
#ifndef TOLUA_RELEASE
 
1704
 tolua_lerror:
 
1705
 tolua_error(tolua_S,"#ferror in function 'List'.",&tolua_err);
 
1706
 return 0;
 
1707
#endif
 
1708
}
 
1709
#endif //#ifndef TOLUA_DISABLE
 
1710
 
 
1711
/* method: List of class  Atlas::Message::Element */
 
1712
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_Element_List01
 
1713
static int tolua_Atlas_Atlas_Message_Element_List01(lua_State* tolua_S)
 
1714
{
 
1715
 tolua_Error tolua_err;
 
1716
 if (
 
1717
     !tolua_isusertype(tolua_S,1,"Atlas::Message::Element",0,&tolua_err) ||
 
1718
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1719
 )
 
1720
  goto tolua_lerror;
 
1721
 else
 
1722
 {
 
1723
  Atlas::Message::Element* self = (Atlas::Message::Element*)  tolua_tousertype(tolua_S,1,0);
 
1724
#ifndef TOLUA_RELEASE
 
1725
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'List'",NULL);
 
1726
#endif
 
1727
  {
 
1728
   Atlas::Message::ListType& tolua_ret = (Atlas::Message::ListType&)  self->List();
 
1729
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Atlas::Message::ListType");
 
1730
  }
 
1731
 }
 
1732
 return 1;
 
1733
tolua_lerror:
 
1734
 return tolua_Atlas_Atlas_Message_Element_List00(tolua_S);
 
1735
}
 
1736
#endif //#ifndef TOLUA_DISABLE
 
1737
 
 
1738
/* get function: first of class  value_type */
 
1739
#ifndef TOLUA_DISABLE_tolua_get_Atlas__Message__MapType__value_type_first
 
1740
static int tolua_get_Atlas__Message__MapType__value_type_first(lua_State* tolua_S)
 
1741
{
 
1742
  Atlas::Message::MapType::value_type* self = (Atlas::Message::MapType::value_type*)  tolua_tousertype(tolua_S,1,0);
 
1743
#ifndef TOLUA_RELEASE
 
1744
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'first'",NULL);
 
1745
#endif
 
1746
  tolua_pushcppstring(tolua_S,(const char*)self->first);
 
1747
 return 1;
 
1748
}
 
1749
#endif //#ifndef TOLUA_DISABLE
 
1750
 
 
1751
/* get function: second of class  value_type */
 
1752
#ifndef TOLUA_DISABLE_tolua_get_Atlas__Message__MapType__value_type_second_ref
 
1753
static int tolua_get_Atlas__Message__MapType__value_type_second_ref(lua_State* tolua_S)
 
1754
{
 
1755
  Atlas::Message::MapType::value_type* self = (Atlas::Message::MapType::value_type*)  tolua_tousertype(tolua_S,1,0);
 
1756
#ifndef TOLUA_RELEASE
 
1757
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'second'",NULL);
 
1758
#endif
 
1759
  tolua_pushusertype(tolua_S,(void*)&self->second,"Atlas::Message::Element");
 
1760
 return 1;
 
1761
}
 
1762
#endif //#ifndef TOLUA_DISABLE
 
1763
 
 
1764
/* set function: second of class  value_type */
 
1765
#ifndef TOLUA_DISABLE_tolua_set_Atlas__Message__MapType__value_type_second_ref
 
1766
static int tolua_set_Atlas__Message__MapType__value_type_second_ref(lua_State* tolua_S)
 
1767
{
 
1768
  Atlas::Message::MapType::value_type* self = (Atlas::Message::MapType::value_type*)  tolua_tousertype(tolua_S,1,0);
 
1769
#ifndef TOLUA_RELEASE
 
1770
  tolua_Error tolua_err;
 
1771
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'second'",NULL);
 
1772
  if (!tolua_isusertype(tolua_S,2,"Atlas::Message::Element",0,&tolua_err))
 
1773
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
1774
#endif
 
1775
  self->second = ((Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0))
 
1776
;
 
1777
 return 0;
 
1778
}
 
1779
#endif //#ifndef TOLUA_DISABLE
 
1780
 
 
1781
/* method: operator* of class  iterator */
 
1782
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_MapType_iterator__mul00
 
1783
static int tolua_Atlas_Atlas_Message_MapType_iterator__mul00(lua_State* tolua_S)
 
1784
{
 
1785
#ifndef TOLUA_RELEASE
 
1786
 tolua_Error tolua_err;
 
1787
 if (
 
1788
     !tolua_isusertype(tolua_S,1,"Atlas::Message::MapType::iterator",0,&tolua_err) ||
 
1789
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1790
 )
 
1791
  goto tolua_lerror;
 
1792
 else
 
1793
#endif
 
1794
 {
 
1795
  Atlas::Message::MapType::iterator* self = (Atlas::Message::MapType::iterator*)  tolua_tousertype(tolua_S,1,0);
 
1796
#ifndef TOLUA_RELEASE
 
1797
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
 
1798
#endif
 
1799
  {
 
1800
   Atlas::Message::MapType::value_type& tolua_ret = (Atlas::Message::MapType::value_type&)  self->operator*();
 
1801
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Atlas::Message::MapType::value_type");
 
1802
  }
 
1803
 }
 
1804
 return 1;
 
1805
#ifndef TOLUA_RELEASE
 
1806
 tolua_lerror:
 
1807
 tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
 
1808
 return 0;
 
1809
#endif
 
1810
}
 
1811
#endif //#ifndef TOLUA_DISABLE
 
1812
 
 
1813
/* method: operator== of class  iterator */
 
1814
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_MapType_iterator__eq00
 
1815
static int tolua_Atlas_Atlas_Message_MapType_iterator__eq00(lua_State* tolua_S)
 
1816
{
 
1817
#ifndef TOLUA_RELEASE
 
1818
 tolua_Error tolua_err;
 
1819
 if (
 
1820
     !tolua_isusertype(tolua_S,1,"Atlas::Message::MapType::iterator",0,&tolua_err) ||
 
1821
     !tolua_isusertype(tolua_S,2,"const Atlas::Message::MapType::iterator",0,&tolua_err) ||
 
1822
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
1823
 )
 
1824
  goto tolua_lerror;
 
1825
 else
 
1826
#endif
 
1827
 {
 
1828
  Atlas::Message::MapType::iterator* self = (Atlas::Message::MapType::iterator*)  tolua_tousertype(tolua_S,1,0);
 
1829
  const Atlas::Message::MapType::iterator* value = ((const Atlas::Message::MapType::iterator*)  tolua_tousertype(tolua_S,2,0));
 
1830
#ifndef TOLUA_RELEASE
 
1831
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
 
1832
#endif
 
1833
  {
 
1834
   bool tolua_ret = (bool)  self->operator==(*value);
 
1835
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
1836
  }
 
1837
 }
 
1838
 return 1;
 
1839
#ifndef TOLUA_RELEASE
 
1840
 tolua_lerror:
 
1841
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 
1842
 return 0;
 
1843
#endif
 
1844
}
 
1845
#endif //#ifndef TOLUA_DISABLE
 
1846
 
 
1847
/* method: clear of class  Atlas::Message::MapType */
 
1848
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_MapType_clear00
 
1849
static int tolua_Atlas_Atlas_Message_MapType_clear00(lua_State* tolua_S)
 
1850
{
 
1851
#ifndef TOLUA_RELEASE
 
1852
 tolua_Error tolua_err;
 
1853
 if (
 
1854
     !tolua_isusertype(tolua_S,1,"Atlas::Message::MapType",0,&tolua_err) ||
 
1855
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1856
 )
 
1857
  goto tolua_lerror;
 
1858
 else
 
1859
#endif
 
1860
 {
 
1861
  Atlas::Message::MapType* self = (Atlas::Message::MapType*)  tolua_tousertype(tolua_S,1,0);
 
1862
#ifndef TOLUA_RELEASE
 
1863
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'",NULL);
 
1864
#endif
 
1865
  {
 
1866
   self->clear();
 
1867
  }
 
1868
 }
 
1869
 return 0;
 
1870
#ifndef TOLUA_RELEASE
 
1871
 tolua_lerror:
 
1872
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 
1873
 return 0;
 
1874
#endif
 
1875
}
 
1876
#endif //#ifndef TOLUA_DISABLE
 
1877
 
 
1878
/* method: size of class  Atlas::Message::MapType */
 
1879
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_MapType_size00
 
1880
static int tolua_Atlas_Atlas_Message_MapType_size00(lua_State* tolua_S)
 
1881
{
 
1882
#ifndef TOLUA_RELEASE
 
1883
 tolua_Error tolua_err;
 
1884
 if (
 
1885
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::MapType",0,&tolua_err) ||
 
1886
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1887
 )
 
1888
  goto tolua_lerror;
 
1889
 else
 
1890
#endif
 
1891
 {
 
1892
  const Atlas::Message::MapType* self = (const Atlas::Message::MapType*)  tolua_tousertype(tolua_S,1,0);
 
1893
#ifndef TOLUA_RELEASE
 
1894
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'",NULL);
 
1895
#endif
 
1896
  {
 
1897
   int tolua_ret = (int)  self->size();
 
1898
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 
1899
  }
 
1900
 }
 
1901
 return 1;
 
1902
#ifndef TOLUA_RELEASE
 
1903
 tolua_lerror:
 
1904
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 
1905
 return 0;
 
1906
#endif
 
1907
}
 
1908
#endif //#ifndef TOLUA_DISABLE
 
1909
 
 
1910
/* method: find of class  Atlas::Message::MapType */
 
1911
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_MapType_find00
 
1912
static int tolua_Atlas_Atlas_Message_MapType_find00(lua_State* tolua_S)
 
1913
{
 
1914
#ifndef TOLUA_RELEASE
 
1915
 tolua_Error tolua_err;
 
1916
 if (
 
1917
     !tolua_isusertype(tolua_S,1,"Atlas::Message::MapType",0,&tolua_err) ||
 
1918
     !tolua_iscppstring_type(tolua_S,2,0,&tolua_err) ||
 
1919
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
1920
 )
 
1921
  goto tolua_lerror;
 
1922
 else
 
1923
#endif
 
1924
 {
 
1925
  Atlas::Message::MapType* self = (Atlas::Message::MapType*)  tolua_tousertype(tolua_S,1,0);
 
1926
  const std::string index = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
1927
#ifndef TOLUA_RELEASE
 
1928
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'find'",NULL);
 
1929
#endif
 
1930
  {
 
1931
   Atlas::Message::MapType::iterator tolua_ret = (Atlas::Message::MapType::iterator)  self->find(index);
 
1932
   {
 
1933
#ifdef __cplusplus
 
1934
    void* tolua_obj = new Atlas::Message::MapType::iterator(tolua_ret);
 
1935
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Atlas::Message::MapType::iterator");
 
1936
#else
 
1937
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Atlas::Message::MapType::iterator));
 
1938
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Atlas::Message::MapType::iterator");
 
1939
#endif
 
1940
   }
 
1941
   tolua_pushcppstring(tolua_S,(const char*)index);
 
1942
  }
 
1943
 }
 
1944
 return 2;
 
1945
#ifndef TOLUA_RELEASE
 
1946
 tolua_lerror:
 
1947
 tolua_error(tolua_S,"#ferror in function 'find'.",&tolua_err);
 
1948
 return 0;
 
1949
#endif
 
1950
}
 
1951
#endif //#ifndef TOLUA_DISABLE
 
1952
 
 
1953
/* method: end of class  Atlas::Message::MapType */
 
1954
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_MapType_theEnd00
 
1955
static int tolua_Atlas_Atlas_Message_MapType_theEnd00(lua_State* tolua_S)
 
1956
{
 
1957
#ifndef TOLUA_RELEASE
 
1958
 tolua_Error tolua_err;
 
1959
 if (
 
1960
     !tolua_isusertype(tolua_S,1,"Atlas::Message::MapType",0,&tolua_err) ||
 
1961
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1962
 )
 
1963
  goto tolua_lerror;
 
1964
 else
 
1965
#endif
 
1966
 {
 
1967
  Atlas::Message::MapType* self = (Atlas::Message::MapType*)  tolua_tousertype(tolua_S,1,0);
 
1968
#ifndef TOLUA_RELEASE
 
1969
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'end'",NULL);
 
1970
#endif
 
1971
  {
 
1972
   Atlas::Message::MapType::iterator tolua_ret = (Atlas::Message::MapType::iterator)  self->end();
 
1973
   {
 
1974
#ifdef __cplusplus
 
1975
    void* tolua_obj = new Atlas::Message::MapType::iterator(tolua_ret);
 
1976
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Atlas::Message::MapType::iterator");
 
1977
#else
 
1978
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Atlas::Message::MapType::iterator));
 
1979
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Atlas::Message::MapType::iterator");
 
1980
#endif
 
1981
   }
 
1982
  }
 
1983
 }
 
1984
 return 1;
 
1985
#ifndef TOLUA_RELEASE
 
1986
 tolua_lerror:
 
1987
 tolua_error(tolua_S,"#ferror in function 'theEnd'.",&tolua_err);
 
1988
 return 0;
 
1989
#endif
 
1990
}
 
1991
#endif //#ifndef TOLUA_DISABLE
 
1992
 
 
1993
/* method: _MapType_findInMap of class  Atlas::Message::MapType */
 
1994
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_MapType_get00
 
1995
static int tolua_Atlas_Atlas_Message_MapType_get00(lua_State* tolua_S)
 
1996
{
 
1997
#ifndef TOLUA_RELEASE
 
1998
 tolua_Error tolua_err;
 
1999
 if (
 
2000
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::MapType",0,&tolua_err) ||
 
2001
     !tolua_iscppstring_type(tolua_S,2,0,&tolua_err) ||
 
2002
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2003
 )
 
2004
  goto tolua_lerror;
 
2005
 else
 
2006
#endif
 
2007
 {
 
2008
  const Atlas::Message::MapType* self = (const Atlas::Message::MapType*)  tolua_tousertype(tolua_S,1,0);
 
2009
  const std::string index = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
2010
#ifndef TOLUA_RELEASE
 
2011
  if (!self) tolua_error(tolua_S,"invalid 'self' in function '_MapType_findInMap'",NULL);
 
2012
#endif
 
2013
  {
 
2014
     const Atlas::Message::Element& tolua_ret = (  const Atlas::Message::Element&)  _MapType_findInMap(self,index);
 
2015
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Atlas::Message::Element");
 
2016
   tolua_pushcppstring(tolua_S,(const char*)index);
 
2017
  }
 
2018
 }
 
2019
 return 2;
 
2020
#ifndef TOLUA_RELEASE
 
2021
 tolua_lerror:
 
2022
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 
2023
 return 0;
 
2024
#endif
 
2025
}
 
2026
#endif //#ifndef TOLUA_DISABLE
 
2027
 
 
2028
/* method: __operator_index of class  Atlas::Message::MapType */
 
2029
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_MapType_get01
 
2030
static int tolua_Atlas_Atlas_Message_MapType_get01(lua_State* tolua_S)
 
2031
{
 
2032
 tolua_Error tolua_err;
 
2033
 if (
 
2034
     !tolua_isusertype(tolua_S,1,"Atlas::Message::MapType",0,&tolua_err) ||
 
2035
     !tolua_iscppstring_type(tolua_S,2,0,&tolua_err) ||
 
2036
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2037
 )
 
2038
  goto tolua_lerror;
 
2039
 else
 
2040
 {
 
2041
  Atlas::Message::MapType* self = (Atlas::Message::MapType*)  tolua_tousertype(tolua_S,1,0);
 
2042
  const std::string index = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
2043
#ifndef TOLUA_RELEASE
 
2044
  if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_index'",NULL);
 
2045
#endif
 
2046
  {
 
2047
   Atlas::Message::Element& tolua_ret = (Atlas::Message::Element&)  self->__operator_index(index);
 
2048
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Atlas::Message::Element");
 
2049
   tolua_pushcppstring(tolua_S,(const char*)index);
 
2050
  }
 
2051
 }
 
2052
 return 2;
 
2053
tolua_lerror:
 
2054
 return tolua_Atlas_Atlas_Message_MapType_get00(tolua_S);
 
2055
}
 
2056
#endif //#ifndef TOLUA_DISABLE
 
2057
 
 
2058
/* method: new of class  Atlas::Message::MapType */
 
2059
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_MapType_new00
 
2060
static int tolua_Atlas_Atlas_Message_MapType_new00(lua_State* tolua_S)
 
2061
{
 
2062
#ifndef TOLUA_RELEASE
 
2063
 tolua_Error tolua_err;
 
2064
 if (
 
2065
     !tolua_isusertable(tolua_S,1,"Atlas::Message::MapType",0,&tolua_err) ||
 
2066
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2067
 )
 
2068
  goto tolua_lerror;
 
2069
 else
 
2070
#endif
 
2071
 {
 
2072
  {
 
2073
   Atlas::Message::MapType* tolua_ret = (Atlas::Message::MapType*)  new Atlas::Message::MapType();
 
2074
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Atlas::Message::MapType");
 
2075
  }
 
2076
 }
 
2077
 return 1;
 
2078
#ifndef TOLUA_RELEASE
 
2079
 tolua_lerror:
 
2080
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 
2081
 return 0;
 
2082
#endif
 
2083
}
 
2084
#endif //#ifndef TOLUA_DISABLE
 
2085
 
 
2086
/* method: new_local of class  Atlas::Message::MapType */
 
2087
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_MapType_new00_local
 
2088
static int tolua_Atlas_Atlas_Message_MapType_new00_local(lua_State* tolua_S)
 
2089
{
 
2090
#ifndef TOLUA_RELEASE
 
2091
 tolua_Error tolua_err;
 
2092
 if (
 
2093
     !tolua_isusertable(tolua_S,1,"Atlas::Message::MapType",0,&tolua_err) ||
 
2094
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2095
 )
 
2096
  goto tolua_lerror;
 
2097
 else
 
2098
#endif
 
2099
 {
 
2100
  {
 
2101
   Atlas::Message::MapType* tolua_ret = (Atlas::Message::MapType*)  new Atlas::Message::MapType();
 
2102
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Atlas::Message::MapType");
 
2103
  }
 
2104
 }
 
2105
 return 1;
 
2106
#ifndef TOLUA_RELEASE
 
2107
 tolua_lerror:
 
2108
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 
2109
 return 0;
 
2110
#endif
 
2111
}
 
2112
#endif //#ifndef TOLUA_DISABLE
 
2113
 
 
2114
/* method: delete of class  Atlas::Message::MapType */
 
2115
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_MapType_delete00
 
2116
static int tolua_Atlas_Atlas_Message_MapType_delete00(lua_State* tolua_S)
 
2117
{
 
2118
#ifndef TOLUA_RELEASE
 
2119
 tolua_Error tolua_err;
 
2120
 if (
 
2121
     !tolua_isusertype(tolua_S,1,"Atlas::Message::MapType",0,&tolua_err) ||
 
2122
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2123
 )
 
2124
  goto tolua_lerror;
 
2125
 else
 
2126
#endif
 
2127
 {
 
2128
  Atlas::Message::MapType* self = (Atlas::Message::MapType*)  tolua_tousertype(tolua_S,1,0);
 
2129
#ifndef TOLUA_RELEASE
 
2130
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
 
2131
#endif
 
2132
  delete self;
 
2133
 }
 
2134
 return 0;
 
2135
#ifndef TOLUA_RELEASE
 
2136
 tolua_lerror:
 
2137
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 
2138
 return 0;
 
2139
#endif
 
2140
}
 
2141
#endif //#ifndef TOLUA_DISABLE
 
2142
 
 
2143
/* method: clear of class  Atlas::Message::ListType */
 
2144
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_ListType_clear00
 
2145
static int tolua_Atlas_Atlas_Message_ListType_clear00(lua_State* tolua_S)
 
2146
{
 
2147
#ifndef TOLUA_RELEASE
 
2148
 tolua_Error tolua_err;
 
2149
 if (
 
2150
     !tolua_isusertype(tolua_S,1,"Atlas::Message::ListType",0,&tolua_err) ||
 
2151
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2152
 )
 
2153
  goto tolua_lerror;
 
2154
 else
 
2155
#endif
 
2156
 {
 
2157
  Atlas::Message::ListType* self = (Atlas::Message::ListType*)  tolua_tousertype(tolua_S,1,0);
 
2158
#ifndef TOLUA_RELEASE
 
2159
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'",NULL);
 
2160
#endif
 
2161
  {
 
2162
   self->clear();
 
2163
  }
 
2164
 }
 
2165
 return 0;
 
2166
#ifndef TOLUA_RELEASE
 
2167
 tolua_lerror:
 
2168
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 
2169
 return 0;
 
2170
#endif
 
2171
}
 
2172
#endif //#ifndef TOLUA_DISABLE
 
2173
 
 
2174
/* method: size of class  Atlas::Message::ListType */
 
2175
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_ListType_size00
 
2176
static int tolua_Atlas_Atlas_Message_ListType_size00(lua_State* tolua_S)
 
2177
{
 
2178
#ifndef TOLUA_RELEASE
 
2179
 tolua_Error tolua_err;
 
2180
 if (
 
2181
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::ListType",0,&tolua_err) ||
 
2182
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2183
 )
 
2184
  goto tolua_lerror;
 
2185
 else
 
2186
#endif
 
2187
 {
 
2188
  const Atlas::Message::ListType* self = (const Atlas::Message::ListType*)  tolua_tousertype(tolua_S,1,0);
 
2189
#ifndef TOLUA_RELEASE
 
2190
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'",NULL);
 
2191
#endif
 
2192
  {
 
2193
   int tolua_ret = (int)  self->size();
 
2194
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 
2195
  }
 
2196
 }
 
2197
 return 1;
 
2198
#ifndef TOLUA_RELEASE
 
2199
 tolua_lerror:
 
2200
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 
2201
 return 0;
 
2202
#endif
 
2203
}
 
2204
#endif //#ifndef TOLUA_DISABLE
 
2205
 
 
2206
/* method: operator[] of class  Atlas::Message::ListType */
 
2207
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_ListType__geti00
 
2208
static int tolua_Atlas_Atlas_Message_ListType__geti00(lua_State* tolua_S)
 
2209
{
 
2210
#ifndef TOLUA_RELEASE
 
2211
 tolua_Error tolua_err;
 
2212
 if (
 
2213
     !tolua_isusertype(tolua_S,1,"const Atlas::Message::ListType",0,&tolua_err) ||
 
2214
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
2215
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2216
 )
 
2217
  goto tolua_lerror;
 
2218
 else
 
2219
#endif
 
2220
 {
 
2221
  const Atlas::Message::ListType* self = (const Atlas::Message::ListType*)  tolua_tousertype(tolua_S,1,0);
 
2222
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
 
2223
#ifndef TOLUA_RELEASE
 
2224
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'",NULL);
 
2225
#endif
 
2226
  {
 
2227
   const Atlas::Message::Element tolua_ret = (const Atlas::Message::Element)  self->operator[](index);
 
2228
   {
 
2229
#ifdef __cplusplus
 
2230
    void* tolua_obj = new Atlas::Message::Element(tolua_ret);
 
2231
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"const Atlas::Message::Element");
 
2232
#else
 
2233
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const Atlas::Message::Element));
 
2234
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"const Atlas::Message::Element");
 
2235
#endif
 
2236
   }
 
2237
  }
 
2238
 }
 
2239
 return 1;
 
2240
#ifndef TOLUA_RELEASE
 
2241
 tolua_lerror:
 
2242
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 
2243
 return 0;
 
2244
#endif
 
2245
}
 
2246
#endif //#ifndef TOLUA_DISABLE
 
2247
 
 
2248
/* method: operator&[] of class  Atlas::Message::ListType */
 
2249
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_ListType__seti00
 
2250
static int tolua_Atlas_Atlas_Message_ListType__seti00(lua_State* tolua_S)
 
2251
{
 
2252
#ifndef TOLUA_RELEASE
 
2253
 tolua_Error tolua_err;
 
2254
 if (
 
2255
     !tolua_isusertype(tolua_S,1,"Atlas::Message::ListType",0,&tolua_err) ||
 
2256
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
2257
     !tolua_isusertype(tolua_S,3,"Atlas::Message::Element",0,&tolua_err) ||
 
2258
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 
2259
 )
 
2260
  goto tolua_lerror;
 
2261
 else
 
2262
#endif
 
2263
 {
 
2264
  Atlas::Message::ListType* self = (Atlas::Message::ListType*)  tolua_tousertype(tolua_S,1,0);
 
2265
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
 
2266
  Atlas::Message::Element tolua_value = *((Atlas::Message::Element*)  tolua_tousertype(tolua_S,3,0));
 
2267
#ifndef TOLUA_RELEASE
 
2268
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'",NULL);
 
2269
#endif
 
2270
  self->operator[](index) =  tolua_value;
 
2271
 }
 
2272
 return 0;
 
2273
#ifndef TOLUA_RELEASE
 
2274
 tolua_lerror:
 
2275
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 
2276
 return 0;
 
2277
#endif
 
2278
}
 
2279
#endif //#ifndef TOLUA_DISABLE
 
2280
 
 
2281
/* method: operator[] of class  Atlas::Message::ListType */
 
2282
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_ListType__geti01
 
2283
static int tolua_Atlas_Atlas_Message_ListType__geti01(lua_State* tolua_S)
 
2284
{
 
2285
 tolua_Error tolua_err;
 
2286
 if (
 
2287
     !tolua_isusertype(tolua_S,1,"Atlas::Message::ListType",0,&tolua_err) ||
 
2288
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
2289
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2290
 )
 
2291
  goto tolua_lerror;
 
2292
 else
 
2293
 {
 
2294
  Atlas::Message::ListType* self = (Atlas::Message::ListType*)  tolua_tousertype(tolua_S,1,0);
 
2295
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
 
2296
#ifndef TOLUA_RELEASE
 
2297
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'",NULL);
 
2298
#endif
 
2299
  {
 
2300
   Atlas::Message::Element tolua_ret = (Atlas::Message::Element)  self->operator[](index);
 
2301
   {
 
2302
#ifdef __cplusplus
 
2303
    void* tolua_obj = new Atlas::Message::Element(tolua_ret);
 
2304
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Atlas::Message::Element");
 
2305
#else
 
2306
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Atlas::Message::Element));
 
2307
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Atlas::Message::Element");
 
2308
#endif
 
2309
   }
 
2310
  }
 
2311
 }
 
2312
 return 1;
 
2313
tolua_lerror:
 
2314
 return tolua_Atlas_Atlas_Message_ListType__geti00(tolua_S);
 
2315
}
 
2316
#endif //#ifndef TOLUA_DISABLE
 
2317
 
 
2318
/* method: push_back of class  Atlas::Message::ListType */
 
2319
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_ListType_push_back00
 
2320
static int tolua_Atlas_Atlas_Message_ListType_push_back00(lua_State* tolua_S)
 
2321
{
 
2322
#ifndef TOLUA_RELEASE
 
2323
 tolua_Error tolua_err;
 
2324
 if (
 
2325
     !tolua_isusertype(tolua_S,1,"Atlas::Message::ListType",0,&tolua_err) ||
 
2326
     !tolua_isusertype(tolua_S,2,"Atlas::Message::Element",0,&tolua_err) ||
 
2327
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2328
 )
 
2329
  goto tolua_lerror;
 
2330
 else
 
2331
#endif
 
2332
 {
 
2333
  Atlas::Message::ListType* self = (Atlas::Message::ListType*)  tolua_tousertype(tolua_S,1,0);
 
2334
  Atlas::Message::Element val = *((Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
 
2335
#ifndef TOLUA_RELEASE
 
2336
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'",NULL);
 
2337
#endif
 
2338
  {
 
2339
   self->push_back(val);
 
2340
  }
 
2341
 }
 
2342
 return 0;
 
2343
#ifndef TOLUA_RELEASE
 
2344
 tolua_lerror:
 
2345
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 
2346
 return 0;
 
2347
#endif
 
2348
}
 
2349
#endif //#ifndef TOLUA_DISABLE
 
2350
 
 
2351
/* method: push_back of class  Atlas::Message::ListType */
 
2352
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_ListType_push_back01
 
2353
static int tolua_Atlas_Atlas_Message_ListType_push_back01(lua_State* tolua_S)
 
2354
{
 
2355
 tolua_Error tolua_err;
 
2356
 if (
 
2357
     !tolua_isusertype(tolua_S,1,"Atlas::Message::ListType",0,&tolua_err) ||
 
2358
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
2359
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2360
 )
 
2361
  goto tolua_lerror;
 
2362
 else
 
2363
 {
 
2364
  Atlas::Message::ListType* self = (Atlas::Message::ListType*)  tolua_tousertype(tolua_S,1,0);
 
2365
  int val = ((int)  tolua_tonumber(tolua_S,2,0));
 
2366
#ifndef TOLUA_RELEASE
 
2367
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'",NULL);
 
2368
#endif
 
2369
  {
 
2370
   self->push_back(val);
 
2371
  }
 
2372
 }
 
2373
 return 0;
 
2374
tolua_lerror:
 
2375
 return tolua_Atlas_Atlas_Message_ListType_push_back00(tolua_S);
 
2376
}
 
2377
#endif //#ifndef TOLUA_DISABLE
 
2378
 
 
2379
/* method: push_back of class  Atlas::Message::ListType */
 
2380
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_ListType_push_back02
 
2381
static int tolua_Atlas_Atlas_Message_ListType_push_back02(lua_State* tolua_S)
 
2382
{
 
2383
 tolua_Error tolua_err;
 
2384
 if (
 
2385
     !tolua_isusertype(tolua_S,1,"Atlas::Message::ListType",0,&tolua_err) ||
 
2386
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 
2387
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2388
 )
 
2389
  goto tolua_lerror;
 
2390
 else
 
2391
 {
 
2392
  Atlas::Message::ListType* self = (Atlas::Message::ListType*)  tolua_tousertype(tolua_S,1,0);
 
2393
  bool val = ((bool)  tolua_toboolean(tolua_S,2,0));
 
2394
#ifndef TOLUA_RELEASE
 
2395
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'",NULL);
 
2396
#endif
 
2397
  {
 
2398
   self->push_back(val);
 
2399
  }
 
2400
 }
 
2401
 return 0;
 
2402
tolua_lerror:
 
2403
 return tolua_Atlas_Atlas_Message_ListType_push_back01(tolua_S);
 
2404
}
 
2405
#endif //#ifndef TOLUA_DISABLE
 
2406
 
 
2407
/* method: push_back of class  Atlas::Message::ListType */
 
2408
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_ListType_push_back03
 
2409
static int tolua_Atlas_Atlas_Message_ListType_push_back03(lua_State* tolua_S)
 
2410
{
 
2411
 tolua_Error tolua_err;
 
2412
 if (
 
2413
     !tolua_isusertype(tolua_S,1,"Atlas::Message::ListType",0,&tolua_err) ||
 
2414
     !tolua_isnumber_type(tolua_S,2,0,&tolua_err) ||
 
2415
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2416
 )
 
2417
  goto tolua_lerror;
 
2418
 else
 
2419
 {
 
2420
  Atlas::Message::ListType* self = (Atlas::Message::ListType*)  tolua_tousertype(tolua_S,1,0);
 
2421
  double val = ((double)  tolua_tonumber(tolua_S,2,0));
 
2422
#ifndef TOLUA_RELEASE
 
2423
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'",NULL);
 
2424
#endif
 
2425
  {
 
2426
   self->push_back(val);
 
2427
  }
 
2428
 }
 
2429
 return 0;
 
2430
tolua_lerror:
 
2431
 return tolua_Atlas_Atlas_Message_ListType_push_back02(tolua_S);
 
2432
}
 
2433
#endif //#ifndef TOLUA_DISABLE
 
2434
 
 
2435
/* method: push_back of class  Atlas::Message::ListType */
 
2436
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_ListType_push_back04
 
2437
static int tolua_Atlas_Atlas_Message_ListType_push_back04(lua_State* tolua_S)
 
2438
{
 
2439
 tolua_Error tolua_err;
 
2440
 if (
 
2441
     !tolua_isusertype(tolua_S,1,"Atlas::Message::ListType",0,&tolua_err) ||
 
2442
     !tolua_isstring_type(tolua_S,2,0,&tolua_err) ||
 
2443
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2444
 )
 
2445
  goto tolua_lerror;
 
2446
 else
 
2447
 {
 
2448
  Atlas::Message::ListType* self = (Atlas::Message::ListType*)  tolua_tousertype(tolua_S,1,0);
 
2449
  const char* val = ((const char*)  tolua_tostring(tolua_S,2,0));
 
2450
#ifndef TOLUA_RELEASE
 
2451
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'",NULL);
 
2452
#endif
 
2453
  {
 
2454
   self->push_back(val);
 
2455
  }
 
2456
 }
 
2457
 return 0;
 
2458
tolua_lerror:
 
2459
 return tolua_Atlas_Atlas_Message_ListType_push_back03(tolua_S);
 
2460
}
 
2461
#endif //#ifndef TOLUA_DISABLE
 
2462
 
 
2463
/* method: push_back of class  Atlas::Message::ListType */
 
2464
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_ListType_push_back05
 
2465
static int tolua_Atlas_Atlas_Message_ListType_push_back05(lua_State* tolua_S)
 
2466
{
 
2467
 tolua_Error tolua_err;
 
2468
 if (
 
2469
     !tolua_isusertype(tolua_S,1,"Atlas::Message::ListType",0,&tolua_err) ||
 
2470
     !tolua_iscppstring_type(tolua_S,2,0,&tolua_err) ||
 
2471
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2472
 )
 
2473
  goto tolua_lerror;
 
2474
 else
 
2475
 {
 
2476
  Atlas::Message::ListType* self = (Atlas::Message::ListType*)  tolua_tousertype(tolua_S,1,0);
 
2477
  const std::string val = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
2478
#ifndef TOLUA_RELEASE
 
2479
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'",NULL);
 
2480
#endif
 
2481
  {
 
2482
   self->push_back(val);
 
2483
   tolua_pushcppstring(tolua_S,(const char*)val);
 
2484
  }
 
2485
 }
 
2486
 return 1;
 
2487
tolua_lerror:
 
2488
 return tolua_Atlas_Atlas_Message_ListType_push_back04(tolua_S);
 
2489
}
 
2490
#endif //#ifndef TOLUA_DISABLE
 
2491
 
 
2492
/* method: new of class  Atlas::Message::ListType */
 
2493
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_ListType_new00
 
2494
static int tolua_Atlas_Atlas_Message_ListType_new00(lua_State* tolua_S)
 
2495
{
 
2496
#ifndef TOLUA_RELEASE
 
2497
 tolua_Error tolua_err;
 
2498
 if (
 
2499
     !tolua_isusertable(tolua_S,1,"Atlas::Message::ListType",0,&tolua_err) ||
 
2500
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2501
 )
 
2502
  goto tolua_lerror;
 
2503
 else
 
2504
#endif
 
2505
 {
 
2506
  {
 
2507
   Atlas::Message::ListType* tolua_ret = (Atlas::Message::ListType*)  new Atlas::Message::ListType();
 
2508
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Atlas::Message::ListType");
 
2509
  }
 
2510
 }
 
2511
 return 1;
 
2512
#ifndef TOLUA_RELEASE
 
2513
 tolua_lerror:
 
2514
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 
2515
 return 0;
 
2516
#endif
 
2517
}
 
2518
#endif //#ifndef TOLUA_DISABLE
 
2519
 
 
2520
/* method: new_local of class  Atlas::Message::ListType */
 
2521
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_ListType_new00_local
 
2522
static int tolua_Atlas_Atlas_Message_ListType_new00_local(lua_State* tolua_S)
 
2523
{
 
2524
#ifndef TOLUA_RELEASE
 
2525
 tolua_Error tolua_err;
 
2526
 if (
 
2527
     !tolua_isusertable(tolua_S,1,"Atlas::Message::ListType",0,&tolua_err) ||
 
2528
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2529
 )
 
2530
  goto tolua_lerror;
 
2531
 else
 
2532
#endif
 
2533
 {
 
2534
  {
 
2535
   Atlas::Message::ListType* tolua_ret = (Atlas::Message::ListType*)  new Atlas::Message::ListType();
 
2536
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Atlas::Message::ListType");
 
2537
  }
 
2538
 }
 
2539
 return 1;
 
2540
#ifndef TOLUA_RELEASE
 
2541
 tolua_lerror:
 
2542
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 
2543
 return 0;
 
2544
#endif
 
2545
}
 
2546
#endif //#ifndef TOLUA_DISABLE
 
2547
 
 
2548
/* method: delete of class  Atlas::Message::ListType */
 
2549
#ifndef TOLUA_DISABLE_tolua_Atlas_Atlas_Message_ListType_delete00
 
2550
static int tolua_Atlas_Atlas_Message_ListType_delete00(lua_State* tolua_S)
 
2551
{
 
2552
#ifndef TOLUA_RELEASE
 
2553
 tolua_Error tolua_err;
 
2554
 if (
 
2555
     !tolua_isusertype(tolua_S,1,"Atlas::Message::ListType",0,&tolua_err) ||
 
2556
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2557
 )
 
2558
  goto tolua_lerror;
 
2559
 else
 
2560
#endif
 
2561
 {
 
2562
  Atlas::Message::ListType* self = (Atlas::Message::ListType*)  tolua_tousertype(tolua_S,1,0);
 
2563
#ifndef TOLUA_RELEASE
 
2564
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
 
2565
#endif
 
2566
  delete self;
 
2567
 }
 
2568
 return 0;
 
2569
#ifndef TOLUA_RELEASE
 
2570
 tolua_lerror:
 
2571
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 
2572
 return 0;
 
2573
#endif
 
2574
}
 
2575
#endif //#ifndef TOLUA_DISABLE
 
2576
 
 
2577
/* Open function */
 
2578
TOLUA_API int tolua_Atlas_open (lua_State* tolua_S)
 
2579
{
 
2580
 tolua_open(tolua_S);
 
2581
 tolua_reg_types(tolua_S);
 
2582
 tolua_module(tolua_S,NULL,0);
 
2583
 tolua_beginmodule(tolua_S,NULL);
 
2584
  tolua_module(tolua_S,"Atlas",0);
 
2585
  tolua_beginmodule(tolua_S,"Atlas");
 
2586
   tolua_module(tolua_S,"Message",0);
 
2587
   tolua_beginmodule(tolua_S,"Message");
 
2588
    #ifdef __cplusplus
 
2589
    tolua_cclass(tolua_S,"Element","Atlas::Message::Element","",tolua_collect_Atlas__Message__Element);
 
2590
    #else
 
2591
    tolua_cclass(tolua_S,"Element","Atlas::Message::Element","",NULL);
 
2592
    #endif
 
2593
    tolua_beginmodule(tolua_S,"Element");
 
2594
     tolua_constant(tolua_S,"TYPE_NONE",Atlas::Message::Element::TYPE_NONE);
 
2595
     tolua_constant(tolua_S,"TYPE_INT",Atlas::Message::Element::TYPE_INT);
 
2596
     tolua_constant(tolua_S,"TYPE_FLOAT",Atlas::Message::Element::TYPE_FLOAT);
 
2597
     tolua_constant(tolua_S,"TYPE_PTR",Atlas::Message::Element::TYPE_PTR);
 
2598
     tolua_constant(tolua_S,"TYPE_STRING",Atlas::Message::Element::TYPE_STRING);
 
2599
     tolua_constant(tolua_S,"TYPE_MAP",Atlas::Message::Element::TYPE_MAP);
 
2600
     tolua_constant(tolua_S,"TYPE_LIST",Atlas::Message::Element::TYPE_LIST);
 
2601
     tolua_function(tolua_S,"new",tolua_Atlas_Atlas_Message_Element_new00);
 
2602
     tolua_function(tolua_S,"new_local",tolua_Atlas_Atlas_Message_Element_new00_local);
 
2603
     tolua_function(tolua_S,".call",tolua_Atlas_Atlas_Message_Element_new00_local);
 
2604
     tolua_function(tolua_S,"delete",tolua_Atlas_Atlas_Message_Element_delete00);
 
2605
     tolua_function(tolua_S,"new",tolua_Atlas_Atlas_Message_Element_new01);
 
2606
     tolua_function(tolua_S,"new_local",tolua_Atlas_Atlas_Message_Element_new01_local);
 
2607
     tolua_function(tolua_S,".call",tolua_Atlas_Atlas_Message_Element_new01_local);
 
2608
     tolua_function(tolua_S,"new",tolua_Atlas_Atlas_Message_Element_new02);
 
2609
     tolua_function(tolua_S,"new_local",tolua_Atlas_Atlas_Message_Element_new02_local);
 
2610
     tolua_function(tolua_S,".call",tolua_Atlas_Atlas_Message_Element_new02_local);
 
2611
     tolua_function(tolua_S,"new",tolua_Atlas_Atlas_Message_Element_new03);
 
2612
     tolua_function(tolua_S,"new_local",tolua_Atlas_Atlas_Message_Element_new03_local);
 
2613
     tolua_function(tolua_S,".call",tolua_Atlas_Atlas_Message_Element_new03_local);
 
2614
     tolua_function(tolua_S,"new",tolua_Atlas_Atlas_Message_Element_new04);
 
2615
     tolua_function(tolua_S,"new_local",tolua_Atlas_Atlas_Message_Element_new04_local);
 
2616
     tolua_function(tolua_S,".call",tolua_Atlas_Atlas_Message_Element_new04_local);
 
2617
     tolua_function(tolua_S,"new",tolua_Atlas_Atlas_Message_Element_new05);
 
2618
     tolua_function(tolua_S,"new_local",tolua_Atlas_Atlas_Message_Element_new05_local);
 
2619
     tolua_function(tolua_S,".call",tolua_Atlas_Atlas_Message_Element_new05_local);
 
2620
     tolua_function(tolua_S,"new",tolua_Atlas_Atlas_Message_Element_new06);
 
2621
     tolua_function(tolua_S,"new_local",tolua_Atlas_Atlas_Message_Element_new06_local);
 
2622
     tolua_function(tolua_S,".call",tolua_Atlas_Atlas_Message_Element_new06_local);
 
2623
     tolua_function(tolua_S,"new",tolua_Atlas_Atlas_Message_Element_new07);
 
2624
     tolua_function(tolua_S,"new_local",tolua_Atlas_Atlas_Message_Element_new07_local);
 
2625
     tolua_function(tolua_S,".call",tolua_Atlas_Atlas_Message_Element_new07_local);
 
2626
     tolua_function(tolua_S,"new",tolua_Atlas_Atlas_Message_Element_new08);
 
2627
     tolua_function(tolua_S,"new_local",tolua_Atlas_Atlas_Message_Element_new08_local);
 
2628
     tolua_function(tolua_S,".call",tolua_Atlas_Atlas_Message_Element_new08_local);
 
2629
     tolua_function(tolua_S,"new",tolua_Atlas_Atlas_Message_Element_new09);
 
2630
     tolua_function(tolua_S,"new_local",tolua_Atlas_Atlas_Message_Element_new09_local);
 
2631
     tolua_function(tolua_S,".call",tolua_Atlas_Atlas_Message_Element_new09_local);
 
2632
     tolua_function(tolua_S,"new",tolua_Atlas_Atlas_Message_Element_new10);
 
2633
     tolua_function(tolua_S,"new_local",tolua_Atlas_Atlas_Message_Element_new10_local);
 
2634
     tolua_function(tolua_S,".call",tolua_Atlas_Atlas_Message_Element_new10_local);
 
2635
     tolua_function(tolua_S,"new",tolua_Atlas_Atlas_Message_Element_new11);
 
2636
     tolua_function(tolua_S,"new_local",tolua_Atlas_Atlas_Message_Element_new11_local);
 
2637
     tolua_function(tolua_S,".call",tolua_Atlas_Atlas_Message_Element_new11_local);
 
2638
     tolua_function(tolua_S,".eq",tolua_Atlas_Atlas_Message_Element__eq00);
 
2639
     tolua_function(tolua_S,".eq",tolua_Atlas_Atlas_Message_Element__eq01);
 
2640
     tolua_function(tolua_S,".eq",tolua_Atlas_Atlas_Message_Element__eq02);
 
2641
     tolua_function(tolua_S,".eq",tolua_Atlas_Atlas_Message_Element__eq03);
 
2642
     tolua_function(tolua_S,".eq",tolua_Atlas_Atlas_Message_Element__eq04);
 
2643
     tolua_function(tolua_S,".eq",tolua_Atlas_Atlas_Message_Element__eq05);
 
2644
     tolua_function(tolua_S,".eq",tolua_Atlas_Atlas_Message_Element__eq06);
 
2645
     tolua_function(tolua_S,".eq",tolua_Atlas_Atlas_Message_Element__eq07);
 
2646
     tolua_function(tolua_S,"getType",tolua_Atlas_Atlas_Message_Element_getType00);
 
2647
     tolua_function(tolua_S,"isNone",tolua_Atlas_Atlas_Message_Element_isNone00);
 
2648
     tolua_function(tolua_S,"isInt",tolua_Atlas_Atlas_Message_Element_isInt00);
 
2649
     tolua_function(tolua_S,"isFloat",tolua_Atlas_Atlas_Message_Element_isFloat00);
 
2650
     tolua_function(tolua_S,"isPtr",tolua_Atlas_Atlas_Message_Element_isPtr00);
 
2651
     tolua_function(tolua_S,"isNum",tolua_Atlas_Atlas_Message_Element_isNum00);
 
2652
     tolua_function(tolua_S,"isString",tolua_Atlas_Atlas_Message_Element_isString00);
 
2653
     tolua_function(tolua_S,"isMap",tolua_Atlas_Atlas_Message_Element_isMap00);
 
2654
     tolua_function(tolua_S,"isList",tolua_Atlas_Atlas_Message_Element_isList00);
 
2655
     tolua_function(tolua_S,"asInt",tolua_Atlas_Atlas_Message_Element_asInt00);
 
2656
     tolua_function(tolua_S,"Int",tolua_Atlas_Atlas_Message_Element_Int00);
 
2657
     tolua_function(tolua_S,"asFloat",tolua_Atlas_Atlas_Message_Element_asFloat00);
 
2658
     tolua_function(tolua_S,"Float",tolua_Atlas_Atlas_Message_Element_Float00);
 
2659
     tolua_function(tolua_S,"asNum",tolua_Atlas_Atlas_Message_Element_asNum00);
 
2660
     tolua_function(tolua_S,"asString",tolua_Atlas_Atlas_Message_Element_asString00);
 
2661
     tolua_function(tolua_S,"asString",tolua_Atlas_Atlas_Message_Element_asString01);
 
2662
     tolua_function(tolua_S,"String",tolua_Atlas_Atlas_Message_Element_String00);
 
2663
     tolua_function(tolua_S,"String",tolua_Atlas_Atlas_Message_Element_String01);
 
2664
     tolua_function(tolua_S,"asMap",tolua_Atlas_Atlas_Message_Element_asMap00);
 
2665
     tolua_function(tolua_S,"asMap",tolua_Atlas_Atlas_Message_Element_asMap01);
 
2666
     tolua_function(tolua_S,"Map",tolua_Atlas_Atlas_Message_Element_Map00);
 
2667
     tolua_function(tolua_S,"Map",tolua_Atlas_Atlas_Message_Element_Map01);
 
2668
     tolua_function(tolua_S,"asList",tolua_Atlas_Atlas_Message_Element_asList00);
 
2669
     tolua_function(tolua_S,"asList",tolua_Atlas_Atlas_Message_Element_asList01);
 
2670
     tolua_function(tolua_S,"List",tolua_Atlas_Atlas_Message_Element_List00);
 
2671
     tolua_function(tolua_S,"List",tolua_Atlas_Atlas_Message_Element_List01);
 
2672
    tolua_endmodule(tolua_S);
 
2673
    #ifdef __cplusplus
 
2674
    tolua_cclass(tolua_S,"MapType","Atlas::Message::MapType","",tolua_collect_Atlas__Message__MapType);
 
2675
    #else
 
2676
    tolua_cclass(tolua_S,"MapType","Atlas::Message::MapType","",NULL);
 
2677
    #endif
 
2678
    tolua_beginmodule(tolua_S,"MapType");
 
2679
     tolua_cclass(tolua_S,"value_type","Atlas::Message::MapType::value_type","",NULL);
 
2680
     tolua_beginmodule(tolua_S,"value_type");
 
2681
      tolua_variable(tolua_S,"first",tolua_get_Atlas__Message__MapType__value_type_first,NULL);
 
2682
      tolua_variable(tolua_S,"second",tolua_get_Atlas__Message__MapType__value_type_second_ref,tolua_set_Atlas__Message__MapType__value_type_second_ref);
 
2683
     tolua_endmodule(tolua_S);
 
2684
     #ifdef __cplusplus
 
2685
     tolua_cclass(tolua_S,"iterator","Atlas::Message::MapType::iterator","",tolua_collect_Atlas__Message__MapType__iterator);
 
2686
     #else
 
2687
     tolua_cclass(tolua_S,"iterator","Atlas::Message::MapType::iterator","",NULL);
 
2688
     #endif
 
2689
     tolua_beginmodule(tolua_S,"iterator");
 
2690
      tolua_function(tolua_S,".mul",tolua_Atlas_Atlas_Message_MapType_iterator__mul00);
 
2691
      tolua_function(tolua_S,".eq",tolua_Atlas_Atlas_Message_MapType_iterator__eq00);
 
2692
     tolua_endmodule(tolua_S);
 
2693
     tolua_function(tolua_S,"clear",tolua_Atlas_Atlas_Message_MapType_clear00);
 
2694
     tolua_function(tolua_S,"size",tolua_Atlas_Atlas_Message_MapType_size00);
 
2695
     tolua_function(tolua_S,"find",tolua_Atlas_Atlas_Message_MapType_find00);
 
2696
     tolua_function(tolua_S,"theEnd",tolua_Atlas_Atlas_Message_MapType_theEnd00);
 
2697
     tolua_function(tolua_S,"get",tolua_Atlas_Atlas_Message_MapType_get00);
 
2698
     tolua_function(tolua_S,"get",tolua_Atlas_Atlas_Message_MapType_get01);
 
2699
     tolua_function(tolua_S,"new",tolua_Atlas_Atlas_Message_MapType_new00);
 
2700
     tolua_function(tolua_S,"new_local",tolua_Atlas_Atlas_Message_MapType_new00_local);
 
2701
     tolua_function(tolua_S,".call",tolua_Atlas_Atlas_Message_MapType_new00_local);
 
2702
     tolua_function(tolua_S,"delete",tolua_Atlas_Atlas_Message_MapType_delete00);
 
2703
    tolua_endmodule(tolua_S);
 
2704
    #ifdef __cplusplus
 
2705
    tolua_cclass(tolua_S,"ListType","Atlas::Message::ListType","",tolua_collect_Atlas__Message__ListType);
 
2706
    #else
 
2707
    tolua_cclass(tolua_S,"ListType","Atlas::Message::ListType","",NULL);
 
2708
    #endif
 
2709
    tolua_beginmodule(tolua_S,"ListType");
 
2710
     tolua_function(tolua_S,"clear",tolua_Atlas_Atlas_Message_ListType_clear00);
 
2711
     tolua_function(tolua_S,"size",tolua_Atlas_Atlas_Message_ListType_size00);
 
2712
     tolua_function(tolua_S,".geti",tolua_Atlas_Atlas_Message_ListType__geti00);
 
2713
     tolua_function(tolua_S,".seti",tolua_Atlas_Atlas_Message_ListType__seti00);
 
2714
     tolua_function(tolua_S,".geti",tolua_Atlas_Atlas_Message_ListType__geti01);
 
2715
     tolua_function(tolua_S,"push_back",tolua_Atlas_Atlas_Message_ListType_push_back00);
 
2716
     tolua_function(tolua_S,"push_back",tolua_Atlas_Atlas_Message_ListType_push_back01);
 
2717
     tolua_function(tolua_S,"push_back",tolua_Atlas_Atlas_Message_ListType_push_back02);
 
2718
     tolua_function(tolua_S,"push_back",tolua_Atlas_Atlas_Message_ListType_push_back03);
 
2719
     tolua_function(tolua_S,"push_back",tolua_Atlas_Atlas_Message_ListType_push_back04);
 
2720
     tolua_function(tolua_S,"push_back",tolua_Atlas_Atlas_Message_ListType_push_back05);
 
2721
     tolua_function(tolua_S,"new",tolua_Atlas_Atlas_Message_ListType_new00);
 
2722
     tolua_function(tolua_S,"new_local",tolua_Atlas_Atlas_Message_ListType_new00_local);
 
2723
     tolua_function(tolua_S,".call",tolua_Atlas_Atlas_Message_ListType_new00_local);
 
2724
     tolua_function(tolua_S,"delete",tolua_Atlas_Atlas_Message_ListType_delete00);
 
2725
    tolua_endmodule(tolua_S);
 
2726
   tolua_endmodule(tolua_S);
 
2727
  tolua_endmodule(tolua_S);
 
2728
 
 
2729
  { /* begin embedded lua code */
 
2730
   int top = lua_gettop(tolua_S);
 
2731
   static unsigned char B[] = {
 
2732
    10,102,117,110, 99,116,105,111,110, 32, 65,116,108, 97,115,
 
2733
     46, 77,101,115,115, 97,103,101, 46, 76,105,115,116, 84,121,
 
2734
    112,101, 58,112, 97,105,114,115, 40, 41, 10,114,101,116,117,
 
2735
    114,110, 32,102,117,110, 99,116,105,111,110, 40, 97, 44, 32,
 
2736
    105, 41, 10,105, 32, 61, 32,105, 32, 43, 32, 49, 10,105,102,
 
2737
     32,105, 32, 60, 32, 97, 58,115,105,122,101, 40, 41, 32,116,
 
2738
    104,101,110, 10,114,101,116,117,114,110, 32,105, 44, 32, 97,
 
2739
     91,105, 93, 10,101,110,100, 10,101,110,100, 44, 32,115,101,
 
2740
    108,102, 44, 32, 45, 49, 10,101,110,100,32
 
2741
   };
 
2742
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 1");
 
2743
   lua_settop(tolua_S, top);
 
2744
  } /* end of embedded lua code */
 
2745
 
 
2746
 tolua_endmodule(tolua_S);
 
2747
 return 1;
 
2748
}
 
2749
 
 
2750
 
 
2751
#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 
2752
 TOLUA_API int luaopen_Atlas (lua_State* tolua_S) {
 
2753
 return tolua_Atlas_open(tolua_S);
 
2754
};
 
2755
#endif
 
2756