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