Fawkes API
Fawkes Development Version
|
00001 /* 00002 ** Lua binding: interfaces_LocalizerControlInterface 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_interfaces_LocalizerControlInterface_open (lua_State* tolua_S); 00028 00029 #include <interfaces/LocalizerControlInterface.h> 00030 using namespace fawkes; 00031 00032 /* function to release collected object via destructor */ 00033 #ifdef __cplusplus 00034 00035 static int tolua_collect_fawkes__LocalizerControlInterface__ResetMessage (lua_State* tolua_S) 00036 { 00037 fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00038 Mtolua_delete(self); 00039 return 0; 00040 } 00041 #endif 00042 00043 00044 /* function to register type */ 00045 static void tolua_reg_types (lua_State* tolua_S) 00046 { 00047 tolua_usertype(tolua_S,"fawkes::LocalizerControlInterface::ResetMessage"); 00048 tolua_usertype(tolua_S,"Message"); 00049 tolua_usertype(tolua_S,"fawkes::LocalizerControlInterface"); 00050 tolua_usertype(tolua_S,"Interface"); 00051 } 00052 00053 /* method: new of class ResetMessage */ 00054 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00 00055 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00(lua_State* tolua_S) 00056 { 00057 #ifndef TOLUA_RELEASE 00058 tolua_Error tolua_err; 00059 if ( 00060 !tolua_isusertable(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00061 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00062 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00063 !tolua_isnumber(tolua_S,4,0,&tolua_err) || 00064 !tolua_isnumber(tolua_S,5,0,&tolua_err) || 00065 !tolua_isnoobj(tolua_S,6,&tolua_err) 00066 ) 00067 goto tolua_lerror; 00068 else 00069 #endif 00070 { 00071 float ini_x = ((float) tolua_tonumber(tolua_S,2,0)); 00072 float ini_y = ((float) tolua_tonumber(tolua_S,3,0)); 00073 float ini_ori = ((float) tolua_tonumber(tolua_S,4,0)); 00074 float ini_variance = ((float) tolua_tonumber(tolua_S,5,0)); 00075 { 00076 fawkes::LocalizerControlInterface::ResetMessage* tolua_ret = (fawkes::LocalizerControlInterface::ResetMessage*) Mtolua_new((fawkes::LocalizerControlInterface::ResetMessage)(ini_x,ini_y,ini_ori,ini_variance)); 00077 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::LocalizerControlInterface::ResetMessage"); 00078 } 00079 } 00080 return 1; 00081 #ifndef TOLUA_RELEASE 00082 tolua_lerror: 00083 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00084 return 0; 00085 #endif 00086 } 00087 #endif //#ifndef TOLUA_DISABLE 00088 00089 /* method: new_local of class ResetMessage */ 00090 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00_local 00091 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00_local(lua_State* tolua_S) 00092 { 00093 #ifndef TOLUA_RELEASE 00094 tolua_Error tolua_err; 00095 if ( 00096 !tolua_isusertable(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00097 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00098 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00099 !tolua_isnumber(tolua_S,4,0,&tolua_err) || 00100 !tolua_isnumber(tolua_S,5,0,&tolua_err) || 00101 !tolua_isnoobj(tolua_S,6,&tolua_err) 00102 ) 00103 goto tolua_lerror; 00104 else 00105 #endif 00106 { 00107 float ini_x = ((float) tolua_tonumber(tolua_S,2,0)); 00108 float ini_y = ((float) tolua_tonumber(tolua_S,3,0)); 00109 float ini_ori = ((float) tolua_tonumber(tolua_S,4,0)); 00110 float ini_variance = ((float) tolua_tonumber(tolua_S,5,0)); 00111 { 00112 fawkes::LocalizerControlInterface::ResetMessage* tolua_ret = (fawkes::LocalizerControlInterface::ResetMessage*) Mtolua_new((fawkes::LocalizerControlInterface::ResetMessage)(ini_x,ini_y,ini_ori,ini_variance)); 00113 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::LocalizerControlInterface::ResetMessage"); 00114 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00115 } 00116 } 00117 return 1; 00118 #ifndef TOLUA_RELEASE 00119 tolua_lerror: 00120 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00121 return 0; 00122 #endif 00123 } 00124 #endif //#ifndef TOLUA_DISABLE 00125 00126 /* method: new of class ResetMessage */ 00127 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new01 00128 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new01(lua_State* tolua_S) 00129 { 00130 tolua_Error tolua_err; 00131 if ( 00132 !tolua_isusertable(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00133 !tolua_isnoobj(tolua_S,2,&tolua_err) 00134 ) 00135 goto tolua_lerror; 00136 else 00137 { 00138 { 00139 fawkes::LocalizerControlInterface::ResetMessage* tolua_ret = (fawkes::LocalizerControlInterface::ResetMessage*) Mtolua_new((fawkes::LocalizerControlInterface::ResetMessage)()); 00140 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::LocalizerControlInterface::ResetMessage"); 00141 } 00142 } 00143 return 1; 00144 tolua_lerror: 00145 return tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00(tolua_S); 00146 } 00147 #endif //#ifndef TOLUA_DISABLE 00148 00149 /* method: new_local of class ResetMessage */ 00150 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new01_local 00151 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new01_local(lua_State* tolua_S) 00152 { 00153 tolua_Error tolua_err; 00154 if ( 00155 !tolua_isusertable(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00156 !tolua_isnoobj(tolua_S,2,&tolua_err) 00157 ) 00158 goto tolua_lerror; 00159 else 00160 { 00161 { 00162 fawkes::LocalizerControlInterface::ResetMessage* tolua_ret = (fawkes::LocalizerControlInterface::ResetMessage*) Mtolua_new((fawkes::LocalizerControlInterface::ResetMessage)()); 00163 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::LocalizerControlInterface::ResetMessage"); 00164 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00165 } 00166 } 00167 return 1; 00168 tolua_lerror: 00169 return tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00_local(tolua_S); 00170 } 00171 #endif //#ifndef TOLUA_DISABLE 00172 00173 /* method: delete of class ResetMessage */ 00174 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_delete00 00175 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_delete00(lua_State* tolua_S) 00176 { 00177 #ifndef TOLUA_RELEASE 00178 tolua_Error tolua_err; 00179 if ( 00180 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00181 !tolua_isnoobj(tolua_S,2,&tolua_err) 00182 ) 00183 goto tolua_lerror; 00184 else 00185 #endif 00186 { 00187 fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00188 #ifndef TOLUA_RELEASE 00189 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00190 #endif 00191 Mtolua_delete(self); 00192 } 00193 return 0; 00194 #ifndef TOLUA_RELEASE 00195 tolua_lerror: 00196 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00197 return 0; 00198 #endif 00199 } 00200 #endif //#ifndef TOLUA_DISABLE 00201 00202 /* method: x of class ResetMessage */ 00203 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_x00 00204 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_x00(lua_State* tolua_S) 00205 { 00206 #ifndef TOLUA_RELEASE 00207 tolua_Error tolua_err; 00208 if ( 00209 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00210 !tolua_isnoobj(tolua_S,2,&tolua_err) 00211 ) 00212 goto tolua_lerror; 00213 else 00214 #endif 00215 { 00216 fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00217 #ifndef TOLUA_RELEASE 00218 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL); 00219 #endif 00220 { 00221 float tolua_ret = (float) self->x(); 00222 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00223 } 00224 } 00225 return 1; 00226 #ifndef TOLUA_RELEASE 00227 tolua_lerror: 00228 tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err); 00229 return 0; 00230 #endif 00231 } 00232 #endif //#ifndef TOLUA_DISABLE 00233 00234 /* method: set_x of class ResetMessage */ 00235 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_x00 00236 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_x00(lua_State* tolua_S) 00237 { 00238 #ifndef TOLUA_RELEASE 00239 tolua_Error tolua_err; 00240 if ( 00241 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00242 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00243 !tolua_isnoobj(tolua_S,3,&tolua_err) 00244 ) 00245 goto tolua_lerror; 00246 else 00247 #endif 00248 { 00249 fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00250 const float new_x = ((const float) tolua_tonumber(tolua_S,2,0)); 00251 #ifndef TOLUA_RELEASE 00252 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_x'", NULL); 00253 #endif 00254 { 00255 self->set_x(new_x); 00256 } 00257 } 00258 return 0; 00259 #ifndef TOLUA_RELEASE 00260 tolua_lerror: 00261 tolua_error(tolua_S,"#ferror in function 'set_x'.",&tolua_err); 00262 return 0; 00263 #endif 00264 } 00265 #endif //#ifndef TOLUA_DISABLE 00266 00267 /* method: maxlenof_x of class ResetMessage */ 00268 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_x00 00269 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_x00(lua_State* tolua_S) 00270 { 00271 #ifndef TOLUA_RELEASE 00272 tolua_Error tolua_err; 00273 if ( 00274 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00275 !tolua_isnoobj(tolua_S,2,&tolua_err) 00276 ) 00277 goto tolua_lerror; 00278 else 00279 #endif 00280 { 00281 const fawkes::LocalizerControlInterface::ResetMessage* self = (const fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00282 #ifndef TOLUA_RELEASE 00283 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_x'", NULL); 00284 #endif 00285 { 00286 int tolua_ret = (int) self->maxlenof_x(); 00287 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00288 } 00289 } 00290 return 1; 00291 #ifndef TOLUA_RELEASE 00292 tolua_lerror: 00293 tolua_error(tolua_S,"#ferror in function 'maxlenof_x'.",&tolua_err); 00294 return 0; 00295 #endif 00296 } 00297 #endif //#ifndef TOLUA_DISABLE 00298 00299 /* method: y of class ResetMessage */ 00300 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_y00 00301 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_y00(lua_State* tolua_S) 00302 { 00303 #ifndef TOLUA_RELEASE 00304 tolua_Error tolua_err; 00305 if ( 00306 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00307 !tolua_isnoobj(tolua_S,2,&tolua_err) 00308 ) 00309 goto tolua_lerror; 00310 else 00311 #endif 00312 { 00313 fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00314 #ifndef TOLUA_RELEASE 00315 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL); 00316 #endif 00317 { 00318 float tolua_ret = (float) self->y(); 00319 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00320 } 00321 } 00322 return 1; 00323 #ifndef TOLUA_RELEASE 00324 tolua_lerror: 00325 tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err); 00326 return 0; 00327 #endif 00328 } 00329 #endif //#ifndef TOLUA_DISABLE 00330 00331 /* method: set_y of class ResetMessage */ 00332 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_y00 00333 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_y00(lua_State* tolua_S) 00334 { 00335 #ifndef TOLUA_RELEASE 00336 tolua_Error tolua_err; 00337 if ( 00338 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00339 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00340 !tolua_isnoobj(tolua_S,3,&tolua_err) 00341 ) 00342 goto tolua_lerror; 00343 else 00344 #endif 00345 { 00346 fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00347 const float new_y = ((const float) tolua_tonumber(tolua_S,2,0)); 00348 #ifndef TOLUA_RELEASE 00349 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_y'", NULL); 00350 #endif 00351 { 00352 self->set_y(new_y); 00353 } 00354 } 00355 return 0; 00356 #ifndef TOLUA_RELEASE 00357 tolua_lerror: 00358 tolua_error(tolua_S,"#ferror in function 'set_y'.",&tolua_err); 00359 return 0; 00360 #endif 00361 } 00362 #endif //#ifndef TOLUA_DISABLE 00363 00364 /* method: maxlenof_y of class ResetMessage */ 00365 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_y00 00366 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_y00(lua_State* tolua_S) 00367 { 00368 #ifndef TOLUA_RELEASE 00369 tolua_Error tolua_err; 00370 if ( 00371 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00372 !tolua_isnoobj(tolua_S,2,&tolua_err) 00373 ) 00374 goto tolua_lerror; 00375 else 00376 #endif 00377 { 00378 const fawkes::LocalizerControlInterface::ResetMessage* self = (const fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00379 #ifndef TOLUA_RELEASE 00380 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_y'", NULL); 00381 #endif 00382 { 00383 int tolua_ret = (int) self->maxlenof_y(); 00384 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00385 } 00386 } 00387 return 1; 00388 #ifndef TOLUA_RELEASE 00389 tolua_lerror: 00390 tolua_error(tolua_S,"#ferror in function 'maxlenof_y'.",&tolua_err); 00391 return 0; 00392 #endif 00393 } 00394 #endif //#ifndef TOLUA_DISABLE 00395 00396 /* method: ori of class ResetMessage */ 00397 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_ori00 00398 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_ori00(lua_State* tolua_S) 00399 { 00400 #ifndef TOLUA_RELEASE 00401 tolua_Error tolua_err; 00402 if ( 00403 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00404 !tolua_isnoobj(tolua_S,2,&tolua_err) 00405 ) 00406 goto tolua_lerror; 00407 else 00408 #endif 00409 { 00410 fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00411 #ifndef TOLUA_RELEASE 00412 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ori'", NULL); 00413 #endif 00414 { 00415 float tolua_ret = (float) self->ori(); 00416 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00417 } 00418 } 00419 return 1; 00420 #ifndef TOLUA_RELEASE 00421 tolua_lerror: 00422 tolua_error(tolua_S,"#ferror in function 'ori'.",&tolua_err); 00423 return 0; 00424 #endif 00425 } 00426 #endif //#ifndef TOLUA_DISABLE 00427 00428 /* method: set_ori of class ResetMessage */ 00429 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_ori00 00430 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_ori00(lua_State* tolua_S) 00431 { 00432 #ifndef TOLUA_RELEASE 00433 tolua_Error tolua_err; 00434 if ( 00435 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00436 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00437 !tolua_isnoobj(tolua_S,3,&tolua_err) 00438 ) 00439 goto tolua_lerror; 00440 else 00441 #endif 00442 { 00443 fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00444 const float new_ori = ((const float) tolua_tonumber(tolua_S,2,0)); 00445 #ifndef TOLUA_RELEASE 00446 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_ori'", NULL); 00447 #endif 00448 { 00449 self->set_ori(new_ori); 00450 } 00451 } 00452 return 0; 00453 #ifndef TOLUA_RELEASE 00454 tolua_lerror: 00455 tolua_error(tolua_S,"#ferror in function 'set_ori'.",&tolua_err); 00456 return 0; 00457 #endif 00458 } 00459 #endif //#ifndef TOLUA_DISABLE 00460 00461 /* method: maxlenof_ori of class ResetMessage */ 00462 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_ori00 00463 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_ori00(lua_State* tolua_S) 00464 { 00465 #ifndef TOLUA_RELEASE 00466 tolua_Error tolua_err; 00467 if ( 00468 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00469 !tolua_isnoobj(tolua_S,2,&tolua_err) 00470 ) 00471 goto tolua_lerror; 00472 else 00473 #endif 00474 { 00475 const fawkes::LocalizerControlInterface::ResetMessage* self = (const fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00476 #ifndef TOLUA_RELEASE 00477 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_ori'", NULL); 00478 #endif 00479 { 00480 int tolua_ret = (int) self->maxlenof_ori(); 00481 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00482 } 00483 } 00484 return 1; 00485 #ifndef TOLUA_RELEASE 00486 tolua_lerror: 00487 tolua_error(tolua_S,"#ferror in function 'maxlenof_ori'.",&tolua_err); 00488 return 0; 00489 #endif 00490 } 00491 #endif //#ifndef TOLUA_DISABLE 00492 00493 /* method: variance of class ResetMessage */ 00494 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_variance00 00495 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_variance00(lua_State* tolua_S) 00496 { 00497 #ifndef TOLUA_RELEASE 00498 tolua_Error tolua_err; 00499 if ( 00500 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00501 !tolua_isnoobj(tolua_S,2,&tolua_err) 00502 ) 00503 goto tolua_lerror; 00504 else 00505 #endif 00506 { 00507 fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00508 #ifndef TOLUA_RELEASE 00509 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'variance'", NULL); 00510 #endif 00511 { 00512 float tolua_ret = (float) self->variance(); 00513 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00514 } 00515 } 00516 return 1; 00517 #ifndef TOLUA_RELEASE 00518 tolua_lerror: 00519 tolua_error(tolua_S,"#ferror in function 'variance'.",&tolua_err); 00520 return 0; 00521 #endif 00522 } 00523 #endif //#ifndef TOLUA_DISABLE 00524 00525 /* method: set_variance of class ResetMessage */ 00526 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_variance00 00527 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_variance00(lua_State* tolua_S) 00528 { 00529 #ifndef TOLUA_RELEASE 00530 tolua_Error tolua_err; 00531 if ( 00532 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00533 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00534 !tolua_isnoobj(tolua_S,3,&tolua_err) 00535 ) 00536 goto tolua_lerror; 00537 else 00538 #endif 00539 { 00540 fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00541 const float new_variance = ((const float) tolua_tonumber(tolua_S,2,0)); 00542 #ifndef TOLUA_RELEASE 00543 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_variance'", NULL); 00544 #endif 00545 { 00546 self->set_variance(new_variance); 00547 } 00548 } 00549 return 0; 00550 #ifndef TOLUA_RELEASE 00551 tolua_lerror: 00552 tolua_error(tolua_S,"#ferror in function 'set_variance'.",&tolua_err); 00553 return 0; 00554 #endif 00555 } 00556 #endif //#ifndef TOLUA_DISABLE 00557 00558 /* method: maxlenof_variance of class ResetMessage */ 00559 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_variance00 00560 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_variance00(lua_State* tolua_S) 00561 { 00562 #ifndef TOLUA_RELEASE 00563 tolua_Error tolua_err; 00564 if ( 00565 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) || 00566 !tolua_isnoobj(tolua_S,2,&tolua_err) 00567 ) 00568 goto tolua_lerror; 00569 else 00570 #endif 00571 { 00572 const fawkes::LocalizerControlInterface::ResetMessage* self = (const fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00573 #ifndef TOLUA_RELEASE 00574 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_variance'", NULL); 00575 #endif 00576 { 00577 int tolua_ret = (int) self->maxlenof_variance(); 00578 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00579 } 00580 } 00581 return 1; 00582 #ifndef TOLUA_RELEASE 00583 tolua_lerror: 00584 tolua_error(tolua_S,"#ferror in function 'maxlenof_variance'.",&tolua_err); 00585 return 0; 00586 #endif 00587 } 00588 #endif //#ifndef TOLUA_DISABLE 00589 00590 /* method: map_name of class fawkes::LocalizerControlInterface */ 00591 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_map_name00 00592 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_map_name00(lua_State* tolua_S) 00593 { 00594 #ifndef TOLUA_RELEASE 00595 tolua_Error tolua_err; 00596 if ( 00597 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 00598 !tolua_isnoobj(tolua_S,2,&tolua_err) 00599 ) 00600 goto tolua_lerror; 00601 else 00602 #endif 00603 { 00604 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 00605 #ifndef TOLUA_RELEASE 00606 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'map_name'", NULL); 00607 #endif 00608 { 00609 char* tolua_ret = (char*) self->map_name(); 00610 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00611 } 00612 } 00613 return 1; 00614 #ifndef TOLUA_RELEASE 00615 tolua_lerror: 00616 tolua_error(tolua_S,"#ferror in function 'map_name'.",&tolua_err); 00617 return 0; 00618 #endif 00619 } 00620 #endif //#ifndef TOLUA_DISABLE 00621 00622 /* method: set_map_name of class fawkes::LocalizerControlInterface */ 00623 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_set_map_name00 00624 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_set_map_name00(lua_State* tolua_S) 00625 { 00626 #ifndef TOLUA_RELEASE 00627 tolua_Error tolua_err; 00628 if ( 00629 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 00630 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00631 !tolua_isnoobj(tolua_S,3,&tolua_err) 00632 ) 00633 goto tolua_lerror; 00634 else 00635 #endif 00636 { 00637 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 00638 const char* new_map_name = ((const char*) tolua_tostring(tolua_S,2,0)); 00639 #ifndef TOLUA_RELEASE 00640 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_map_name'", NULL); 00641 #endif 00642 { 00643 self->set_map_name(new_map_name); 00644 } 00645 } 00646 return 0; 00647 #ifndef TOLUA_RELEASE 00648 tolua_lerror: 00649 tolua_error(tolua_S,"#ferror in function 'set_map_name'.",&tolua_err); 00650 return 0; 00651 #endif 00652 } 00653 #endif //#ifndef TOLUA_DISABLE 00654 00655 /* method: maxlenof_map_name of class fawkes::LocalizerControlInterface */ 00656 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_maxlenof_map_name00 00657 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_maxlenof_map_name00(lua_State* tolua_S) 00658 { 00659 #ifndef TOLUA_RELEASE 00660 tolua_Error tolua_err; 00661 if ( 00662 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 00663 !tolua_isnoobj(tolua_S,2,&tolua_err) 00664 ) 00665 goto tolua_lerror; 00666 else 00667 #endif 00668 { 00669 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 00670 #ifndef TOLUA_RELEASE 00671 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_map_name'", NULL); 00672 #endif 00673 { 00674 int tolua_ret = (int) self->maxlenof_map_name(); 00675 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00676 } 00677 } 00678 return 1; 00679 #ifndef TOLUA_RELEASE 00680 tolua_lerror: 00681 tolua_error(tolua_S,"#ferror in function 'maxlenof_map_name'.",&tolua_err); 00682 return 0; 00683 #endif 00684 } 00685 #endif //#ifndef TOLUA_DISABLE 00686 00687 /* method: oftype of class fawkes::LocalizerControlInterface */ 00688 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_oftype00 00689 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_oftype00(lua_State* tolua_S) 00690 { 00691 #ifndef TOLUA_RELEASE 00692 tolua_Error tolua_err; 00693 if ( 00694 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 00695 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00696 !tolua_isnoobj(tolua_S,3,&tolua_err) 00697 ) 00698 goto tolua_lerror; 00699 else 00700 #endif 00701 { 00702 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 00703 const char* interface_type = ((const char*) tolua_tostring(tolua_S,2,0)); 00704 #ifndef TOLUA_RELEASE 00705 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL); 00706 #endif 00707 { 00708 bool tolua_ret = (bool) self->oftype(interface_type); 00709 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00710 } 00711 } 00712 return 1; 00713 #ifndef TOLUA_RELEASE 00714 tolua_lerror: 00715 tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err); 00716 return 0; 00717 #endif 00718 } 00719 #endif //#ifndef TOLUA_DISABLE 00720 00721 /* method: datachunk of class fawkes::LocalizerControlInterface */ 00722 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_datachunk00 00723 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_datachunk00(lua_State* tolua_S) 00724 { 00725 #ifndef TOLUA_RELEASE 00726 tolua_Error tolua_err; 00727 if ( 00728 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 00729 !tolua_isnoobj(tolua_S,2,&tolua_err) 00730 ) 00731 goto tolua_lerror; 00732 else 00733 #endif 00734 { 00735 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 00736 #ifndef TOLUA_RELEASE 00737 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL); 00738 #endif 00739 { 00740 const void* tolua_ret = (const void*) self->datachunk(); 00741 tolua_pushuserdata(tolua_S,(void*)tolua_ret); 00742 } 00743 } 00744 return 1; 00745 #ifndef TOLUA_RELEASE 00746 tolua_lerror: 00747 tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err); 00748 return 0; 00749 #endif 00750 } 00751 #endif //#ifndef TOLUA_DISABLE 00752 00753 /* method: datasize of class fawkes::LocalizerControlInterface */ 00754 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_datasize00 00755 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_datasize00(lua_State* tolua_S) 00756 { 00757 #ifndef TOLUA_RELEASE 00758 tolua_Error tolua_err; 00759 if ( 00760 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 00761 !tolua_isnoobj(tolua_S,2,&tolua_err) 00762 ) 00763 goto tolua_lerror; 00764 else 00765 #endif 00766 { 00767 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 00768 #ifndef TOLUA_RELEASE 00769 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL); 00770 #endif 00771 { 00772 unsigned int tolua_ret = (unsigned int) self->datasize(); 00773 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00774 } 00775 } 00776 return 1; 00777 #ifndef TOLUA_RELEASE 00778 tolua_lerror: 00779 tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err); 00780 return 0; 00781 #endif 00782 } 00783 #endif //#ifndef TOLUA_DISABLE 00784 00785 /* method: type of class fawkes::LocalizerControlInterface */ 00786 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_type00 00787 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_type00(lua_State* tolua_S) 00788 { 00789 #ifndef TOLUA_RELEASE 00790 tolua_Error tolua_err; 00791 if ( 00792 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 00793 !tolua_isnoobj(tolua_S,2,&tolua_err) 00794 ) 00795 goto tolua_lerror; 00796 else 00797 #endif 00798 { 00799 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 00800 #ifndef TOLUA_RELEASE 00801 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL); 00802 #endif 00803 { 00804 const char* tolua_ret = (const char*) self->type(); 00805 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00806 } 00807 } 00808 return 1; 00809 #ifndef TOLUA_RELEASE 00810 tolua_lerror: 00811 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err); 00812 return 0; 00813 #endif 00814 } 00815 #endif //#ifndef TOLUA_DISABLE 00816 00817 /* method: id of class fawkes::LocalizerControlInterface */ 00818 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_id00 00819 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_id00(lua_State* tolua_S) 00820 { 00821 #ifndef TOLUA_RELEASE 00822 tolua_Error tolua_err; 00823 if ( 00824 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 00825 !tolua_isnoobj(tolua_S,2,&tolua_err) 00826 ) 00827 goto tolua_lerror; 00828 else 00829 #endif 00830 { 00831 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 00832 #ifndef TOLUA_RELEASE 00833 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL); 00834 #endif 00835 { 00836 const char* tolua_ret = (const char*) self->id(); 00837 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00838 } 00839 } 00840 return 1; 00841 #ifndef TOLUA_RELEASE 00842 tolua_lerror: 00843 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err); 00844 return 0; 00845 #endif 00846 } 00847 #endif //#ifndef TOLUA_DISABLE 00848 00849 /* method: uid of class fawkes::LocalizerControlInterface */ 00850 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_uid00 00851 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_uid00(lua_State* tolua_S) 00852 { 00853 #ifndef TOLUA_RELEASE 00854 tolua_Error tolua_err; 00855 if ( 00856 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 00857 !tolua_isnoobj(tolua_S,2,&tolua_err) 00858 ) 00859 goto tolua_lerror; 00860 else 00861 #endif 00862 { 00863 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 00864 #ifndef TOLUA_RELEASE 00865 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL); 00866 #endif 00867 { 00868 const char* tolua_ret = (const char*) self->uid(); 00869 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00870 } 00871 } 00872 return 1; 00873 #ifndef TOLUA_RELEASE 00874 tolua_lerror: 00875 tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err); 00876 return 0; 00877 #endif 00878 } 00879 #endif //#ifndef TOLUA_DISABLE 00880 00881 /* method: serial of class fawkes::LocalizerControlInterface */ 00882 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_serial00 00883 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_serial00(lua_State* tolua_S) 00884 { 00885 #ifndef TOLUA_RELEASE 00886 tolua_Error tolua_err; 00887 if ( 00888 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 00889 !tolua_isnoobj(tolua_S,2,&tolua_err) 00890 ) 00891 goto tolua_lerror; 00892 else 00893 #endif 00894 { 00895 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 00896 #ifndef TOLUA_RELEASE 00897 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL); 00898 #endif 00899 { 00900 unsigned int tolua_ret = (unsigned int) self->serial(); 00901 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00902 } 00903 } 00904 return 1; 00905 #ifndef TOLUA_RELEASE 00906 tolua_lerror: 00907 tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err); 00908 return 0; 00909 #endif 00910 } 00911 #endif //#ifndef TOLUA_DISABLE 00912 00913 /* method: mem_serial of class fawkes::LocalizerControlInterface */ 00914 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_mem_serial00 00915 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_mem_serial00(lua_State* tolua_S) 00916 { 00917 #ifndef TOLUA_RELEASE 00918 tolua_Error tolua_err; 00919 if ( 00920 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 00921 !tolua_isnoobj(tolua_S,2,&tolua_err) 00922 ) 00923 goto tolua_lerror; 00924 else 00925 #endif 00926 { 00927 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 00928 #ifndef TOLUA_RELEASE 00929 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL); 00930 #endif 00931 { 00932 unsigned int tolua_ret = (unsigned int) self->mem_serial(); 00933 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00934 } 00935 } 00936 return 1; 00937 #ifndef TOLUA_RELEASE 00938 tolua_lerror: 00939 tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err); 00940 return 0; 00941 #endif 00942 } 00943 #endif //#ifndef TOLUA_DISABLE 00944 00945 /* method: operator== of class fawkes::LocalizerControlInterface */ 00946 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface__eq00 00947 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface__eq00(lua_State* tolua_S) 00948 { 00949 #ifndef TOLUA_RELEASE 00950 tolua_Error tolua_err; 00951 if ( 00952 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 00953 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) || 00954 !tolua_isnoobj(tolua_S,3,&tolua_err) 00955 ) 00956 goto tolua_lerror; 00957 else 00958 #endif 00959 { 00960 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 00961 Interface* comp = ((Interface*) tolua_tousertype(tolua_S,2,0)); 00962 #ifndef TOLUA_RELEASE 00963 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL); 00964 #endif 00965 { 00966 bool tolua_ret = (bool) self->operator==(*comp); 00967 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00968 } 00969 } 00970 return 1; 00971 #ifndef TOLUA_RELEASE 00972 tolua_lerror: 00973 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err); 00974 return 0; 00975 #endif 00976 } 00977 #endif //#ifndef TOLUA_DISABLE 00978 00979 /* method: hash of class fawkes::LocalizerControlInterface */ 00980 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash00 00981 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash00(lua_State* tolua_S) 00982 { 00983 #ifndef TOLUA_RELEASE 00984 tolua_Error tolua_err; 00985 if ( 00986 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 00987 !tolua_isnoobj(tolua_S,2,&tolua_err) 00988 ) 00989 goto tolua_lerror; 00990 else 00991 #endif 00992 { 00993 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 00994 #ifndef TOLUA_RELEASE 00995 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL); 00996 #endif 00997 { 00998 unsigned const char* tolua_ret = ( unsigned const char*) self->hash(); 00999 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01000 } 01001 } 01002 return 1; 01003 #ifndef TOLUA_RELEASE 01004 tolua_lerror: 01005 tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err); 01006 return 0; 01007 #endif 01008 } 01009 #endif //#ifndef TOLUA_DISABLE 01010 01011 /* method: hash_size of class fawkes::LocalizerControlInterface */ 01012 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash_size00 01013 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash_size00(lua_State* tolua_S) 01014 { 01015 #ifndef TOLUA_RELEASE 01016 tolua_Error tolua_err; 01017 if ( 01018 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 01019 !tolua_isnoobj(tolua_S,2,&tolua_err) 01020 ) 01021 goto tolua_lerror; 01022 else 01023 #endif 01024 { 01025 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01026 #ifndef TOLUA_RELEASE 01027 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL); 01028 #endif 01029 { 01030 int tolua_ret = (int) self->hash_size(); 01031 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01032 } 01033 } 01034 return 1; 01035 #ifndef TOLUA_RELEASE 01036 tolua_lerror: 01037 tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err); 01038 return 0; 01039 #endif 01040 } 01041 #endif //#ifndef TOLUA_DISABLE 01042 01043 /* method: hash_printable of class fawkes::LocalizerControlInterface */ 01044 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash_printable00 01045 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash_printable00(lua_State* tolua_S) 01046 { 01047 #ifndef TOLUA_RELEASE 01048 tolua_Error tolua_err; 01049 if ( 01050 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 01051 !tolua_isnoobj(tolua_S,2,&tolua_err) 01052 ) 01053 goto tolua_lerror; 01054 else 01055 #endif 01056 { 01057 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01058 #ifndef TOLUA_RELEASE 01059 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL); 01060 #endif 01061 { 01062 const char* tolua_ret = (const char*) self->hash_printable(); 01063 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01064 } 01065 } 01066 return 1; 01067 #ifndef TOLUA_RELEASE 01068 tolua_lerror: 01069 tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err); 01070 return 0; 01071 #endif 01072 } 01073 #endif //#ifndef TOLUA_DISABLE 01074 01075 /* method: is_writer of class fawkes::LocalizerControlInterface */ 01076 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_is_writer00 01077 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_is_writer00(lua_State* tolua_S) 01078 { 01079 #ifndef TOLUA_RELEASE 01080 tolua_Error tolua_err; 01081 if ( 01082 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 01083 !tolua_isnoobj(tolua_S,2,&tolua_err) 01084 ) 01085 goto tolua_lerror; 01086 else 01087 #endif 01088 { 01089 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01090 #ifndef TOLUA_RELEASE 01091 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL); 01092 #endif 01093 { 01094 bool tolua_ret = (bool) self->is_writer(); 01095 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01096 } 01097 } 01098 return 1; 01099 #ifndef TOLUA_RELEASE 01100 tolua_lerror: 01101 tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err); 01102 return 0; 01103 #endif 01104 } 01105 #endif //#ifndef TOLUA_DISABLE 01106 01107 /* method: set_from_chunk of class fawkes::LocalizerControlInterface */ 01108 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_set_from_chunk00 01109 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_set_from_chunk00(lua_State* tolua_S) 01110 { 01111 #ifndef TOLUA_RELEASE 01112 tolua_Error tolua_err; 01113 if ( 01114 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 01115 !tolua_isuserdata(tolua_S,2,0,&tolua_err) || 01116 !tolua_isnoobj(tolua_S,3,&tolua_err) 01117 ) 01118 goto tolua_lerror; 01119 else 01120 #endif 01121 { 01122 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01123 void* chunk = ((void*) tolua_touserdata(tolua_S,2,0)); 01124 #ifndef TOLUA_RELEASE 01125 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL); 01126 #endif 01127 { 01128 self->set_from_chunk(chunk); 01129 } 01130 } 01131 return 0; 01132 #ifndef TOLUA_RELEASE 01133 tolua_lerror: 01134 tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err); 01135 return 0; 01136 #endif 01137 } 01138 #endif //#ifndef TOLUA_DISABLE 01139 01140 /* method: create_message of class fawkes::LocalizerControlInterface */ 01141 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_create_message00 01142 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_create_message00(lua_State* tolua_S) 01143 { 01144 #ifndef TOLUA_RELEASE 01145 tolua_Error tolua_err; 01146 if ( 01147 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 01148 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01149 !tolua_isnoobj(tolua_S,3,&tolua_err) 01150 ) 01151 goto tolua_lerror; 01152 else 01153 #endif 01154 { 01155 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01156 const char* type = ((const char*) tolua_tostring(tolua_S,2,0)); 01157 #ifndef TOLUA_RELEASE 01158 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL); 01159 #endif 01160 { 01161 Message* tolua_ret = (Message*) self->create_message(type); 01162 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 01163 } 01164 } 01165 return 1; 01166 #ifndef TOLUA_RELEASE 01167 tolua_lerror: 01168 tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err); 01169 return 0; 01170 #endif 01171 } 01172 #endif //#ifndef TOLUA_DISABLE 01173 01174 /* method: read of class fawkes::LocalizerControlInterface */ 01175 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_read00 01176 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_read00(lua_State* tolua_S) 01177 { 01178 #ifndef TOLUA_RELEASE 01179 tolua_Error tolua_err; 01180 if ( 01181 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 01182 !tolua_isnoobj(tolua_S,2,&tolua_err) 01183 ) 01184 goto tolua_lerror; 01185 else 01186 #endif 01187 { 01188 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01189 #ifndef TOLUA_RELEASE 01190 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL); 01191 #endif 01192 { 01193 self->read(); 01194 } 01195 } 01196 return 0; 01197 #ifndef TOLUA_RELEASE 01198 tolua_lerror: 01199 tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err); 01200 return 0; 01201 #endif 01202 } 01203 #endif //#ifndef TOLUA_DISABLE 01204 01205 /* method: write of class fawkes::LocalizerControlInterface */ 01206 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_write00 01207 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_write00(lua_State* tolua_S) 01208 { 01209 #ifndef TOLUA_RELEASE 01210 tolua_Error tolua_err; 01211 if ( 01212 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 01213 !tolua_isnoobj(tolua_S,2,&tolua_err) 01214 ) 01215 goto tolua_lerror; 01216 else 01217 #endif 01218 { 01219 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01220 #ifndef TOLUA_RELEASE 01221 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL); 01222 #endif 01223 { 01224 self->write(); 01225 } 01226 } 01227 return 0; 01228 #ifndef TOLUA_RELEASE 01229 tolua_lerror: 01230 tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err); 01231 return 0; 01232 #endif 01233 } 01234 #endif //#ifndef TOLUA_DISABLE 01235 01236 /* method: has_writer of class fawkes::LocalizerControlInterface */ 01237 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_has_writer00 01238 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_has_writer00(lua_State* tolua_S) 01239 { 01240 #ifndef TOLUA_RELEASE 01241 tolua_Error tolua_err; 01242 if ( 01243 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 01244 !tolua_isnoobj(tolua_S,2,&tolua_err) 01245 ) 01246 goto tolua_lerror; 01247 else 01248 #endif 01249 { 01250 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01251 #ifndef TOLUA_RELEASE 01252 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL); 01253 #endif 01254 { 01255 bool tolua_ret = (bool) self->has_writer(); 01256 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01257 } 01258 } 01259 return 1; 01260 #ifndef TOLUA_RELEASE 01261 tolua_lerror: 01262 tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err); 01263 return 0; 01264 #endif 01265 } 01266 #endif //#ifndef TOLUA_DISABLE 01267 01268 /* method: num_readers of class fawkes::LocalizerControlInterface */ 01269 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_num_readers00 01270 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_num_readers00(lua_State* tolua_S) 01271 { 01272 #ifndef TOLUA_RELEASE 01273 tolua_Error tolua_err; 01274 if ( 01275 !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) || 01276 !tolua_isnoobj(tolua_S,2,&tolua_err) 01277 ) 01278 goto tolua_lerror; 01279 else 01280 #endif 01281 { 01282 const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01283 #ifndef TOLUA_RELEASE 01284 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL); 01285 #endif 01286 { 01287 unsigned int tolua_ret = (unsigned int) self->num_readers(); 01288 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01289 } 01290 } 01291 return 1; 01292 #ifndef TOLUA_RELEASE 01293 tolua_lerror: 01294 tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err); 01295 return 0; 01296 #endif 01297 } 01298 #endif //#ifndef TOLUA_DISABLE 01299 01300 /* method: msgq_enqueue_copy of class fawkes::LocalizerControlInterface */ 01301 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_enqueue_copy00 01302 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_enqueue_copy00(lua_State* tolua_S) 01303 { 01304 #ifndef TOLUA_RELEASE 01305 tolua_Error tolua_err; 01306 if ( 01307 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 01308 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 01309 !tolua_isnoobj(tolua_S,3,&tolua_err) 01310 ) 01311 goto tolua_lerror; 01312 else 01313 #endif 01314 { 01315 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01316 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 01317 #ifndef TOLUA_RELEASE 01318 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL); 01319 #endif 01320 { 01321 unsigned int tolua_ret = (unsigned int) self->msgq_enqueue_copy(message); 01322 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01323 } 01324 } 01325 return 1; 01326 #ifndef TOLUA_RELEASE 01327 tolua_lerror: 01328 tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err); 01329 return 0; 01330 #endif 01331 } 01332 #endif //#ifndef TOLUA_DISABLE 01333 01334 /* method: msgq_remove of class fawkes::LocalizerControlInterface */ 01335 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_remove00 01336 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_remove00(lua_State* tolua_S) 01337 { 01338 #ifndef TOLUA_RELEASE 01339 tolua_Error tolua_err; 01340 if ( 01341 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 01342 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 01343 !tolua_isnoobj(tolua_S,3,&tolua_err) 01344 ) 01345 goto tolua_lerror; 01346 else 01347 #endif 01348 { 01349 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01350 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 01351 #ifndef TOLUA_RELEASE 01352 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 01353 #endif 01354 { 01355 self->msgq_remove(message); 01356 } 01357 } 01358 return 0; 01359 #ifndef TOLUA_RELEASE 01360 tolua_lerror: 01361 tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err); 01362 return 0; 01363 #endif 01364 } 01365 #endif //#ifndef TOLUA_DISABLE 01366 01367 /* method: msgq_remove of class fawkes::LocalizerControlInterface */ 01368 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_remove01 01369 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_remove01(lua_State* tolua_S) 01370 { 01371 tolua_Error tolua_err; 01372 if ( 01373 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 01374 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01375 !tolua_isnoobj(tolua_S,3,&tolua_err) 01376 ) 01377 goto tolua_lerror; 01378 else 01379 { 01380 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01381 unsigned int message_id = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 01382 #ifndef TOLUA_RELEASE 01383 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 01384 #endif 01385 { 01386 self->msgq_remove(message_id); 01387 } 01388 } 01389 return 0; 01390 tolua_lerror: 01391 return tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_remove00(tolua_S); 01392 } 01393 #endif //#ifndef TOLUA_DISABLE 01394 01395 /* method: msgq_size of class fawkes::LocalizerControlInterface */ 01396 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_size00 01397 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_size00(lua_State* tolua_S) 01398 { 01399 #ifndef TOLUA_RELEASE 01400 tolua_Error tolua_err; 01401 if ( 01402 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 01403 !tolua_isnoobj(tolua_S,2,&tolua_err) 01404 ) 01405 goto tolua_lerror; 01406 else 01407 #endif 01408 { 01409 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01410 #ifndef TOLUA_RELEASE 01411 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL); 01412 #endif 01413 { 01414 unsigned int tolua_ret = (unsigned int) self->msgq_size(); 01415 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01416 } 01417 } 01418 return 1; 01419 #ifndef TOLUA_RELEASE 01420 tolua_lerror: 01421 tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err); 01422 return 0; 01423 #endif 01424 } 01425 #endif //#ifndef TOLUA_DISABLE 01426 01427 /* method: msgq_flush of class fawkes::LocalizerControlInterface */ 01428 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_flush00 01429 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_flush00(lua_State* tolua_S) 01430 { 01431 #ifndef TOLUA_RELEASE 01432 tolua_Error tolua_err; 01433 if ( 01434 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 01435 !tolua_isnoobj(tolua_S,2,&tolua_err) 01436 ) 01437 goto tolua_lerror; 01438 else 01439 #endif 01440 { 01441 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01442 #ifndef TOLUA_RELEASE 01443 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL); 01444 #endif 01445 { 01446 self->msgq_flush(); 01447 } 01448 } 01449 return 0; 01450 #ifndef TOLUA_RELEASE 01451 tolua_lerror: 01452 tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err); 01453 return 0; 01454 #endif 01455 } 01456 #endif //#ifndef TOLUA_DISABLE 01457 01458 /* method: msgq_lock of class fawkes::LocalizerControlInterface */ 01459 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_lock00 01460 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_lock00(lua_State* tolua_S) 01461 { 01462 #ifndef TOLUA_RELEASE 01463 tolua_Error tolua_err; 01464 if ( 01465 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 01466 !tolua_isnoobj(tolua_S,2,&tolua_err) 01467 ) 01468 goto tolua_lerror; 01469 else 01470 #endif 01471 { 01472 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01473 #ifndef TOLUA_RELEASE 01474 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL); 01475 #endif 01476 { 01477 self->msgq_lock(); 01478 } 01479 } 01480 return 0; 01481 #ifndef TOLUA_RELEASE 01482 tolua_lerror: 01483 tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err); 01484 return 0; 01485 #endif 01486 } 01487 #endif //#ifndef TOLUA_DISABLE 01488 01489 /* method: msgq_try_lock of class fawkes::LocalizerControlInterface */ 01490 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_try_lock00 01491 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_try_lock00(lua_State* tolua_S) 01492 { 01493 #ifndef TOLUA_RELEASE 01494 tolua_Error tolua_err; 01495 if ( 01496 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 01497 !tolua_isnoobj(tolua_S,2,&tolua_err) 01498 ) 01499 goto tolua_lerror; 01500 else 01501 #endif 01502 { 01503 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01504 #ifndef TOLUA_RELEASE 01505 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL); 01506 #endif 01507 { 01508 bool tolua_ret = (bool) self->msgq_try_lock(); 01509 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01510 } 01511 } 01512 return 1; 01513 #ifndef TOLUA_RELEASE 01514 tolua_lerror: 01515 tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err); 01516 return 0; 01517 #endif 01518 } 01519 #endif //#ifndef TOLUA_DISABLE 01520 01521 /* method: msgq_unlock of class fawkes::LocalizerControlInterface */ 01522 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_unlock00 01523 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_unlock00(lua_State* tolua_S) 01524 { 01525 #ifndef TOLUA_RELEASE 01526 tolua_Error tolua_err; 01527 if ( 01528 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 01529 !tolua_isnoobj(tolua_S,2,&tolua_err) 01530 ) 01531 goto tolua_lerror; 01532 else 01533 #endif 01534 { 01535 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01536 #ifndef TOLUA_RELEASE 01537 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL); 01538 #endif 01539 { 01540 self->msgq_unlock(); 01541 } 01542 } 01543 return 0; 01544 #ifndef TOLUA_RELEASE 01545 tolua_lerror: 01546 tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err); 01547 return 0; 01548 #endif 01549 } 01550 #endif //#ifndef TOLUA_DISABLE 01551 01552 /* method: msgq_pop of class fawkes::LocalizerControlInterface */ 01553 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_pop00 01554 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_pop00(lua_State* tolua_S) 01555 { 01556 #ifndef TOLUA_RELEASE 01557 tolua_Error tolua_err; 01558 if ( 01559 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 01560 !tolua_isnoobj(tolua_S,2,&tolua_err) 01561 ) 01562 goto tolua_lerror; 01563 else 01564 #endif 01565 { 01566 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01567 #ifndef TOLUA_RELEASE 01568 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL); 01569 #endif 01570 { 01571 self->msgq_pop(); 01572 } 01573 } 01574 return 0; 01575 #ifndef TOLUA_RELEASE 01576 tolua_lerror: 01577 tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err); 01578 return 0; 01579 #endif 01580 } 01581 #endif //#ifndef TOLUA_DISABLE 01582 01583 /* method: msgq_first of class fawkes::LocalizerControlInterface */ 01584 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_first00 01585 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_first00(lua_State* tolua_S) 01586 { 01587 #ifndef TOLUA_RELEASE 01588 tolua_Error tolua_err; 01589 if ( 01590 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 01591 !tolua_isnoobj(tolua_S,2,&tolua_err) 01592 ) 01593 goto tolua_lerror; 01594 else 01595 #endif 01596 { 01597 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01598 #ifndef TOLUA_RELEASE 01599 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL); 01600 #endif 01601 { 01602 Message* tolua_ret = (Message*) self->msgq_first(); 01603 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 01604 } 01605 } 01606 return 1; 01607 #ifndef TOLUA_RELEASE 01608 tolua_lerror: 01609 tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err); 01610 return 0; 01611 #endif 01612 } 01613 #endif //#ifndef TOLUA_DISABLE 01614 01615 /* method: msgq_empty of class fawkes::LocalizerControlInterface */ 01616 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_empty00 01617 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_empty00(lua_State* tolua_S) 01618 { 01619 #ifndef TOLUA_RELEASE 01620 tolua_Error tolua_err; 01621 if ( 01622 !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) || 01623 !tolua_isnoobj(tolua_S,2,&tolua_err) 01624 ) 01625 goto tolua_lerror; 01626 else 01627 #endif 01628 { 01629 fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*) tolua_tousertype(tolua_S,1,0); 01630 #ifndef TOLUA_RELEASE 01631 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL); 01632 #endif 01633 { 01634 bool tolua_ret = (bool) self->msgq_empty(); 01635 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01636 } 01637 } 01638 return 1; 01639 #ifndef TOLUA_RELEASE 01640 tolua_lerror: 01641 tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err); 01642 return 0; 01643 #endif 01644 } 01645 #endif //#ifndef TOLUA_DISABLE 01646 01647 /* Open function */ 01648 TOLUA_API int tolua_interfaces_LocalizerControlInterface_open (lua_State* tolua_S) 01649 { 01650 tolua_open(tolua_S); 01651 tolua_reg_types(tolua_S); 01652 tolua_module(tolua_S,NULL,0); 01653 tolua_beginmodule(tolua_S,NULL); 01654 tolua_module(tolua_S,"fawkes",0); 01655 tolua_beginmodule(tolua_S,"fawkes"); 01656 tolua_cclass(tolua_S,"LocalizerControlInterface","fawkes::LocalizerControlInterface","Interface",NULL); 01657 tolua_beginmodule(tolua_S,"LocalizerControlInterface"); 01658 #ifdef __cplusplus 01659 tolua_cclass(tolua_S,"ResetMessage","fawkes::LocalizerControlInterface::ResetMessage","Message",tolua_collect_fawkes__LocalizerControlInterface__ResetMessage); 01660 #else 01661 tolua_cclass(tolua_S,"ResetMessage","fawkes::LocalizerControlInterface::ResetMessage","Message",NULL); 01662 #endif 01663 tolua_beginmodule(tolua_S,"ResetMessage"); 01664 tolua_function(tolua_S,"new",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00); 01665 tolua_function(tolua_S,"new_local",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00_local); 01666 tolua_function(tolua_S,".call",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00_local); 01667 tolua_function(tolua_S,"new",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new01); 01668 tolua_function(tolua_S,"new_local",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new01_local); 01669 tolua_function(tolua_S,".call",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new01_local); 01670 tolua_function(tolua_S,"delete",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_delete00); 01671 tolua_function(tolua_S,"x",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_x00); 01672 tolua_function(tolua_S,"set_x",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_x00); 01673 tolua_function(tolua_S,"maxlenof_x",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_x00); 01674 tolua_function(tolua_S,"y",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_y00); 01675 tolua_function(tolua_S,"set_y",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_y00); 01676 tolua_function(tolua_S,"maxlenof_y",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_y00); 01677 tolua_function(tolua_S,"ori",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_ori00); 01678 tolua_function(tolua_S,"set_ori",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_ori00); 01679 tolua_function(tolua_S,"maxlenof_ori",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_ori00); 01680 tolua_function(tolua_S,"variance",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_variance00); 01681 tolua_function(tolua_S,"set_variance",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_variance00); 01682 tolua_function(tolua_S,"maxlenof_variance",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_variance00); 01683 tolua_endmodule(tolua_S); 01684 tolua_function(tolua_S,"map_name",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_map_name00); 01685 tolua_function(tolua_S,"set_map_name",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_set_map_name00); 01686 tolua_function(tolua_S,"maxlenof_map_name",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_maxlenof_map_name00); 01687 tolua_function(tolua_S,"oftype",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_oftype00); 01688 tolua_function(tolua_S,"datachunk",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_datachunk00); 01689 tolua_function(tolua_S,"datasize",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_datasize00); 01690 tolua_function(tolua_S,"type",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_type00); 01691 tolua_function(tolua_S,"id",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_id00); 01692 tolua_function(tolua_S,"uid",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_uid00); 01693 tolua_function(tolua_S,"serial",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_serial00); 01694 tolua_function(tolua_S,"mem_serial",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_mem_serial00); 01695 tolua_function(tolua_S,".eq",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface__eq00); 01696 tolua_function(tolua_S,"hash",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash00); 01697 tolua_function(tolua_S,"hash_size",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash_size00); 01698 tolua_function(tolua_S,"hash_printable",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash_printable00); 01699 tolua_function(tolua_S,"is_writer",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_is_writer00); 01700 tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_set_from_chunk00); 01701 tolua_function(tolua_S,"create_message",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_create_message00); 01702 tolua_function(tolua_S,"read",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_read00); 01703 tolua_function(tolua_S,"write",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_write00); 01704 tolua_function(tolua_S,"has_writer",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_has_writer00); 01705 tolua_function(tolua_S,"num_readers",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_num_readers00); 01706 tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_enqueue_copy00); 01707 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_remove00); 01708 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_remove01); 01709 tolua_function(tolua_S,"msgq_size",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_size00); 01710 tolua_function(tolua_S,"msgq_flush",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_flush00); 01711 tolua_function(tolua_S,"msgq_lock",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_lock00); 01712 tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_try_lock00); 01713 tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_unlock00); 01714 tolua_function(tolua_S,"msgq_pop",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_pop00); 01715 tolua_function(tolua_S,"msgq_first",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_first00); 01716 tolua_function(tolua_S,"msgq_empty",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_empty00); 01717 tolua_endmodule(tolua_S); 01718 tolua_endmodule(tolua_S); 01719 tolua_endmodule(tolua_S); 01720 return 1; 01721 } 01722 01723 01724 extern "C" { 01725 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501 01726 TOLUA_API int luaopen_interfaces_LocalizerControlInterface (lua_State* tolua_S) { 01727 return tolua_interfaces_LocalizerControlInterface_open(tolua_S); 01728 }; 01729 #endif 01730 } 01731 01732