Fawkes API  Fawkes Development Version
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
fawkesinterface_tolua.cpp
1 /*
2 ** Lua binding: fawkesinterface
3 ** Generated automatically by tolua++-1.0.92
4 */
5 /* This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version. A runtime exception applies to
9  * this software (see LICENSE.GPL_WRE file mentioned below for details).
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU Library General Public License for more details.
15  *
16  * Read the full text in the LICENSE.GPL_WRE file in the doc directory.
17  */
18 
19 #ifndef __cplusplus
20 #include "stdlib.h"
21 #endif
22 #include "string.h"
23 
24 #include "tolua++.h"
25 
26 /* Exported function */
27 TOLUA_API int tolua_fawkesinterface_open (lua_State* tolua_S);
28 
29 #include <interface/interface.h>
30 #include <interface/message.h>
31 #include <interface/message_queue.h>
32 
33 /* function to release collected object via destructor */
34 #ifdef __cplusplus
35 
36 static int tolua_collect_fawkes__MessageQueue__MessageIterator (lua_State* tolua_S)
37 {
39  Mtolua_delete(self);
40  return 0;
41 }
42 
43 static int tolua_collect_fawkes__Message (lua_State* tolua_S)
44 {
45  fawkes::Message* self = (fawkes::Message*) tolua_tousertype(tolua_S,1,0);
46  Mtolua_delete(self);
47  return 0;
48 }
49 
50 static int tolua_collect_fawkes__MessageQueue (lua_State* tolua_S)
51 {
52  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
53  Mtolua_delete(self);
54  return 0;
55 }
56 
57 static int tolua_collect_size_t (lua_State* tolua_S)
58 {
59  size_t* self = (size_t*) tolua_tousertype(tolua_S,1,0);
60  Mtolua_delete(self);
61  return 0;
62 }
63 #endif
64 
65 
66 /* function to register type */
67 static void tolua_reg_types (lua_State* tolua_S)
68 {
69  tolua_usertype(tolua_S,"fawkes::MessageQueue::MessageIterator");
70  tolua_usertype(tolua_S,"fawkes::Message");
71  tolua_usertype(tolua_S,"fawkes::Interface");
72  tolua_usertype(tolua_S,"fawkes::MessageQueue");
73  tolua_usertype(tolua_S,"RefCount");
74  tolua_usertype(tolua_S,"size_t");
75 }
76 
77 /* method: oftype of class fawkes::Interface */
78 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_oftype00
79 static int tolua_fawkesinterface_fawkes_Interface_oftype00(lua_State* tolua_S)
80 {
81 #ifndef TOLUA_RELEASE
82  tolua_Error tolua_err;
83  if (
84  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
85  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
86  !tolua_isnoobj(tolua_S,3,&tolua_err)
87  )
88  goto tolua_lerror;
89  else
90 #endif
91  {
92  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
93  const char* interface_type = ((const char*) tolua_tostring(tolua_S,2,0));
94 #ifndef TOLUA_RELEASE
95  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL);
96 #endif
97  {
98  bool tolua_ret = (bool) self->oftype(interface_type);
99  tolua_pushboolean(tolua_S,(bool)tolua_ret);
100  }
101  }
102  return 1;
103 #ifndef TOLUA_RELEASE
104  tolua_lerror:
105  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
106  return 0;
107 #endif
108 }
109 #endif //#ifndef TOLUA_DISABLE
110 
111 /* method: datachunk of class fawkes::Interface */
112 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_datachunk00
113 static int tolua_fawkesinterface_fawkes_Interface_datachunk00(lua_State* tolua_S)
114 {
115 #ifndef TOLUA_RELEASE
116  tolua_Error tolua_err;
117  if (
118  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
119  !tolua_isnoobj(tolua_S,2,&tolua_err)
120  )
121  goto tolua_lerror;
122  else
123 #endif
124  {
125  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
126 #ifndef TOLUA_RELEASE
127  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL);
128 #endif
129  {
130  const void* tolua_ret = (const void*) self->datachunk();
131  tolua_pushuserdata(tolua_S,(void*)tolua_ret);
132  }
133  }
134  return 1;
135 #ifndef TOLUA_RELEASE
136  tolua_lerror:
137  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
138  return 0;
139 #endif
140 }
141 #endif //#ifndef TOLUA_DISABLE
142 
143 /* method: datasize of class fawkes::Interface */
144 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_datasize00
145 static int tolua_fawkesinterface_fawkes_Interface_datasize00(lua_State* tolua_S)
146 {
147 #ifndef TOLUA_RELEASE
148  tolua_Error tolua_err;
149  if (
150  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
151  !tolua_isnoobj(tolua_S,2,&tolua_err)
152  )
153  goto tolua_lerror;
154  else
155 #endif
156  {
157  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
158 #ifndef TOLUA_RELEASE
159  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL);
160 #endif
161  {
162  unsigned int tolua_ret = (unsigned int) self->datasize();
163  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
164  }
165  }
166  return 1;
167 #ifndef TOLUA_RELEASE
168  tolua_lerror:
169  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
170  return 0;
171 #endif
172 }
173 #endif //#ifndef TOLUA_DISABLE
174 
175 /* method: type of class fawkes::Interface */
176 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_type00
177 static int tolua_fawkesinterface_fawkes_Interface_type00(lua_State* tolua_S)
178 {
179 #ifndef TOLUA_RELEASE
180  tolua_Error tolua_err;
181  if (
182  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
183  !tolua_isnoobj(tolua_S,2,&tolua_err)
184  )
185  goto tolua_lerror;
186  else
187 #endif
188  {
189  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
190 #ifndef TOLUA_RELEASE
191  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
192 #endif
193  {
194  const char* tolua_ret = (const char*) self->type();
195  tolua_pushstring(tolua_S,(const char*)tolua_ret);
196  }
197  }
198  return 1;
199 #ifndef TOLUA_RELEASE
200  tolua_lerror:
201  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
202  return 0;
203 #endif
204 }
205 #endif //#ifndef TOLUA_DISABLE
206 
207 /* method: id of class fawkes::Interface */
208 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_id00
209 static int tolua_fawkesinterface_fawkes_Interface_id00(lua_State* tolua_S)
210 {
211 #ifndef TOLUA_RELEASE
212  tolua_Error tolua_err;
213  if (
214  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
215  !tolua_isnoobj(tolua_S,2,&tolua_err)
216  )
217  goto tolua_lerror;
218  else
219 #endif
220  {
221  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
222 #ifndef TOLUA_RELEASE
223  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL);
224 #endif
225  {
226  const char* tolua_ret = (const char*) self->id();
227  tolua_pushstring(tolua_S,(const char*)tolua_ret);
228  }
229  }
230  return 1;
231 #ifndef TOLUA_RELEASE
232  tolua_lerror:
233  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
234  return 0;
235 #endif
236 }
237 #endif //#ifndef TOLUA_DISABLE
238 
239 /* method: uid of class fawkes::Interface */
240 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_uid00
241 static int tolua_fawkesinterface_fawkes_Interface_uid00(lua_State* tolua_S)
242 {
243 #ifndef TOLUA_RELEASE
244  tolua_Error tolua_err;
245  if (
246  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
247  !tolua_isnoobj(tolua_S,2,&tolua_err)
248  )
249  goto tolua_lerror;
250  else
251 #endif
252  {
253  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
254 #ifndef TOLUA_RELEASE
255  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL);
256 #endif
257  {
258  const char* tolua_ret = (const char*) self->uid();
259  tolua_pushstring(tolua_S,(const char*)tolua_ret);
260  }
261  }
262  return 1;
263 #ifndef TOLUA_RELEASE
264  tolua_lerror:
265  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
266  return 0;
267 #endif
268 }
269 #endif //#ifndef TOLUA_DISABLE
270 
271 /* method: serial of class fawkes::Interface */
272 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_serial00
273 static int tolua_fawkesinterface_fawkes_Interface_serial00(lua_State* tolua_S)
274 {
275 #ifndef TOLUA_RELEASE
276  tolua_Error tolua_err;
277  if (
278  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
279  !tolua_isnoobj(tolua_S,2,&tolua_err)
280  )
281  goto tolua_lerror;
282  else
283 #endif
284  {
285  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
286 #ifndef TOLUA_RELEASE
287  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL);
288 #endif
289  {
290  unsigned int tolua_ret = (unsigned int) self->serial();
291  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
292  }
293  }
294  return 1;
295 #ifndef TOLUA_RELEASE
296  tolua_lerror:
297  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
298  return 0;
299 #endif
300 }
301 #endif //#ifndef TOLUA_DISABLE
302 
303 /* method: mem_serial of class fawkes::Interface */
304 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_mem_serial00
305 static int tolua_fawkesinterface_fawkes_Interface_mem_serial00(lua_State* tolua_S)
306 {
307 #ifndef TOLUA_RELEASE
308  tolua_Error tolua_err;
309  if (
310  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
311  !tolua_isnoobj(tolua_S,2,&tolua_err)
312  )
313  goto tolua_lerror;
314  else
315 #endif
316  {
317  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
318 #ifndef TOLUA_RELEASE
319  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL);
320 #endif
321  {
322  unsigned int tolua_ret = (unsigned int) self->mem_serial();
323  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
324  }
325  }
326  return 1;
327 #ifndef TOLUA_RELEASE
328  tolua_lerror:
329  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
330  return 0;
331 #endif
332 }
333 #endif //#ifndef TOLUA_DISABLE
334 
335 /* method: operator== of class fawkes::Interface */
336 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface__eq00
337 static int tolua_fawkesinterface_fawkes_Interface__eq00(lua_State* tolua_S)
338 {
339 #ifndef TOLUA_RELEASE
340  tolua_Error tolua_err;
341  if (
342  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
343  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Interface",0,&tolua_err)) ||
344  !tolua_isnoobj(tolua_S,3,&tolua_err)
345  )
346  goto tolua_lerror;
347  else
348 #endif
349  {
350  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
351  fawkes::Interface* comp = ((fawkes::Interface*) tolua_tousertype(tolua_S,2,0));
352 #ifndef TOLUA_RELEASE
353  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
354 #endif
355  {
356  bool tolua_ret = (bool) self->operator==(*comp);
357  tolua_pushboolean(tolua_S,(bool)tolua_ret);
358  }
359  }
360  return 1;
361 #ifndef TOLUA_RELEASE
362  tolua_lerror:
363  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
364  return 0;
365 #endif
366 }
367 #endif //#ifndef TOLUA_DISABLE
368 
369 /* method: hash of class fawkes::Interface */
370 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_hash00
371 static int tolua_fawkesinterface_fawkes_Interface_hash00(lua_State* tolua_S)
372 {
373 #ifndef TOLUA_RELEASE
374  tolua_Error tolua_err;
375  if (
376  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
377  !tolua_isnoobj(tolua_S,2,&tolua_err)
378  )
379  goto tolua_lerror;
380  else
381 #endif
382  {
383  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
384 #ifndef TOLUA_RELEASE
385  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL);
386 #endif
387  {
388  unsigned const char* tolua_ret = ( unsigned const char*) self->hash();
389  tolua_pushstring(tolua_S,(const char*)tolua_ret);
390  }
391  }
392  return 1;
393 #ifndef TOLUA_RELEASE
394  tolua_lerror:
395  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
396  return 0;
397 #endif
398 }
399 #endif //#ifndef TOLUA_DISABLE
400 
401 /* method: hash_size of class fawkes::Interface */
402 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_hash_size00
403 static int tolua_fawkesinterface_fawkes_Interface_hash_size00(lua_State* tolua_S)
404 {
405 #ifndef TOLUA_RELEASE
406  tolua_Error tolua_err;
407  if (
408  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
409  !tolua_isnoobj(tolua_S,2,&tolua_err)
410  )
411  goto tolua_lerror;
412  else
413 #endif
414  {
415  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
416 #ifndef TOLUA_RELEASE
417  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL);
418 #endif
419  {
420  size_t tolua_ret = (size_t) self->hash_size();
421  {
422 #ifdef __cplusplus
423  void* tolua_obj = Mtolua_new((size_t)(tolua_ret));
424  tolua_pushusertype(tolua_S,tolua_obj,"size_t");
425  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
426 #else
427  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(size_t));
428  tolua_pushusertype(tolua_S,tolua_obj,"size_t");
429  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
430 #endif
431  }
432  }
433  }
434  return 1;
435 #ifndef TOLUA_RELEASE
436  tolua_lerror:
437  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
438  return 0;
439 #endif
440 }
441 #endif //#ifndef TOLUA_DISABLE
442 
443 /* method: hash_printable of class fawkes::Interface */
444 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_hash_printable00
445 static int tolua_fawkesinterface_fawkes_Interface_hash_printable00(lua_State* tolua_S)
446 {
447 #ifndef TOLUA_RELEASE
448  tolua_Error tolua_err;
449  if (
450  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
451  !tolua_isnoobj(tolua_S,2,&tolua_err)
452  )
453  goto tolua_lerror;
454  else
455 #endif
456  {
457  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
458 #ifndef TOLUA_RELEASE
459  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL);
460 #endif
461  {
462  const char* tolua_ret = (const char*) self->hash_printable();
463  tolua_pushstring(tolua_S,(const char*)tolua_ret);
464  }
465  }
466  return 1;
467 #ifndef TOLUA_RELEASE
468  tolua_lerror:
469  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
470  return 0;
471 #endif
472 }
473 #endif //#ifndef TOLUA_DISABLE
474 
475 /* method: is_writer of class fawkes::Interface */
476 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_is_writer00
477 static int tolua_fawkesinterface_fawkes_Interface_is_writer00(lua_State* tolua_S)
478 {
479 #ifndef TOLUA_RELEASE
480  tolua_Error tolua_err;
481  if (
482  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
483  !tolua_isnoobj(tolua_S,2,&tolua_err)
484  )
485  goto tolua_lerror;
486  else
487 #endif
488  {
489  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
490 #ifndef TOLUA_RELEASE
491  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL);
492 #endif
493  {
494  bool tolua_ret = (bool) self->is_writer();
495  tolua_pushboolean(tolua_S,(bool)tolua_ret);
496  }
497  }
498  return 1;
499 #ifndef TOLUA_RELEASE
500  tolua_lerror:
501  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
502  return 0;
503 #endif
504 }
505 #endif //#ifndef TOLUA_DISABLE
506 
507 /* method: set_from_chunk of class fawkes::Interface */
508 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_set_from_chunk00
509 static int tolua_fawkesinterface_fawkes_Interface_set_from_chunk00(lua_State* tolua_S)
510 {
511 #ifndef TOLUA_RELEASE
512  tolua_Error tolua_err;
513  if (
514  !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
515  !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
516  !tolua_isnoobj(tolua_S,3,&tolua_err)
517  )
518  goto tolua_lerror;
519  else
520 #endif
521  {
522  fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
523  void* chunk = ((void*) tolua_touserdata(tolua_S,2,0));
524 #ifndef TOLUA_RELEASE
525  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL);
526 #endif
527  {
528  self->set_from_chunk(chunk);
529  }
530  }
531  return 0;
532 #ifndef TOLUA_RELEASE
533  tolua_lerror:
534  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
535  return 0;
536 #endif
537 }
538 #endif //#ifndef TOLUA_DISABLE
539 
540 /* method: create_message of class fawkes::Interface */
541 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_create_message00
542 static int tolua_fawkesinterface_fawkes_Interface_create_message00(lua_State* tolua_S)
543 {
544 #ifndef TOLUA_RELEASE
545  tolua_Error tolua_err;
546  if (
547  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
548  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
549  !tolua_isnoobj(tolua_S,3,&tolua_err)
550  )
551  goto tolua_lerror;
552  else
553 #endif
554  {
555  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
556  const char* type = ((const char*) tolua_tostring(tolua_S,2,0));
557 #ifndef TOLUA_RELEASE
558  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL);
559 #endif
560  {
561  fawkes::Message* tolua_ret = (fawkes::Message*) self->create_message(type);
562  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
563  }
564  }
565  return 1;
566 #ifndef TOLUA_RELEASE
567  tolua_lerror:
568  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
569  return 0;
570 #endif
571 }
572 #endif //#ifndef TOLUA_DISABLE
573 
574 /* method: read of class fawkes::Interface */
575 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_read00
576 static int tolua_fawkesinterface_fawkes_Interface_read00(lua_State* tolua_S)
577 {
578 #ifndef TOLUA_RELEASE
579  tolua_Error tolua_err;
580  if (
581  !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
582  !tolua_isnoobj(tolua_S,2,&tolua_err)
583  )
584  goto tolua_lerror;
585  else
586 #endif
587  {
588  fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
589 #ifndef TOLUA_RELEASE
590  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
591 #endif
592  {
593  self->read();
594  }
595  }
596  return 0;
597 #ifndef TOLUA_RELEASE
598  tolua_lerror:
599  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
600  return 0;
601 #endif
602 }
603 #endif //#ifndef TOLUA_DISABLE
604 
605 /* method: write of class fawkes::Interface */
606 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_write00
607 static int tolua_fawkesinterface_fawkes_Interface_write00(lua_State* tolua_S)
608 {
609 #ifndef TOLUA_RELEASE
610  tolua_Error tolua_err;
611  if (
612  !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
613  !tolua_isnoobj(tolua_S,2,&tolua_err)
614  )
615  goto tolua_lerror;
616  else
617 #endif
618  {
619  fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
620 #ifndef TOLUA_RELEASE
621  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
622 #endif
623  {
624  self->write();
625  }
626  }
627  return 0;
628 #ifndef TOLUA_RELEASE
629  tolua_lerror:
630  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
631  return 0;
632 #endif
633 }
634 #endif //#ifndef TOLUA_DISABLE
635 
636 /* method: has_writer of class fawkes::Interface */
637 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_has_writer00
638 static int tolua_fawkesinterface_fawkes_Interface_has_writer00(lua_State* tolua_S)
639 {
640 #ifndef TOLUA_RELEASE
641  tolua_Error tolua_err;
642  if (
643  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
644  !tolua_isnoobj(tolua_S,2,&tolua_err)
645  )
646  goto tolua_lerror;
647  else
648 #endif
649  {
650  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
651 #ifndef TOLUA_RELEASE
652  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL);
653 #endif
654  {
655  bool tolua_ret = (bool) self->has_writer();
656  tolua_pushboolean(tolua_S,(bool)tolua_ret);
657  }
658  }
659  return 1;
660 #ifndef TOLUA_RELEASE
661  tolua_lerror:
662  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
663  return 0;
664 #endif
665 }
666 #endif //#ifndef TOLUA_DISABLE
667 
668 /* method: num_readers of class fawkes::Interface */
669 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_num_readers00
670 static int tolua_fawkesinterface_fawkes_Interface_num_readers00(lua_State* tolua_S)
671 {
672 #ifndef TOLUA_RELEASE
673  tolua_Error tolua_err;
674  if (
675  !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
676  !tolua_isnoobj(tolua_S,2,&tolua_err)
677  )
678  goto tolua_lerror;
679  else
680 #endif
681  {
682  const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
683 #ifndef TOLUA_RELEASE
684  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL);
685 #endif
686  {
687  unsigned int tolua_ret = (unsigned int) self->num_readers();
688  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
689  }
690  }
691  return 1;
692 #ifndef TOLUA_RELEASE
693  tolua_lerror:
694  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
695  return 0;
696 #endif
697 }
698 #endif //#ifndef TOLUA_DISABLE
699 
700 /* method: msgq_enqueue_copy of class fawkes::Interface */
701 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_enqueue_copy00
702 static int tolua_fawkesinterface_fawkes_Interface_msgq_enqueue_copy00(lua_State* tolua_S)
703 {
704 #ifndef TOLUA_RELEASE
705  tolua_Error tolua_err;
706  if (
707  !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
708  !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) ||
709  !tolua_isnoobj(tolua_S,3,&tolua_err)
710  )
711  goto tolua_lerror;
712  else
713 #endif
714  {
715  fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
716  fawkes::Message* message = ((fawkes::Message*) tolua_tousertype(tolua_S,2,0));
717 #ifndef TOLUA_RELEASE
718  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL);
719 #endif
720  {
721  unsigned int tolua_ret = (unsigned int) self->msgq_enqueue_copy(message);
722  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
723  }
724  }
725  return 1;
726 #ifndef TOLUA_RELEASE
727  tolua_lerror:
728  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
729  return 0;
730 #endif
731 }
732 #endif //#ifndef TOLUA_DISABLE
733 
734 /* method: msgq_remove of class fawkes::Interface */
735 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_remove00
736 static int tolua_fawkesinterface_fawkes_Interface_msgq_remove00(lua_State* tolua_S)
737 {
738 #ifndef TOLUA_RELEASE
739  tolua_Error tolua_err;
740  if (
741  !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
742  !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) ||
743  !tolua_isnoobj(tolua_S,3,&tolua_err)
744  )
745  goto tolua_lerror;
746  else
747 #endif
748  {
749  fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
750  fawkes::Message* message = ((fawkes::Message*) tolua_tousertype(tolua_S,2,0));
751 #ifndef TOLUA_RELEASE
752  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
753 #endif
754  {
755  self->msgq_remove(message);
756  }
757  }
758  return 0;
759 #ifndef TOLUA_RELEASE
760  tolua_lerror:
761  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
762  return 0;
763 #endif
764 }
765 #endif //#ifndef TOLUA_DISABLE
766 
767 /* method: msgq_remove of class fawkes::Interface */
768 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_remove01
769 static int tolua_fawkesinterface_fawkes_Interface_msgq_remove01(lua_State* tolua_S)
770 {
771  tolua_Error tolua_err;
772  if (
773  !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
774  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
775  !tolua_isnoobj(tolua_S,3,&tolua_err)
776  )
777  goto tolua_lerror;
778  else
779  {
780  fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
781  unsigned int message_id = ((unsigned int) tolua_tonumber(tolua_S,2,0));
782 #ifndef TOLUA_RELEASE
783  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
784 #endif
785  {
786  self->msgq_remove(message_id);
787  }
788  }
789  return 0;
790 tolua_lerror:
791  return tolua_fawkesinterface_fawkes_Interface_msgq_remove00(tolua_S);
792 }
793 #endif //#ifndef TOLUA_DISABLE
794 
795 /* method: msgq_size of class fawkes::Interface */
796 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_size00
797 static int tolua_fawkesinterface_fawkes_Interface_msgq_size00(lua_State* tolua_S)
798 {
799 #ifndef TOLUA_RELEASE
800  tolua_Error tolua_err;
801  if (
802  !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
803  !tolua_isnoobj(tolua_S,2,&tolua_err)
804  )
805  goto tolua_lerror;
806  else
807 #endif
808  {
809  fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
810 #ifndef TOLUA_RELEASE
811  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL);
812 #endif
813  {
814  unsigned int tolua_ret = (unsigned int) self->msgq_size();
815  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
816  }
817  }
818  return 1;
819 #ifndef TOLUA_RELEASE
820  tolua_lerror:
821  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
822  return 0;
823 #endif
824 }
825 #endif //#ifndef TOLUA_DISABLE
826 
827 /* method: msgq_flush of class fawkes::Interface */
828 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_flush00
829 static int tolua_fawkesinterface_fawkes_Interface_msgq_flush00(lua_State* tolua_S)
830 {
831 #ifndef TOLUA_RELEASE
832  tolua_Error tolua_err;
833  if (
834  !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
835  !tolua_isnoobj(tolua_S,2,&tolua_err)
836  )
837  goto tolua_lerror;
838  else
839 #endif
840  {
841  fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
842 #ifndef TOLUA_RELEASE
843  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL);
844 #endif
845  {
846  self->msgq_flush();
847  }
848  }
849  return 0;
850 #ifndef TOLUA_RELEASE
851  tolua_lerror:
852  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
853  return 0;
854 #endif
855 }
856 #endif //#ifndef TOLUA_DISABLE
857 
858 /* method: msgq_lock of class fawkes::Interface */
859 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_lock00
860 static int tolua_fawkesinterface_fawkes_Interface_msgq_lock00(lua_State* tolua_S)
861 {
862 #ifndef TOLUA_RELEASE
863  tolua_Error tolua_err;
864  if (
865  !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
866  !tolua_isnoobj(tolua_S,2,&tolua_err)
867  )
868  goto tolua_lerror;
869  else
870 #endif
871  {
872  fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
873 #ifndef TOLUA_RELEASE
874  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL);
875 #endif
876  {
877  self->msgq_lock();
878  }
879  }
880  return 0;
881 #ifndef TOLUA_RELEASE
882  tolua_lerror:
883  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
884  return 0;
885 #endif
886 }
887 #endif //#ifndef TOLUA_DISABLE
888 
889 /* method: msgq_try_lock of class fawkes::Interface */
890 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_try_lock00
891 static int tolua_fawkesinterface_fawkes_Interface_msgq_try_lock00(lua_State* tolua_S)
892 {
893 #ifndef TOLUA_RELEASE
894  tolua_Error tolua_err;
895  if (
896  !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
897  !tolua_isnoobj(tolua_S,2,&tolua_err)
898  )
899  goto tolua_lerror;
900  else
901 #endif
902  {
903  fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
904 #ifndef TOLUA_RELEASE
905  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL);
906 #endif
907  {
908  bool tolua_ret = (bool) self->msgq_try_lock();
909  tolua_pushboolean(tolua_S,(bool)tolua_ret);
910  }
911  }
912  return 1;
913 #ifndef TOLUA_RELEASE
914  tolua_lerror:
915  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
916  return 0;
917 #endif
918 }
919 #endif //#ifndef TOLUA_DISABLE
920 
921 /* method: msgq_unlock of class fawkes::Interface */
922 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_unlock00
923 static int tolua_fawkesinterface_fawkes_Interface_msgq_unlock00(lua_State* tolua_S)
924 {
925 #ifndef TOLUA_RELEASE
926  tolua_Error tolua_err;
927  if (
928  !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
929  !tolua_isnoobj(tolua_S,2,&tolua_err)
930  )
931  goto tolua_lerror;
932  else
933 #endif
934  {
935  fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
936 #ifndef TOLUA_RELEASE
937  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL);
938 #endif
939  {
940  self->msgq_unlock();
941  }
942  }
943  return 0;
944 #ifndef TOLUA_RELEASE
945  tolua_lerror:
946  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
947  return 0;
948 #endif
949 }
950 #endif //#ifndef TOLUA_DISABLE
951 
952 /* method: msgq_pop of class fawkes::Interface */
953 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_pop00
954 static int tolua_fawkesinterface_fawkes_Interface_msgq_pop00(lua_State* tolua_S)
955 {
956 #ifndef TOLUA_RELEASE
957  tolua_Error tolua_err;
958  if (
959  !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
960  !tolua_isnoobj(tolua_S,2,&tolua_err)
961  )
962  goto tolua_lerror;
963  else
964 #endif
965  {
966  fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
967 #ifndef TOLUA_RELEASE
968  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL);
969 #endif
970  {
971  self->msgq_pop();
972  }
973  }
974  return 0;
975 #ifndef TOLUA_RELEASE
976  tolua_lerror:
977  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
978  return 0;
979 #endif
980 }
981 #endif //#ifndef TOLUA_DISABLE
982 
983 /* method: msgq_first of class fawkes::Interface */
984 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_first00
985 static int tolua_fawkesinterface_fawkes_Interface_msgq_first00(lua_State* tolua_S)
986 {
987 #ifndef TOLUA_RELEASE
988  tolua_Error tolua_err;
989  if (
990  !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
991  !tolua_isnoobj(tolua_S,2,&tolua_err)
992  )
993  goto tolua_lerror;
994  else
995 #endif
996  {
997  fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
998 #ifndef TOLUA_RELEASE
999  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL);
1000 #endif
1001  {
1002  fawkes::Message* tolua_ret = (fawkes::Message*) self->msgq_first();
1003  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
1004  }
1005  }
1006  return 1;
1007 #ifndef TOLUA_RELEASE
1008  tolua_lerror:
1009  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
1010  return 0;
1011 #endif
1012 }
1013 #endif //#ifndef TOLUA_DISABLE
1014 
1015 /* method: msgq_empty of class fawkes::Interface */
1016 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_empty00
1017 static int tolua_fawkesinterface_fawkes_Interface_msgq_empty00(lua_State* tolua_S)
1018 {
1019 #ifndef TOLUA_RELEASE
1020  tolua_Error tolua_err;
1021  if (
1022  !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
1023  !tolua_isnoobj(tolua_S,2,&tolua_err)
1024  )
1025  goto tolua_lerror;
1026  else
1027 #endif
1028  {
1029  fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0);
1030 #ifndef TOLUA_RELEASE
1031  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL);
1032 #endif
1033  {
1034  bool tolua_ret = (bool) self->msgq_empty();
1035  tolua_pushboolean(tolua_S,(bool)tolua_ret);
1036  }
1037  }
1038  return 1;
1039 #ifndef TOLUA_RELEASE
1040  tolua_lerror:
1041  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
1042  return 0;
1043 #endif
1044 }
1045 #endif //#ifndef TOLUA_DISABLE
1046 
1047 /* method: new of class fawkes::Message */
1048 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new00
1049 static int tolua_fawkesinterface_fawkes_Message_new00(lua_State* tolua_S)
1050 {
1051 #ifndef TOLUA_RELEASE
1052  tolua_Error tolua_err;
1053  if (
1054  !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
1055  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1056  !tolua_isnoobj(tolua_S,3,&tolua_err)
1057  )
1058  goto tolua_lerror;
1059  else
1060 #endif
1061  {
1062  const char* type = ((const char*) tolua_tostring(tolua_S,2,0));
1063  {
1064  fawkes::Message* tolua_ret = (fawkes::Message*) Mtolua_new((fawkes::Message)(type));
1065  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
1066  }
1067  }
1068  return 1;
1069 #ifndef TOLUA_RELEASE
1070  tolua_lerror:
1071  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1072  return 0;
1073 #endif
1074 }
1075 #endif //#ifndef TOLUA_DISABLE
1076 
1077 /* method: new_local of class fawkes::Message */
1078 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new00_local
1079 static int tolua_fawkesinterface_fawkes_Message_new00_local(lua_State* tolua_S)
1080 {
1081 #ifndef TOLUA_RELEASE
1082  tolua_Error tolua_err;
1083  if (
1084  !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
1085  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1086  !tolua_isnoobj(tolua_S,3,&tolua_err)
1087  )
1088  goto tolua_lerror;
1089  else
1090 #endif
1091  {
1092  const char* type = ((const char*) tolua_tostring(tolua_S,2,0));
1093  {
1094  fawkes::Message* tolua_ret = (fawkes::Message*) Mtolua_new((fawkes::Message)(type));
1095  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
1096  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1097  }
1098  }
1099  return 1;
1100 #ifndef TOLUA_RELEASE
1101  tolua_lerror:
1102  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1103  return 0;
1104 #endif
1105 }
1106 #endif //#ifndef TOLUA_DISABLE
1107 
1108 /* method: new of class fawkes::Message */
1109 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new01
1110 static int tolua_fawkesinterface_fawkes_Message_new01(lua_State* tolua_S)
1111 {
1112  tolua_Error tolua_err;
1113  if (
1114  !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
1115  !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) ||
1116  !tolua_isnoobj(tolua_S,3,&tolua_err)
1117  )
1118  goto tolua_lerror;
1119  else
1120  {
1121  fawkes::Message* mesg = ((fawkes::Message*) tolua_tousertype(tolua_S,2,0));
1122  {
1123  fawkes::Message* tolua_ret = (fawkes::Message*) Mtolua_new((fawkes::Message)(mesg));
1124  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
1125  }
1126  }
1127  return 1;
1128 tolua_lerror:
1129  return tolua_fawkesinterface_fawkes_Message_new00(tolua_S);
1130 }
1131 #endif //#ifndef TOLUA_DISABLE
1132 
1133 /* method: new_local of class fawkes::Message */
1134 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new01_local
1135 static int tolua_fawkesinterface_fawkes_Message_new01_local(lua_State* tolua_S)
1136 {
1137  tolua_Error tolua_err;
1138  if (
1139  !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
1140  !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) ||
1141  !tolua_isnoobj(tolua_S,3,&tolua_err)
1142  )
1143  goto tolua_lerror;
1144  else
1145  {
1146  fawkes::Message* mesg = ((fawkes::Message*) tolua_tousertype(tolua_S,2,0));
1147  {
1148  fawkes::Message* tolua_ret = (fawkes::Message*) Mtolua_new((fawkes::Message)(mesg));
1149  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
1150  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1151  }
1152  }
1153  return 1;
1154 tolua_lerror:
1155  return tolua_fawkesinterface_fawkes_Message_new00_local(tolua_S);
1156 }
1157 #endif //#ifndef TOLUA_DISABLE
1158 
1159 /* method: new of class fawkes::Message */
1160 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new02
1161 static int tolua_fawkesinterface_fawkes_Message_new02(lua_State* tolua_S)
1162 {
1163  tolua_Error tolua_err;
1164  if (
1165  !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
1166  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err)) ||
1167  !tolua_isnoobj(tolua_S,3,&tolua_err)
1168  )
1169  goto tolua_lerror;
1170  else
1171  {
1172  fawkes::Message* mesg = ((fawkes::Message*) tolua_tousertype(tolua_S,2,0));
1173  {
1174  fawkes::Message* tolua_ret = (fawkes::Message*) Mtolua_new((fawkes::Message)(*mesg));
1175  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
1176  }
1177  }
1178  return 1;
1179 tolua_lerror:
1180  return tolua_fawkesinterface_fawkes_Message_new01(tolua_S);
1181 }
1182 #endif //#ifndef TOLUA_DISABLE
1183 
1184 /* method: new_local of class fawkes::Message */
1185 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new02_local
1186 static int tolua_fawkesinterface_fawkes_Message_new02_local(lua_State* tolua_S)
1187 {
1188  tolua_Error tolua_err;
1189  if (
1190  !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
1191  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err)) ||
1192  !tolua_isnoobj(tolua_S,3,&tolua_err)
1193  )
1194  goto tolua_lerror;
1195  else
1196  {
1197  fawkes::Message* mesg = ((fawkes::Message*) tolua_tousertype(tolua_S,2,0));
1198  {
1199  fawkes::Message* tolua_ret = (fawkes::Message*) Mtolua_new((fawkes::Message)(*mesg));
1200  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
1201  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1202  }
1203  }
1204  return 1;
1205 tolua_lerror:
1206  return tolua_fawkesinterface_fawkes_Message_new01_local(tolua_S);
1207 }
1208 #endif //#ifndef TOLUA_DISABLE
1209 
1210 /* method: sender_id of class fawkes::Message */
1211 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_sender_id00
1212 static int tolua_fawkesinterface_fawkes_Message_sender_id00(lua_State* tolua_S)
1213 {
1214 #ifndef TOLUA_RELEASE
1215  tolua_Error tolua_err;
1216  if (
1217  !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) ||
1218  !tolua_isnoobj(tolua_S,2,&tolua_err)
1219  )
1220  goto tolua_lerror;
1221  else
1222 #endif
1223  {
1224  const fawkes::Message* self = (const fawkes::Message*) tolua_tousertype(tolua_S,1,0);
1225 #ifndef TOLUA_RELEASE
1226  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sender_id'", NULL);
1227 #endif
1228  {
1229  unsigned int tolua_ret = (unsigned int) self->sender_id();
1230  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1231  }
1232  }
1233  return 1;
1234 #ifndef TOLUA_RELEASE
1235  tolua_lerror:
1236  tolua_error(tolua_S,"#ferror in function 'sender_id'.",&tolua_err);
1237  return 0;
1238 #endif
1239 }
1240 #endif //#ifndef TOLUA_DISABLE
1241 
1242 /* method: sender_thread_name of class fawkes::Message */
1243 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_sender_thread_name00
1244 static int tolua_fawkesinterface_fawkes_Message_sender_thread_name00(lua_State* tolua_S)
1245 {
1246 #ifndef TOLUA_RELEASE
1247  tolua_Error tolua_err;
1248  if (
1249  !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) ||
1250  !tolua_isnoobj(tolua_S,2,&tolua_err)
1251  )
1252  goto tolua_lerror;
1253  else
1254 #endif
1255  {
1256  const fawkes::Message* self = (const fawkes::Message*) tolua_tousertype(tolua_S,1,0);
1257 #ifndef TOLUA_RELEASE
1258  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sender_thread_name'", NULL);
1259 #endif
1260  {
1261  const char* tolua_ret = (const char*) self->sender_thread_name();
1262  tolua_pushstring(tolua_S,(const char*)tolua_ret);
1263  }
1264  }
1265  return 1;
1266 #ifndef TOLUA_RELEASE
1267  tolua_lerror:
1268  tolua_error(tolua_S,"#ferror in function 'sender_thread_name'.",&tolua_err);
1269  return 0;
1270 #endif
1271 }
1272 #endif //#ifndef TOLUA_DISABLE
1273 
1274 /* method: interface of class fawkes::Message */
1275 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_interface00
1276 static int tolua_fawkesinterface_fawkes_Message_interface00(lua_State* tolua_S)
1277 {
1278 #ifndef TOLUA_RELEASE
1279  tolua_Error tolua_err;
1280  if (
1281  !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) ||
1282  !tolua_isnoobj(tolua_S,2,&tolua_err)
1283  )
1284  goto tolua_lerror;
1285  else
1286 #endif
1287  {
1288  const fawkes::Message* self = (const fawkes::Message*) tolua_tousertype(tolua_S,1,0);
1289 #ifndef TOLUA_RELEASE
1290  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'interface'", NULL);
1291 #endif
1292  {
1293  fawkes::Interface* tolua_ret = (fawkes::Interface*) self->interface();
1294  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Interface");
1295  }
1296  }
1297  return 1;
1298 #ifndef TOLUA_RELEASE
1299  tolua_lerror:
1300  tolua_error(tolua_S,"#ferror in function 'interface'.",&tolua_err);
1301  return 0;
1302 #endif
1303 }
1304 #endif //#ifndef TOLUA_DISABLE
1305 
1306 /* method: type of class fawkes::Message */
1307 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_type00
1308 static int tolua_fawkesinterface_fawkes_Message_type00(lua_State* tolua_S)
1309 {
1310 #ifndef TOLUA_RELEASE
1311  tolua_Error tolua_err;
1312  if (
1313  !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) ||
1314  !tolua_isnoobj(tolua_S,2,&tolua_err)
1315  )
1316  goto tolua_lerror;
1317  else
1318 #endif
1319  {
1320  const fawkes::Message* self = (const fawkes::Message*) tolua_tousertype(tolua_S,1,0);
1321 #ifndef TOLUA_RELEASE
1322  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
1323 #endif
1324  {
1325  const char* tolua_ret = (const char*) self->type();
1326  tolua_pushstring(tolua_S,(const char*)tolua_ret);
1327  }
1328  }
1329  return 1;
1330 #ifndef TOLUA_RELEASE
1331  tolua_lerror:
1332  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
1333  return 0;
1334 #endif
1335 }
1336 #endif //#ifndef TOLUA_DISABLE
1337 
1338 /* method: datachunk of class fawkes::Message */
1339 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_datachunk00
1340 static int tolua_fawkesinterface_fawkes_Message_datachunk00(lua_State* tolua_S)
1341 {
1342 #ifndef TOLUA_RELEASE
1343  tolua_Error tolua_err;
1344  if (
1345  !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) ||
1346  !tolua_isnoobj(tolua_S,2,&tolua_err)
1347  )
1348  goto tolua_lerror;
1349  else
1350 #endif
1351  {
1352  const fawkes::Message* self = (const fawkes::Message*) tolua_tousertype(tolua_S,1,0);
1353 #ifndef TOLUA_RELEASE
1354  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL);
1355 #endif
1356  {
1357  const void* tolua_ret = (const void*) self->datachunk();
1358  tolua_pushuserdata(tolua_S,(void*)tolua_ret);
1359  }
1360  }
1361  return 1;
1362 #ifndef TOLUA_RELEASE
1363  tolua_lerror:
1364  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
1365  return 0;
1366 #endif
1367 }
1368 #endif //#ifndef TOLUA_DISABLE
1369 
1370 /* method: datasize of class fawkes::Message */
1371 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_datasize00
1372 static int tolua_fawkesinterface_fawkes_Message_datasize00(lua_State* tolua_S)
1373 {
1374 #ifndef TOLUA_RELEASE
1375  tolua_Error tolua_err;
1376  if (
1377  !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) ||
1378  !tolua_isnoobj(tolua_S,2,&tolua_err)
1379  )
1380  goto tolua_lerror;
1381  else
1382 #endif
1383  {
1384  const fawkes::Message* self = (const fawkes::Message*) tolua_tousertype(tolua_S,1,0);
1385 #ifndef TOLUA_RELEASE
1386  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL);
1387 #endif
1388  {
1389  unsigned int tolua_ret = (unsigned int) self->datasize();
1390  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1391  }
1392  }
1393  return 1;
1394 #ifndef TOLUA_RELEASE
1395  tolua_lerror:
1396  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
1397  return 0;
1398 #endif
1399 }
1400 #endif //#ifndef TOLUA_DISABLE
1401 
1402 /* method: set_from_chunk of class fawkes::Message */
1403 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_set_from_chunk00
1404 static int tolua_fawkesinterface_fawkes_Message_set_from_chunk00(lua_State* tolua_S)
1405 {
1406 #ifndef TOLUA_RELEASE
1407  tolua_Error tolua_err;
1408  if (
1409  !tolua_isusertype(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
1410  !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
1411  !tolua_isnoobj(tolua_S,3,&tolua_err)
1412  )
1413  goto tolua_lerror;
1414  else
1415 #endif
1416  {
1417  fawkes::Message* self = (fawkes::Message*) tolua_tousertype(tolua_S,1,0);
1418  const void* chunk = ((const void*) tolua_touserdata(tolua_S,2,0));
1419 #ifndef TOLUA_RELEASE
1420  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL);
1421 #endif
1422  {
1423  self->set_from_chunk(chunk);
1424  }
1425  }
1426  return 0;
1427 #ifndef TOLUA_RELEASE
1428  tolua_lerror:
1429  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
1430  return 0;
1431 #endif
1432 }
1433 #endif //#ifndef TOLUA_DISABLE
1434 
1435 /* method: ref of class fawkes::Message */
1436 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_ref00
1437 static int tolua_fawkesinterface_fawkes_Message_ref00(lua_State* tolua_S)
1438 {
1439 #ifndef TOLUA_RELEASE
1440  tolua_Error tolua_err;
1441  if (
1442  !tolua_isusertype(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
1443  !tolua_isnoobj(tolua_S,2,&tolua_err)
1444  )
1445  goto tolua_lerror;
1446  else
1447 #endif
1448  {
1449  fawkes::Message* self = (fawkes::Message*) tolua_tousertype(tolua_S,1,0);
1450 #ifndef TOLUA_RELEASE
1451  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ref'", NULL);
1452 #endif
1453  {
1454  self->ref();
1455  }
1456  }
1457  return 0;
1458 #ifndef TOLUA_RELEASE
1459  tolua_lerror:
1460  tolua_error(tolua_S,"#ferror in function 'ref'.",&tolua_err);
1461  return 0;
1462 #endif
1463 }
1464 #endif //#ifndef TOLUA_DISABLE
1465 
1466 /* method: unref of class fawkes::Message */
1467 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_unref00
1468 static int tolua_fawkesinterface_fawkes_Message_unref00(lua_State* tolua_S)
1469 {
1470 #ifndef TOLUA_RELEASE
1471  tolua_Error tolua_err;
1472  if (
1473  !tolua_isusertype(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
1474  !tolua_isnoobj(tolua_S,2,&tolua_err)
1475  )
1476  goto tolua_lerror;
1477  else
1478 #endif
1479  {
1480  fawkes::Message* self = (fawkes::Message*) tolua_tousertype(tolua_S,1,0);
1481 #ifndef TOLUA_RELEASE
1482  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unref'", NULL);
1483 #endif
1484  {
1485  self->unref();
1486  }
1487  }
1488  return 0;
1489 #ifndef TOLUA_RELEASE
1490  tolua_lerror:
1491  tolua_error(tolua_S,"#ferror in function 'unref'.",&tolua_err);
1492  return 0;
1493 #endif
1494 }
1495 #endif //#ifndef TOLUA_DISABLE
1496 
1497 /* method: refcount of class fawkes::Message */
1498 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_refcount00
1499 static int tolua_fawkesinterface_fawkes_Message_refcount00(lua_State* tolua_S)
1500 {
1501 #ifndef TOLUA_RELEASE
1502  tolua_Error tolua_err;
1503  if (
1504  !tolua_isusertype(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
1505  !tolua_isnoobj(tolua_S,2,&tolua_err)
1506  )
1507  goto tolua_lerror;
1508  else
1509 #endif
1510  {
1511  fawkes::Message* self = (fawkes::Message*) tolua_tousertype(tolua_S,1,0);
1512 #ifndef TOLUA_RELEASE
1513  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'refcount'", NULL);
1514 #endif
1515  {
1516  unsigned int tolua_ret = (unsigned int) self->refcount();
1517  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1518  }
1519  }
1520  return 1;
1521 #ifndef TOLUA_RELEASE
1522  tolua_lerror:
1523  tolua_error(tolua_S,"#ferror in function 'refcount'.",&tolua_err);
1524  return 0;
1525 #endif
1526 }
1527 #endif //#ifndef TOLUA_DISABLE
1528 
1529 /* method: new of class fawkes::MessageQueue */
1530 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_new00
1531 static int tolua_fawkesinterface_fawkes_MessageQueue_new00(lua_State* tolua_S)
1532 {
1533 #ifndef TOLUA_RELEASE
1534  tolua_Error tolua_err;
1535  if (
1536  !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
1537  !tolua_isnoobj(tolua_S,2,&tolua_err)
1538  )
1539  goto tolua_lerror;
1540  else
1541 #endif
1542  {
1543  {
1544  fawkes::MessageQueue* tolua_ret = (fawkes::MessageQueue*) Mtolua_new((fawkes::MessageQueue)());
1545  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue");
1546  }
1547  }
1548  return 1;
1549 #ifndef TOLUA_RELEASE
1550  tolua_lerror:
1551  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1552  return 0;
1553 #endif
1554 }
1555 #endif //#ifndef TOLUA_DISABLE
1556 
1557 /* method: new_local of class fawkes::MessageQueue */
1558 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_new00_local
1559 static int tolua_fawkesinterface_fawkes_MessageQueue_new00_local(lua_State* tolua_S)
1560 {
1561 #ifndef TOLUA_RELEASE
1562  tolua_Error tolua_err;
1563  if (
1564  !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
1565  !tolua_isnoobj(tolua_S,2,&tolua_err)
1566  )
1567  goto tolua_lerror;
1568  else
1569 #endif
1570  {
1571  {
1572  fawkes::MessageQueue* tolua_ret = (fawkes::MessageQueue*) Mtolua_new((fawkes::MessageQueue)());
1573  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue");
1574  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1575  }
1576  }
1577  return 1;
1578 #ifndef TOLUA_RELEASE
1579  tolua_lerror:
1580  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1581  return 0;
1582 #endif
1583 }
1584 #endif //#ifndef TOLUA_DISABLE
1585 
1586 /* method: delete of class fawkes::MessageQueue */
1587 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_delete00
1588 static int tolua_fawkesinterface_fawkes_MessageQueue_delete00(lua_State* tolua_S)
1589 {
1590 #ifndef TOLUA_RELEASE
1591  tolua_Error tolua_err;
1592  if (
1593  !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
1594  !tolua_isnoobj(tolua_S,2,&tolua_err)
1595  )
1596  goto tolua_lerror;
1597  else
1598 #endif
1599  {
1600  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
1601 #ifndef TOLUA_RELEASE
1602  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
1603 #endif
1604  Mtolua_delete(self);
1605  }
1606  return 0;
1607 #ifndef TOLUA_RELEASE
1608  tolua_lerror:
1609  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
1610  return 0;
1611 #endif
1612 }
1613 #endif //#ifndef TOLUA_DISABLE
1614 
1615 /* method: new of class MessageIterator */
1616 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00
1617 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00(lua_State* tolua_S)
1618 {
1619 #ifndef TOLUA_RELEASE
1620  tolua_Error tolua_err;
1621  if (
1622  !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
1623  !tolua_isnoobj(tolua_S,2,&tolua_err)
1624  )
1625  goto tolua_lerror;
1626  else
1627 #endif
1628  {
1629  {
1631  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue::MessageIterator");
1632  }
1633  }
1634  return 1;
1635 #ifndef TOLUA_RELEASE
1636  tolua_lerror:
1637  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1638  return 0;
1639 #endif
1640 }
1641 #endif //#ifndef TOLUA_DISABLE
1642 
1643 /* method: new_local of class MessageIterator */
1644 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local
1645 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local(lua_State* tolua_S)
1646 {
1647 #ifndef TOLUA_RELEASE
1648  tolua_Error tolua_err;
1649  if (
1650  !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
1651  !tolua_isnoobj(tolua_S,2,&tolua_err)
1652  )
1653  goto tolua_lerror;
1654  else
1655 #endif
1656  {
1657  {
1659  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue::MessageIterator");
1660  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1661  }
1662  }
1663  return 1;
1664 #ifndef TOLUA_RELEASE
1665  tolua_lerror:
1666  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1667  return 0;
1668 #endif
1669 }
1670 #endif //#ifndef TOLUA_DISABLE
1671 
1672 /* method: new of class MessageIterator */
1673 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01
1674 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01(lua_State* tolua_S)
1675 {
1676  tolua_Error tolua_err;
1677  if (
1678  !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
1679  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err)) ||
1680  !tolua_isnoobj(tolua_S,3,&tolua_err)
1681  )
1682  goto tolua_lerror;
1683  else
1684  {
1685  const fawkes::MessageQueue::MessageIterator* it = ((const fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,2,0));
1686  {
1688  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue::MessageIterator");
1689  }
1690  }
1691  return 1;
1692 tolua_lerror:
1693  return tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00(tolua_S);
1694 }
1695 #endif //#ifndef TOLUA_DISABLE
1696 
1697 /* method: new_local of class MessageIterator */
1698 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local
1699 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local(lua_State* tolua_S)
1700 {
1701  tolua_Error tolua_err;
1702  if (
1703  !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
1704  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err)) ||
1705  !tolua_isnoobj(tolua_S,3,&tolua_err)
1706  )
1707  goto tolua_lerror;
1708  else
1709  {
1710  const fawkes::MessageQueue::MessageIterator* it = ((const fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,2,0));
1711  {
1713  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue::MessageIterator");
1714  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1715  }
1716  }
1717  return 1;
1718 tolua_lerror:
1719  return tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local(tolua_S);
1720 }
1721 #endif //#ifndef TOLUA_DISABLE
1722 
1723 /* method: operator+ of class MessageIterator */
1724 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__add00
1725 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__add00(lua_State* tolua_S)
1726 {
1727 #ifndef TOLUA_RELEASE
1728  tolua_Error tolua_err;
1729  if (
1730  !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
1731  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1732  !tolua_isnoobj(tolua_S,3,&tolua_err)
1733  )
1734  goto tolua_lerror;
1735  else
1736 #endif
1737  {
1738  fawkes::MessageQueue::MessageIterator* self = (fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,1,0);
1739  unsigned int i = ((unsigned int) tolua_tonumber(tolua_S,2,0));
1740 #ifndef TOLUA_RELEASE
1741  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'", NULL);
1742 #endif
1743  {
1745  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::MessageQueue::MessageIterator");
1746  }
1747  }
1748  return 1;
1749 #ifndef TOLUA_RELEASE
1750  tolua_lerror:
1751  tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
1752  return 0;
1753 #endif
1754 }
1755 #endif //#ifndef TOLUA_DISABLE
1756 
1757 /* method: operator== of class MessageIterator */
1758 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__eq00
1759 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__eq00(lua_State* tolua_S)
1760 {
1761 #ifndef TOLUA_RELEASE
1762  tolua_Error tolua_err;
1763  if (
1764  !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
1765  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err)) ||
1766  !tolua_isnoobj(tolua_S,3,&tolua_err)
1767  )
1768  goto tolua_lerror;
1769  else
1770 #endif
1771  {
1772  const fawkes::MessageQueue::MessageIterator* self = (const fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,1,0);
1773  const fawkes::MessageQueue::MessageIterator* c = ((const fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,2,0));
1774 #ifndef TOLUA_RELEASE
1775  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
1776 #endif
1777  {
1778  bool tolua_ret = (bool) self->operator==(*c);
1779  tolua_pushboolean(tolua_S,(bool)tolua_ret);
1780  }
1781  }
1782  return 1;
1783 #ifndef TOLUA_RELEASE
1784  tolua_lerror:
1785  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
1786  return 0;
1787 #endif
1788 }
1789 #endif //#ifndef TOLUA_DISABLE
1790 
1791 /* method: operator* of class MessageIterator */
1792 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__mul00
1793 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__mul00(lua_State* tolua_S)
1794 {
1795 #ifndef TOLUA_RELEASE
1796  tolua_Error tolua_err;
1797  if (
1798  !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
1799  !tolua_isnoobj(tolua_S,2,&tolua_err)
1800  )
1801  goto tolua_lerror;
1802  else
1803 #endif
1804  {
1805  const fawkes::MessageQueue::MessageIterator* self = (const fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,1,0);
1806 #ifndef TOLUA_RELEASE
1807  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
1808 #endif
1809  {
1810  fawkes::Message* tolua_ret = (fawkes::Message*) self->operator*();
1811  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
1812  }
1813  }
1814  return 1;
1815 #ifndef TOLUA_RELEASE
1816  tolua_lerror:
1817  tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
1818  return 0;
1819 #endif
1820 }
1821 #endif //#ifndef TOLUA_DISABLE
1822 
1823 /* method: id of class MessageIterator */
1824 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_id00
1825 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_id00(lua_State* tolua_S)
1826 {
1827 #ifndef TOLUA_RELEASE
1828  tolua_Error tolua_err;
1829  if (
1830  !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
1831  !tolua_isnoobj(tolua_S,2,&tolua_err)
1832  )
1833  goto tolua_lerror;
1834  else
1835 #endif
1836  {
1837  const fawkes::MessageQueue::MessageIterator* self = (const fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,1,0);
1838 #ifndef TOLUA_RELEASE
1839  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL);
1840 #endif
1841  {
1842  unsigned int tolua_ret = (unsigned int) self->id();
1843  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1844  }
1845  }
1846  return 1;
1847 #ifndef TOLUA_RELEASE
1848  tolua_lerror:
1849  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
1850  return 0;
1851 #endif
1852 }
1853 #endif //#ifndef TOLUA_DISABLE
1854 
1855 /* method: append of class fawkes::MessageQueue */
1856 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_append00
1857 static int tolua_fawkesinterface_fawkes_MessageQueue_append00(lua_State* tolua_S)
1858 {
1859 #ifndef TOLUA_RELEASE
1860  tolua_Error tolua_err;
1861  if (
1862  !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
1863  !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) ||
1864  !tolua_isnoobj(tolua_S,3,&tolua_err)
1865  )
1866  goto tolua_lerror;
1867  else
1868 #endif
1869  {
1870  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
1871  fawkes::Message* msg = ((fawkes::Message*) tolua_tousertype(tolua_S,2,0));
1872 #ifndef TOLUA_RELEASE
1873  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'append'", NULL);
1874 #endif
1875  {
1876  self->append(msg);
1877  }
1878  }
1879  return 0;
1880 #ifndef TOLUA_RELEASE
1881  tolua_lerror:
1882  tolua_error(tolua_S,"#ferror in function 'append'.",&tolua_err);
1883  return 0;
1884 #endif
1885 }
1886 #endif //#ifndef TOLUA_DISABLE
1887 
1888 /* method: remove of class fawkes::MessageQueue */
1889 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_remove00
1890 static int tolua_fawkesinterface_fawkes_MessageQueue_remove00(lua_State* tolua_S)
1891 {
1892 #ifndef TOLUA_RELEASE
1893  tolua_Error tolua_err;
1894  if (
1895  !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
1896  !tolua_isusertype(tolua_S,2,"const fawkes::Message",0,&tolua_err) ||
1897  !tolua_isnoobj(tolua_S,3,&tolua_err)
1898  )
1899  goto tolua_lerror;
1900  else
1901 #endif
1902  {
1903  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
1904  const fawkes::Message* msg = ((const fawkes::Message*) tolua_tousertype(tolua_S,2,0));
1905 #ifndef TOLUA_RELEASE
1906  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'", NULL);
1907 #endif
1908  {
1909  self->remove(msg);
1910  }
1911  }
1912  return 0;
1913 #ifndef TOLUA_RELEASE
1914  tolua_lerror:
1915  tolua_error(tolua_S,"#ferror in function 'remove'.",&tolua_err);
1916  return 0;
1917 #endif
1918 }
1919 #endif //#ifndef TOLUA_DISABLE
1920 
1921 /* method: remove of class fawkes::MessageQueue */
1922 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_remove01
1923 static int tolua_fawkesinterface_fawkes_MessageQueue_remove01(lua_State* tolua_S)
1924 {
1925  tolua_Error tolua_err;
1926  if (
1927  !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
1928  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1929  !tolua_isnoobj(tolua_S,3,&tolua_err)
1930  )
1931  goto tolua_lerror;
1932  else
1933  {
1934  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
1935  unsigned const int msg_id = ((unsigned const int) tolua_tonumber(tolua_S,2,0));
1936 #ifndef TOLUA_RELEASE
1937  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'", NULL);
1938 #endif
1939  {
1940  self->remove(msg_id);
1941  }
1942  }
1943  return 0;
1944 tolua_lerror:
1945  return tolua_fawkesinterface_fawkes_MessageQueue_remove00(tolua_S);
1946 }
1947 #endif //#ifndef TOLUA_DISABLE
1948 
1949 /* method: insert_after of class fawkes::MessageQueue */
1950 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_insert_after00
1951 static int tolua_fawkesinterface_fawkes_MessageQueue_insert_after00(lua_State* tolua_S)
1952 {
1953 #ifndef TOLUA_RELEASE
1954  tolua_Error tolua_err;
1955  if (
1956  !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
1957  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err)) ||
1958  !tolua_isusertype(tolua_S,3,"fawkes::Message",0,&tolua_err) ||
1959  !tolua_isnoobj(tolua_S,4,&tolua_err)
1960  )
1961  goto tolua_lerror;
1962  else
1963 #endif
1964  {
1965  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
1966  const fawkes::MessageQueue::MessageIterator* it = ((const fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,2,0));
1967  fawkes::Message* msg = ((fawkes::Message*) tolua_tousertype(tolua_S,3,0));
1968 #ifndef TOLUA_RELEASE
1969  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insert_after'", NULL);
1970 #endif
1971  {
1972  self->insert_after(*it,msg);
1973  }
1974  }
1975  return 0;
1976 #ifndef TOLUA_RELEASE
1977  tolua_lerror:
1978  tolua_error(tolua_S,"#ferror in function 'insert_after'.",&tolua_err);
1979  return 0;
1980 #endif
1981 }
1982 #endif //#ifndef TOLUA_DISABLE
1983 
1984 /* method: size of class fawkes::MessageQueue */
1985 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_size00
1986 static int tolua_fawkesinterface_fawkes_MessageQueue_size00(lua_State* tolua_S)
1987 {
1988 #ifndef TOLUA_RELEASE
1989  tolua_Error tolua_err;
1990  if (
1991  !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue",0,&tolua_err) ||
1992  !tolua_isnoobj(tolua_S,2,&tolua_err)
1993  )
1994  goto tolua_lerror;
1995  else
1996 #endif
1997  {
1998  const fawkes::MessageQueue* self = (const fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
1999 #ifndef TOLUA_RELEASE
2000  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
2001 #endif
2002  {
2003  unsigned int tolua_ret = (unsigned int) self->size();
2004  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2005  }
2006  }
2007  return 1;
2008 #ifndef TOLUA_RELEASE
2009  tolua_lerror:
2010  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
2011  return 0;
2012 #endif
2013 }
2014 #endif //#ifndef TOLUA_DISABLE
2015 
2016 /* method: flush of class fawkes::MessageQueue */
2017 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_flush00
2018 static int tolua_fawkesinterface_fawkes_MessageQueue_flush00(lua_State* tolua_S)
2019 {
2020 #ifndef TOLUA_RELEASE
2021  tolua_Error tolua_err;
2022  if (
2023  !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
2024  !tolua_isnoobj(tolua_S,2,&tolua_err)
2025  )
2026  goto tolua_lerror;
2027  else
2028 #endif
2029  {
2030  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
2031 #ifndef TOLUA_RELEASE
2032  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'flush'", NULL);
2033 #endif
2034  {
2035  self->flush();
2036  }
2037  }
2038  return 0;
2039 #ifndef TOLUA_RELEASE
2040  tolua_lerror:
2041  tolua_error(tolua_S,"#ferror in function 'flush'.",&tolua_err);
2042  return 0;
2043 #endif
2044 }
2045 #endif //#ifndef TOLUA_DISABLE
2046 
2047 /* method: empty of class fawkes::MessageQueue */
2048 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_empty00
2049 static int tolua_fawkesinterface_fawkes_MessageQueue_empty00(lua_State* tolua_S)
2050 {
2051 #ifndef TOLUA_RELEASE
2052  tolua_Error tolua_err;
2053  if (
2054  !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue",0,&tolua_err) ||
2055  !tolua_isnoobj(tolua_S,2,&tolua_err)
2056  )
2057  goto tolua_lerror;
2058  else
2059 #endif
2060  {
2061  const fawkes::MessageQueue* self = (const fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
2062 #ifndef TOLUA_RELEASE
2063  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'empty'", NULL);
2064 #endif
2065  {
2066  bool tolua_ret = (bool) self->empty();
2067  tolua_pushboolean(tolua_S,(bool)tolua_ret);
2068  }
2069  }
2070  return 1;
2071 #ifndef TOLUA_RELEASE
2072  tolua_lerror:
2073  tolua_error(tolua_S,"#ferror in function 'empty'.",&tolua_err);
2074  return 0;
2075 #endif
2076 }
2077 #endif //#ifndef TOLUA_DISABLE
2078 
2079 /* method: lock of class fawkes::MessageQueue */
2080 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_lock00
2081 static int tolua_fawkesinterface_fawkes_MessageQueue_lock00(lua_State* tolua_S)
2082 {
2083 #ifndef TOLUA_RELEASE
2084  tolua_Error tolua_err;
2085  if (
2086  !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
2087  !tolua_isnoobj(tolua_S,2,&tolua_err)
2088  )
2089  goto tolua_lerror;
2090  else
2091 #endif
2092  {
2093  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
2094 #ifndef TOLUA_RELEASE
2095  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lock'", NULL);
2096 #endif
2097  {
2098  self->lock();
2099  }
2100  }
2101  return 0;
2102 #ifndef TOLUA_RELEASE
2103  tolua_lerror:
2104  tolua_error(tolua_S,"#ferror in function 'lock'.",&tolua_err);
2105  return 0;
2106 #endif
2107 }
2108 #endif //#ifndef TOLUA_DISABLE
2109 
2110 /* method: try_lock of class fawkes::MessageQueue */
2111 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_try_lock00
2112 static int tolua_fawkesinterface_fawkes_MessageQueue_try_lock00(lua_State* tolua_S)
2113 {
2114 #ifndef TOLUA_RELEASE
2115  tolua_Error tolua_err;
2116  if (
2117  !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
2118  !tolua_isnoobj(tolua_S,2,&tolua_err)
2119  )
2120  goto tolua_lerror;
2121  else
2122 #endif
2123  {
2124  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
2125 #ifndef TOLUA_RELEASE
2126  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'try_lock'", NULL);
2127 #endif
2128  {
2129  bool tolua_ret = (bool) self->try_lock();
2130  tolua_pushboolean(tolua_S,(bool)tolua_ret);
2131  }
2132  }
2133  return 1;
2134 #ifndef TOLUA_RELEASE
2135  tolua_lerror:
2136  tolua_error(tolua_S,"#ferror in function 'try_lock'.",&tolua_err);
2137  return 0;
2138 #endif
2139 }
2140 #endif //#ifndef TOLUA_DISABLE
2141 
2142 /* method: unlock of class fawkes::MessageQueue */
2143 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_unlock00
2144 static int tolua_fawkesinterface_fawkes_MessageQueue_unlock00(lua_State* tolua_S)
2145 {
2146 #ifndef TOLUA_RELEASE
2147  tolua_Error tolua_err;
2148  if (
2149  !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
2150  !tolua_isnoobj(tolua_S,2,&tolua_err)
2151  )
2152  goto tolua_lerror;
2153  else
2154 #endif
2155  {
2156  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
2157 #ifndef TOLUA_RELEASE
2158  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unlock'", NULL);
2159 #endif
2160  {
2161  self->unlock();
2162  }
2163  }
2164  return 0;
2165 #ifndef TOLUA_RELEASE
2166  tolua_lerror:
2167  tolua_error(tolua_S,"#ferror in function 'unlock'.",&tolua_err);
2168  return 0;
2169 #endif
2170 }
2171 #endif //#ifndef TOLUA_DISABLE
2172 
2173 /* method: first of class fawkes::MessageQueue */
2174 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_first00
2175 static int tolua_fawkesinterface_fawkes_MessageQueue_first00(lua_State* tolua_S)
2176 {
2177 #ifndef TOLUA_RELEASE
2178  tolua_Error tolua_err;
2179  if (
2180  !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
2181  !tolua_isnoobj(tolua_S,2,&tolua_err)
2182  )
2183  goto tolua_lerror;
2184  else
2185 #endif
2186  {
2187  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
2188 #ifndef TOLUA_RELEASE
2189  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'first'", NULL);
2190 #endif
2191  {
2192  fawkes::Message* tolua_ret = (fawkes::Message*) self->first();
2193  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
2194  }
2195  }
2196  return 1;
2197 #ifndef TOLUA_RELEASE
2198  tolua_lerror:
2199  tolua_error(tolua_S,"#ferror in function 'first'.",&tolua_err);
2200  return 0;
2201 #endif
2202 }
2203 #endif //#ifndef TOLUA_DISABLE
2204 
2205 /* method: pop of class fawkes::MessageQueue */
2206 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_pop00
2207 static int tolua_fawkesinterface_fawkes_MessageQueue_pop00(lua_State* tolua_S)
2208 {
2209 #ifndef TOLUA_RELEASE
2210  tolua_Error tolua_err;
2211  if (
2212  !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
2213  !tolua_isnoobj(tolua_S,2,&tolua_err)
2214  )
2215  goto tolua_lerror;
2216  else
2217 #endif
2218  {
2219  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
2220 #ifndef TOLUA_RELEASE
2221  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pop'", NULL);
2222 #endif
2223  {
2224  self->pop();
2225  }
2226  }
2227  return 0;
2228 #ifndef TOLUA_RELEASE
2229  tolua_lerror:
2230  tolua_error(tolua_S,"#ferror in function 'pop'.",&tolua_err);
2231  return 0;
2232 #endif
2233 }
2234 #endif //#ifndef TOLUA_DISABLE
2235 
2236 /* method: begin of class fawkes::MessageQueue */
2237 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_begin00
2238 static int tolua_fawkesinterface_fawkes_MessageQueue_begin00(lua_State* tolua_S)
2239 {
2240 #ifndef TOLUA_RELEASE
2241  tolua_Error tolua_err;
2242  if (
2243  !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
2244  !tolua_isnoobj(tolua_S,2,&tolua_err)
2245  )
2246  goto tolua_lerror;
2247  else
2248 #endif
2249  {
2250  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
2251 #ifndef TOLUA_RELEASE
2252  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'begin'", NULL);
2253 #endif
2254  {
2256  {
2257 #ifdef __cplusplus
2258  void* tolua_obj = Mtolua_new((fawkes::MessageQueue::MessageIterator)(tolua_ret));
2259  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::MessageQueue::MessageIterator");
2260  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2261 #else
2262  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::MessageQueue::MessageIterator));
2263  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::MessageQueue::MessageIterator");
2264  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2265 #endif
2266  }
2267  }
2268  }
2269  return 1;
2270 #ifndef TOLUA_RELEASE
2271  tolua_lerror:
2272  tolua_error(tolua_S,"#ferror in function 'begin'.",&tolua_err);
2273  return 0;
2274 #endif
2275 }
2276 #endif //#ifndef TOLUA_DISABLE
2277 
2278 /* method: end of class fawkes::MessageQueue */
2279 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_end00
2280 static int tolua_fawkesinterface_fawkes_MessageQueue_end00(lua_State* tolua_S)
2281 {
2282 #ifndef TOLUA_RELEASE
2283  tolua_Error tolua_err;
2284  if (
2285  !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
2286  !tolua_isnoobj(tolua_S,2,&tolua_err)
2287  )
2288  goto tolua_lerror;
2289  else
2290 #endif
2291  {
2292  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
2293 #ifndef TOLUA_RELEASE
2294  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'end'", NULL);
2295 #endif
2296  {
2298  {
2299 #ifdef __cplusplus
2300  void* tolua_obj = Mtolua_new((fawkes::MessageQueue::MessageIterator)(tolua_ret));
2301  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::MessageQueue::MessageIterator");
2302  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2303 #else
2304  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::MessageQueue::MessageIterator));
2305  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::MessageQueue::MessageIterator");
2306  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2307 #endif
2308  }
2309  }
2310  }
2311  return 1;
2312 #ifndef TOLUA_RELEASE
2313  tolua_lerror:
2314  tolua_error(tolua_S,"#ferror in function 'end'.",&tolua_err);
2315  return 0;
2316 #endif
2317 }
2318 #endif //#ifndef TOLUA_DISABLE
2319 
2320 /* Open function */
2321 TOLUA_API int tolua_fawkesinterface_open (lua_State* tolua_S)
2322 {
2323  tolua_open(tolua_S);
2324  tolua_reg_types(tolua_S);
2325  tolua_module(tolua_S,NULL,0);
2326  tolua_beginmodule(tolua_S,NULL);
2327  tolua_module(tolua_S,"fawkes",0);
2328  tolua_beginmodule(tolua_S,"fawkes");
2329  tolua_cclass(tolua_S,"Interface","fawkes::Interface","",NULL);
2330  tolua_beginmodule(tolua_S,"Interface");
2331  tolua_function(tolua_S,"oftype",tolua_fawkesinterface_fawkes_Interface_oftype00);
2332  tolua_function(tolua_S,"datachunk",tolua_fawkesinterface_fawkes_Interface_datachunk00);
2333  tolua_function(tolua_S,"datasize",tolua_fawkesinterface_fawkes_Interface_datasize00);
2334  tolua_function(tolua_S,"type",tolua_fawkesinterface_fawkes_Interface_type00);
2335  tolua_function(tolua_S,"id",tolua_fawkesinterface_fawkes_Interface_id00);
2336  tolua_function(tolua_S,"uid",tolua_fawkesinterface_fawkes_Interface_uid00);
2337  tolua_function(tolua_S,"serial",tolua_fawkesinterface_fawkes_Interface_serial00);
2338  tolua_function(tolua_S,"mem_serial",tolua_fawkesinterface_fawkes_Interface_mem_serial00);
2339  tolua_function(tolua_S,".eq",tolua_fawkesinterface_fawkes_Interface__eq00);
2340  tolua_function(tolua_S,"hash",tolua_fawkesinterface_fawkes_Interface_hash00);
2341  tolua_function(tolua_S,"hash_size",tolua_fawkesinterface_fawkes_Interface_hash_size00);
2342  tolua_function(tolua_S,"hash_printable",tolua_fawkesinterface_fawkes_Interface_hash_printable00);
2343  tolua_function(tolua_S,"is_writer",tolua_fawkesinterface_fawkes_Interface_is_writer00);
2344  tolua_function(tolua_S,"set_from_chunk",tolua_fawkesinterface_fawkes_Interface_set_from_chunk00);
2345  tolua_function(tolua_S,"create_message",tolua_fawkesinterface_fawkes_Interface_create_message00);
2346  tolua_function(tolua_S,"read",tolua_fawkesinterface_fawkes_Interface_read00);
2347  tolua_function(tolua_S,"write",tolua_fawkesinterface_fawkes_Interface_write00);
2348  tolua_function(tolua_S,"has_writer",tolua_fawkesinterface_fawkes_Interface_has_writer00);
2349  tolua_function(tolua_S,"num_readers",tolua_fawkesinterface_fawkes_Interface_num_readers00);
2350  tolua_function(tolua_S,"msgq_enqueue_copy",tolua_fawkesinterface_fawkes_Interface_msgq_enqueue_copy00);
2351  tolua_function(tolua_S,"msgq_remove",tolua_fawkesinterface_fawkes_Interface_msgq_remove00);
2352  tolua_function(tolua_S,"msgq_remove",tolua_fawkesinterface_fawkes_Interface_msgq_remove01);
2353  tolua_function(tolua_S,"msgq_size",tolua_fawkesinterface_fawkes_Interface_msgq_size00);
2354  tolua_function(tolua_S,"msgq_flush",tolua_fawkesinterface_fawkes_Interface_msgq_flush00);
2355  tolua_function(tolua_S,"msgq_lock",tolua_fawkesinterface_fawkes_Interface_msgq_lock00);
2356  tolua_function(tolua_S,"msgq_try_lock",tolua_fawkesinterface_fawkes_Interface_msgq_try_lock00);
2357  tolua_function(tolua_S,"msgq_unlock",tolua_fawkesinterface_fawkes_Interface_msgq_unlock00);
2358  tolua_function(tolua_S,"msgq_pop",tolua_fawkesinterface_fawkes_Interface_msgq_pop00);
2359  tolua_function(tolua_S,"msgq_first",tolua_fawkesinterface_fawkes_Interface_msgq_first00);
2360  tolua_function(tolua_S,"msgq_empty",tolua_fawkesinterface_fawkes_Interface_msgq_empty00);
2361  tolua_endmodule(tolua_S);
2362  tolua_endmodule(tolua_S);
2363  tolua_module(tolua_S,"fawkes",0);
2364  tolua_beginmodule(tolua_S,"fawkes");
2365  #ifdef __cplusplus
2366  tolua_cclass(tolua_S,"Message","fawkes::Message","RefCount",tolua_collect_fawkes__Message);
2367  #else
2368  tolua_cclass(tolua_S,"Message","fawkes::Message","RefCount",NULL);
2369  #endif
2370  tolua_beginmodule(tolua_S,"Message");
2371  tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_Message_new00);
2372  tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_Message_new00_local);
2373  tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_Message_new00_local);
2374  tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_Message_new01);
2375  tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_Message_new01_local);
2376  tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_Message_new01_local);
2377  tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_Message_new02);
2378  tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_Message_new02_local);
2379  tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_Message_new02_local);
2380  tolua_function(tolua_S,"sender_id",tolua_fawkesinterface_fawkes_Message_sender_id00);
2381  tolua_function(tolua_S,"sender_thread_name",tolua_fawkesinterface_fawkes_Message_sender_thread_name00);
2382  tolua_function(tolua_S,"interface",tolua_fawkesinterface_fawkes_Message_interface00);
2383  tolua_function(tolua_S,"type",tolua_fawkesinterface_fawkes_Message_type00);
2384  tolua_function(tolua_S,"datachunk",tolua_fawkesinterface_fawkes_Message_datachunk00);
2385  tolua_function(tolua_S,"datasize",tolua_fawkesinterface_fawkes_Message_datasize00);
2386  tolua_function(tolua_S,"set_from_chunk",tolua_fawkesinterface_fawkes_Message_set_from_chunk00);
2387  tolua_function(tolua_S,"ref",tolua_fawkesinterface_fawkes_Message_ref00);
2388  tolua_function(tolua_S,"unref",tolua_fawkesinterface_fawkes_Message_unref00);
2389  tolua_function(tolua_S,"refcount",tolua_fawkesinterface_fawkes_Message_refcount00);
2390  tolua_endmodule(tolua_S);
2391  tolua_endmodule(tolua_S);
2392  tolua_module(tolua_S,"fawkes",0);
2393  tolua_beginmodule(tolua_S,"fawkes");
2394  #ifdef __cplusplus
2395  tolua_cclass(tolua_S,"MessageQueue","fawkes::MessageQueue","",tolua_collect_fawkes__MessageQueue);
2396  #else
2397  tolua_cclass(tolua_S,"MessageQueue","fawkes::MessageQueue","",NULL);
2398  #endif
2399  tolua_beginmodule(tolua_S,"MessageQueue");
2400  tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_MessageQueue_new00);
2401  tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_MessageQueue_new00_local);
2402  tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_MessageQueue_new00_local);
2403  tolua_function(tolua_S,"delete",tolua_fawkesinterface_fawkes_MessageQueue_delete00);
2404  #ifdef __cplusplus
2405  tolua_cclass(tolua_S,"MessageIterator","fawkes::MessageQueue::MessageIterator","",tolua_collect_fawkes__MessageQueue__MessageIterator);
2406  #else
2407  tolua_cclass(tolua_S,"MessageIterator","fawkes::MessageQueue::MessageIterator","",NULL);
2408  #endif
2409  tolua_beginmodule(tolua_S,"MessageIterator");
2410  tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00);
2411  tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local);
2412  tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local);
2413  tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01);
2414  tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local);
2415  tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local);
2416  tolua_function(tolua_S,".add",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__add00);
2417  tolua_function(tolua_S,".eq",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__eq00);
2418  tolua_function(tolua_S,".mul",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__mul00);
2419  tolua_function(tolua_S,"id",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_id00);
2420  tolua_endmodule(tolua_S);
2421  tolua_function(tolua_S,"append",tolua_fawkesinterface_fawkes_MessageQueue_append00);
2422  tolua_function(tolua_S,"remove",tolua_fawkesinterface_fawkes_MessageQueue_remove00);
2423  tolua_function(tolua_S,"remove",tolua_fawkesinterface_fawkes_MessageQueue_remove01);
2424  tolua_function(tolua_S,"insert_after",tolua_fawkesinterface_fawkes_MessageQueue_insert_after00);
2425  tolua_function(tolua_S,"size",tolua_fawkesinterface_fawkes_MessageQueue_size00);
2426  tolua_function(tolua_S,"flush",tolua_fawkesinterface_fawkes_MessageQueue_flush00);
2427  tolua_function(tolua_S,"empty",tolua_fawkesinterface_fawkes_MessageQueue_empty00);
2428  tolua_function(tolua_S,"lock",tolua_fawkesinterface_fawkes_MessageQueue_lock00);
2429  tolua_function(tolua_S,"try_lock",tolua_fawkesinterface_fawkes_MessageQueue_try_lock00);
2430  tolua_function(tolua_S,"unlock",tolua_fawkesinterface_fawkes_MessageQueue_unlock00);
2431  tolua_function(tolua_S,"first",tolua_fawkesinterface_fawkes_MessageQueue_first00);
2432  tolua_function(tolua_S,"pop",tolua_fawkesinterface_fawkes_MessageQueue_pop00);
2433  tolua_function(tolua_S,"begin",tolua_fawkesinterface_fawkes_MessageQueue_begin00);
2434  tolua_function(tolua_S,"end",tolua_fawkesinterface_fawkes_MessageQueue_end00);
2435  tolua_endmodule(tolua_S);
2436  tolua_endmodule(tolua_S);
2437  tolua_endmodule(tolua_S);
2438  return 1;
2439 }
2440 
2441 
2442 extern "C" {
2443 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
2444  TOLUA_API int luaopen_fawkesinterface (lua_State* tolua_S) {
2445  return tolua_fawkesinterface_open(tolua_S);
2446 };
2447 #endif
2448 }
2449 
2450