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 */
29TOLUA_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
40static int tolua_collect_fawkes__MessageQueue__MessageIterator (lua_State* tolua_S)
41{
43 Mtolua_delete(self);
44 return 0;
45}
46
47static 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
54static 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
61static 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
68static 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 */
78static 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
93static 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
125static 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
159static 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
191static 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
223static 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
255static 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
287static 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
319static 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
361static 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
393static 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
427static 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
459static 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
501static 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
533static 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
565static 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
598static 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
632static 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
663static 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
694static 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
726static 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
758static 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
790static 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
822static 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
854static 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
887static 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
920static 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
953static 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
987static 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
1020static 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;
1041tolua_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
1048static 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
1080static 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
1111static 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
1142static 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
1174static 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
1205static 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
1236static 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
1268static 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
1300static 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
1330static 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
1361static 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;
1379tolua_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
1386static 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;
1405tolua_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
1412static 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;
1430tolua_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
1437static 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;
1456tolua_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
1463static 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
1495static 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
1537static 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
1579static 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
1611static 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
1643static 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
1675static 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
1707static 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
1739static 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
1772static 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
1803static 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
1834static 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
1866static 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
1894static 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
1923static 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
1952static 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
1980static 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
2009static 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;
2027tolua_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
2034static 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;
2053tolua_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
2060static 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 {
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
2094static 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
2128static 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
2160static 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
2192static 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
2225static 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
2258static 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;
2279tolua_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
2286static 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
2321static 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
2353static 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
2384static 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
2416static 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
2447static 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
2479static 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
2510static 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
2542static 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
2573static 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
2615static 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 */
2656TOLUA_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
2832extern "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
bool msgq_try_lock()
Try to lock message queue.
Definition: interface.cpp:1119
const char * hash_printable() const
Get printable interface hash.
Definition: interface.cpp:314
const void * datachunk() const
Get data chunk.
Definition: interface.cpp:436
unsigned int msgq_enqueue_copy(Message *message)
Enqueue copy of message at end of queue.
Definition: interface.cpp:953
const char * type() const
Get type of interface.
Definition: interface.cpp:652
void set_auto_timestamping(bool enabled)
Enable or disable automated timestamping.
Definition: interface.cpp:755
void msgq_pop()
Erase first message from queue.
Definition: interface.cpp:1215
const Time * timestamp() const
Get timestamp of last write.
Definition: interface.cpp:714
Message * msgq_first()
Get the first message from the message queue.
Definition: interface.cpp:1200
bool changed() const
Definition: interface.cpp:789
size_t hash_size() const
Get size of interface hash.
Definition: interface.cpp:426
virtual Message * create_message(const char *type) const =0
Create message based on type name.
bool is_writer() const
Check if this is a writing instance.
Definition: interface.cpp:445
void msgq_remove(Message *message)
Remove message from queue.
Definition: interface.cpp:1010
const unsigned char * hash() const
Get interface hash.
Definition: interface.cpp:305
unsigned int msgq_size()
Get size of message queue.
Definition: interface.cpp:1045
void write()
Write from local copy into BlackBoard memory.
Definition: interface.cpp:501
const char * id() const
Get identifier of interface.
Definition: interface.cpp:661
unsigned int mem_serial() const
Get memory serial of interface.
Definition: interface.cpp:704
Uuid serial() const
Get instance serial of interface.
Definition: interface.cpp:695
bool msgq_empty()
Check if queue is empty.
Definition: interface.cpp:1062
void set_from_chunk(void *chunk)
Set from a raw data chunk.
Definition: interface.cpp:831
void msgq_lock()
Lock message queue.
Definition: interface.cpp:1098
const char * uid() const
Get unique identifier of interface.
Definition: interface.cpp:686
void msgq_flush()
Flush all messages.
Definition: interface.cpp:1079
unsigned int num_readers() const
Get the number of readers.
Definition: interface.cpp:876
void read()
Read from BlackBoard into local copy.
Definition: interface.cpp:479
void msgq_unlock()
Unlock message queue.
Definition: interface.cpp:1137
void set_clock(Clock *clock)
Set clock to use for timestamping.
Definition: interface.cpp:745
unsigned int datasize() const
Get data size.
Definition: interface.cpp:540
bool has_writer() const
Check if there is a writer for the interface.
Definition: interface.cpp:848
bool oftype(const char *interface_type) const
Check if interface is of given type.
Definition: interface.cpp:643
void set_timestamp(const Time *t=NULL)
Set timestamp.
Definition: interface.cpp:724
bool refreshed() const
Check if data has been refreshed.
Definition: interface.cpp:811
Message queue used in interfaces.
Definition: message_queue.h:42
MessageIterator end()
Get iterator to element beyond end of message queue list.
void append(Message *msg)
Append message to queue.
void unlock()
Unlock message queue.
void pop()
Erase first message from queue.
void flush()
Delete all messages from queue.
void lock()
Lock message queue.
void remove(const Message *msg)
Remove message from queue.
bool empty() const
Check if message queue is empty.
MessageIterator begin()
Get iterator to first element in message queue.
bool try_lock()
Try to lock message queue.
void insert_after(const MessageIterator &it, Message *msg)
Enqueue message after given iterator.
unsigned int size() const
Get number of messages in queue.
Message * first()
Get first message from queue.
Base class for all messages passed through interfaces in Fawkes BlackBoard.
Definition: message.h:44
const char * type() const
Get message type.
Definition: message.cpp:381
const void * datachunk() const
Get pointer to data.
Definition: message.cpp:281
unsigned int datasize() const
Get size of data.
Definition: message.cpp:290
Uuid source_id() const
Get ID of the original source of the message.
Definition: message.cpp:346
Interface * interface() const
Get transmitting interface.
Definition: message.cpp:372
void set_from_chunk(const void *chunk)
Set from raw data chunk.
Definition: message.cpp:301
Uuid sender_id() const
Get ID of the immediate sender, not necessarily the creator of the message.
Definition: message.cpp:336
const char * sender_thread_name() const
Get sender of message.
Definition: message.cpp:327
unsigned int id() const
Get message ID.
Definition: message.cpp:181
void unref()
Decrement reference count and conditionally delete this instance.
Definition: refcount.cpp:95
void ref()
Increment reference count.
Definition: refcount.cpp:67
unsigned int refcount()
Get reference count for this instance.
Definition: refcount.cpp:120
A class for handling time.
Definition: time.h:93
A convenience class for universally unique identifiers (UUIDs).
Definition: uuid.h:29
std::string get_string() const
Get the string representation of the Uuid.
Definition: uuid.cpp:107