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