Fawkes API
Fawkes Development Version
|
00001 /* 00002 ** Lua binding: fawkesinterface 00003 ** Generated automatically by tolua++-1.0.92 00004 */ 00005 /* This program is free software; you can redistribute it and/or modify 00006 * it under the terms of the GNU General Public License as published by 00007 * the Free Software Foundation; either version 2 of the License, or 00008 * (at your option) any later version. A runtime exception applies to 00009 * this software (see LICENSE.GPL_WRE file mentioned below for details). 00010 * 00011 * This program is distributed in the hope that it will be useful, 00012 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00014 * GNU Library General Public License for more details. 00015 * 00016 * Read the full text in the LICENSE.GPL_WRE file in the doc directory. 00017 */ 00018 00019 #ifndef __cplusplus 00020 #include "stdlib.h" 00021 #endif 00022 #include "string.h" 00023 00024 #include "tolua++.h" 00025 00026 /* Exported function */ 00027 TOLUA_API int tolua_fawkesinterface_open (lua_State* tolua_S); 00028 00029 #include <interface/interface.h> 00030 #include <interface/message.h> 00031 #include <interface/message_queue.h> 00032 00033 /* function to release collected object via destructor */ 00034 #ifdef __cplusplus 00035 00036 static int tolua_collect_fawkes__MessageQueue__MessageIterator (lua_State* tolua_S) 00037 { 00038 fawkes::MessageQueue::MessageIterator* self = (fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,1,0); 00039 Mtolua_delete(self); 00040 return 0; 00041 } 00042 00043 static int tolua_collect_fawkes__Message (lua_State* tolua_S) 00044 { 00045 fawkes::Message* self = (fawkes::Message*) tolua_tousertype(tolua_S,1,0); 00046 Mtolua_delete(self); 00047 return 0; 00048 } 00049 00050 static int tolua_collect_fawkes__MessageQueue (lua_State* tolua_S) 00051 { 00052 fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 00053 Mtolua_delete(self); 00054 return 0; 00055 } 00056 00057 static int tolua_collect_size_t (lua_State* tolua_S) 00058 { 00059 size_t* self = (size_t*) tolua_tousertype(tolua_S,1,0); 00060 Mtolua_delete(self); 00061 return 0; 00062 } 00063 #endif 00064 00065 00066 /* function to register type */ 00067 static void tolua_reg_types (lua_State* tolua_S) 00068 { 00069 tolua_usertype(tolua_S,"fawkes::MessageQueue::MessageIterator"); 00070 tolua_usertype(tolua_S,"fawkes::Message"); 00071 tolua_usertype(tolua_S,"fawkes::Interface"); 00072 tolua_usertype(tolua_S,"fawkes::MessageQueue"); 00073 tolua_usertype(tolua_S,"RefCount"); 00074 tolua_usertype(tolua_S,"size_t"); 00075 } 00076 00077 /* method: oftype of class fawkes::Interface */ 00078 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_oftype00 00079 static int tolua_fawkesinterface_fawkes_Interface_oftype00(lua_State* tolua_S) 00080 { 00081 #ifndef TOLUA_RELEASE 00082 tolua_Error tolua_err; 00083 if ( 00084 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00085 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00086 !tolua_isnoobj(tolua_S,3,&tolua_err) 00087 ) 00088 goto tolua_lerror; 00089 else 00090 #endif 00091 { 00092 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00093 const char* interface_type = ((const char*) tolua_tostring(tolua_S,2,0)); 00094 #ifndef TOLUA_RELEASE 00095 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL); 00096 #endif 00097 { 00098 bool tolua_ret = (bool) self->oftype(interface_type); 00099 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00100 } 00101 } 00102 return 1; 00103 #ifndef TOLUA_RELEASE 00104 tolua_lerror: 00105 tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err); 00106 return 0; 00107 #endif 00108 } 00109 #endif //#ifndef TOLUA_DISABLE 00110 00111 /* method: datachunk of class fawkes::Interface */ 00112 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_datachunk00 00113 static int tolua_fawkesinterface_fawkes_Interface_datachunk00(lua_State* tolua_S) 00114 { 00115 #ifndef TOLUA_RELEASE 00116 tolua_Error tolua_err; 00117 if ( 00118 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00119 !tolua_isnoobj(tolua_S,2,&tolua_err) 00120 ) 00121 goto tolua_lerror; 00122 else 00123 #endif 00124 { 00125 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00126 #ifndef TOLUA_RELEASE 00127 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL); 00128 #endif 00129 { 00130 const void* tolua_ret = (const void*) self->datachunk(); 00131 tolua_pushuserdata(tolua_S,(void*)tolua_ret); 00132 } 00133 } 00134 return 1; 00135 #ifndef TOLUA_RELEASE 00136 tolua_lerror: 00137 tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err); 00138 return 0; 00139 #endif 00140 } 00141 #endif //#ifndef TOLUA_DISABLE 00142 00143 /* method: datasize of class fawkes::Interface */ 00144 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_datasize00 00145 static int tolua_fawkesinterface_fawkes_Interface_datasize00(lua_State* tolua_S) 00146 { 00147 #ifndef TOLUA_RELEASE 00148 tolua_Error tolua_err; 00149 if ( 00150 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00151 !tolua_isnoobj(tolua_S,2,&tolua_err) 00152 ) 00153 goto tolua_lerror; 00154 else 00155 #endif 00156 { 00157 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00158 #ifndef TOLUA_RELEASE 00159 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL); 00160 #endif 00161 { 00162 unsigned int tolua_ret = (unsigned int) self->datasize(); 00163 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00164 } 00165 } 00166 return 1; 00167 #ifndef TOLUA_RELEASE 00168 tolua_lerror: 00169 tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err); 00170 return 0; 00171 #endif 00172 } 00173 #endif //#ifndef TOLUA_DISABLE 00174 00175 /* method: type of class fawkes::Interface */ 00176 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_type00 00177 static int tolua_fawkesinterface_fawkes_Interface_type00(lua_State* tolua_S) 00178 { 00179 #ifndef TOLUA_RELEASE 00180 tolua_Error tolua_err; 00181 if ( 00182 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00183 !tolua_isnoobj(tolua_S,2,&tolua_err) 00184 ) 00185 goto tolua_lerror; 00186 else 00187 #endif 00188 { 00189 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00190 #ifndef TOLUA_RELEASE 00191 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL); 00192 #endif 00193 { 00194 const char* tolua_ret = (const char*) self->type(); 00195 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00196 } 00197 } 00198 return 1; 00199 #ifndef TOLUA_RELEASE 00200 tolua_lerror: 00201 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err); 00202 return 0; 00203 #endif 00204 } 00205 #endif //#ifndef TOLUA_DISABLE 00206 00207 /* method: id of class fawkes::Interface */ 00208 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_id00 00209 static int tolua_fawkesinterface_fawkes_Interface_id00(lua_State* tolua_S) 00210 { 00211 #ifndef TOLUA_RELEASE 00212 tolua_Error tolua_err; 00213 if ( 00214 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00215 !tolua_isnoobj(tolua_S,2,&tolua_err) 00216 ) 00217 goto tolua_lerror; 00218 else 00219 #endif 00220 { 00221 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00222 #ifndef TOLUA_RELEASE 00223 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL); 00224 #endif 00225 { 00226 const char* tolua_ret = (const char*) self->id(); 00227 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00228 } 00229 } 00230 return 1; 00231 #ifndef TOLUA_RELEASE 00232 tolua_lerror: 00233 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err); 00234 return 0; 00235 #endif 00236 } 00237 #endif //#ifndef TOLUA_DISABLE 00238 00239 /* method: uid of class fawkes::Interface */ 00240 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_uid00 00241 static int tolua_fawkesinterface_fawkes_Interface_uid00(lua_State* tolua_S) 00242 { 00243 #ifndef TOLUA_RELEASE 00244 tolua_Error tolua_err; 00245 if ( 00246 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00247 !tolua_isnoobj(tolua_S,2,&tolua_err) 00248 ) 00249 goto tolua_lerror; 00250 else 00251 #endif 00252 { 00253 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00254 #ifndef TOLUA_RELEASE 00255 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL); 00256 #endif 00257 { 00258 const char* tolua_ret = (const char*) self->uid(); 00259 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00260 } 00261 } 00262 return 1; 00263 #ifndef TOLUA_RELEASE 00264 tolua_lerror: 00265 tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err); 00266 return 0; 00267 #endif 00268 } 00269 #endif //#ifndef TOLUA_DISABLE 00270 00271 /* method: serial of class fawkes::Interface */ 00272 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_serial00 00273 static int tolua_fawkesinterface_fawkes_Interface_serial00(lua_State* tolua_S) 00274 { 00275 #ifndef TOLUA_RELEASE 00276 tolua_Error tolua_err; 00277 if ( 00278 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00279 !tolua_isnoobj(tolua_S,2,&tolua_err) 00280 ) 00281 goto tolua_lerror; 00282 else 00283 #endif 00284 { 00285 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00286 #ifndef TOLUA_RELEASE 00287 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL); 00288 #endif 00289 { 00290 unsigned int tolua_ret = (unsigned int) self->serial(); 00291 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00292 } 00293 } 00294 return 1; 00295 #ifndef TOLUA_RELEASE 00296 tolua_lerror: 00297 tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err); 00298 return 0; 00299 #endif 00300 } 00301 #endif //#ifndef TOLUA_DISABLE 00302 00303 /* method: mem_serial of class fawkes::Interface */ 00304 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_mem_serial00 00305 static int tolua_fawkesinterface_fawkes_Interface_mem_serial00(lua_State* tolua_S) 00306 { 00307 #ifndef TOLUA_RELEASE 00308 tolua_Error tolua_err; 00309 if ( 00310 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00311 !tolua_isnoobj(tolua_S,2,&tolua_err) 00312 ) 00313 goto tolua_lerror; 00314 else 00315 #endif 00316 { 00317 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00318 #ifndef TOLUA_RELEASE 00319 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL); 00320 #endif 00321 { 00322 unsigned int tolua_ret = (unsigned int) self->mem_serial(); 00323 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00324 } 00325 } 00326 return 1; 00327 #ifndef TOLUA_RELEASE 00328 tolua_lerror: 00329 tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err); 00330 return 0; 00331 #endif 00332 } 00333 #endif //#ifndef TOLUA_DISABLE 00334 00335 /* method: operator== of class fawkes::Interface */ 00336 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface__eq00 00337 static int tolua_fawkesinterface_fawkes_Interface__eq00(lua_State* tolua_S) 00338 { 00339 #ifndef TOLUA_RELEASE 00340 tolua_Error tolua_err; 00341 if ( 00342 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00343 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Interface",0,&tolua_err)) || 00344 !tolua_isnoobj(tolua_S,3,&tolua_err) 00345 ) 00346 goto tolua_lerror; 00347 else 00348 #endif 00349 { 00350 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00351 fawkes::Interface* comp = ((fawkes::Interface*) tolua_tousertype(tolua_S,2,0)); 00352 #ifndef TOLUA_RELEASE 00353 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL); 00354 #endif 00355 { 00356 bool tolua_ret = (bool) self->operator==(*comp); 00357 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00358 } 00359 } 00360 return 1; 00361 #ifndef TOLUA_RELEASE 00362 tolua_lerror: 00363 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err); 00364 return 0; 00365 #endif 00366 } 00367 #endif //#ifndef TOLUA_DISABLE 00368 00369 /* method: hash of class fawkes::Interface */ 00370 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_hash00 00371 static int tolua_fawkesinterface_fawkes_Interface_hash00(lua_State* tolua_S) 00372 { 00373 #ifndef TOLUA_RELEASE 00374 tolua_Error tolua_err; 00375 if ( 00376 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00377 !tolua_isnoobj(tolua_S,2,&tolua_err) 00378 ) 00379 goto tolua_lerror; 00380 else 00381 #endif 00382 { 00383 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00384 #ifndef TOLUA_RELEASE 00385 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL); 00386 #endif 00387 { 00388 unsigned const char* tolua_ret = ( unsigned const char*) self->hash(); 00389 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00390 } 00391 } 00392 return 1; 00393 #ifndef TOLUA_RELEASE 00394 tolua_lerror: 00395 tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err); 00396 return 0; 00397 #endif 00398 } 00399 #endif //#ifndef TOLUA_DISABLE 00400 00401 /* method: hash_size of class fawkes::Interface */ 00402 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_hash_size00 00403 static int tolua_fawkesinterface_fawkes_Interface_hash_size00(lua_State* tolua_S) 00404 { 00405 #ifndef TOLUA_RELEASE 00406 tolua_Error tolua_err; 00407 if ( 00408 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00409 !tolua_isnoobj(tolua_S,2,&tolua_err) 00410 ) 00411 goto tolua_lerror; 00412 else 00413 #endif 00414 { 00415 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00416 #ifndef TOLUA_RELEASE 00417 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL); 00418 #endif 00419 { 00420 size_t tolua_ret = (size_t) self->hash_size(); 00421 { 00422 #ifdef __cplusplus 00423 void* tolua_obj = Mtolua_new((size_t)(tolua_ret)); 00424 tolua_pushusertype(tolua_S,tolua_obj,"size_t"); 00425 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00426 #else 00427 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(size_t)); 00428 tolua_pushusertype(tolua_S,tolua_obj,"size_t"); 00429 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00430 #endif 00431 } 00432 } 00433 } 00434 return 1; 00435 #ifndef TOLUA_RELEASE 00436 tolua_lerror: 00437 tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err); 00438 return 0; 00439 #endif 00440 } 00441 #endif //#ifndef TOLUA_DISABLE 00442 00443 /* method: hash_printable of class fawkes::Interface */ 00444 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_hash_printable00 00445 static int tolua_fawkesinterface_fawkes_Interface_hash_printable00(lua_State* tolua_S) 00446 { 00447 #ifndef TOLUA_RELEASE 00448 tolua_Error tolua_err; 00449 if ( 00450 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00451 !tolua_isnoobj(tolua_S,2,&tolua_err) 00452 ) 00453 goto tolua_lerror; 00454 else 00455 #endif 00456 { 00457 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00458 #ifndef TOLUA_RELEASE 00459 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL); 00460 #endif 00461 { 00462 const char* tolua_ret = (const char*) self->hash_printable(); 00463 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00464 } 00465 } 00466 return 1; 00467 #ifndef TOLUA_RELEASE 00468 tolua_lerror: 00469 tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err); 00470 return 0; 00471 #endif 00472 } 00473 #endif //#ifndef TOLUA_DISABLE 00474 00475 /* method: is_writer of class fawkes::Interface */ 00476 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_is_writer00 00477 static int tolua_fawkesinterface_fawkes_Interface_is_writer00(lua_State* tolua_S) 00478 { 00479 #ifndef TOLUA_RELEASE 00480 tolua_Error tolua_err; 00481 if ( 00482 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00483 !tolua_isnoobj(tolua_S,2,&tolua_err) 00484 ) 00485 goto tolua_lerror; 00486 else 00487 #endif 00488 { 00489 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00490 #ifndef TOLUA_RELEASE 00491 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL); 00492 #endif 00493 { 00494 bool tolua_ret = (bool) self->is_writer(); 00495 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00496 } 00497 } 00498 return 1; 00499 #ifndef TOLUA_RELEASE 00500 tolua_lerror: 00501 tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err); 00502 return 0; 00503 #endif 00504 } 00505 #endif //#ifndef TOLUA_DISABLE 00506 00507 /* method: set_from_chunk of class fawkes::Interface */ 00508 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_set_from_chunk00 00509 static int tolua_fawkesinterface_fawkes_Interface_set_from_chunk00(lua_State* tolua_S) 00510 { 00511 #ifndef TOLUA_RELEASE 00512 tolua_Error tolua_err; 00513 if ( 00514 !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) || 00515 !tolua_isuserdata(tolua_S,2,0,&tolua_err) || 00516 !tolua_isnoobj(tolua_S,3,&tolua_err) 00517 ) 00518 goto tolua_lerror; 00519 else 00520 #endif 00521 { 00522 fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00523 void* chunk = ((void*) tolua_touserdata(tolua_S,2,0)); 00524 #ifndef TOLUA_RELEASE 00525 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL); 00526 #endif 00527 { 00528 self->set_from_chunk(chunk); 00529 } 00530 } 00531 return 0; 00532 #ifndef TOLUA_RELEASE 00533 tolua_lerror: 00534 tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err); 00535 return 0; 00536 #endif 00537 } 00538 #endif //#ifndef TOLUA_DISABLE 00539 00540 /* method: create_message of class fawkes::Interface */ 00541 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_create_message00 00542 static int tolua_fawkesinterface_fawkes_Interface_create_message00(lua_State* tolua_S) 00543 { 00544 #ifndef TOLUA_RELEASE 00545 tolua_Error tolua_err; 00546 if ( 00547 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00548 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00549 !tolua_isnoobj(tolua_S,3,&tolua_err) 00550 ) 00551 goto tolua_lerror; 00552 else 00553 #endif 00554 { 00555 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00556 const char* type = ((const char*) tolua_tostring(tolua_S,2,0)); 00557 #ifndef TOLUA_RELEASE 00558 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL); 00559 #endif 00560 { 00561 fawkes::Message* tolua_ret = (fawkes::Message*) self->create_message(type); 00562 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message"); 00563 } 00564 } 00565 return 1; 00566 #ifndef TOLUA_RELEASE 00567 tolua_lerror: 00568 tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err); 00569 return 0; 00570 #endif 00571 } 00572 #endif //#ifndef TOLUA_DISABLE 00573 00574 /* method: read of class fawkes::Interface */ 00575 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_read00 00576 static int tolua_fawkesinterface_fawkes_Interface_read00(lua_State* tolua_S) 00577 { 00578 #ifndef TOLUA_RELEASE 00579 tolua_Error tolua_err; 00580 if ( 00581 !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) || 00582 !tolua_isnoobj(tolua_S,2,&tolua_err) 00583 ) 00584 goto tolua_lerror; 00585 else 00586 #endif 00587 { 00588 fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00589 #ifndef TOLUA_RELEASE 00590 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL); 00591 #endif 00592 { 00593 self->read(); 00594 } 00595 } 00596 return 0; 00597 #ifndef TOLUA_RELEASE 00598 tolua_lerror: 00599 tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err); 00600 return 0; 00601 #endif 00602 } 00603 #endif //#ifndef TOLUA_DISABLE 00604 00605 /* method: write of class fawkes::Interface */ 00606 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_write00 00607 static int tolua_fawkesinterface_fawkes_Interface_write00(lua_State* tolua_S) 00608 { 00609 #ifndef TOLUA_RELEASE 00610 tolua_Error tolua_err; 00611 if ( 00612 !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) || 00613 !tolua_isnoobj(tolua_S,2,&tolua_err) 00614 ) 00615 goto tolua_lerror; 00616 else 00617 #endif 00618 { 00619 fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00620 #ifndef TOLUA_RELEASE 00621 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL); 00622 #endif 00623 { 00624 self->write(); 00625 } 00626 } 00627 return 0; 00628 #ifndef TOLUA_RELEASE 00629 tolua_lerror: 00630 tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err); 00631 return 0; 00632 #endif 00633 } 00634 #endif //#ifndef TOLUA_DISABLE 00635 00636 /* method: has_writer of class fawkes::Interface */ 00637 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_has_writer00 00638 static int tolua_fawkesinterface_fawkes_Interface_has_writer00(lua_State* tolua_S) 00639 { 00640 #ifndef TOLUA_RELEASE 00641 tolua_Error tolua_err; 00642 if ( 00643 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00644 !tolua_isnoobj(tolua_S,2,&tolua_err) 00645 ) 00646 goto tolua_lerror; 00647 else 00648 #endif 00649 { 00650 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00651 #ifndef TOLUA_RELEASE 00652 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL); 00653 #endif 00654 { 00655 bool tolua_ret = (bool) self->has_writer(); 00656 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00657 } 00658 } 00659 return 1; 00660 #ifndef TOLUA_RELEASE 00661 tolua_lerror: 00662 tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err); 00663 return 0; 00664 #endif 00665 } 00666 #endif //#ifndef TOLUA_DISABLE 00667 00668 /* method: num_readers of class fawkes::Interface */ 00669 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_num_readers00 00670 static int tolua_fawkesinterface_fawkes_Interface_num_readers00(lua_State* tolua_S) 00671 { 00672 #ifndef TOLUA_RELEASE 00673 tolua_Error tolua_err; 00674 if ( 00675 !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) || 00676 !tolua_isnoobj(tolua_S,2,&tolua_err) 00677 ) 00678 goto tolua_lerror; 00679 else 00680 #endif 00681 { 00682 const fawkes::Interface* self = (const fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00683 #ifndef TOLUA_RELEASE 00684 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL); 00685 #endif 00686 { 00687 unsigned int tolua_ret = (unsigned int) self->num_readers(); 00688 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00689 } 00690 } 00691 return 1; 00692 #ifndef TOLUA_RELEASE 00693 tolua_lerror: 00694 tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err); 00695 return 0; 00696 #endif 00697 } 00698 #endif //#ifndef TOLUA_DISABLE 00699 00700 /* method: msgq_enqueue_copy of class fawkes::Interface */ 00701 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_enqueue_copy00 00702 static int tolua_fawkesinterface_fawkes_Interface_msgq_enqueue_copy00(lua_State* tolua_S) 00703 { 00704 #ifndef TOLUA_RELEASE 00705 tolua_Error tolua_err; 00706 if ( 00707 !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) || 00708 !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) || 00709 !tolua_isnoobj(tolua_S,3,&tolua_err) 00710 ) 00711 goto tolua_lerror; 00712 else 00713 #endif 00714 { 00715 fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00716 fawkes::Message* message = ((fawkes::Message*) tolua_tousertype(tolua_S,2,0)); 00717 #ifndef TOLUA_RELEASE 00718 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL); 00719 #endif 00720 { 00721 unsigned int tolua_ret = (unsigned int) self->msgq_enqueue_copy(message); 00722 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00723 } 00724 } 00725 return 1; 00726 #ifndef TOLUA_RELEASE 00727 tolua_lerror: 00728 tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err); 00729 return 0; 00730 #endif 00731 } 00732 #endif //#ifndef TOLUA_DISABLE 00733 00734 /* method: msgq_remove of class fawkes::Interface */ 00735 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_remove00 00736 static int tolua_fawkesinterface_fawkes_Interface_msgq_remove00(lua_State* tolua_S) 00737 { 00738 #ifndef TOLUA_RELEASE 00739 tolua_Error tolua_err; 00740 if ( 00741 !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) || 00742 !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) || 00743 !tolua_isnoobj(tolua_S,3,&tolua_err) 00744 ) 00745 goto tolua_lerror; 00746 else 00747 #endif 00748 { 00749 fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00750 fawkes::Message* message = ((fawkes::Message*) tolua_tousertype(tolua_S,2,0)); 00751 #ifndef TOLUA_RELEASE 00752 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 00753 #endif 00754 { 00755 self->msgq_remove(message); 00756 } 00757 } 00758 return 0; 00759 #ifndef TOLUA_RELEASE 00760 tolua_lerror: 00761 tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err); 00762 return 0; 00763 #endif 00764 } 00765 #endif //#ifndef TOLUA_DISABLE 00766 00767 /* method: msgq_remove of class fawkes::Interface */ 00768 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_remove01 00769 static int tolua_fawkesinterface_fawkes_Interface_msgq_remove01(lua_State* tolua_S) 00770 { 00771 tolua_Error tolua_err; 00772 if ( 00773 !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) || 00774 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00775 !tolua_isnoobj(tolua_S,3,&tolua_err) 00776 ) 00777 goto tolua_lerror; 00778 else 00779 { 00780 fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00781 unsigned int message_id = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 00782 #ifndef TOLUA_RELEASE 00783 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 00784 #endif 00785 { 00786 self->msgq_remove(message_id); 00787 } 00788 } 00789 return 0; 00790 tolua_lerror: 00791 return tolua_fawkesinterface_fawkes_Interface_msgq_remove00(tolua_S); 00792 } 00793 #endif //#ifndef TOLUA_DISABLE 00794 00795 /* method: msgq_size of class fawkes::Interface */ 00796 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_size00 00797 static int tolua_fawkesinterface_fawkes_Interface_msgq_size00(lua_State* tolua_S) 00798 { 00799 #ifndef TOLUA_RELEASE 00800 tolua_Error tolua_err; 00801 if ( 00802 !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) || 00803 !tolua_isnoobj(tolua_S,2,&tolua_err) 00804 ) 00805 goto tolua_lerror; 00806 else 00807 #endif 00808 { 00809 fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00810 #ifndef TOLUA_RELEASE 00811 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL); 00812 #endif 00813 { 00814 unsigned int tolua_ret = (unsigned int) self->msgq_size(); 00815 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00816 } 00817 } 00818 return 1; 00819 #ifndef TOLUA_RELEASE 00820 tolua_lerror: 00821 tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err); 00822 return 0; 00823 #endif 00824 } 00825 #endif //#ifndef TOLUA_DISABLE 00826 00827 /* method: msgq_flush of class fawkes::Interface */ 00828 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_flush00 00829 static int tolua_fawkesinterface_fawkes_Interface_msgq_flush00(lua_State* tolua_S) 00830 { 00831 #ifndef TOLUA_RELEASE 00832 tolua_Error tolua_err; 00833 if ( 00834 !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) || 00835 !tolua_isnoobj(tolua_S,2,&tolua_err) 00836 ) 00837 goto tolua_lerror; 00838 else 00839 #endif 00840 { 00841 fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00842 #ifndef TOLUA_RELEASE 00843 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL); 00844 #endif 00845 { 00846 self->msgq_flush(); 00847 } 00848 } 00849 return 0; 00850 #ifndef TOLUA_RELEASE 00851 tolua_lerror: 00852 tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err); 00853 return 0; 00854 #endif 00855 } 00856 #endif //#ifndef TOLUA_DISABLE 00857 00858 /* method: msgq_lock of class fawkes::Interface */ 00859 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_lock00 00860 static int tolua_fawkesinterface_fawkes_Interface_msgq_lock00(lua_State* tolua_S) 00861 { 00862 #ifndef TOLUA_RELEASE 00863 tolua_Error tolua_err; 00864 if ( 00865 !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) || 00866 !tolua_isnoobj(tolua_S,2,&tolua_err) 00867 ) 00868 goto tolua_lerror; 00869 else 00870 #endif 00871 { 00872 fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00873 #ifndef TOLUA_RELEASE 00874 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL); 00875 #endif 00876 { 00877 self->msgq_lock(); 00878 } 00879 } 00880 return 0; 00881 #ifndef TOLUA_RELEASE 00882 tolua_lerror: 00883 tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err); 00884 return 0; 00885 #endif 00886 } 00887 #endif //#ifndef TOLUA_DISABLE 00888 00889 /* method: msgq_try_lock of class fawkes::Interface */ 00890 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_try_lock00 00891 static int tolua_fawkesinterface_fawkes_Interface_msgq_try_lock00(lua_State* tolua_S) 00892 { 00893 #ifndef TOLUA_RELEASE 00894 tolua_Error tolua_err; 00895 if ( 00896 !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) || 00897 !tolua_isnoobj(tolua_S,2,&tolua_err) 00898 ) 00899 goto tolua_lerror; 00900 else 00901 #endif 00902 { 00903 fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00904 #ifndef TOLUA_RELEASE 00905 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL); 00906 #endif 00907 { 00908 bool tolua_ret = (bool) self->msgq_try_lock(); 00909 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00910 } 00911 } 00912 return 1; 00913 #ifndef TOLUA_RELEASE 00914 tolua_lerror: 00915 tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err); 00916 return 0; 00917 #endif 00918 } 00919 #endif //#ifndef TOLUA_DISABLE 00920 00921 /* method: msgq_unlock of class fawkes::Interface */ 00922 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_unlock00 00923 static int tolua_fawkesinterface_fawkes_Interface_msgq_unlock00(lua_State* tolua_S) 00924 { 00925 #ifndef TOLUA_RELEASE 00926 tolua_Error tolua_err; 00927 if ( 00928 !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) || 00929 !tolua_isnoobj(tolua_S,2,&tolua_err) 00930 ) 00931 goto tolua_lerror; 00932 else 00933 #endif 00934 { 00935 fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00936 #ifndef TOLUA_RELEASE 00937 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL); 00938 #endif 00939 { 00940 self->msgq_unlock(); 00941 } 00942 } 00943 return 0; 00944 #ifndef TOLUA_RELEASE 00945 tolua_lerror: 00946 tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err); 00947 return 0; 00948 #endif 00949 } 00950 #endif //#ifndef TOLUA_DISABLE 00951 00952 /* method: msgq_pop of class fawkes::Interface */ 00953 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_pop00 00954 static int tolua_fawkesinterface_fawkes_Interface_msgq_pop00(lua_State* tolua_S) 00955 { 00956 #ifndef TOLUA_RELEASE 00957 tolua_Error tolua_err; 00958 if ( 00959 !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) || 00960 !tolua_isnoobj(tolua_S,2,&tolua_err) 00961 ) 00962 goto tolua_lerror; 00963 else 00964 #endif 00965 { 00966 fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00967 #ifndef TOLUA_RELEASE 00968 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL); 00969 #endif 00970 { 00971 self->msgq_pop(); 00972 } 00973 } 00974 return 0; 00975 #ifndef TOLUA_RELEASE 00976 tolua_lerror: 00977 tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err); 00978 return 0; 00979 #endif 00980 } 00981 #endif //#ifndef TOLUA_DISABLE 00982 00983 /* method: msgq_first of class fawkes::Interface */ 00984 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_first00 00985 static int tolua_fawkesinterface_fawkes_Interface_msgq_first00(lua_State* tolua_S) 00986 { 00987 #ifndef TOLUA_RELEASE 00988 tolua_Error tolua_err; 00989 if ( 00990 !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) || 00991 !tolua_isnoobj(tolua_S,2,&tolua_err) 00992 ) 00993 goto tolua_lerror; 00994 else 00995 #endif 00996 { 00997 fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 00998 #ifndef TOLUA_RELEASE 00999 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL); 01000 #endif 01001 { 01002 fawkes::Message* tolua_ret = (fawkes::Message*) self->msgq_first(); 01003 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message"); 01004 } 01005 } 01006 return 1; 01007 #ifndef TOLUA_RELEASE 01008 tolua_lerror: 01009 tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err); 01010 return 0; 01011 #endif 01012 } 01013 #endif //#ifndef TOLUA_DISABLE 01014 01015 /* method: msgq_empty of class fawkes::Interface */ 01016 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_empty00 01017 static int tolua_fawkesinterface_fawkes_Interface_msgq_empty00(lua_State* tolua_S) 01018 { 01019 #ifndef TOLUA_RELEASE 01020 tolua_Error tolua_err; 01021 if ( 01022 !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) || 01023 !tolua_isnoobj(tolua_S,2,&tolua_err) 01024 ) 01025 goto tolua_lerror; 01026 else 01027 #endif 01028 { 01029 fawkes::Interface* self = (fawkes::Interface*) tolua_tousertype(tolua_S,1,0); 01030 #ifndef TOLUA_RELEASE 01031 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL); 01032 #endif 01033 { 01034 bool tolua_ret = (bool) self->msgq_empty(); 01035 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01036 } 01037 } 01038 return 1; 01039 #ifndef TOLUA_RELEASE 01040 tolua_lerror: 01041 tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err); 01042 return 0; 01043 #endif 01044 } 01045 #endif //#ifndef TOLUA_DISABLE 01046 01047 /* method: new of class fawkes::Message */ 01048 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new00 01049 static int tolua_fawkesinterface_fawkes_Message_new00(lua_State* tolua_S) 01050 { 01051 #ifndef TOLUA_RELEASE 01052 tolua_Error tolua_err; 01053 if ( 01054 !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) || 01055 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01056 !tolua_isnoobj(tolua_S,3,&tolua_err) 01057 ) 01058 goto tolua_lerror; 01059 else 01060 #endif 01061 { 01062 const char* type = ((const char*) tolua_tostring(tolua_S,2,0)); 01063 { 01064 fawkes::Message* tolua_ret = (fawkes::Message*) Mtolua_new((fawkes::Message)(type)); 01065 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message"); 01066 } 01067 } 01068 return 1; 01069 #ifndef TOLUA_RELEASE 01070 tolua_lerror: 01071 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01072 return 0; 01073 #endif 01074 } 01075 #endif //#ifndef TOLUA_DISABLE 01076 01077 /* method: new_local of class fawkes::Message */ 01078 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new00_local 01079 static int tolua_fawkesinterface_fawkes_Message_new00_local(lua_State* tolua_S) 01080 { 01081 #ifndef TOLUA_RELEASE 01082 tolua_Error tolua_err; 01083 if ( 01084 !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) || 01085 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01086 !tolua_isnoobj(tolua_S,3,&tolua_err) 01087 ) 01088 goto tolua_lerror; 01089 else 01090 #endif 01091 { 01092 const char* type = ((const char*) tolua_tostring(tolua_S,2,0)); 01093 { 01094 fawkes::Message* tolua_ret = (fawkes::Message*) Mtolua_new((fawkes::Message)(type)); 01095 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message"); 01096 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01097 } 01098 } 01099 return 1; 01100 #ifndef TOLUA_RELEASE 01101 tolua_lerror: 01102 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01103 return 0; 01104 #endif 01105 } 01106 #endif //#ifndef TOLUA_DISABLE 01107 01108 /* method: new of class fawkes::Message */ 01109 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new01 01110 static int tolua_fawkesinterface_fawkes_Message_new01(lua_State* tolua_S) 01111 { 01112 tolua_Error tolua_err; 01113 if ( 01114 !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) || 01115 !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) || 01116 !tolua_isnoobj(tolua_S,3,&tolua_err) 01117 ) 01118 goto tolua_lerror; 01119 else 01120 { 01121 fawkes::Message* mesg = ((fawkes::Message*) tolua_tousertype(tolua_S,2,0)); 01122 { 01123 fawkes::Message* tolua_ret = (fawkes::Message*) Mtolua_new((fawkes::Message)(mesg)); 01124 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message"); 01125 } 01126 } 01127 return 1; 01128 tolua_lerror: 01129 return tolua_fawkesinterface_fawkes_Message_new00(tolua_S); 01130 } 01131 #endif //#ifndef TOLUA_DISABLE 01132 01133 /* method: new_local of class fawkes::Message */ 01134 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new01_local 01135 static int tolua_fawkesinterface_fawkes_Message_new01_local(lua_State* tolua_S) 01136 { 01137 tolua_Error tolua_err; 01138 if ( 01139 !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) || 01140 !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) || 01141 !tolua_isnoobj(tolua_S,3,&tolua_err) 01142 ) 01143 goto tolua_lerror; 01144 else 01145 { 01146 fawkes::Message* mesg = ((fawkes::Message*) tolua_tousertype(tolua_S,2,0)); 01147 { 01148 fawkes::Message* tolua_ret = (fawkes::Message*) Mtolua_new((fawkes::Message)(mesg)); 01149 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message"); 01150 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01151 } 01152 } 01153 return 1; 01154 tolua_lerror: 01155 return tolua_fawkesinterface_fawkes_Message_new00_local(tolua_S); 01156 } 01157 #endif //#ifndef TOLUA_DISABLE 01158 01159 /* method: new of class fawkes::Message */ 01160 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new02 01161 static int tolua_fawkesinterface_fawkes_Message_new02(lua_State* tolua_S) 01162 { 01163 tolua_Error tolua_err; 01164 if ( 01165 !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) || 01166 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err)) || 01167 !tolua_isnoobj(tolua_S,3,&tolua_err) 01168 ) 01169 goto tolua_lerror; 01170 else 01171 { 01172 fawkes::Message* mesg = ((fawkes::Message*) tolua_tousertype(tolua_S,2,0)); 01173 { 01174 fawkes::Message* tolua_ret = (fawkes::Message*) Mtolua_new((fawkes::Message)(*mesg)); 01175 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message"); 01176 } 01177 } 01178 return 1; 01179 tolua_lerror: 01180 return tolua_fawkesinterface_fawkes_Message_new01(tolua_S); 01181 } 01182 #endif //#ifndef TOLUA_DISABLE 01183 01184 /* method: new_local of class fawkes::Message */ 01185 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new02_local 01186 static int tolua_fawkesinterface_fawkes_Message_new02_local(lua_State* tolua_S) 01187 { 01188 tolua_Error tolua_err; 01189 if ( 01190 !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) || 01191 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err)) || 01192 !tolua_isnoobj(tolua_S,3,&tolua_err) 01193 ) 01194 goto tolua_lerror; 01195 else 01196 { 01197 fawkes::Message* mesg = ((fawkes::Message*) tolua_tousertype(tolua_S,2,0)); 01198 { 01199 fawkes::Message* tolua_ret = (fawkes::Message*) Mtolua_new((fawkes::Message)(*mesg)); 01200 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message"); 01201 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01202 } 01203 } 01204 return 1; 01205 tolua_lerror: 01206 return tolua_fawkesinterface_fawkes_Message_new01_local(tolua_S); 01207 } 01208 #endif //#ifndef TOLUA_DISABLE 01209 01210 /* method: sender_id of class fawkes::Message */ 01211 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_sender_id00 01212 static int tolua_fawkesinterface_fawkes_Message_sender_id00(lua_State* tolua_S) 01213 { 01214 #ifndef TOLUA_RELEASE 01215 tolua_Error tolua_err; 01216 if ( 01217 !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) || 01218 !tolua_isnoobj(tolua_S,2,&tolua_err) 01219 ) 01220 goto tolua_lerror; 01221 else 01222 #endif 01223 { 01224 const fawkes::Message* self = (const fawkes::Message*) tolua_tousertype(tolua_S,1,0); 01225 #ifndef TOLUA_RELEASE 01226 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sender_id'", NULL); 01227 #endif 01228 { 01229 unsigned int tolua_ret = (unsigned int) self->sender_id(); 01230 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01231 } 01232 } 01233 return 1; 01234 #ifndef TOLUA_RELEASE 01235 tolua_lerror: 01236 tolua_error(tolua_S,"#ferror in function 'sender_id'.",&tolua_err); 01237 return 0; 01238 #endif 01239 } 01240 #endif //#ifndef TOLUA_DISABLE 01241 01242 /* method: sender_thread_name of class fawkes::Message */ 01243 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_sender_thread_name00 01244 static int tolua_fawkesinterface_fawkes_Message_sender_thread_name00(lua_State* tolua_S) 01245 { 01246 #ifndef TOLUA_RELEASE 01247 tolua_Error tolua_err; 01248 if ( 01249 !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) || 01250 !tolua_isnoobj(tolua_S,2,&tolua_err) 01251 ) 01252 goto tolua_lerror; 01253 else 01254 #endif 01255 { 01256 const fawkes::Message* self = (const fawkes::Message*) tolua_tousertype(tolua_S,1,0); 01257 #ifndef TOLUA_RELEASE 01258 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sender_thread_name'", NULL); 01259 #endif 01260 { 01261 const char* tolua_ret = (const char*) self->sender_thread_name(); 01262 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01263 } 01264 } 01265 return 1; 01266 #ifndef TOLUA_RELEASE 01267 tolua_lerror: 01268 tolua_error(tolua_S,"#ferror in function 'sender_thread_name'.",&tolua_err); 01269 return 0; 01270 #endif 01271 } 01272 #endif //#ifndef TOLUA_DISABLE 01273 01274 /* method: interface of class fawkes::Message */ 01275 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_interface00 01276 static int tolua_fawkesinterface_fawkes_Message_interface00(lua_State* tolua_S) 01277 { 01278 #ifndef TOLUA_RELEASE 01279 tolua_Error tolua_err; 01280 if ( 01281 !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) || 01282 !tolua_isnoobj(tolua_S,2,&tolua_err) 01283 ) 01284 goto tolua_lerror; 01285 else 01286 #endif 01287 { 01288 const fawkes::Message* self = (const fawkes::Message*) tolua_tousertype(tolua_S,1,0); 01289 #ifndef TOLUA_RELEASE 01290 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'interface'", NULL); 01291 #endif 01292 { 01293 fawkes::Interface* tolua_ret = (fawkes::Interface*) self->interface(); 01294 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Interface"); 01295 } 01296 } 01297 return 1; 01298 #ifndef TOLUA_RELEASE 01299 tolua_lerror: 01300 tolua_error(tolua_S,"#ferror in function 'interface'.",&tolua_err); 01301 return 0; 01302 #endif 01303 } 01304 #endif //#ifndef TOLUA_DISABLE 01305 01306 /* method: type of class fawkes::Message */ 01307 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_type00 01308 static int tolua_fawkesinterface_fawkes_Message_type00(lua_State* tolua_S) 01309 { 01310 #ifndef TOLUA_RELEASE 01311 tolua_Error tolua_err; 01312 if ( 01313 !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) || 01314 !tolua_isnoobj(tolua_S,2,&tolua_err) 01315 ) 01316 goto tolua_lerror; 01317 else 01318 #endif 01319 { 01320 const fawkes::Message* self = (const fawkes::Message*) tolua_tousertype(tolua_S,1,0); 01321 #ifndef TOLUA_RELEASE 01322 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL); 01323 #endif 01324 { 01325 const char* tolua_ret = (const char*) self->type(); 01326 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01327 } 01328 } 01329 return 1; 01330 #ifndef TOLUA_RELEASE 01331 tolua_lerror: 01332 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err); 01333 return 0; 01334 #endif 01335 } 01336 #endif //#ifndef TOLUA_DISABLE 01337 01338 /* method: datachunk of class fawkes::Message */ 01339 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_datachunk00 01340 static int tolua_fawkesinterface_fawkes_Message_datachunk00(lua_State* tolua_S) 01341 { 01342 #ifndef TOLUA_RELEASE 01343 tolua_Error tolua_err; 01344 if ( 01345 !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) || 01346 !tolua_isnoobj(tolua_S,2,&tolua_err) 01347 ) 01348 goto tolua_lerror; 01349 else 01350 #endif 01351 { 01352 const fawkes::Message* self = (const fawkes::Message*) tolua_tousertype(tolua_S,1,0); 01353 #ifndef TOLUA_RELEASE 01354 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL); 01355 #endif 01356 { 01357 const void* tolua_ret = (const void*) self->datachunk(); 01358 tolua_pushuserdata(tolua_S,(void*)tolua_ret); 01359 } 01360 } 01361 return 1; 01362 #ifndef TOLUA_RELEASE 01363 tolua_lerror: 01364 tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err); 01365 return 0; 01366 #endif 01367 } 01368 #endif //#ifndef TOLUA_DISABLE 01369 01370 /* method: datasize of class fawkes::Message */ 01371 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_datasize00 01372 static int tolua_fawkesinterface_fawkes_Message_datasize00(lua_State* tolua_S) 01373 { 01374 #ifndef TOLUA_RELEASE 01375 tolua_Error tolua_err; 01376 if ( 01377 !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) || 01378 !tolua_isnoobj(tolua_S,2,&tolua_err) 01379 ) 01380 goto tolua_lerror; 01381 else 01382 #endif 01383 { 01384 const fawkes::Message* self = (const fawkes::Message*) tolua_tousertype(tolua_S,1,0); 01385 #ifndef TOLUA_RELEASE 01386 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL); 01387 #endif 01388 { 01389 unsigned int tolua_ret = (unsigned int) self->datasize(); 01390 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01391 } 01392 } 01393 return 1; 01394 #ifndef TOLUA_RELEASE 01395 tolua_lerror: 01396 tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err); 01397 return 0; 01398 #endif 01399 } 01400 #endif //#ifndef TOLUA_DISABLE 01401 01402 /* method: set_from_chunk of class fawkes::Message */ 01403 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_set_from_chunk00 01404 static int tolua_fawkesinterface_fawkes_Message_set_from_chunk00(lua_State* tolua_S) 01405 { 01406 #ifndef TOLUA_RELEASE 01407 tolua_Error tolua_err; 01408 if ( 01409 !tolua_isusertype(tolua_S,1,"fawkes::Message",0,&tolua_err) || 01410 !tolua_isuserdata(tolua_S,2,0,&tolua_err) || 01411 !tolua_isnoobj(tolua_S,3,&tolua_err) 01412 ) 01413 goto tolua_lerror; 01414 else 01415 #endif 01416 { 01417 fawkes::Message* self = (fawkes::Message*) tolua_tousertype(tolua_S,1,0); 01418 const void* chunk = ((const void*) tolua_touserdata(tolua_S,2,0)); 01419 #ifndef TOLUA_RELEASE 01420 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL); 01421 #endif 01422 { 01423 self->set_from_chunk(chunk); 01424 } 01425 } 01426 return 0; 01427 #ifndef TOLUA_RELEASE 01428 tolua_lerror: 01429 tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err); 01430 return 0; 01431 #endif 01432 } 01433 #endif //#ifndef TOLUA_DISABLE 01434 01435 /* method: ref of class fawkes::Message */ 01436 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_ref00 01437 static int tolua_fawkesinterface_fawkes_Message_ref00(lua_State* tolua_S) 01438 { 01439 #ifndef TOLUA_RELEASE 01440 tolua_Error tolua_err; 01441 if ( 01442 !tolua_isusertype(tolua_S,1,"fawkes::Message",0,&tolua_err) || 01443 !tolua_isnoobj(tolua_S,2,&tolua_err) 01444 ) 01445 goto tolua_lerror; 01446 else 01447 #endif 01448 { 01449 fawkes::Message* self = (fawkes::Message*) tolua_tousertype(tolua_S,1,0); 01450 #ifndef TOLUA_RELEASE 01451 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ref'", NULL); 01452 #endif 01453 { 01454 self->ref(); 01455 } 01456 } 01457 return 0; 01458 #ifndef TOLUA_RELEASE 01459 tolua_lerror: 01460 tolua_error(tolua_S,"#ferror in function 'ref'.",&tolua_err); 01461 return 0; 01462 #endif 01463 } 01464 #endif //#ifndef TOLUA_DISABLE 01465 01466 /* method: unref of class fawkes::Message */ 01467 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_unref00 01468 static int tolua_fawkesinterface_fawkes_Message_unref00(lua_State* tolua_S) 01469 { 01470 #ifndef TOLUA_RELEASE 01471 tolua_Error tolua_err; 01472 if ( 01473 !tolua_isusertype(tolua_S,1,"fawkes::Message",0,&tolua_err) || 01474 !tolua_isnoobj(tolua_S,2,&tolua_err) 01475 ) 01476 goto tolua_lerror; 01477 else 01478 #endif 01479 { 01480 fawkes::Message* self = (fawkes::Message*) tolua_tousertype(tolua_S,1,0); 01481 #ifndef TOLUA_RELEASE 01482 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unref'", NULL); 01483 #endif 01484 { 01485 self->unref(); 01486 } 01487 } 01488 return 0; 01489 #ifndef TOLUA_RELEASE 01490 tolua_lerror: 01491 tolua_error(tolua_S,"#ferror in function 'unref'.",&tolua_err); 01492 return 0; 01493 #endif 01494 } 01495 #endif //#ifndef TOLUA_DISABLE 01496 01497 /* method: refcount of class fawkes::Message */ 01498 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_refcount00 01499 static int tolua_fawkesinterface_fawkes_Message_refcount00(lua_State* tolua_S) 01500 { 01501 #ifndef TOLUA_RELEASE 01502 tolua_Error tolua_err; 01503 if ( 01504 !tolua_isusertype(tolua_S,1,"fawkes::Message",0,&tolua_err) || 01505 !tolua_isnoobj(tolua_S,2,&tolua_err) 01506 ) 01507 goto tolua_lerror; 01508 else 01509 #endif 01510 { 01511 fawkes::Message* self = (fawkes::Message*) tolua_tousertype(tolua_S,1,0); 01512 #ifndef TOLUA_RELEASE 01513 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'refcount'", NULL); 01514 #endif 01515 { 01516 unsigned int tolua_ret = (unsigned int) self->refcount(); 01517 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01518 } 01519 } 01520 return 1; 01521 #ifndef TOLUA_RELEASE 01522 tolua_lerror: 01523 tolua_error(tolua_S,"#ferror in function 'refcount'.",&tolua_err); 01524 return 0; 01525 #endif 01526 } 01527 #endif //#ifndef TOLUA_DISABLE 01528 01529 /* method: new of class fawkes::MessageQueue */ 01530 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_new00 01531 static int tolua_fawkesinterface_fawkes_MessageQueue_new00(lua_State* tolua_S) 01532 { 01533 #ifndef TOLUA_RELEASE 01534 tolua_Error tolua_err; 01535 if ( 01536 !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 01537 !tolua_isnoobj(tolua_S,2,&tolua_err) 01538 ) 01539 goto tolua_lerror; 01540 else 01541 #endif 01542 { 01543 { 01544 fawkes::MessageQueue* tolua_ret = (fawkes::MessageQueue*) Mtolua_new((fawkes::MessageQueue)()); 01545 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue"); 01546 } 01547 } 01548 return 1; 01549 #ifndef TOLUA_RELEASE 01550 tolua_lerror: 01551 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01552 return 0; 01553 #endif 01554 } 01555 #endif //#ifndef TOLUA_DISABLE 01556 01557 /* method: new_local of class fawkes::MessageQueue */ 01558 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_new00_local 01559 static int tolua_fawkesinterface_fawkes_MessageQueue_new00_local(lua_State* tolua_S) 01560 { 01561 #ifndef TOLUA_RELEASE 01562 tolua_Error tolua_err; 01563 if ( 01564 !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 01565 !tolua_isnoobj(tolua_S,2,&tolua_err) 01566 ) 01567 goto tolua_lerror; 01568 else 01569 #endif 01570 { 01571 { 01572 fawkes::MessageQueue* tolua_ret = (fawkes::MessageQueue*) Mtolua_new((fawkes::MessageQueue)()); 01573 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue"); 01574 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01575 } 01576 } 01577 return 1; 01578 #ifndef TOLUA_RELEASE 01579 tolua_lerror: 01580 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01581 return 0; 01582 #endif 01583 } 01584 #endif //#ifndef TOLUA_DISABLE 01585 01586 /* method: delete of class fawkes::MessageQueue */ 01587 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_delete00 01588 static int tolua_fawkesinterface_fawkes_MessageQueue_delete00(lua_State* tolua_S) 01589 { 01590 #ifndef TOLUA_RELEASE 01591 tolua_Error tolua_err; 01592 if ( 01593 !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 01594 !tolua_isnoobj(tolua_S,2,&tolua_err) 01595 ) 01596 goto tolua_lerror; 01597 else 01598 #endif 01599 { 01600 fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 01601 #ifndef TOLUA_RELEASE 01602 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 01603 #endif 01604 Mtolua_delete(self); 01605 } 01606 return 0; 01607 #ifndef TOLUA_RELEASE 01608 tolua_lerror: 01609 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 01610 return 0; 01611 #endif 01612 } 01613 #endif //#ifndef TOLUA_DISABLE 01614 01615 /* method: new of class MessageIterator */ 01616 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00 01617 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00(lua_State* tolua_S) 01618 { 01619 #ifndef TOLUA_RELEASE 01620 tolua_Error tolua_err; 01621 if ( 01622 !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) || 01623 !tolua_isnoobj(tolua_S,2,&tolua_err) 01624 ) 01625 goto tolua_lerror; 01626 else 01627 #endif 01628 { 01629 { 01630 fawkes::MessageQueue::MessageIterator* tolua_ret = (fawkes::MessageQueue::MessageIterator*) Mtolua_new((fawkes::MessageQueue::MessageIterator)()); 01631 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue::MessageIterator"); 01632 } 01633 } 01634 return 1; 01635 #ifndef TOLUA_RELEASE 01636 tolua_lerror: 01637 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01638 return 0; 01639 #endif 01640 } 01641 #endif //#ifndef TOLUA_DISABLE 01642 01643 /* method: new_local of class MessageIterator */ 01644 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local 01645 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local(lua_State* tolua_S) 01646 { 01647 #ifndef TOLUA_RELEASE 01648 tolua_Error tolua_err; 01649 if ( 01650 !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) || 01651 !tolua_isnoobj(tolua_S,2,&tolua_err) 01652 ) 01653 goto tolua_lerror; 01654 else 01655 #endif 01656 { 01657 { 01658 fawkes::MessageQueue::MessageIterator* tolua_ret = (fawkes::MessageQueue::MessageIterator*) Mtolua_new((fawkes::MessageQueue::MessageIterator)()); 01659 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue::MessageIterator"); 01660 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01661 } 01662 } 01663 return 1; 01664 #ifndef TOLUA_RELEASE 01665 tolua_lerror: 01666 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01667 return 0; 01668 #endif 01669 } 01670 #endif //#ifndef TOLUA_DISABLE 01671 01672 /* method: new of class MessageIterator */ 01673 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01 01674 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01(lua_State* tolua_S) 01675 { 01676 tolua_Error tolua_err; 01677 if ( 01678 !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) || 01679 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err)) || 01680 !tolua_isnoobj(tolua_S,3,&tolua_err) 01681 ) 01682 goto tolua_lerror; 01683 else 01684 { 01685 const fawkes::MessageQueue::MessageIterator* it = ((const fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,2,0)); 01686 { 01687 fawkes::MessageQueue::MessageIterator* tolua_ret = (fawkes::MessageQueue::MessageIterator*) Mtolua_new((fawkes::MessageQueue::MessageIterator)(*it)); 01688 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue::MessageIterator"); 01689 } 01690 } 01691 return 1; 01692 tolua_lerror: 01693 return tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00(tolua_S); 01694 } 01695 #endif //#ifndef TOLUA_DISABLE 01696 01697 /* method: new_local of class MessageIterator */ 01698 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local 01699 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local(lua_State* tolua_S) 01700 { 01701 tolua_Error tolua_err; 01702 if ( 01703 !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) || 01704 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err)) || 01705 !tolua_isnoobj(tolua_S,3,&tolua_err) 01706 ) 01707 goto tolua_lerror; 01708 else 01709 { 01710 const fawkes::MessageQueue::MessageIterator* it = ((const fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,2,0)); 01711 { 01712 fawkes::MessageQueue::MessageIterator* tolua_ret = (fawkes::MessageQueue::MessageIterator*) Mtolua_new((fawkes::MessageQueue::MessageIterator)(*it)); 01713 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue::MessageIterator"); 01714 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01715 } 01716 } 01717 return 1; 01718 tolua_lerror: 01719 return tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local(tolua_S); 01720 } 01721 #endif //#ifndef TOLUA_DISABLE 01722 01723 /* method: operator+ of class MessageIterator */ 01724 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__add00 01725 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__add00(lua_State* tolua_S) 01726 { 01727 #ifndef TOLUA_RELEASE 01728 tolua_Error tolua_err; 01729 if ( 01730 !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) || 01731 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01732 !tolua_isnoobj(tolua_S,3,&tolua_err) 01733 ) 01734 goto tolua_lerror; 01735 else 01736 #endif 01737 { 01738 fawkes::MessageQueue::MessageIterator* self = (fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,1,0); 01739 unsigned int i = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 01740 #ifndef TOLUA_RELEASE 01741 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'", NULL); 01742 #endif 01743 { 01744 fawkes::MessageQueue::MessageIterator& tolua_ret = (fawkes::MessageQueue::MessageIterator&) self->operator+(i); 01745 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::MessageQueue::MessageIterator"); 01746 } 01747 } 01748 return 1; 01749 #ifndef TOLUA_RELEASE 01750 tolua_lerror: 01751 tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err); 01752 return 0; 01753 #endif 01754 } 01755 #endif //#ifndef TOLUA_DISABLE 01756 01757 /* method: operator== of class MessageIterator */ 01758 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__eq00 01759 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__eq00(lua_State* tolua_S) 01760 { 01761 #ifndef TOLUA_RELEASE 01762 tolua_Error tolua_err; 01763 if ( 01764 !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) || 01765 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err)) || 01766 !tolua_isnoobj(tolua_S,3,&tolua_err) 01767 ) 01768 goto tolua_lerror; 01769 else 01770 #endif 01771 { 01772 const fawkes::MessageQueue::MessageIterator* self = (const fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,1,0); 01773 const fawkes::MessageQueue::MessageIterator* c = ((const fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,2,0)); 01774 #ifndef TOLUA_RELEASE 01775 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL); 01776 #endif 01777 { 01778 bool tolua_ret = (bool) self->operator==(*c); 01779 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01780 } 01781 } 01782 return 1; 01783 #ifndef TOLUA_RELEASE 01784 tolua_lerror: 01785 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err); 01786 return 0; 01787 #endif 01788 } 01789 #endif //#ifndef TOLUA_DISABLE 01790 01791 /* method: operator* of class MessageIterator */ 01792 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__mul00 01793 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__mul00(lua_State* tolua_S) 01794 { 01795 #ifndef TOLUA_RELEASE 01796 tolua_Error tolua_err; 01797 if ( 01798 !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) || 01799 !tolua_isnoobj(tolua_S,2,&tolua_err) 01800 ) 01801 goto tolua_lerror; 01802 else 01803 #endif 01804 { 01805 const fawkes::MessageQueue::MessageIterator* self = (const fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,1,0); 01806 #ifndef TOLUA_RELEASE 01807 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL); 01808 #endif 01809 { 01810 fawkes::Message* tolua_ret = (fawkes::Message*) self->operator*(); 01811 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message"); 01812 } 01813 } 01814 return 1; 01815 #ifndef TOLUA_RELEASE 01816 tolua_lerror: 01817 tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err); 01818 return 0; 01819 #endif 01820 } 01821 #endif //#ifndef TOLUA_DISABLE 01822 01823 /* method: id of class MessageIterator */ 01824 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_id00 01825 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_id00(lua_State* tolua_S) 01826 { 01827 #ifndef TOLUA_RELEASE 01828 tolua_Error tolua_err; 01829 if ( 01830 !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) || 01831 !tolua_isnoobj(tolua_S,2,&tolua_err) 01832 ) 01833 goto tolua_lerror; 01834 else 01835 #endif 01836 { 01837 const fawkes::MessageQueue::MessageIterator* self = (const fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,1,0); 01838 #ifndef TOLUA_RELEASE 01839 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL); 01840 #endif 01841 { 01842 unsigned int tolua_ret = (unsigned int) self->id(); 01843 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01844 } 01845 } 01846 return 1; 01847 #ifndef TOLUA_RELEASE 01848 tolua_lerror: 01849 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err); 01850 return 0; 01851 #endif 01852 } 01853 #endif //#ifndef TOLUA_DISABLE 01854 01855 /* method: append of class fawkes::MessageQueue */ 01856 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_append00 01857 static int tolua_fawkesinterface_fawkes_MessageQueue_append00(lua_State* tolua_S) 01858 { 01859 #ifndef TOLUA_RELEASE 01860 tolua_Error tolua_err; 01861 if ( 01862 !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 01863 !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) || 01864 !tolua_isnoobj(tolua_S,3,&tolua_err) 01865 ) 01866 goto tolua_lerror; 01867 else 01868 #endif 01869 { 01870 fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 01871 fawkes::Message* msg = ((fawkes::Message*) tolua_tousertype(tolua_S,2,0)); 01872 #ifndef TOLUA_RELEASE 01873 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'append'", NULL); 01874 #endif 01875 { 01876 self->append(msg); 01877 } 01878 } 01879 return 0; 01880 #ifndef TOLUA_RELEASE 01881 tolua_lerror: 01882 tolua_error(tolua_S,"#ferror in function 'append'.",&tolua_err); 01883 return 0; 01884 #endif 01885 } 01886 #endif //#ifndef TOLUA_DISABLE 01887 01888 /* method: remove of class fawkes::MessageQueue */ 01889 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_remove00 01890 static int tolua_fawkesinterface_fawkes_MessageQueue_remove00(lua_State* tolua_S) 01891 { 01892 #ifndef TOLUA_RELEASE 01893 tolua_Error tolua_err; 01894 if ( 01895 !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 01896 !tolua_isusertype(tolua_S,2,"const fawkes::Message",0,&tolua_err) || 01897 !tolua_isnoobj(tolua_S,3,&tolua_err) 01898 ) 01899 goto tolua_lerror; 01900 else 01901 #endif 01902 { 01903 fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 01904 const fawkes::Message* msg = ((const fawkes::Message*) tolua_tousertype(tolua_S,2,0)); 01905 #ifndef TOLUA_RELEASE 01906 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'", NULL); 01907 #endif 01908 { 01909 self->remove(msg); 01910 } 01911 } 01912 return 0; 01913 #ifndef TOLUA_RELEASE 01914 tolua_lerror: 01915 tolua_error(tolua_S,"#ferror in function 'remove'.",&tolua_err); 01916 return 0; 01917 #endif 01918 } 01919 #endif //#ifndef TOLUA_DISABLE 01920 01921 /* method: remove of class fawkes::MessageQueue */ 01922 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_remove01 01923 static int tolua_fawkesinterface_fawkes_MessageQueue_remove01(lua_State* tolua_S) 01924 { 01925 tolua_Error tolua_err; 01926 if ( 01927 !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 01928 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01929 !tolua_isnoobj(tolua_S,3,&tolua_err) 01930 ) 01931 goto tolua_lerror; 01932 else 01933 { 01934 fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 01935 unsigned const int msg_id = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 01936 #ifndef TOLUA_RELEASE 01937 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'", NULL); 01938 #endif 01939 { 01940 self->remove(msg_id); 01941 } 01942 } 01943 return 0; 01944 tolua_lerror: 01945 return tolua_fawkesinterface_fawkes_MessageQueue_remove00(tolua_S); 01946 } 01947 #endif //#ifndef TOLUA_DISABLE 01948 01949 /* method: insert_after of class fawkes::MessageQueue */ 01950 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_insert_after00 01951 static int tolua_fawkesinterface_fawkes_MessageQueue_insert_after00(lua_State* tolua_S) 01952 { 01953 #ifndef TOLUA_RELEASE 01954 tolua_Error tolua_err; 01955 if ( 01956 !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 01957 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err)) || 01958 !tolua_isusertype(tolua_S,3,"fawkes::Message",0,&tolua_err) || 01959 !tolua_isnoobj(tolua_S,4,&tolua_err) 01960 ) 01961 goto tolua_lerror; 01962 else 01963 #endif 01964 { 01965 fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 01966 const fawkes::MessageQueue::MessageIterator* it = ((const fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,2,0)); 01967 fawkes::Message* msg = ((fawkes::Message*) tolua_tousertype(tolua_S,3,0)); 01968 #ifndef TOLUA_RELEASE 01969 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insert_after'", NULL); 01970 #endif 01971 { 01972 self->insert_after(*it,msg); 01973 } 01974 } 01975 return 0; 01976 #ifndef TOLUA_RELEASE 01977 tolua_lerror: 01978 tolua_error(tolua_S,"#ferror in function 'insert_after'.",&tolua_err); 01979 return 0; 01980 #endif 01981 } 01982 #endif //#ifndef TOLUA_DISABLE 01983 01984 /* method: size of class fawkes::MessageQueue */ 01985 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_size00 01986 static int tolua_fawkesinterface_fawkes_MessageQueue_size00(lua_State* tolua_S) 01987 { 01988 #ifndef TOLUA_RELEASE 01989 tolua_Error tolua_err; 01990 if ( 01991 !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue",0,&tolua_err) || 01992 !tolua_isnoobj(tolua_S,2,&tolua_err) 01993 ) 01994 goto tolua_lerror; 01995 else 01996 #endif 01997 { 01998 const fawkes::MessageQueue* self = (const fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 01999 #ifndef TOLUA_RELEASE 02000 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL); 02001 #endif 02002 { 02003 unsigned int tolua_ret = (unsigned int) self->size(); 02004 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02005 } 02006 } 02007 return 1; 02008 #ifndef TOLUA_RELEASE 02009 tolua_lerror: 02010 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err); 02011 return 0; 02012 #endif 02013 } 02014 #endif //#ifndef TOLUA_DISABLE 02015 02016 /* method: flush of class fawkes::MessageQueue */ 02017 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_flush00 02018 static int tolua_fawkesinterface_fawkes_MessageQueue_flush00(lua_State* tolua_S) 02019 { 02020 #ifndef TOLUA_RELEASE 02021 tolua_Error tolua_err; 02022 if ( 02023 !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 02024 !tolua_isnoobj(tolua_S,2,&tolua_err) 02025 ) 02026 goto tolua_lerror; 02027 else 02028 #endif 02029 { 02030 fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 02031 #ifndef TOLUA_RELEASE 02032 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'flush'", NULL); 02033 #endif 02034 { 02035 self->flush(); 02036 } 02037 } 02038 return 0; 02039 #ifndef TOLUA_RELEASE 02040 tolua_lerror: 02041 tolua_error(tolua_S,"#ferror in function 'flush'.",&tolua_err); 02042 return 0; 02043 #endif 02044 } 02045 #endif //#ifndef TOLUA_DISABLE 02046 02047 /* method: empty of class fawkes::MessageQueue */ 02048 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_empty00 02049 static int tolua_fawkesinterface_fawkes_MessageQueue_empty00(lua_State* tolua_S) 02050 { 02051 #ifndef TOLUA_RELEASE 02052 tolua_Error tolua_err; 02053 if ( 02054 !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue",0,&tolua_err) || 02055 !tolua_isnoobj(tolua_S,2,&tolua_err) 02056 ) 02057 goto tolua_lerror; 02058 else 02059 #endif 02060 { 02061 const fawkes::MessageQueue* self = (const fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 02062 #ifndef TOLUA_RELEASE 02063 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'empty'", NULL); 02064 #endif 02065 { 02066 bool tolua_ret = (bool) self->empty(); 02067 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02068 } 02069 } 02070 return 1; 02071 #ifndef TOLUA_RELEASE 02072 tolua_lerror: 02073 tolua_error(tolua_S,"#ferror in function 'empty'.",&tolua_err); 02074 return 0; 02075 #endif 02076 } 02077 #endif //#ifndef TOLUA_DISABLE 02078 02079 /* method: lock of class fawkes::MessageQueue */ 02080 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_lock00 02081 static int tolua_fawkesinterface_fawkes_MessageQueue_lock00(lua_State* tolua_S) 02082 { 02083 #ifndef TOLUA_RELEASE 02084 tolua_Error tolua_err; 02085 if ( 02086 !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 02087 !tolua_isnoobj(tolua_S,2,&tolua_err) 02088 ) 02089 goto tolua_lerror; 02090 else 02091 #endif 02092 { 02093 fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 02094 #ifndef TOLUA_RELEASE 02095 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lock'", NULL); 02096 #endif 02097 { 02098 self->lock(); 02099 } 02100 } 02101 return 0; 02102 #ifndef TOLUA_RELEASE 02103 tolua_lerror: 02104 tolua_error(tolua_S,"#ferror in function 'lock'.",&tolua_err); 02105 return 0; 02106 #endif 02107 } 02108 #endif //#ifndef TOLUA_DISABLE 02109 02110 /* method: try_lock of class fawkes::MessageQueue */ 02111 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_try_lock00 02112 static int tolua_fawkesinterface_fawkes_MessageQueue_try_lock00(lua_State* tolua_S) 02113 { 02114 #ifndef TOLUA_RELEASE 02115 tolua_Error tolua_err; 02116 if ( 02117 !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 02118 !tolua_isnoobj(tolua_S,2,&tolua_err) 02119 ) 02120 goto tolua_lerror; 02121 else 02122 #endif 02123 { 02124 fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 02125 #ifndef TOLUA_RELEASE 02126 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'try_lock'", NULL); 02127 #endif 02128 { 02129 bool tolua_ret = (bool) self->try_lock(); 02130 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02131 } 02132 } 02133 return 1; 02134 #ifndef TOLUA_RELEASE 02135 tolua_lerror: 02136 tolua_error(tolua_S,"#ferror in function 'try_lock'.",&tolua_err); 02137 return 0; 02138 #endif 02139 } 02140 #endif //#ifndef TOLUA_DISABLE 02141 02142 /* method: unlock of class fawkes::MessageQueue */ 02143 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_unlock00 02144 static int tolua_fawkesinterface_fawkes_MessageQueue_unlock00(lua_State* tolua_S) 02145 { 02146 #ifndef TOLUA_RELEASE 02147 tolua_Error tolua_err; 02148 if ( 02149 !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 02150 !tolua_isnoobj(tolua_S,2,&tolua_err) 02151 ) 02152 goto tolua_lerror; 02153 else 02154 #endif 02155 { 02156 fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 02157 #ifndef TOLUA_RELEASE 02158 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unlock'", NULL); 02159 #endif 02160 { 02161 self->unlock(); 02162 } 02163 } 02164 return 0; 02165 #ifndef TOLUA_RELEASE 02166 tolua_lerror: 02167 tolua_error(tolua_S,"#ferror in function 'unlock'.",&tolua_err); 02168 return 0; 02169 #endif 02170 } 02171 #endif //#ifndef TOLUA_DISABLE 02172 02173 /* method: first of class fawkes::MessageQueue */ 02174 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_first00 02175 static int tolua_fawkesinterface_fawkes_MessageQueue_first00(lua_State* tolua_S) 02176 { 02177 #ifndef TOLUA_RELEASE 02178 tolua_Error tolua_err; 02179 if ( 02180 !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 02181 !tolua_isnoobj(tolua_S,2,&tolua_err) 02182 ) 02183 goto tolua_lerror; 02184 else 02185 #endif 02186 { 02187 fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 02188 #ifndef TOLUA_RELEASE 02189 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'first'", NULL); 02190 #endif 02191 { 02192 fawkes::Message* tolua_ret = (fawkes::Message*) self->first(); 02193 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message"); 02194 } 02195 } 02196 return 1; 02197 #ifndef TOLUA_RELEASE 02198 tolua_lerror: 02199 tolua_error(tolua_S,"#ferror in function 'first'.",&tolua_err); 02200 return 0; 02201 #endif 02202 } 02203 #endif //#ifndef TOLUA_DISABLE 02204 02205 /* method: pop of class fawkes::MessageQueue */ 02206 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_pop00 02207 static int tolua_fawkesinterface_fawkes_MessageQueue_pop00(lua_State* tolua_S) 02208 { 02209 #ifndef TOLUA_RELEASE 02210 tolua_Error tolua_err; 02211 if ( 02212 !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 02213 !tolua_isnoobj(tolua_S,2,&tolua_err) 02214 ) 02215 goto tolua_lerror; 02216 else 02217 #endif 02218 { 02219 fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 02220 #ifndef TOLUA_RELEASE 02221 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pop'", NULL); 02222 #endif 02223 { 02224 self->pop(); 02225 } 02226 } 02227 return 0; 02228 #ifndef TOLUA_RELEASE 02229 tolua_lerror: 02230 tolua_error(tolua_S,"#ferror in function 'pop'.",&tolua_err); 02231 return 0; 02232 #endif 02233 } 02234 #endif //#ifndef TOLUA_DISABLE 02235 02236 /* method: begin of class fawkes::MessageQueue */ 02237 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_begin00 02238 static int tolua_fawkesinterface_fawkes_MessageQueue_begin00(lua_State* tolua_S) 02239 { 02240 #ifndef TOLUA_RELEASE 02241 tolua_Error tolua_err; 02242 if ( 02243 !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 02244 !tolua_isnoobj(tolua_S,2,&tolua_err) 02245 ) 02246 goto tolua_lerror; 02247 else 02248 #endif 02249 { 02250 fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 02251 #ifndef TOLUA_RELEASE 02252 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'begin'", NULL); 02253 #endif 02254 { 02255 fawkes::MessageQueue::MessageIterator tolua_ret = (fawkes::MessageQueue::MessageIterator) self->begin(); 02256 { 02257 #ifdef __cplusplus 02258 void* tolua_obj = Mtolua_new((fawkes::MessageQueue::MessageIterator)(tolua_ret)); 02259 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::MessageQueue::MessageIterator"); 02260 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 02261 #else 02262 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::MessageQueue::MessageIterator)); 02263 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::MessageQueue::MessageIterator"); 02264 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 02265 #endif 02266 } 02267 } 02268 } 02269 return 1; 02270 #ifndef TOLUA_RELEASE 02271 tolua_lerror: 02272 tolua_error(tolua_S,"#ferror in function 'begin'.",&tolua_err); 02273 return 0; 02274 #endif 02275 } 02276 #endif //#ifndef TOLUA_DISABLE 02277 02278 /* method: end of class fawkes::MessageQueue */ 02279 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_end00 02280 static int tolua_fawkesinterface_fawkes_MessageQueue_end00(lua_State* tolua_S) 02281 { 02282 #ifndef TOLUA_RELEASE 02283 tolua_Error tolua_err; 02284 if ( 02285 !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) || 02286 !tolua_isnoobj(tolua_S,2,&tolua_err) 02287 ) 02288 goto tolua_lerror; 02289 else 02290 #endif 02291 { 02292 fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0); 02293 #ifndef TOLUA_RELEASE 02294 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'end'", NULL); 02295 #endif 02296 { 02297 fawkes::MessageQueue::MessageIterator tolua_ret = (fawkes::MessageQueue::MessageIterator) self->end(); 02298 { 02299 #ifdef __cplusplus 02300 void* tolua_obj = Mtolua_new((fawkes::MessageQueue::MessageIterator)(tolua_ret)); 02301 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::MessageQueue::MessageIterator"); 02302 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 02303 #else 02304 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::MessageQueue::MessageIterator)); 02305 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::MessageQueue::MessageIterator"); 02306 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 02307 #endif 02308 } 02309 } 02310 } 02311 return 1; 02312 #ifndef TOLUA_RELEASE 02313 tolua_lerror: 02314 tolua_error(tolua_S,"#ferror in function 'end'.",&tolua_err); 02315 return 0; 02316 #endif 02317 } 02318 #endif //#ifndef TOLUA_DISABLE 02319 02320 /* Open function */ 02321 TOLUA_API int tolua_fawkesinterface_open (lua_State* tolua_S) 02322 { 02323 tolua_open(tolua_S); 02324 tolua_reg_types(tolua_S); 02325 tolua_module(tolua_S,NULL,0); 02326 tolua_beginmodule(tolua_S,NULL); 02327 tolua_module(tolua_S,"fawkes",0); 02328 tolua_beginmodule(tolua_S,"fawkes"); 02329 tolua_cclass(tolua_S,"Interface","fawkes::Interface","",NULL); 02330 tolua_beginmodule(tolua_S,"Interface"); 02331 tolua_function(tolua_S,"oftype",tolua_fawkesinterface_fawkes_Interface_oftype00); 02332 tolua_function(tolua_S,"datachunk",tolua_fawkesinterface_fawkes_Interface_datachunk00); 02333 tolua_function(tolua_S,"datasize",tolua_fawkesinterface_fawkes_Interface_datasize00); 02334 tolua_function(tolua_S,"type",tolua_fawkesinterface_fawkes_Interface_type00); 02335 tolua_function(tolua_S,"id",tolua_fawkesinterface_fawkes_Interface_id00); 02336 tolua_function(tolua_S,"uid",tolua_fawkesinterface_fawkes_Interface_uid00); 02337 tolua_function(tolua_S,"serial",tolua_fawkesinterface_fawkes_Interface_serial00); 02338 tolua_function(tolua_S,"mem_serial",tolua_fawkesinterface_fawkes_Interface_mem_serial00); 02339 tolua_function(tolua_S,".eq",tolua_fawkesinterface_fawkes_Interface__eq00); 02340 tolua_function(tolua_S,"hash",tolua_fawkesinterface_fawkes_Interface_hash00); 02341 tolua_function(tolua_S,"hash_size",tolua_fawkesinterface_fawkes_Interface_hash_size00); 02342 tolua_function(tolua_S,"hash_printable",tolua_fawkesinterface_fawkes_Interface_hash_printable00); 02343 tolua_function(tolua_S,"is_writer",tolua_fawkesinterface_fawkes_Interface_is_writer00); 02344 tolua_function(tolua_S,"set_from_chunk",tolua_fawkesinterface_fawkes_Interface_set_from_chunk00); 02345 tolua_function(tolua_S,"create_message",tolua_fawkesinterface_fawkes_Interface_create_message00); 02346 tolua_function(tolua_S,"read",tolua_fawkesinterface_fawkes_Interface_read00); 02347 tolua_function(tolua_S,"write",tolua_fawkesinterface_fawkes_Interface_write00); 02348 tolua_function(tolua_S,"has_writer",tolua_fawkesinterface_fawkes_Interface_has_writer00); 02349 tolua_function(tolua_S,"num_readers",tolua_fawkesinterface_fawkes_Interface_num_readers00); 02350 tolua_function(tolua_S,"msgq_enqueue_copy",tolua_fawkesinterface_fawkes_Interface_msgq_enqueue_copy00); 02351 tolua_function(tolua_S,"msgq_remove",tolua_fawkesinterface_fawkes_Interface_msgq_remove00); 02352 tolua_function(tolua_S,"msgq_remove",tolua_fawkesinterface_fawkes_Interface_msgq_remove01); 02353 tolua_function(tolua_S,"msgq_size",tolua_fawkesinterface_fawkes_Interface_msgq_size00); 02354 tolua_function(tolua_S,"msgq_flush",tolua_fawkesinterface_fawkes_Interface_msgq_flush00); 02355 tolua_function(tolua_S,"msgq_lock",tolua_fawkesinterface_fawkes_Interface_msgq_lock00); 02356 tolua_function(tolua_S,"msgq_try_lock",tolua_fawkesinterface_fawkes_Interface_msgq_try_lock00); 02357 tolua_function(tolua_S,"msgq_unlock",tolua_fawkesinterface_fawkes_Interface_msgq_unlock00); 02358 tolua_function(tolua_S,"msgq_pop",tolua_fawkesinterface_fawkes_Interface_msgq_pop00); 02359 tolua_function(tolua_S,"msgq_first",tolua_fawkesinterface_fawkes_Interface_msgq_first00); 02360 tolua_function(tolua_S,"msgq_empty",tolua_fawkesinterface_fawkes_Interface_msgq_empty00); 02361 tolua_endmodule(tolua_S); 02362 tolua_endmodule(tolua_S); 02363 tolua_module(tolua_S,"fawkes",0); 02364 tolua_beginmodule(tolua_S,"fawkes"); 02365 #ifdef __cplusplus 02366 tolua_cclass(tolua_S,"Message","fawkes::Message","RefCount",tolua_collect_fawkes__Message); 02367 #else 02368 tolua_cclass(tolua_S,"Message","fawkes::Message","RefCount",NULL); 02369 #endif 02370 tolua_beginmodule(tolua_S,"Message"); 02371 tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_Message_new00); 02372 tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_Message_new00_local); 02373 tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_Message_new00_local); 02374 tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_Message_new01); 02375 tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_Message_new01_local); 02376 tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_Message_new01_local); 02377 tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_Message_new02); 02378 tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_Message_new02_local); 02379 tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_Message_new02_local); 02380 tolua_function(tolua_S,"sender_id",tolua_fawkesinterface_fawkes_Message_sender_id00); 02381 tolua_function(tolua_S,"sender_thread_name",tolua_fawkesinterface_fawkes_Message_sender_thread_name00); 02382 tolua_function(tolua_S,"interface",tolua_fawkesinterface_fawkes_Message_interface00); 02383 tolua_function(tolua_S,"type",tolua_fawkesinterface_fawkes_Message_type00); 02384 tolua_function(tolua_S,"datachunk",tolua_fawkesinterface_fawkes_Message_datachunk00); 02385 tolua_function(tolua_S,"datasize",tolua_fawkesinterface_fawkes_Message_datasize00); 02386 tolua_function(tolua_S,"set_from_chunk",tolua_fawkesinterface_fawkes_Message_set_from_chunk00); 02387 tolua_function(tolua_S,"ref",tolua_fawkesinterface_fawkes_Message_ref00); 02388 tolua_function(tolua_S,"unref",tolua_fawkesinterface_fawkes_Message_unref00); 02389 tolua_function(tolua_S,"refcount",tolua_fawkesinterface_fawkes_Message_refcount00); 02390 tolua_endmodule(tolua_S); 02391 tolua_endmodule(tolua_S); 02392 tolua_module(tolua_S,"fawkes",0); 02393 tolua_beginmodule(tolua_S,"fawkes"); 02394 #ifdef __cplusplus 02395 tolua_cclass(tolua_S,"MessageQueue","fawkes::MessageQueue","",tolua_collect_fawkes__MessageQueue); 02396 #else 02397 tolua_cclass(tolua_S,"MessageQueue","fawkes::MessageQueue","",NULL); 02398 #endif 02399 tolua_beginmodule(tolua_S,"MessageQueue"); 02400 tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_MessageQueue_new00); 02401 tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_MessageQueue_new00_local); 02402 tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_MessageQueue_new00_local); 02403 tolua_function(tolua_S,"delete",tolua_fawkesinterface_fawkes_MessageQueue_delete00); 02404 #ifdef __cplusplus 02405 tolua_cclass(tolua_S,"MessageIterator","fawkes::MessageQueue::MessageIterator","",tolua_collect_fawkes__MessageQueue__MessageIterator); 02406 #else 02407 tolua_cclass(tolua_S,"MessageIterator","fawkes::MessageQueue::MessageIterator","",NULL); 02408 #endif 02409 tolua_beginmodule(tolua_S,"MessageIterator"); 02410 tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00); 02411 tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local); 02412 tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local); 02413 tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01); 02414 tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local); 02415 tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local); 02416 tolua_function(tolua_S,".add",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__add00); 02417 tolua_function(tolua_S,".eq",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__eq00); 02418 tolua_function(tolua_S,".mul",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__mul00); 02419 tolua_function(tolua_S,"id",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_id00); 02420 tolua_endmodule(tolua_S); 02421 tolua_function(tolua_S,"append",tolua_fawkesinterface_fawkes_MessageQueue_append00); 02422 tolua_function(tolua_S,"remove",tolua_fawkesinterface_fawkes_MessageQueue_remove00); 02423 tolua_function(tolua_S,"remove",tolua_fawkesinterface_fawkes_MessageQueue_remove01); 02424 tolua_function(tolua_S,"insert_after",tolua_fawkesinterface_fawkes_MessageQueue_insert_after00); 02425 tolua_function(tolua_S,"size",tolua_fawkesinterface_fawkes_MessageQueue_size00); 02426 tolua_function(tolua_S,"flush",tolua_fawkesinterface_fawkes_MessageQueue_flush00); 02427 tolua_function(tolua_S,"empty",tolua_fawkesinterface_fawkes_MessageQueue_empty00); 02428 tolua_function(tolua_S,"lock",tolua_fawkesinterface_fawkes_MessageQueue_lock00); 02429 tolua_function(tolua_S,"try_lock",tolua_fawkesinterface_fawkes_MessageQueue_try_lock00); 02430 tolua_function(tolua_S,"unlock",tolua_fawkesinterface_fawkes_MessageQueue_unlock00); 02431 tolua_function(tolua_S,"first",tolua_fawkesinterface_fawkes_MessageQueue_first00); 02432 tolua_function(tolua_S,"pop",tolua_fawkesinterface_fawkes_MessageQueue_pop00); 02433 tolua_function(tolua_S,"begin",tolua_fawkesinterface_fawkes_MessageQueue_begin00); 02434 tolua_function(tolua_S,"end",tolua_fawkesinterface_fawkes_MessageQueue_end00); 02435 tolua_endmodule(tolua_S); 02436 tolua_endmodule(tolua_S); 02437 tolua_endmodule(tolua_S); 02438 return 1; 02439 } 02440 02441 02442 extern "C" { 02443 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501 02444 TOLUA_API int luaopen_fawkesinterface (lua_State* tolua_S) { 02445 return tolua_fawkesinterface_open(tolua_S); 02446 }; 02447 #endif 02448 } 02449 02450