19#include <core/exception.h>
29TOLUA_API
int tolua_fawkesinterface_open (lua_State* tolua_S);
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>
40static int tolua_collect_fawkes__MessageQueue__MessageIterator (lua_State* tolua_S)
47static int tolua_collect_fawkes__Message (lua_State* tolua_S)
54static int tolua_collect_fawkes__Uuid (lua_State* tolua_S)
61static int tolua_collect_fawkes__MessageQueue (lua_State* tolua_S)
68static int tolua_collect_size_t (lua_State* tolua_S)
70 size_t* self = (
size_t*) tolua_tousertype(tolua_S,1,0);
78static void tolua_reg_types (lua_State* tolua_S)
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");
92#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Uuid_get_string00
93static int tolua_fawkesinterface_fawkes_Uuid_get_string00(lua_State* tolua_S)
96 tolua_Error tolua_err;
98 !tolua_isusertype(tolua_S,1,
"const fawkes::Uuid",0,&tolua_err) ||
99 !tolua_isnoobj(tolua_S,2,&tolua_err)
107 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'get_string'", NULL);
109 bool exc_caught =
false;
112 std::string tolua_ret = (std::string) self->
get_string();
113 tolua_pushcppstring(tolua_S,(
const char*)tolua_ret);
119 catch (std::exception &e) {
121 lua_pushstring(tolua_S, e.what());
123 if (exc_caught) lua_error(tolua_S);
129 tolua_error(tolua_S,
"#ferror in function 'get_string'.",&tolua_err);
136#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_oftype00
137static int tolua_fawkesinterface_fawkes_Interface_oftype00(lua_State* tolua_S)
140 tolua_Error tolua_err;
142 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
143 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
144 !tolua_isnoobj(tolua_S,3,&tolua_err)
151 const char* interface_type = ((
const char*) tolua_tostring(tolua_S,2,0));
153 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'oftype'", NULL);
155 bool exc_caught =
false;
158 bool tolua_ret = (bool) self->
oftype(interface_type);
159 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
165 catch (std::exception &e) {
167 lua_pushstring(tolua_S, e.what());
169 if (exc_caught) lua_error(tolua_S);
175 tolua_error(tolua_S,
"#ferror in function 'oftype'.",&tolua_err);
182#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_datachunk00
183static int tolua_fawkesinterface_fawkes_Interface_datachunk00(lua_State* tolua_S)
186 tolua_Error tolua_err;
188 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
189 !tolua_isnoobj(tolua_S,2,&tolua_err)
197 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'datachunk'", NULL);
199 bool exc_caught =
false;
202 const void* tolua_ret = (
const void*) self->
datachunk();
203 tolua_pushuserdata(tolua_S,(
void*)tolua_ret);
209 catch (std::exception &e) {
211 lua_pushstring(tolua_S, e.what());
213 if (exc_caught) lua_error(tolua_S);
219 tolua_error(tolua_S,
"#ferror in function 'datachunk'.",&tolua_err);
226#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_datasize00
227static int tolua_fawkesinterface_fawkes_Interface_datasize00(lua_State* tolua_S)
230 tolua_Error tolua_err;
232 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
233 !tolua_isnoobj(tolua_S,2,&tolua_err)
241 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'datasize'", NULL);
243 bool exc_caught =
false;
246 unsigned int tolua_ret = (
unsigned int) self->
datasize();
247 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
253 catch (std::exception &e) {
255 lua_pushstring(tolua_S, e.what());
257 if (exc_caught) lua_error(tolua_S);
263 tolua_error(tolua_S,
"#ferror in function 'datasize'.",&tolua_err);
270#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_type00
271static int tolua_fawkesinterface_fawkes_Interface_type00(lua_State* tolua_S)
274 tolua_Error tolua_err;
276 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
277 !tolua_isnoobj(tolua_S,2,&tolua_err)
285 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'type'", NULL);
287 bool exc_caught =
false;
290 const char* tolua_ret = (
const char*) self->
type();
291 tolua_pushstring(tolua_S,(
const char*)tolua_ret);
297 catch (std::exception &e) {
299 lua_pushstring(tolua_S, e.what());
301 if (exc_caught) lua_error(tolua_S);
307 tolua_error(tolua_S,
"#ferror in function 'type'.",&tolua_err);
314#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_id00
315static int tolua_fawkesinterface_fawkes_Interface_id00(lua_State* tolua_S)
318 tolua_Error tolua_err;
320 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
321 !tolua_isnoobj(tolua_S,2,&tolua_err)
329 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'id'", NULL);
331 bool exc_caught =
false;
334 const char* tolua_ret = (
const char*) self->
id();
335 tolua_pushstring(tolua_S,(
const char*)tolua_ret);
341 catch (std::exception &e) {
343 lua_pushstring(tolua_S, e.what());
345 if (exc_caught) lua_error(tolua_S);
351 tolua_error(tolua_S,
"#ferror in function 'id'.",&tolua_err);
358#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_uid00
359static int tolua_fawkesinterface_fawkes_Interface_uid00(lua_State* tolua_S)
362 tolua_Error tolua_err;
364 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
365 !tolua_isnoobj(tolua_S,2,&tolua_err)
373 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'uid'", NULL);
375 bool exc_caught =
false;
378 const char* tolua_ret = (
const char*) self->
uid();
379 tolua_pushstring(tolua_S,(
const char*)tolua_ret);
385 catch (std::exception &e) {
387 lua_pushstring(tolua_S, e.what());
389 if (exc_caught) lua_error(tolua_S);
395 tolua_error(tolua_S,
"#ferror in function 'uid'.",&tolua_err);
402#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_serial00
403static int tolua_fawkesinterface_fawkes_Interface_serial00(lua_State* tolua_S)
406 tolua_Error tolua_err;
408 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
409 !tolua_isnoobj(tolua_S,2,&tolua_err)
417 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'serial'", NULL);
419 bool exc_caught =
false;
425 void* tolua_obj = Mtolua_new((
fawkes::Uuid)(tolua_ret));
426 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::Uuid");
427 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
429 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(
fawkes::Uuid));
430 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::Uuid");
431 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
439 catch (std::exception &e) {
441 lua_pushstring(tolua_S, e.what());
443 if (exc_caught) lua_error(tolua_S);
449 tolua_error(tolua_S,
"#ferror in function 'serial'.",&tolua_err);
456#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_mem_serial00
457static int tolua_fawkesinterface_fawkes_Interface_mem_serial00(lua_State* tolua_S)
460 tolua_Error tolua_err;
462 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
463 !tolua_isnoobj(tolua_S,2,&tolua_err)
471 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'mem_serial'", NULL);
473 bool exc_caught =
false;
476 unsigned int tolua_ret = (
unsigned int) self->
mem_serial();
477 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
483 catch (std::exception &e) {
485 lua_pushstring(tolua_S, e.what());
487 if (exc_caught) lua_error(tolua_S);
493 tolua_error(tolua_S,
"#ferror in function 'mem_serial'.",&tolua_err);
500#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface__eq00
501static int tolua_fawkesinterface_fawkes_Interface__eq00(lua_State* tolua_S)
504 tolua_Error tolua_err;
506 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
507 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"fawkes::Interface",0,&tolua_err)) ||
508 !tolua_isnoobj(tolua_S,3,&tolua_err)
517 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'operator=='", NULL);
519 bool exc_caught =
false;
522 bool tolua_ret = (bool) self->operator==(*comp);
523 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
529 catch (std::exception &e) {
531 lua_pushstring(tolua_S, e.what());
533 if (exc_caught) lua_error(tolua_S);
539 tolua_error(tolua_S,
"#ferror in function '.eq'.",&tolua_err);
546#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_hash00
547static int tolua_fawkesinterface_fawkes_Interface_hash00(lua_State* tolua_S)
550 tolua_Error tolua_err;
552 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
553 !tolua_isnoobj(tolua_S,2,&tolua_err)
561 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'hash'", NULL);
563 bool exc_caught =
false;
566 unsigned const char* tolua_ret = (
unsigned const char*) self->
hash();
567 tolua_pushstring(tolua_S,(
const char*)tolua_ret);
573 catch (std::exception &e) {
575 lua_pushstring(tolua_S, e.what());
577 if (exc_caught) lua_error(tolua_S);
583 tolua_error(tolua_S,
"#ferror in function 'hash'.",&tolua_err);
590#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_hash_size00
591static int tolua_fawkesinterface_fawkes_Interface_hash_size00(lua_State* tolua_S)
594 tolua_Error tolua_err;
596 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
597 !tolua_isnoobj(tolua_S,2,&tolua_err)
605 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'hash_size'", NULL);
607 bool exc_caught =
false;
610 size_t tolua_ret = (size_t) self->
hash_size();
613 void* tolua_obj = Mtolua_new((
size_t)(tolua_ret));
614 tolua_pushusertype(tolua_S,tolua_obj,
"size_t");
615 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
617 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(
size_t));
618 tolua_pushusertype(tolua_S,tolua_obj,
"size_t");
619 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
627 catch (std::exception &e) {
629 lua_pushstring(tolua_S, e.what());
631 if (exc_caught) lua_error(tolua_S);
637 tolua_error(tolua_S,
"#ferror in function 'hash_size'.",&tolua_err);
644#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_hash_printable00
645static int tolua_fawkesinterface_fawkes_Interface_hash_printable00(lua_State* tolua_S)
648 tolua_Error tolua_err;
650 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
651 !tolua_isnoobj(tolua_S,2,&tolua_err)
659 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'hash_printable'", NULL);
661 bool exc_caught =
false;
665 tolua_pushstring(tolua_S,(
const char*)tolua_ret);
671 catch (std::exception &e) {
673 lua_pushstring(tolua_S, e.what());
675 if (exc_caught) lua_error(tolua_S);
681 tolua_error(tolua_S,
"#ferror in function 'hash_printable'.",&tolua_err);
688#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_is_writer00
689static int tolua_fawkesinterface_fawkes_Interface_is_writer00(lua_State* tolua_S)
692 tolua_Error tolua_err;
694 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
695 !tolua_isnoobj(tolua_S,2,&tolua_err)
703 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'is_writer'", NULL);
705 bool exc_caught =
false;
708 bool tolua_ret = (bool) self->
is_writer();
709 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
715 catch (std::exception &e) {
717 lua_pushstring(tolua_S, e.what());
719 if (exc_caught) lua_error(tolua_S);
725 tolua_error(tolua_S,
"#ferror in function 'is_writer'.",&tolua_err);
732#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_set_from_chunk00
733static int tolua_fawkesinterface_fawkes_Interface_set_from_chunk00(lua_State* tolua_S)
736 tolua_Error tolua_err;
738 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
739 !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
740 !tolua_isnoobj(tolua_S,3,&tolua_err)
747 void* chunk = ((
void*) tolua_touserdata(tolua_S,2,0));
749 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'set_from_chunk'", NULL);
751 bool exc_caught =
false;
760 catch (std::exception &e) {
762 lua_pushstring(tolua_S, e.what());
764 if (exc_caught) lua_error(tolua_S);
770 tolua_error(tolua_S,
"#ferror in function 'set_from_chunk'.",&tolua_err);
777#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_create_message_generic00
778static int tolua_fawkesinterface_fawkes_Interface_create_message_generic00(lua_State* tolua_S)
781 tolua_Error tolua_err;
783 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
784 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
785 !tolua_isnoobj(tolua_S,3,&tolua_err)
792 const char* type = ((
const char*) tolua_tostring(tolua_S,2,0));
794 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'create_message'", NULL);
796 bool exc_caught =
false;
800 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::Message");
806 catch (std::exception &e) {
808 lua_pushstring(tolua_S, e.what());
810 if (exc_caught) lua_error(tolua_S);
816 tolua_error(tolua_S,
"#ferror in function 'create_message_generic'.",&tolua_err);
823#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_read00
824static int tolua_fawkesinterface_fawkes_Interface_read00(lua_State* tolua_S)
827 tolua_Error tolua_err;
829 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
830 !tolua_isnoobj(tolua_S,2,&tolua_err)
838 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'read'", NULL);
840 bool exc_caught =
false;
849 catch (std::exception &e) {
851 lua_pushstring(tolua_S, e.what());
853 if (exc_caught) lua_error(tolua_S);
859 tolua_error(tolua_S,
"#ferror in function 'read'.",&tolua_err);
866#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_write00
867static int tolua_fawkesinterface_fawkes_Interface_write00(lua_State* tolua_S)
870 tolua_Error tolua_err;
872 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
873 !tolua_isnoobj(tolua_S,2,&tolua_err)
881 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'write'", NULL);
883 bool exc_caught =
false;
892 catch (std::exception &e) {
894 lua_pushstring(tolua_S, e.what());
896 if (exc_caught) lua_error(tolua_S);
902 tolua_error(tolua_S,
"#ferror in function 'write'.",&tolua_err);
909#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_has_writer00
910static int tolua_fawkesinterface_fawkes_Interface_has_writer00(lua_State* tolua_S)
913 tolua_Error tolua_err;
915 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
916 !tolua_isnoobj(tolua_S,2,&tolua_err)
924 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'has_writer'", NULL);
926 bool exc_caught =
false;
930 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
936 catch (std::exception &e) {
938 lua_pushstring(tolua_S, e.what());
940 if (exc_caught) lua_error(tolua_S);
946 tolua_error(tolua_S,
"#ferror in function 'has_writer'.",&tolua_err);
953#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_num_readers00
954static int tolua_fawkesinterface_fawkes_Interface_num_readers00(lua_State* tolua_S)
957 tolua_Error tolua_err;
959 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
960 !tolua_isnoobj(tolua_S,2,&tolua_err)
968 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'num_readers'", NULL);
970 bool exc_caught =
false;
973 unsigned int tolua_ret = (
unsigned int) self->
num_readers();
974 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
980 catch (std::exception &e) {
982 lua_pushstring(tolua_S, e.what());
984 if (exc_caught) lua_error(tolua_S);
990 tolua_error(tolua_S,
"#ferror in function 'num_readers'.",&tolua_err);
997#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_changed00
998static int tolua_fawkesinterface_fawkes_Interface_changed00(lua_State* tolua_S)
1000#ifndef TOLUA_RELEASE
1001 tolua_Error tolua_err;
1003 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
1004 !tolua_isnoobj(tolua_S,2,&tolua_err)
1011#ifndef TOLUA_RELEASE
1012 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'changed'", NULL);
1014 bool exc_caught =
false;
1017 bool tolua_ret = (bool) self->
changed();
1018 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
1024 catch (std::exception &e) {
1026 lua_pushstring(tolua_S, e.what());
1028 if (exc_caught) lua_error(tolua_S);
1032#ifndef TOLUA_RELEASE
1034 tolua_error(tolua_S,
"#ferror in function 'changed'.",&tolua_err);
1041#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_refreshed00
1042static int tolua_fawkesinterface_fawkes_Interface_refreshed00(lua_State* tolua_S)
1044#ifndef TOLUA_RELEASE
1045 tolua_Error tolua_err;
1047 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
1048 !tolua_isnoobj(tolua_S,2,&tolua_err)
1055#ifndef TOLUA_RELEASE
1056 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'refreshed'", NULL);
1058 bool exc_caught =
false;
1061 bool tolua_ret = (bool) self->
refreshed();
1062 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
1068 catch (std::exception &e) {
1070 lua_pushstring(tolua_S, e.what());
1072 if (exc_caught) lua_error(tolua_S);
1076#ifndef TOLUA_RELEASE
1078 tolua_error(tolua_S,
"#ferror in function 'refreshed'.",&tolua_err);
1085#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_timestamp00
1086static int tolua_fawkesinterface_fawkes_Interface_timestamp00(lua_State* tolua_S)
1088#ifndef TOLUA_RELEASE
1089 tolua_Error tolua_err;
1091 !tolua_isusertype(tolua_S,1,
"const fawkes::Interface",0,&tolua_err) ||
1092 !tolua_isnoobj(tolua_S,2,&tolua_err)
1099#ifndef TOLUA_RELEASE
1100 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'timestamp'", NULL);
1102 bool exc_caught =
false;
1106 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"const fawkes::Time");
1112 catch (std::exception &e) {
1114 lua_pushstring(tolua_S, e.what());
1116 if (exc_caught) lua_error(tolua_S);
1120#ifndef TOLUA_RELEASE
1122 tolua_error(tolua_S,
"#ferror in function 'timestamp'.",&tolua_err);
1129#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_set_auto_timestamping00
1130static int tolua_fawkesinterface_fawkes_Interface_set_auto_timestamping00(lua_State* tolua_S)
1132#ifndef TOLUA_RELEASE
1133 tolua_Error tolua_err;
1135 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
1136 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
1137 !tolua_isnoobj(tolua_S,3,&tolua_err)
1144 bool enabled = ((bool) tolua_toboolean(tolua_S,2,0));
1145#ifndef TOLUA_RELEASE
1146 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'set_auto_timestamping'", NULL);
1148 bool exc_caught =
false;
1157 catch (std::exception &e) {
1159 lua_pushstring(tolua_S, e.what());
1161 if (exc_caught) lua_error(tolua_S);
1165#ifndef TOLUA_RELEASE
1167 tolua_error(tolua_S,
"#ferror in function 'set_auto_timestamping'.",&tolua_err);
1174#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_set_timestamp00
1175static int tolua_fawkesinterface_fawkes_Interface_set_timestamp00(lua_State* tolua_S)
1177#ifndef TOLUA_RELEASE
1178 tolua_Error tolua_err;
1180 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
1181 !tolua_isusertype(tolua_S,2,
"const fawkes::Time",0,&tolua_err) ||
1182 !tolua_isnoobj(tolua_S,3,&tolua_err)
1190#ifndef TOLUA_RELEASE
1191 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'set_timestamp'", NULL);
1193 bool exc_caught =
false;
1202 catch (std::exception &e) {
1204 lua_pushstring(tolua_S, e.what());
1206 if (exc_caught) lua_error(tolua_S);
1210#ifndef TOLUA_RELEASE
1212 tolua_error(tolua_S,
"#ferror in function 'set_timestamp'.",&tolua_err);
1219#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_set_clock00
1220static int tolua_fawkesinterface_fawkes_Interface_set_clock00(lua_State* tolua_S)
1222#ifndef TOLUA_RELEASE
1223 tolua_Error tolua_err;
1225 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
1226 !tolua_isusertype(tolua_S,2,
"fawkes::Clock",0,&tolua_err) ||
1227 !tolua_isnoobj(tolua_S,3,&tolua_err)
1235#ifndef TOLUA_RELEASE
1236 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'set_clock'", NULL);
1238 bool exc_caught =
false;
1247 catch (std::exception &e) {
1249 lua_pushstring(tolua_S, e.what());
1251 if (exc_caught) lua_error(tolua_S);
1255#ifndef TOLUA_RELEASE
1257 tolua_error(tolua_S,
"#ferror in function 'set_clock'.",&tolua_err);
1264#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_enqueue_copy00
1265static int tolua_fawkesinterface_fawkes_Interface_msgq_enqueue_copy00(lua_State* tolua_S)
1267#ifndef TOLUA_RELEASE
1268 tolua_Error tolua_err;
1270 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
1271 !tolua_isusertype(tolua_S,2,
"fawkes::Message",0,&tolua_err) ||
1272 !tolua_isnoobj(tolua_S,3,&tolua_err)
1280#ifndef TOLUA_RELEASE
1281 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'msgq_enqueue_copy'", NULL);
1283 bool exc_caught =
false;
1287 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1293 catch (std::exception &e) {
1295 lua_pushstring(tolua_S, e.what());
1297 if (exc_caught) lua_error(tolua_S);
1301#ifndef TOLUA_RELEASE
1303 tolua_error(tolua_S,
"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
1310#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_remove00
1311static int tolua_fawkesinterface_fawkes_Interface_msgq_remove00(lua_State* tolua_S)
1313#ifndef TOLUA_RELEASE
1314 tolua_Error tolua_err;
1316 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
1317 !tolua_isusertype(tolua_S,2,
"fawkes::Message",0,&tolua_err) ||
1318 !tolua_isnoobj(tolua_S,3,&tolua_err)
1326#ifndef TOLUA_RELEASE
1327 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'msgq_remove'", NULL);
1329 bool exc_caught =
false;
1338 catch (std::exception &e) {
1340 lua_pushstring(tolua_S, e.what());
1342 if (exc_caught) lua_error(tolua_S);
1346#ifndef TOLUA_RELEASE
1348 tolua_error(tolua_S,
"#ferror in function 'msgq_remove'.",&tolua_err);
1355#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_remove01
1356static int tolua_fawkesinterface_fawkes_Interface_msgq_remove01(lua_State* tolua_S)
1358 tolua_Error tolua_err;
1360 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
1361 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1362 !tolua_isnoobj(tolua_S,3,&tolua_err)
1368 unsigned int message_id = ((
unsigned int) tolua_tonumber(tolua_S,2,0));
1369#ifndef TOLUA_RELEASE
1370 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'msgq_remove'", NULL);
1372 bool exc_caught =
false;
1381 catch (std::exception &e) {
1383 lua_pushstring(tolua_S, e.what());
1385 if (exc_caught) lua_error(tolua_S);
1390 return tolua_fawkesinterface_fawkes_Interface_msgq_remove00(tolua_S);
1395#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_size00
1396static int tolua_fawkesinterface_fawkes_Interface_msgq_size00(lua_State* tolua_S)
1398#ifndef TOLUA_RELEASE
1399 tolua_Error tolua_err;
1401 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
1402 !tolua_isnoobj(tolua_S,2,&tolua_err)
1409#ifndef TOLUA_RELEASE
1410 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'msgq_size'", NULL);
1412 bool exc_caught =
false;
1415 unsigned int tolua_ret = (
unsigned int) self->
msgq_size();
1416 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1422 catch (std::exception &e) {
1424 lua_pushstring(tolua_S, e.what());
1426 if (exc_caught) lua_error(tolua_S);
1430#ifndef TOLUA_RELEASE
1432 tolua_error(tolua_S,
"#ferror in function 'msgq_size'.",&tolua_err);
1439#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_flush00
1440static int tolua_fawkesinterface_fawkes_Interface_msgq_flush00(lua_State* tolua_S)
1442#ifndef TOLUA_RELEASE
1443 tolua_Error tolua_err;
1445 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
1446 !tolua_isnoobj(tolua_S,2,&tolua_err)
1453#ifndef TOLUA_RELEASE
1454 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'msgq_flush'", NULL);
1456 bool exc_caught =
false;
1465 catch (std::exception &e) {
1467 lua_pushstring(tolua_S, e.what());
1469 if (exc_caught) lua_error(tolua_S);
1473#ifndef TOLUA_RELEASE
1475 tolua_error(tolua_S,
"#ferror in function 'msgq_flush'.",&tolua_err);
1482#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_lock00
1483static int tolua_fawkesinterface_fawkes_Interface_msgq_lock00(lua_State* tolua_S)
1485#ifndef TOLUA_RELEASE
1486 tolua_Error tolua_err;
1488 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
1489 !tolua_isnoobj(tolua_S,2,&tolua_err)
1496#ifndef TOLUA_RELEASE
1497 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'msgq_lock'", NULL);
1499 bool exc_caught =
false;
1508 catch (std::exception &e) {
1510 lua_pushstring(tolua_S, e.what());
1512 if (exc_caught) lua_error(tolua_S);
1516#ifndef TOLUA_RELEASE
1518 tolua_error(tolua_S,
"#ferror in function 'msgq_lock'.",&tolua_err);
1525#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_try_lock00
1526static int tolua_fawkesinterface_fawkes_Interface_msgq_try_lock00(lua_State* tolua_S)
1528#ifndef TOLUA_RELEASE
1529 tolua_Error tolua_err;
1531 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
1532 !tolua_isnoobj(tolua_S,2,&tolua_err)
1539#ifndef TOLUA_RELEASE
1540 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'msgq_try_lock'", NULL);
1542 bool exc_caught =
false;
1546 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
1552 catch (std::exception &e) {
1554 lua_pushstring(tolua_S, e.what());
1556 if (exc_caught) lua_error(tolua_S);
1560#ifndef TOLUA_RELEASE
1562 tolua_error(tolua_S,
"#ferror in function 'msgq_try_lock'.",&tolua_err);
1569#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_unlock00
1570static int tolua_fawkesinterface_fawkes_Interface_msgq_unlock00(lua_State* tolua_S)
1572#ifndef TOLUA_RELEASE
1573 tolua_Error tolua_err;
1575 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
1576 !tolua_isnoobj(tolua_S,2,&tolua_err)
1583#ifndef TOLUA_RELEASE
1584 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'msgq_unlock'", NULL);
1586 bool exc_caught =
false;
1595 catch (std::exception &e) {
1597 lua_pushstring(tolua_S, e.what());
1599 if (exc_caught) lua_error(tolua_S);
1603#ifndef TOLUA_RELEASE
1605 tolua_error(tolua_S,
"#ferror in function 'msgq_unlock'.",&tolua_err);
1612#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_pop00
1613static int tolua_fawkesinterface_fawkes_Interface_msgq_pop00(lua_State* tolua_S)
1615#ifndef TOLUA_RELEASE
1616 tolua_Error tolua_err;
1618 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
1619 !tolua_isnoobj(tolua_S,2,&tolua_err)
1626#ifndef TOLUA_RELEASE
1627 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'msgq_pop'", NULL);
1629 bool exc_caught =
false;
1638 catch (std::exception &e) {
1640 lua_pushstring(tolua_S, e.what());
1642 if (exc_caught) lua_error(tolua_S);
1646#ifndef TOLUA_RELEASE
1648 tolua_error(tolua_S,
"#ferror in function 'msgq_pop'.",&tolua_err);
1655#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_first_generic00
1656static int tolua_fawkesinterface_fawkes_Interface_msgq_first_generic00(lua_State* tolua_S)
1658#ifndef TOLUA_RELEASE
1659 tolua_Error tolua_err;
1661 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
1662 !tolua_isnoobj(tolua_S,2,&tolua_err)
1669#ifndef TOLUA_RELEASE
1670 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'msgq_first'", NULL);
1672 bool exc_caught =
false;
1676 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::Message");
1682 catch (std::exception &e) {
1684 lua_pushstring(tolua_S, e.what());
1686 if (exc_caught) lua_error(tolua_S);
1690#ifndef TOLUA_RELEASE
1692 tolua_error(tolua_S,
"#ferror in function 'msgq_first_generic'.",&tolua_err);
1699#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_empty00
1700static int tolua_fawkesinterface_fawkes_Interface_msgq_empty00(lua_State* tolua_S)
1702#ifndef TOLUA_RELEASE
1703 tolua_Error tolua_err;
1705 !tolua_isusertype(tolua_S,1,
"fawkes::Interface",0,&tolua_err) ||
1706 !tolua_isnoobj(tolua_S,2,&tolua_err)
1713#ifndef TOLUA_RELEASE
1714 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'msgq_empty'", NULL);
1716 bool exc_caught =
false;
1720 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
1726 catch (std::exception &e) {
1728 lua_pushstring(tolua_S, e.what());
1730 if (exc_caught) lua_error(tolua_S);
1734#ifndef TOLUA_RELEASE
1736 tolua_error(tolua_S,
"#ferror in function 'msgq_empty'.",&tolua_err);
1743#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new00
1744static int tolua_fawkesinterface_fawkes_Message_new00(lua_State* tolua_S)
1746#ifndef TOLUA_RELEASE
1747 tolua_Error tolua_err;
1749 !tolua_isusertable(tolua_S,1,
"fawkes::Message",0,&tolua_err) ||
1750 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1751 !tolua_isnoobj(tolua_S,3,&tolua_err)
1757 const char* type = ((
const char*) tolua_tostring(tolua_S,2,0));
1758 bool exc_caught =
false;
1762 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::Message");
1768 catch (std::exception &e) {
1770 lua_pushstring(tolua_S, e.what());
1772 if (exc_caught) lua_error(tolua_S);
1776#ifndef TOLUA_RELEASE
1778 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
1785#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new00_local
1786static int tolua_fawkesinterface_fawkes_Message_new00_local(lua_State* tolua_S)
1788#ifndef TOLUA_RELEASE
1789 tolua_Error tolua_err;
1791 !tolua_isusertable(tolua_S,1,
"fawkes::Message",0,&tolua_err) ||
1792 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1793 !tolua_isnoobj(tolua_S,3,&tolua_err)
1799 const char* type = ((
const char*) tolua_tostring(tolua_S,2,0));
1800 bool exc_caught =
false;
1804 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::Message");
1805 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1811 catch (std::exception &e) {
1813 lua_pushstring(tolua_S, e.what());
1815 if (exc_caught) lua_error(tolua_S);
1819#ifndef TOLUA_RELEASE
1821 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
1828#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new01
1829static int tolua_fawkesinterface_fawkes_Message_new01(lua_State* tolua_S)
1831 tolua_Error tolua_err;
1833 !tolua_isusertable(tolua_S,1,
"fawkes::Message",0,&tolua_err) ||
1834 !tolua_isusertype(tolua_S,2,
"fawkes::Message",0,&tolua_err) ||
1835 !tolua_isnoobj(tolua_S,3,&tolua_err)
1841 bool exc_caught =
false;
1845 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::Message");
1851 catch (std::exception &e) {
1853 lua_pushstring(tolua_S, e.what());
1855 if (exc_caught) lua_error(tolua_S);
1860 return tolua_fawkesinterface_fawkes_Message_new00(tolua_S);
1865#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new01_local
1866static int tolua_fawkesinterface_fawkes_Message_new01_local(lua_State* tolua_S)
1868 tolua_Error tolua_err;
1870 !tolua_isusertable(tolua_S,1,
"fawkes::Message",0,&tolua_err) ||
1871 !tolua_isusertype(tolua_S,2,
"fawkes::Message",0,&tolua_err) ||
1872 !tolua_isnoobj(tolua_S,3,&tolua_err)
1878 bool exc_caught =
false;
1882 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::Message");
1883 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1889 catch (std::exception &e) {
1891 lua_pushstring(tolua_S, e.what());
1893 if (exc_caught) lua_error(tolua_S);
1898 return tolua_fawkesinterface_fawkes_Message_new00_local(tolua_S);
1903#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new02
1904static int tolua_fawkesinterface_fawkes_Message_new02(lua_State* tolua_S)
1906 tolua_Error tolua_err;
1908 !tolua_isusertable(tolua_S,1,
"fawkes::Message",0,&tolua_err) ||
1909 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"fawkes::Message",0,&tolua_err)) ||
1910 !tolua_isnoobj(tolua_S,3,&tolua_err)
1916 bool exc_caught =
false;
1920 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::Message");
1926 catch (std::exception &e) {
1928 lua_pushstring(tolua_S, e.what());
1930 if (exc_caught) lua_error(tolua_S);
1935 return tolua_fawkesinterface_fawkes_Message_new01(tolua_S);
1940#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new02_local
1941static int tolua_fawkesinterface_fawkes_Message_new02_local(lua_State* tolua_S)
1943 tolua_Error tolua_err;
1945 !tolua_isusertable(tolua_S,1,
"fawkes::Message",0,&tolua_err) ||
1946 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"fawkes::Message",0,&tolua_err)) ||
1947 !tolua_isnoobj(tolua_S,3,&tolua_err)
1953 bool exc_caught =
false;
1957 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::Message");
1958 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1964 catch (std::exception &e) {
1966 lua_pushstring(tolua_S, e.what());
1968 if (exc_caught) lua_error(tolua_S);
1973 return tolua_fawkesinterface_fawkes_Message_new01_local(tolua_S);
1978#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_id00
1979static int tolua_fawkesinterface_fawkes_Message_id00(lua_State* tolua_S)
1981#ifndef TOLUA_RELEASE
1982 tolua_Error tolua_err;
1984 !tolua_isusertype(tolua_S,1,
"const fawkes::Message",0,&tolua_err) ||
1985 !tolua_isnoobj(tolua_S,2,&tolua_err)
1992#ifndef TOLUA_RELEASE
1993 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'id'", NULL);
1995 bool exc_caught =
false;
1998 unsigned int tolua_ret = (
unsigned int) self->
id();
1999 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2005 catch (std::exception &e) {
2007 lua_pushstring(tolua_S, e.what());
2009 if (exc_caught) lua_error(tolua_S);
2013#ifndef TOLUA_RELEASE
2015 tolua_error(tolua_S,
"#ferror in function 'id'.",&tolua_err);
2022#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_sender_id00
2023static int tolua_fawkesinterface_fawkes_Message_sender_id00(lua_State* tolua_S)
2025#ifndef TOLUA_RELEASE
2026 tolua_Error tolua_err;
2028 !tolua_isusertype(tolua_S,1,
"const fawkes::Message",0,&tolua_err) ||
2029 !tolua_isnoobj(tolua_S,2,&tolua_err)
2036#ifndef TOLUA_RELEASE
2037 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'sender_id'", NULL);
2039 bool exc_caught =
false;
2045 void* tolua_obj = Mtolua_new((
fawkes::Uuid)(tolua_ret));
2046 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::Uuid");
2047 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2049 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(
fawkes::Uuid));
2050 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::Uuid");
2051 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2059 catch (std::exception &e) {
2061 lua_pushstring(tolua_S, e.what());
2063 if (exc_caught) lua_error(tolua_S);
2067#ifndef TOLUA_RELEASE
2069 tolua_error(tolua_S,
"#ferror in function 'sender_id'.",&tolua_err);
2076#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_source_id00
2077static int tolua_fawkesinterface_fawkes_Message_source_id00(lua_State* tolua_S)
2079#ifndef TOLUA_RELEASE
2080 tolua_Error tolua_err;
2082 !tolua_isusertype(tolua_S,1,
"const fawkes::Message",0,&tolua_err) ||
2083 !tolua_isnoobj(tolua_S,2,&tolua_err)
2090#ifndef TOLUA_RELEASE
2091 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'source_id'", NULL);
2093 bool exc_caught =
false;
2099 void* tolua_obj = Mtolua_new((
fawkes::Uuid)(tolua_ret));
2100 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::Uuid");
2101 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2103 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(
fawkes::Uuid));
2104 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::Uuid");
2105 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2113 catch (std::exception &e) {
2115 lua_pushstring(tolua_S, e.what());
2117 if (exc_caught) lua_error(tolua_S);
2121#ifndef TOLUA_RELEASE
2123 tolua_error(tolua_S,
"#ferror in function 'source_id'.",&tolua_err);
2130#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_sender_thread_name00
2131static int tolua_fawkesinterface_fawkes_Message_sender_thread_name00(lua_State* tolua_S)
2133#ifndef TOLUA_RELEASE
2134 tolua_Error tolua_err;
2136 !tolua_isusertype(tolua_S,1,
"const fawkes::Message",0,&tolua_err) ||
2137 !tolua_isnoobj(tolua_S,2,&tolua_err)
2144#ifndef TOLUA_RELEASE
2145 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'sender_thread_name'", NULL);
2147 bool exc_caught =
false;
2151 tolua_pushstring(tolua_S,(
const char*)tolua_ret);
2157 catch (std::exception &e) {
2159 lua_pushstring(tolua_S, e.what());
2161 if (exc_caught) lua_error(tolua_S);
2165#ifndef TOLUA_RELEASE
2167 tolua_error(tolua_S,
"#ferror in function 'sender_thread_name'.",&tolua_err);
2174#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_interface00
2175static int tolua_fawkesinterface_fawkes_Message_interface00(lua_State* tolua_S)
2177#ifndef TOLUA_RELEASE
2178 tolua_Error tolua_err;
2180 !tolua_isusertype(tolua_S,1,
"const fawkes::Message",0,&tolua_err) ||
2181 !tolua_isnoobj(tolua_S,2,&tolua_err)
2188#ifndef TOLUA_RELEASE
2189 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'interface'", NULL);
2191 bool exc_caught =
false;
2195 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::Interface");
2201 catch (std::exception &e) {
2203 lua_pushstring(tolua_S, e.what());
2205 if (exc_caught) lua_error(tolua_S);
2209#ifndef TOLUA_RELEASE
2211 tolua_error(tolua_S,
"#ferror in function 'interface'.",&tolua_err);
2218#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_type00
2219static int tolua_fawkesinterface_fawkes_Message_type00(lua_State* tolua_S)
2221#ifndef TOLUA_RELEASE
2222 tolua_Error tolua_err;
2224 !tolua_isusertype(tolua_S,1,
"const fawkes::Message",0,&tolua_err) ||
2225 !tolua_isnoobj(tolua_S,2,&tolua_err)
2232#ifndef TOLUA_RELEASE
2233 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'type'", NULL);
2235 bool exc_caught =
false;
2238 const char* tolua_ret = (
const char*) self->
type();
2239 tolua_pushstring(tolua_S,(
const char*)tolua_ret);
2245 catch (std::exception &e) {
2247 lua_pushstring(tolua_S, e.what());
2249 if (exc_caught) lua_error(tolua_S);
2253#ifndef TOLUA_RELEASE
2255 tolua_error(tolua_S,
"#ferror in function 'type'.",&tolua_err);
2262#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_datachunk00
2263static int tolua_fawkesinterface_fawkes_Message_datachunk00(lua_State* tolua_S)
2265#ifndef TOLUA_RELEASE
2266 tolua_Error tolua_err;
2268 !tolua_isusertype(tolua_S,1,
"const fawkes::Message",0,&tolua_err) ||
2269 !tolua_isnoobj(tolua_S,2,&tolua_err)
2276#ifndef TOLUA_RELEASE
2277 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'datachunk'", NULL);
2279 bool exc_caught =
false;
2282 const void* tolua_ret = (
const void*) self->
datachunk();
2283 tolua_pushuserdata(tolua_S,(
void*)tolua_ret);
2289 catch (std::exception &e) {
2291 lua_pushstring(tolua_S, e.what());
2293 if (exc_caught) lua_error(tolua_S);
2297#ifndef TOLUA_RELEASE
2299 tolua_error(tolua_S,
"#ferror in function 'datachunk'.",&tolua_err);
2306#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_datasize00
2307static int tolua_fawkesinterface_fawkes_Message_datasize00(lua_State* tolua_S)
2309#ifndef TOLUA_RELEASE
2310 tolua_Error tolua_err;
2312 !tolua_isusertype(tolua_S,1,
"const fawkes::Message",0,&tolua_err) ||
2313 !tolua_isnoobj(tolua_S,2,&tolua_err)
2320#ifndef TOLUA_RELEASE
2321 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'datasize'", NULL);
2323 bool exc_caught =
false;
2326 unsigned int tolua_ret = (
unsigned int) self->
datasize();
2327 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2333 catch (std::exception &e) {
2335 lua_pushstring(tolua_S, e.what());
2337 if (exc_caught) lua_error(tolua_S);
2341#ifndef TOLUA_RELEASE
2343 tolua_error(tolua_S,
"#ferror in function 'datasize'.",&tolua_err);
2350#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_set_from_chunk00
2351static int tolua_fawkesinterface_fawkes_Message_set_from_chunk00(lua_State* tolua_S)
2353#ifndef TOLUA_RELEASE
2354 tolua_Error tolua_err;
2356 !tolua_isusertype(tolua_S,1,
"fawkes::Message",0,&tolua_err) ||
2357 !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
2358 !tolua_isnoobj(tolua_S,3,&tolua_err)
2365 const void* chunk = ((
const void*) tolua_touserdata(tolua_S,2,0));
2366#ifndef TOLUA_RELEASE
2367 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'set_from_chunk'", NULL);
2369 bool exc_caught =
false;
2378 catch (std::exception &e) {
2380 lua_pushstring(tolua_S, e.what());
2382 if (exc_caught) lua_error(tolua_S);
2386#ifndef TOLUA_RELEASE
2388 tolua_error(tolua_S,
"#ferror in function 'set_from_chunk'.",&tolua_err);
2395#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_ref00
2396static int tolua_fawkesinterface_fawkes_Message_ref00(lua_State* tolua_S)
2398#ifndef TOLUA_RELEASE
2399 tolua_Error tolua_err;
2401 !tolua_isusertype(tolua_S,1,
"fawkes::Message",0,&tolua_err) ||
2402 !tolua_isnoobj(tolua_S,2,&tolua_err)
2409#ifndef TOLUA_RELEASE
2410 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'ref'", NULL);
2412 bool exc_caught =
false;
2421 catch (std::exception &e) {
2423 lua_pushstring(tolua_S, e.what());
2425 if (exc_caught) lua_error(tolua_S);
2429#ifndef TOLUA_RELEASE
2431 tolua_error(tolua_S,
"#ferror in function 'ref'.",&tolua_err);
2438#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_unref00
2439static int tolua_fawkesinterface_fawkes_Message_unref00(lua_State* tolua_S)
2441#ifndef TOLUA_RELEASE
2442 tolua_Error tolua_err;
2444 !tolua_isusertype(tolua_S,1,
"fawkes::Message",0,&tolua_err) ||
2445 !tolua_isnoobj(tolua_S,2,&tolua_err)
2452#ifndef TOLUA_RELEASE
2453 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'unref'", NULL);
2455 bool exc_caught =
false;
2464 catch (std::exception &e) {
2466 lua_pushstring(tolua_S, e.what());
2468 if (exc_caught) lua_error(tolua_S);
2472#ifndef TOLUA_RELEASE
2474 tolua_error(tolua_S,
"#ferror in function 'unref'.",&tolua_err);
2481#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_refcount00
2482static int tolua_fawkesinterface_fawkes_Message_refcount00(lua_State* tolua_S)
2484#ifndef TOLUA_RELEASE
2485 tolua_Error tolua_err;
2487 !tolua_isusertype(tolua_S,1,
"fawkes::Message",0,&tolua_err) ||
2488 !tolua_isnoobj(tolua_S,2,&tolua_err)
2495#ifndef TOLUA_RELEASE
2496 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'refcount'", NULL);
2498 bool exc_caught =
false;
2501 unsigned int tolua_ret = (
unsigned int) self->
refcount();
2502 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2508 catch (std::exception &e) {
2510 lua_pushstring(tolua_S, e.what());
2512 if (exc_caught) lua_error(tolua_S);
2516#ifndef TOLUA_RELEASE
2518 tolua_error(tolua_S,
"#ferror in function 'refcount'.",&tolua_err);
2525#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_new00
2526static int tolua_fawkesinterface_fawkes_MessageQueue_new00(lua_State* tolua_S)
2528#ifndef TOLUA_RELEASE
2529 tolua_Error tolua_err;
2531 !tolua_isusertable(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
2532 !tolua_isnoobj(tolua_S,2,&tolua_err)
2538 bool exc_caught =
false;
2542 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::MessageQueue");
2548 catch (std::exception &e) {
2550 lua_pushstring(tolua_S, e.what());
2552 if (exc_caught) lua_error(tolua_S);
2556#ifndef TOLUA_RELEASE
2558 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
2565#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_new00_local
2566static int tolua_fawkesinterface_fawkes_MessageQueue_new00_local(lua_State* tolua_S)
2568#ifndef TOLUA_RELEASE
2569 tolua_Error tolua_err;
2571 !tolua_isusertable(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
2572 !tolua_isnoobj(tolua_S,2,&tolua_err)
2578 bool exc_caught =
false;
2582 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::MessageQueue");
2583 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2589 catch (std::exception &e) {
2591 lua_pushstring(tolua_S, e.what());
2593 if (exc_caught) lua_error(tolua_S);
2597#ifndef TOLUA_RELEASE
2599 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
2606#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_delete00
2607static int tolua_fawkesinterface_fawkes_MessageQueue_delete00(lua_State* tolua_S)
2609#ifndef TOLUA_RELEASE
2610 tolua_Error tolua_err;
2612 !tolua_isusertype(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
2613 !tolua_isnoobj(tolua_S,2,&tolua_err)
2620#ifndef TOLUA_RELEASE
2621 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'delete'", NULL);
2623 bool exc_caught =
false;
2625 Mtolua_delete(self);
2630 catch (std::exception &e) {
2632 lua_pushstring(tolua_S, e.what());
2634 if (exc_caught) lua_error(tolua_S);
2638#ifndef TOLUA_RELEASE
2640 tolua_error(tolua_S,
"#ferror in function 'delete'.",&tolua_err);
2647#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00
2648static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00(lua_State* tolua_S)
2650#ifndef TOLUA_RELEASE
2651 tolua_Error tolua_err;
2653 !tolua_isusertable(tolua_S,1,
"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
2654 !tolua_isnoobj(tolua_S,2,&tolua_err)
2660 bool exc_caught =
false;
2664 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::MessageQueue::MessageIterator");
2670 catch (std::exception &e) {
2672 lua_pushstring(tolua_S, e.what());
2674 if (exc_caught) lua_error(tolua_S);
2678#ifndef TOLUA_RELEASE
2680 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
2687#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local
2688static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local(lua_State* tolua_S)
2690#ifndef TOLUA_RELEASE
2691 tolua_Error tolua_err;
2693 !tolua_isusertable(tolua_S,1,
"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
2694 !tolua_isnoobj(tolua_S,2,&tolua_err)
2700 bool exc_caught =
false;
2704 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::MessageQueue::MessageIterator");
2705 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2711 catch (std::exception &e) {
2713 lua_pushstring(tolua_S, e.what());
2715 if (exc_caught) lua_error(tolua_S);
2719#ifndef TOLUA_RELEASE
2721 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
2728#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01
2729static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01(lua_State* tolua_S)
2731 tolua_Error tolua_err;
2733 !tolua_isusertable(tolua_S,1,
"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
2734 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::MessageQueue::MessageIterator",0,&tolua_err)) ||
2735 !tolua_isnoobj(tolua_S,3,&tolua_err)
2741 bool exc_caught =
false;
2745 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::MessageQueue::MessageIterator");
2751 catch (std::exception &e) {
2753 lua_pushstring(tolua_S, e.what());
2755 if (exc_caught) lua_error(tolua_S);
2760 return tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00(tolua_S);
2765#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local
2766static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local(lua_State* tolua_S)
2768 tolua_Error tolua_err;
2770 !tolua_isusertable(tolua_S,1,
"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
2771 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::MessageQueue::MessageIterator",0,&tolua_err)) ||
2772 !tolua_isnoobj(tolua_S,3,&tolua_err)
2778 bool exc_caught =
false;
2782 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::MessageQueue::MessageIterator");
2783 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2789 catch (std::exception &e) {
2791 lua_pushstring(tolua_S, e.what());
2793 if (exc_caught) lua_error(tolua_S);
2798 return tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local(tolua_S);
2803#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__add00
2804static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__add00(lua_State* tolua_S)
2806#ifndef TOLUA_RELEASE
2807 tolua_Error tolua_err;
2809 !tolua_isusertype(tolua_S,1,
"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
2810 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2811 !tolua_isnoobj(tolua_S,3,&tolua_err)
2818 unsigned int i = ((
unsigned int) tolua_tonumber(tolua_S,2,0));
2819#ifndef TOLUA_RELEASE
2820 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'operator+'", NULL);
2822 bool exc_caught =
false;
2826 tolua_pushusertype(tolua_S,(
void*)&tolua_ret,
"fawkes::MessageQueue::MessageIterator");
2832 catch (std::exception &e) {
2834 lua_pushstring(tolua_S, e.what());
2836 if (exc_caught) lua_error(tolua_S);
2840#ifndef TOLUA_RELEASE
2842 tolua_error(tolua_S,
"#ferror in function '.add'.",&tolua_err);
2849#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__eq00
2850static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__eq00(lua_State* tolua_S)
2852#ifndef TOLUA_RELEASE
2853 tolua_Error tolua_err;
2855 !tolua_isusertype(tolua_S,1,
"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
2856 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::MessageQueue::MessageIterator",0,&tolua_err)) ||
2857 !tolua_isnoobj(tolua_S,3,&tolua_err)
2865#ifndef TOLUA_RELEASE
2866 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'operator=='", NULL);
2868 bool exc_caught =
false;
2871 bool tolua_ret = (bool) self->operator==(*c);
2872 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
2878 catch (std::exception &e) {
2880 lua_pushstring(tolua_S, e.what());
2882 if (exc_caught) lua_error(tolua_S);
2886#ifndef TOLUA_RELEASE
2888 tolua_error(tolua_S,
"#ferror in function '.eq'.",&tolua_err);
2895#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__mul00
2896static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__mul00(lua_State* tolua_S)
2898#ifndef TOLUA_RELEASE
2899 tolua_Error tolua_err;
2901 !tolua_isusertype(tolua_S,1,
"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
2902 !tolua_isnoobj(tolua_S,2,&tolua_err)
2909#ifndef TOLUA_RELEASE
2910 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'operator*'", NULL);
2912 bool exc_caught =
false;
2916 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::Message");
2922 catch (std::exception &e) {
2924 lua_pushstring(tolua_S, e.what());
2926 if (exc_caught) lua_error(tolua_S);
2930#ifndef TOLUA_RELEASE
2932 tolua_error(tolua_S,
"#ferror in function '.mul'.",&tolua_err);
2939#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_id00
2940static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_id00(lua_State* tolua_S)
2942#ifndef TOLUA_RELEASE
2943 tolua_Error tolua_err;
2945 !tolua_isusertype(tolua_S,1,
"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
2946 !tolua_isnoobj(tolua_S,2,&tolua_err)
2953#ifndef TOLUA_RELEASE
2954 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'id'", NULL);
2956 bool exc_caught =
false;
2959 unsigned int tolua_ret = (
unsigned int) self->
id();
2960 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2966 catch (std::exception &e) {
2968 lua_pushstring(tolua_S, e.what());
2970 if (exc_caught) lua_error(tolua_S);
2974#ifndef TOLUA_RELEASE
2976 tolua_error(tolua_S,
"#ferror in function 'id'.",&tolua_err);
2983#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_append00
2984static int tolua_fawkesinterface_fawkes_MessageQueue_append00(lua_State* tolua_S)
2986#ifndef TOLUA_RELEASE
2987 tolua_Error tolua_err;
2989 !tolua_isusertype(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
2990 !tolua_isusertype(tolua_S,2,
"fawkes::Message",0,&tolua_err) ||
2991 !tolua_isnoobj(tolua_S,3,&tolua_err)
2999#ifndef TOLUA_RELEASE
3000 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'append'", NULL);
3002 bool exc_caught =
false;
3011 catch (std::exception &e) {
3013 lua_pushstring(tolua_S, e.what());
3015 if (exc_caught) lua_error(tolua_S);
3019#ifndef TOLUA_RELEASE
3021 tolua_error(tolua_S,
"#ferror in function 'append'.",&tolua_err);
3028#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_remove00
3029static int tolua_fawkesinterface_fawkes_MessageQueue_remove00(lua_State* tolua_S)
3031#ifndef TOLUA_RELEASE
3032 tolua_Error tolua_err;
3034 !tolua_isusertype(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
3035 !tolua_isusertype(tolua_S,2,
"const fawkes::Message",0,&tolua_err) ||
3036 !tolua_isnoobj(tolua_S,3,&tolua_err)
3044#ifndef TOLUA_RELEASE
3045 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'remove'", NULL);
3047 bool exc_caught =
false;
3056 catch (std::exception &e) {
3058 lua_pushstring(tolua_S, e.what());
3060 if (exc_caught) lua_error(tolua_S);
3064#ifndef TOLUA_RELEASE
3066 tolua_error(tolua_S,
"#ferror in function 'remove'.",&tolua_err);
3073#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_remove01
3074static int tolua_fawkesinterface_fawkes_MessageQueue_remove01(lua_State* tolua_S)
3076 tolua_Error tolua_err;
3078 !tolua_isusertype(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
3079 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
3080 !tolua_isnoobj(tolua_S,3,&tolua_err)
3086 unsigned const int msg_id = ((
unsigned const int) tolua_tonumber(tolua_S,2,0));
3087#ifndef TOLUA_RELEASE
3088 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'remove'", NULL);
3090 bool exc_caught =
false;
3099 catch (std::exception &e) {
3101 lua_pushstring(tolua_S, e.what());
3103 if (exc_caught) lua_error(tolua_S);
3108 return tolua_fawkesinterface_fawkes_MessageQueue_remove00(tolua_S);
3113#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_insert_after00
3114static int tolua_fawkesinterface_fawkes_MessageQueue_insert_after00(lua_State* tolua_S)
3116#ifndef TOLUA_RELEASE
3117 tolua_Error tolua_err;
3119 !tolua_isusertype(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
3120 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::MessageQueue::MessageIterator",0,&tolua_err)) ||
3121 !tolua_isusertype(tolua_S,3,
"fawkes::Message",0,&tolua_err) ||
3122 !tolua_isnoobj(tolua_S,4,&tolua_err)
3131#ifndef TOLUA_RELEASE
3132 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'insert_after'", NULL);
3134 bool exc_caught =
false;
3143 catch (std::exception &e) {
3145 lua_pushstring(tolua_S, e.what());
3147 if (exc_caught) lua_error(tolua_S);
3151#ifndef TOLUA_RELEASE
3153 tolua_error(tolua_S,
"#ferror in function 'insert_after'.",&tolua_err);
3160#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_size00
3161static int tolua_fawkesinterface_fawkes_MessageQueue_size00(lua_State* tolua_S)
3163#ifndef TOLUA_RELEASE
3164 tolua_Error tolua_err;
3166 !tolua_isusertype(tolua_S,1,
"const fawkes::MessageQueue",0,&tolua_err) ||
3167 !tolua_isnoobj(tolua_S,2,&tolua_err)
3174#ifndef TOLUA_RELEASE
3175 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'size'", NULL);
3177 bool exc_caught =
false;
3180 unsigned int tolua_ret = (
unsigned int) self->
size();
3181 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
3187 catch (std::exception &e) {
3189 lua_pushstring(tolua_S, e.what());
3191 if (exc_caught) lua_error(tolua_S);
3195#ifndef TOLUA_RELEASE
3197 tolua_error(tolua_S,
"#ferror in function 'size'.",&tolua_err);
3204#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_flush00
3205static int tolua_fawkesinterface_fawkes_MessageQueue_flush00(lua_State* tolua_S)
3207#ifndef TOLUA_RELEASE
3208 tolua_Error tolua_err;
3210 !tolua_isusertype(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
3211 !tolua_isnoobj(tolua_S,2,&tolua_err)
3218#ifndef TOLUA_RELEASE
3219 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'flush'", NULL);
3221 bool exc_caught =
false;
3230 catch (std::exception &e) {
3232 lua_pushstring(tolua_S, e.what());
3234 if (exc_caught) lua_error(tolua_S);
3238#ifndef TOLUA_RELEASE
3240 tolua_error(tolua_S,
"#ferror in function 'flush'.",&tolua_err);
3247#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_empty00
3248static int tolua_fawkesinterface_fawkes_MessageQueue_empty00(lua_State* tolua_S)
3250#ifndef TOLUA_RELEASE
3251 tolua_Error tolua_err;
3253 !tolua_isusertype(tolua_S,1,
"const fawkes::MessageQueue",0,&tolua_err) ||
3254 !tolua_isnoobj(tolua_S,2,&tolua_err)
3261#ifndef TOLUA_RELEASE
3262 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'empty'", NULL);
3264 bool exc_caught =
false;
3267 bool tolua_ret = (bool) self->
empty();
3268 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
3274 catch (std::exception &e) {
3276 lua_pushstring(tolua_S, e.what());
3278 if (exc_caught) lua_error(tolua_S);
3282#ifndef TOLUA_RELEASE
3284 tolua_error(tolua_S,
"#ferror in function 'empty'.",&tolua_err);
3291#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_lock00
3292static int tolua_fawkesinterface_fawkes_MessageQueue_lock00(lua_State* tolua_S)
3294#ifndef TOLUA_RELEASE
3295 tolua_Error tolua_err;
3297 !tolua_isusertype(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
3298 !tolua_isnoobj(tolua_S,2,&tolua_err)
3305#ifndef TOLUA_RELEASE
3306 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'lock'", NULL);
3308 bool exc_caught =
false;
3317 catch (std::exception &e) {
3319 lua_pushstring(tolua_S, e.what());
3321 if (exc_caught) lua_error(tolua_S);
3325#ifndef TOLUA_RELEASE
3327 tolua_error(tolua_S,
"#ferror in function 'lock'.",&tolua_err);
3334#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_try_lock00
3335static int tolua_fawkesinterface_fawkes_MessageQueue_try_lock00(lua_State* tolua_S)
3337#ifndef TOLUA_RELEASE
3338 tolua_Error tolua_err;
3340 !tolua_isusertype(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
3341 !tolua_isnoobj(tolua_S,2,&tolua_err)
3348#ifndef TOLUA_RELEASE
3349 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'try_lock'", NULL);
3351 bool exc_caught =
false;
3354 bool tolua_ret = (bool) self->
try_lock();
3355 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
3361 catch (std::exception &e) {
3363 lua_pushstring(tolua_S, e.what());
3365 if (exc_caught) lua_error(tolua_S);
3369#ifndef TOLUA_RELEASE
3371 tolua_error(tolua_S,
"#ferror in function 'try_lock'.",&tolua_err);
3378#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_unlock00
3379static int tolua_fawkesinterface_fawkes_MessageQueue_unlock00(lua_State* tolua_S)
3381#ifndef TOLUA_RELEASE
3382 tolua_Error tolua_err;
3384 !tolua_isusertype(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
3385 !tolua_isnoobj(tolua_S,2,&tolua_err)
3392#ifndef TOLUA_RELEASE
3393 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'unlock'", NULL);
3395 bool exc_caught =
false;
3404 catch (std::exception &e) {
3406 lua_pushstring(tolua_S, e.what());
3408 if (exc_caught) lua_error(tolua_S);
3412#ifndef TOLUA_RELEASE
3414 tolua_error(tolua_S,
"#ferror in function 'unlock'.",&tolua_err);
3421#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_first00
3422static int tolua_fawkesinterface_fawkes_MessageQueue_first00(lua_State* tolua_S)
3424#ifndef TOLUA_RELEASE
3425 tolua_Error tolua_err;
3427 !tolua_isusertype(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
3428 !tolua_isnoobj(tolua_S,2,&tolua_err)
3435#ifndef TOLUA_RELEASE
3436 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'first'", NULL);
3438 bool exc_caught =
false;
3442 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::Message");
3448 catch (std::exception &e) {
3450 lua_pushstring(tolua_S, e.what());
3452 if (exc_caught) lua_error(tolua_S);
3456#ifndef TOLUA_RELEASE
3458 tolua_error(tolua_S,
"#ferror in function 'first'.",&tolua_err);
3465#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_pop00
3466static int tolua_fawkesinterface_fawkes_MessageQueue_pop00(lua_State* tolua_S)
3468#ifndef TOLUA_RELEASE
3469 tolua_Error tolua_err;
3471 !tolua_isusertype(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
3472 !tolua_isnoobj(tolua_S,2,&tolua_err)
3479#ifndef TOLUA_RELEASE
3480 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'pop'", NULL);
3482 bool exc_caught =
false;
3491 catch (std::exception &e) {
3493 lua_pushstring(tolua_S, e.what());
3495 if (exc_caught) lua_error(tolua_S);
3499#ifndef TOLUA_RELEASE
3501 tolua_error(tolua_S,
"#ferror in function 'pop'.",&tolua_err);
3508#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_begin00
3509static int tolua_fawkesinterface_fawkes_MessageQueue_begin00(lua_State* tolua_S)
3511#ifndef TOLUA_RELEASE
3512 tolua_Error tolua_err;
3514 !tolua_isusertype(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
3515 !tolua_isnoobj(tolua_S,2,&tolua_err)
3522#ifndef TOLUA_RELEASE
3523 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'begin'", NULL);
3525 bool exc_caught =
false;
3532 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::MessageQueue::MessageIterator");
3533 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3536 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::MessageQueue::MessageIterator");
3537 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3545 catch (std::exception &e) {
3547 lua_pushstring(tolua_S, e.what());
3549 if (exc_caught) lua_error(tolua_S);
3553#ifndef TOLUA_RELEASE
3555 tolua_error(tolua_S,
"#ferror in function 'begin'.",&tolua_err);
3562#ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_end00
3563static int tolua_fawkesinterface_fawkes_MessageQueue_end00(lua_State* tolua_S)
3565#ifndef TOLUA_RELEASE
3566 tolua_Error tolua_err;
3568 !tolua_isusertype(tolua_S,1,
"fawkes::MessageQueue",0,&tolua_err) ||
3569 !tolua_isnoobj(tolua_S,2,&tolua_err)
3576#ifndef TOLUA_RELEASE
3577 if (!self) tolua_error(tolua_S,
"invalid 'self' in function 'end'", NULL);
3579 bool exc_caught =
false;
3586 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::MessageQueue::MessageIterator");
3587 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3590 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::MessageQueue::MessageIterator");
3591 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3599 catch (std::exception &e) {
3601 lua_pushstring(tolua_S, e.what());
3603 if (exc_caught) lua_error(tolua_S);
3607#ifndef TOLUA_RELEASE
3609 tolua_error(tolua_S,
"#ferror in function 'end'.",&tolua_err);
3616TOLUA_API
int tolua_fawkesinterface_open (lua_State* tolua_S)
3618 tolua_open(tolua_S);
3619 tolua_reg_types(tolua_S);
3620 tolua_module(tolua_S,NULL,0);
3621 tolua_beginmodule(tolua_S,NULL);
3622 tolua_module(tolua_S,
"fawkes",0);
3623 tolua_beginmodule(tolua_S,
"fawkes");
3625 tolua_cclass(tolua_S,
"Uuid",
"fawkes::Uuid",
"",tolua_collect_fawkes__Uuid);
3627 tolua_cclass(tolua_S,
"Uuid",
"fawkes::Uuid",
"",NULL);
3629 tolua_beginmodule(tolua_S,
"Uuid");
3630 tolua_function(tolua_S,
"get_string",tolua_fawkesinterface_fawkes_Uuid_get_string00);
3631 tolua_endmodule(tolua_S);
3632 tolua_cclass(tolua_S,
"Interface",
"fawkes::Interface",
"",NULL);
3633 tolua_beginmodule(tolua_S,
"Interface");
3634 tolua_function(tolua_S,
"oftype",tolua_fawkesinterface_fawkes_Interface_oftype00);
3635 tolua_function(tolua_S,
"datachunk",tolua_fawkesinterface_fawkes_Interface_datachunk00);
3636 tolua_function(tolua_S,
"datasize",tolua_fawkesinterface_fawkes_Interface_datasize00);
3637 tolua_function(tolua_S,
"type",tolua_fawkesinterface_fawkes_Interface_type00);
3638 tolua_function(tolua_S,
"id",tolua_fawkesinterface_fawkes_Interface_id00);
3639 tolua_function(tolua_S,
"uid",tolua_fawkesinterface_fawkes_Interface_uid00);
3640 tolua_function(tolua_S,
"serial",tolua_fawkesinterface_fawkes_Interface_serial00);
3641 tolua_function(tolua_S,
"mem_serial",tolua_fawkesinterface_fawkes_Interface_mem_serial00);
3642 tolua_function(tolua_S,
".eq",tolua_fawkesinterface_fawkes_Interface__eq00);
3643 tolua_function(tolua_S,
"hash",tolua_fawkesinterface_fawkes_Interface_hash00);
3644 tolua_function(tolua_S,
"hash_size",tolua_fawkesinterface_fawkes_Interface_hash_size00);
3645 tolua_function(tolua_S,
"hash_printable",tolua_fawkesinterface_fawkes_Interface_hash_printable00);
3646 tolua_function(tolua_S,
"is_writer",tolua_fawkesinterface_fawkes_Interface_is_writer00);
3647 tolua_function(tolua_S,
"set_from_chunk",tolua_fawkesinterface_fawkes_Interface_set_from_chunk00);
3648 tolua_function(tolua_S,
"create_message_generic",tolua_fawkesinterface_fawkes_Interface_create_message_generic00);
3649 tolua_function(tolua_S,
"read",tolua_fawkesinterface_fawkes_Interface_read00);
3650 tolua_function(tolua_S,
"write",tolua_fawkesinterface_fawkes_Interface_write00);
3651 tolua_function(tolua_S,
"has_writer",tolua_fawkesinterface_fawkes_Interface_has_writer00);
3652 tolua_function(tolua_S,
"num_readers",tolua_fawkesinterface_fawkes_Interface_num_readers00);
3653 tolua_function(tolua_S,
"changed",tolua_fawkesinterface_fawkes_Interface_changed00);
3654 tolua_function(tolua_S,
"refreshed",tolua_fawkesinterface_fawkes_Interface_refreshed00);
3655 tolua_function(tolua_S,
"timestamp",tolua_fawkesinterface_fawkes_Interface_timestamp00);
3656 tolua_function(tolua_S,
"set_auto_timestamping",tolua_fawkesinterface_fawkes_Interface_set_auto_timestamping00);
3657 tolua_function(tolua_S,
"set_timestamp",tolua_fawkesinterface_fawkes_Interface_set_timestamp00);
3658 tolua_function(tolua_S,
"set_clock",tolua_fawkesinterface_fawkes_Interface_set_clock00);
3659 tolua_function(tolua_S,
"msgq_enqueue_copy",tolua_fawkesinterface_fawkes_Interface_msgq_enqueue_copy00);
3660 tolua_function(tolua_S,
"msgq_remove",tolua_fawkesinterface_fawkes_Interface_msgq_remove00);
3661 tolua_function(tolua_S,
"msgq_remove",tolua_fawkesinterface_fawkes_Interface_msgq_remove01);
3662 tolua_function(tolua_S,
"msgq_size",tolua_fawkesinterface_fawkes_Interface_msgq_size00);
3663 tolua_function(tolua_S,
"msgq_flush",tolua_fawkesinterface_fawkes_Interface_msgq_flush00);
3664 tolua_function(tolua_S,
"msgq_lock",tolua_fawkesinterface_fawkes_Interface_msgq_lock00);
3665 tolua_function(tolua_S,
"msgq_try_lock",tolua_fawkesinterface_fawkes_Interface_msgq_try_lock00);
3666 tolua_function(tolua_S,
"msgq_unlock",tolua_fawkesinterface_fawkes_Interface_msgq_unlock00);
3667 tolua_function(tolua_S,
"msgq_pop",tolua_fawkesinterface_fawkes_Interface_msgq_pop00);
3668 tolua_function(tolua_S,
"msgq_first_generic",tolua_fawkesinterface_fawkes_Interface_msgq_first_generic00);
3669 tolua_function(tolua_S,
"msgq_empty",tolua_fawkesinterface_fawkes_Interface_msgq_empty00);
3670 tolua_endmodule(tolua_S);
3673 int top = lua_gettop(tolua_S);
3674 static const unsigned char B[] = {
3675 10,102,117,110, 99,116,105,111,110, 32,102, 97,119,107,101,
3676 115, 46, 73,110,116,101,114,102, 97, 99,101, 58,109,115,103,
3677 113, 95,102,105,114,115,116, 40, 41, 10,108,111, 99, 97,108,
3678 32,109,101,115,115, 97,103,101, 32, 61, 32,115,101,108,102,
3679 58,109,115,103,113, 95,102,105,114,115,116, 95,103,101,110,
3680 101,114,105, 99, 40, 41, 10,108,111, 99, 97,108, 32,109, 32,
3681 61, 32,116,111,108,117, 97, 46, 99, 97,115,116, 40,109,101,
3682 115,115, 97,103,101, 44, 32, 34,102, 97,119,107,101,115, 58,
3683 58, 34, 32, 46, 46, 32,115,101,108,102, 58,116,121,112,101,
3684 40, 41, 32, 46, 46, 32, 34, 58, 58, 34, 32, 46, 46, 32,109,
3685 101,115,115, 97,103,101, 58,116,121,112,101, 40, 41, 41, 10,
3686 114,101,116,117,114,110, 32,109, 10,101,110,100, 10,102,117,
3687 110, 99,116,105,111,110, 32,102, 97,119,107,101,115, 46, 73,
3688 110,116,101,114,102, 97, 99,101, 58, 99,114,101, 97,116,101,
3689 95,109,101,115,115, 97,103,101, 40,116,121,112,101, 41, 10,
3690 108,111, 99, 97,108, 32,109,101,115,115, 97,103,101, 32, 61,
3691 32,115,101,108,102, 58, 99,114,101, 97,116,101, 95,109,101,
3692 115,115, 97,103,101, 95,103,101,110,101,114,105, 99, 40,116,
3693 121,112,101, 41, 10,114,101,116,117,114,110, 32,116,111,108,
3694 117, 97, 46, 99, 97,115,116, 40,109,101,115,115, 97,103,101,
3695 44, 32, 34,102, 97,119,107,101,115, 58, 58, 34, 32, 46, 46,
3696 32,115,101,108,102, 58,116,121,112,101, 40, 41, 32, 46, 46,
3697 32, 34, 58, 58, 34, 32, 46, 46, 32,109,101,115,115, 97,103,
3698 101, 58,116,121,112,101, 40, 41, 41, 10,101,110,100, 10,102,
3699 117,110, 99,116,105,111,110, 32,102, 97,119,107,101,115, 46,
3700 73,110,116,101,114,102, 97, 99,101, 58,109,115,103,113, 95,
3701 101,110,113,117,101,117,101, 40,109,101,115,115, 97,103,101,
3702 41, 10,114,101,116,117,114,110, 32,115,101,108,102, 58,109,
3703 115,103,113, 95,101,110,113,117,101,117,101, 95, 99,111,112,
3704 121, 40,109,101,115,115, 97,103,101, 41, 10,101,110,100, 45,
3705 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,32
3707 tolua_dobuffer(tolua_S,(
char*)B,
sizeof(B),
"tolua: embedded Lua code 1");
3708 lua_settop(tolua_S, top);
3711 tolua_endmodule(tolua_S);
3712 tolua_module(tolua_S,
"fawkes",0);
3713 tolua_beginmodule(tolua_S,
"fawkes");
3715 tolua_cclass(tolua_S,
"Message",
"fawkes::Message",
"RefCount",tolua_collect_fawkes__Message);
3717 tolua_cclass(tolua_S,
"Message",
"fawkes::Message",
"RefCount",NULL);
3719 tolua_beginmodule(tolua_S,
"Message");
3720 tolua_function(tolua_S,
"new",tolua_fawkesinterface_fawkes_Message_new00);
3721 tolua_function(tolua_S,
"new_local",tolua_fawkesinterface_fawkes_Message_new00_local);
3722 tolua_function(tolua_S,
".call",tolua_fawkesinterface_fawkes_Message_new00_local);
3723 tolua_function(tolua_S,
"new",tolua_fawkesinterface_fawkes_Message_new01);
3724 tolua_function(tolua_S,
"new_local",tolua_fawkesinterface_fawkes_Message_new01_local);
3725 tolua_function(tolua_S,
".call",tolua_fawkesinterface_fawkes_Message_new01_local);
3726 tolua_function(tolua_S,
"new",tolua_fawkesinterface_fawkes_Message_new02);
3727 tolua_function(tolua_S,
"new_local",tolua_fawkesinterface_fawkes_Message_new02_local);
3728 tolua_function(tolua_S,
".call",tolua_fawkesinterface_fawkes_Message_new02_local);
3729 tolua_function(tolua_S,
"id",tolua_fawkesinterface_fawkes_Message_id00);
3730 tolua_function(tolua_S,
"sender_id",tolua_fawkesinterface_fawkes_Message_sender_id00);
3731 tolua_function(tolua_S,
"source_id",tolua_fawkesinterface_fawkes_Message_source_id00);
3732 tolua_function(tolua_S,
"sender_thread_name",tolua_fawkesinterface_fawkes_Message_sender_thread_name00);
3733 tolua_function(tolua_S,
"interface",tolua_fawkesinterface_fawkes_Message_interface00);
3734 tolua_function(tolua_S,
"type",tolua_fawkesinterface_fawkes_Message_type00);
3735 tolua_function(tolua_S,
"datachunk",tolua_fawkesinterface_fawkes_Message_datachunk00);
3736 tolua_function(tolua_S,
"datasize",tolua_fawkesinterface_fawkes_Message_datasize00);
3737 tolua_function(tolua_S,
"set_from_chunk",tolua_fawkesinterface_fawkes_Message_set_from_chunk00);
3738 tolua_function(tolua_S,
"ref",tolua_fawkesinterface_fawkes_Message_ref00);
3739 tolua_function(tolua_S,
"unref",tolua_fawkesinterface_fawkes_Message_unref00);
3740 tolua_function(tolua_S,
"refcount",tolua_fawkesinterface_fawkes_Message_refcount00);
3741 tolua_endmodule(tolua_S);
3742 tolua_endmodule(tolua_S);
3743 tolua_module(tolua_S,
"fawkes",0);
3744 tolua_beginmodule(tolua_S,
"fawkes");
3746 tolua_cclass(tolua_S,
"MessageQueue",
"fawkes::MessageQueue",
"",tolua_collect_fawkes__MessageQueue);
3748 tolua_cclass(tolua_S,
"MessageQueue",
"fawkes::MessageQueue",
"",NULL);
3750 tolua_beginmodule(tolua_S,
"MessageQueue");
3751 tolua_function(tolua_S,
"new",tolua_fawkesinterface_fawkes_MessageQueue_new00);
3752 tolua_function(tolua_S,
"new_local",tolua_fawkesinterface_fawkes_MessageQueue_new00_local);
3753 tolua_function(tolua_S,
".call",tolua_fawkesinterface_fawkes_MessageQueue_new00_local);
3754 tolua_function(tolua_S,
"delete",tolua_fawkesinterface_fawkes_MessageQueue_delete00);
3756 tolua_cclass(tolua_S,
"MessageIterator",
"fawkes::MessageQueue::MessageIterator",
"",tolua_collect_fawkes__MessageQueue__MessageIterator);
3758 tolua_cclass(tolua_S,
"MessageIterator",
"fawkes::MessageQueue::MessageIterator",
"",NULL);
3760 tolua_beginmodule(tolua_S,
"MessageIterator");
3761 tolua_function(tolua_S,
"new",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00);
3762 tolua_function(tolua_S,
"new_local",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local);
3763 tolua_function(tolua_S,
".call",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local);
3764 tolua_function(tolua_S,
"new",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01);
3765 tolua_function(tolua_S,
"new_local",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local);
3766 tolua_function(tolua_S,
".call",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local);
3767 tolua_function(tolua_S,
".add",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__add00);
3768 tolua_function(tolua_S,
".eq",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__eq00);
3769 tolua_function(tolua_S,
".mul",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__mul00);
3770 tolua_function(tolua_S,
"id",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_id00);
3771 tolua_endmodule(tolua_S);
3772 tolua_function(tolua_S,
"append",tolua_fawkesinterface_fawkes_MessageQueue_append00);
3773 tolua_function(tolua_S,
"remove",tolua_fawkesinterface_fawkes_MessageQueue_remove00);
3774 tolua_function(tolua_S,
"remove",tolua_fawkesinterface_fawkes_MessageQueue_remove01);
3775 tolua_function(tolua_S,
"insert_after",tolua_fawkesinterface_fawkes_MessageQueue_insert_after00);
3776 tolua_function(tolua_S,
"size",tolua_fawkesinterface_fawkes_MessageQueue_size00);
3777 tolua_function(tolua_S,
"flush",tolua_fawkesinterface_fawkes_MessageQueue_flush00);
3778 tolua_function(tolua_S,
"empty",tolua_fawkesinterface_fawkes_MessageQueue_empty00);
3779 tolua_function(tolua_S,
"lock",tolua_fawkesinterface_fawkes_MessageQueue_lock00);
3780 tolua_function(tolua_S,
"try_lock",tolua_fawkesinterface_fawkes_MessageQueue_try_lock00);
3781 tolua_function(tolua_S,
"unlock",tolua_fawkesinterface_fawkes_MessageQueue_unlock00);
3782 tolua_function(tolua_S,
"first",tolua_fawkesinterface_fawkes_MessageQueue_first00);
3783 tolua_function(tolua_S,
"pop",tolua_fawkesinterface_fawkes_MessageQueue_pop00);
3784 tolua_function(tolua_S,
"begin",tolua_fawkesinterface_fawkes_MessageQueue_begin00);
3785 tolua_function(tolua_S,
"end",tolua_fawkesinterface_fawkes_MessageQueue_end00);
3786 tolua_endmodule(tolua_S);
3787 tolua_endmodule(tolua_S);
3788 tolua_endmodule(tolua_S);
3794#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
3795 TOLUA_API
int luaopen_fawkesinterface (lua_State* tolua_S) {
3796 return tolua_fawkesinterface_open(tolua_S);
This is supposed to be the central clock in Fawkes.
Base class for exceptions in Fawkes.
virtual const char * what_no_backtrace() const noexcept
Get primary string (does not implicitly print the back trace).
Base class for all Fawkes BlackBoard interfaces.
bool msgq_try_lock()
Try to lock message queue.
const char * hash_printable() const
Get printable interface hash.
const void * datachunk() const
Get data chunk.
unsigned int msgq_enqueue_copy(Message *message)
Enqueue copy of message at end of queue.
const char * type() const
Get type of interface.
void set_auto_timestamping(bool enabled)
Enable or disable automated timestamping.
void msgq_pop()
Erase first message from queue.
const Time * timestamp() const
Get timestamp of last write.
Message * msgq_first()
Get the first message from the message queue.
size_t hash_size() const
Get size of interface hash.
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.
void msgq_remove(Message *message)
Remove message from queue.
const unsigned char * hash() const
Get interface hash.
unsigned int msgq_size()
Get size of message queue.
void write()
Write from local copy into BlackBoard memory.
const char * id() const
Get identifier of interface.
unsigned int mem_serial() const
Get memory serial of interface.
Uuid serial() const
Get instance serial of interface.
bool msgq_empty()
Check if queue is empty.
void set_from_chunk(void *chunk)
Set from a raw data chunk.
void msgq_lock()
Lock message queue.
const char * uid() const
Get unique identifier of interface.
void msgq_flush()
Flush all messages.
unsigned int num_readers() const
Get the number of readers.
void read()
Read from BlackBoard into local copy.
void msgq_unlock()
Unlock message queue.
void set_clock(Clock *clock)
Set clock to use for timestamping.
unsigned int datasize() const
Get data size.
bool has_writer() const
Check if there is a writer for the interface.
bool oftype(const char *interface_type) const
Check if interface is of given type.
void set_timestamp(const Time *t=NULL)
Set timestamp.
bool refreshed() const
Check if data has been refreshed.
Message queue used in interfaces.
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.
const char * type() const
Get message type.
const void * datachunk() const
Get pointer to data.
unsigned int datasize() const
Get size of data.
Uuid source_id() const
Get ID of the original source of the message.
Interface * interface() const
Get transmitting interface.
void set_from_chunk(const void *chunk)
Set from raw data chunk.
Uuid sender_id() const
Get ID of the immediate sender, not necessarily the creator of the message.
const char * sender_thread_name() const
Get sender of message.
unsigned int id() const
Get message ID.
void unref()
Decrement reference count and conditionally delete this instance.
void ref()
Increment reference count.
unsigned int refcount()
Get reference count for this instance.
A class for handling time.
A convenience class for universally unique identifiers (UUIDs).
std::string get_string() const
Get the string representation of the Uuid.