Fawkes API Fawkes Development Version
|
00001 /* 00002 ** Lua binding: interfaces_FacerInterface 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_FacerInterface_open (lua_State* tolua_S); 00028 00029 #include <interfaces/FacerInterface.h> 00030 using namespace fawkes; 00031 00032 /* function to release collected object via destructor */ 00033 #ifdef __cplusplus 00034 00035 static int tolua_collect_fawkes__FacerInterface__LearnFaceMessage (lua_State* tolua_S) 00036 { 00037 fawkes::FacerInterface::LearnFaceMessage* self = (fawkes::FacerInterface::LearnFaceMessage*) tolua_tousertype(tolua_S,1,0); 00038 Mtolua_delete(self); 00039 return 0; 00040 } 00041 00042 static int tolua_collect_fawkes__FacerInterface__SetOpmodeMessage (lua_State* tolua_S) 00043 { 00044 fawkes::FacerInterface::SetOpmodeMessage* self = (fawkes::FacerInterface::SetOpmodeMessage*) tolua_tousertype(tolua_S,1,0); 00045 Mtolua_delete(self); 00046 return 0; 00047 } 00048 00049 static int tolua_collect_fawkes__FacerInterface__GetNameMessage (lua_State* tolua_S) 00050 { 00051 fawkes::FacerInterface::GetNameMessage* self = (fawkes::FacerInterface::GetNameMessage*) tolua_tousertype(tolua_S,1,0); 00052 Mtolua_delete(self); 00053 return 0; 00054 } 00055 00056 static int tolua_collect_fawkes__FacerInterface__SetNameMessage (lua_State* tolua_S) 00057 { 00058 fawkes::FacerInterface::SetNameMessage* self = (fawkes::FacerInterface::SetNameMessage*) tolua_tousertype(tolua_S,1,0); 00059 Mtolua_delete(self); 00060 return 0; 00061 } 00062 00063 static int tolua_collect_fawkes__FacerInterface__EnableIdentityMessage (lua_State* tolua_S) 00064 { 00065 fawkes::FacerInterface::EnableIdentityMessage* self = (fawkes::FacerInterface::EnableIdentityMessage*) tolua_tousertype(tolua_S,1,0); 00066 Mtolua_delete(self); 00067 return 0; 00068 } 00069 #endif 00070 00071 00072 /* function to register type */ 00073 static void tolua_reg_types (lua_State* tolua_S) 00074 { 00075 tolua_usertype(tolua_S,"Message"); 00076 tolua_usertype(tolua_S,"fawkes::FacerInterface::GetNameMessage"); 00077 tolua_usertype(tolua_S,"fawkes::FacerInterface::LearnFaceMessage"); 00078 tolua_usertype(tolua_S,"fawkes::FacerInterface::SetOpmodeMessage"); 00079 tolua_usertype(tolua_S,"fawkes::FacerInterface::EnableIdentityMessage"); 00080 tolua_usertype(tolua_S,"fawkes::FacerInterface"); 00081 tolua_usertype(tolua_S,"fawkes::FacerInterface::SetNameMessage"); 00082 tolua_usertype(tolua_S,"Interface"); 00083 } 00084 00085 /* method: new of class LearnFaceMessage */ 00086 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new00 00087 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new00(lua_State* tolua_S) 00088 { 00089 #ifndef TOLUA_RELEASE 00090 tolua_Error tolua_err; 00091 if ( 00092 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::LearnFaceMessage",0,&tolua_err) || 00093 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00094 !tolua_isnoobj(tolua_S,3,&tolua_err) 00095 ) 00096 goto tolua_lerror; 00097 else 00098 #endif 00099 { 00100 char* ini_name = ((char*) tolua_tostring(tolua_S,2,0)); 00101 { 00102 fawkes::FacerInterface::LearnFaceMessage* tolua_ret = (fawkes::FacerInterface::LearnFaceMessage*) Mtolua_new((fawkes::FacerInterface::LearnFaceMessage)(ini_name)); 00103 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::LearnFaceMessage"); 00104 } 00105 } 00106 return 1; 00107 #ifndef TOLUA_RELEASE 00108 tolua_lerror: 00109 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00110 return 0; 00111 #endif 00112 } 00113 #endif //#ifndef TOLUA_DISABLE 00114 00115 /* method: new_local of class LearnFaceMessage */ 00116 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new00_local 00117 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new00_local(lua_State* tolua_S) 00118 { 00119 #ifndef TOLUA_RELEASE 00120 tolua_Error tolua_err; 00121 if ( 00122 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::LearnFaceMessage",0,&tolua_err) || 00123 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00124 !tolua_isnoobj(tolua_S,3,&tolua_err) 00125 ) 00126 goto tolua_lerror; 00127 else 00128 #endif 00129 { 00130 char* ini_name = ((char*) tolua_tostring(tolua_S,2,0)); 00131 { 00132 fawkes::FacerInterface::LearnFaceMessage* tolua_ret = (fawkes::FacerInterface::LearnFaceMessage*) Mtolua_new((fawkes::FacerInterface::LearnFaceMessage)(ini_name)); 00133 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::LearnFaceMessage"); 00134 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00135 } 00136 } 00137 return 1; 00138 #ifndef TOLUA_RELEASE 00139 tolua_lerror: 00140 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00141 return 0; 00142 #endif 00143 } 00144 #endif //#ifndef TOLUA_DISABLE 00145 00146 /* method: new of class LearnFaceMessage */ 00147 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new01 00148 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new01(lua_State* tolua_S) 00149 { 00150 tolua_Error tolua_err; 00151 if ( 00152 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::LearnFaceMessage",0,&tolua_err) || 00153 !tolua_isnoobj(tolua_S,2,&tolua_err) 00154 ) 00155 goto tolua_lerror; 00156 else 00157 { 00158 { 00159 fawkes::FacerInterface::LearnFaceMessage* tolua_ret = (fawkes::FacerInterface::LearnFaceMessage*) Mtolua_new((fawkes::FacerInterface::LearnFaceMessage)()); 00160 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::LearnFaceMessage"); 00161 } 00162 } 00163 return 1; 00164 tolua_lerror: 00165 return tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new00(tolua_S); 00166 } 00167 #endif //#ifndef TOLUA_DISABLE 00168 00169 /* method: new_local of class LearnFaceMessage */ 00170 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new01_local 00171 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new01_local(lua_State* tolua_S) 00172 { 00173 tolua_Error tolua_err; 00174 if ( 00175 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::LearnFaceMessage",0,&tolua_err) || 00176 !tolua_isnoobj(tolua_S,2,&tolua_err) 00177 ) 00178 goto tolua_lerror; 00179 else 00180 { 00181 { 00182 fawkes::FacerInterface::LearnFaceMessage* tolua_ret = (fawkes::FacerInterface::LearnFaceMessage*) Mtolua_new((fawkes::FacerInterface::LearnFaceMessage)()); 00183 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::LearnFaceMessage"); 00184 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00185 } 00186 } 00187 return 1; 00188 tolua_lerror: 00189 return tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new00_local(tolua_S); 00190 } 00191 #endif //#ifndef TOLUA_DISABLE 00192 00193 /* method: delete of class LearnFaceMessage */ 00194 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_delete00 00195 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_delete00(lua_State* tolua_S) 00196 { 00197 #ifndef TOLUA_RELEASE 00198 tolua_Error tolua_err; 00199 if ( 00200 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::LearnFaceMessage",0,&tolua_err) || 00201 !tolua_isnoobj(tolua_S,2,&tolua_err) 00202 ) 00203 goto tolua_lerror; 00204 else 00205 #endif 00206 { 00207 fawkes::FacerInterface::LearnFaceMessage* self = (fawkes::FacerInterface::LearnFaceMessage*) tolua_tousertype(tolua_S,1,0); 00208 #ifndef TOLUA_RELEASE 00209 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00210 #endif 00211 Mtolua_delete(self); 00212 } 00213 return 0; 00214 #ifndef TOLUA_RELEASE 00215 tolua_lerror: 00216 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00217 return 0; 00218 #endif 00219 } 00220 #endif //#ifndef TOLUA_DISABLE 00221 00222 /* method: name of class LearnFaceMessage */ 00223 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_name00 00224 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_name00(lua_State* tolua_S) 00225 { 00226 #ifndef TOLUA_RELEASE 00227 tolua_Error tolua_err; 00228 if ( 00229 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::LearnFaceMessage",0,&tolua_err) || 00230 !tolua_isnoobj(tolua_S,2,&tolua_err) 00231 ) 00232 goto tolua_lerror; 00233 else 00234 #endif 00235 { 00236 fawkes::FacerInterface::LearnFaceMessage* self = (fawkes::FacerInterface::LearnFaceMessage*) tolua_tousertype(tolua_S,1,0); 00237 #ifndef TOLUA_RELEASE 00238 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL); 00239 #endif 00240 { 00241 char* tolua_ret = (char*) self->name(); 00242 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00243 } 00244 } 00245 return 1; 00246 #ifndef TOLUA_RELEASE 00247 tolua_lerror: 00248 tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err); 00249 return 0; 00250 #endif 00251 } 00252 #endif //#ifndef TOLUA_DISABLE 00253 00254 /* method: set_name of class LearnFaceMessage */ 00255 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_set_name00 00256 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_set_name00(lua_State* tolua_S) 00257 { 00258 #ifndef TOLUA_RELEASE 00259 tolua_Error tolua_err; 00260 if ( 00261 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::LearnFaceMessage",0,&tolua_err) || 00262 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00263 !tolua_isnoobj(tolua_S,3,&tolua_err) 00264 ) 00265 goto tolua_lerror; 00266 else 00267 #endif 00268 { 00269 fawkes::FacerInterface::LearnFaceMessage* self = (fawkes::FacerInterface::LearnFaceMessage*) tolua_tousertype(tolua_S,1,0); 00270 const char* new_name = ((const char*) tolua_tostring(tolua_S,2,0)); 00271 #ifndef TOLUA_RELEASE 00272 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_name'", NULL); 00273 #endif 00274 { 00275 self->set_name(new_name); 00276 } 00277 } 00278 return 0; 00279 #ifndef TOLUA_RELEASE 00280 tolua_lerror: 00281 tolua_error(tolua_S,"#ferror in function 'set_name'.",&tolua_err); 00282 return 0; 00283 #endif 00284 } 00285 #endif //#ifndef TOLUA_DISABLE 00286 00287 /* method: maxlenof_name of class LearnFaceMessage */ 00288 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_maxlenof_name00 00289 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_maxlenof_name00(lua_State* tolua_S) 00290 { 00291 #ifndef TOLUA_RELEASE 00292 tolua_Error tolua_err; 00293 if ( 00294 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface::LearnFaceMessage",0,&tolua_err) || 00295 !tolua_isnoobj(tolua_S,2,&tolua_err) 00296 ) 00297 goto tolua_lerror; 00298 else 00299 #endif 00300 { 00301 const fawkes::FacerInterface::LearnFaceMessage* self = (const fawkes::FacerInterface::LearnFaceMessage*) tolua_tousertype(tolua_S,1,0); 00302 #ifndef TOLUA_RELEASE 00303 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_name'", NULL); 00304 #endif 00305 { 00306 int tolua_ret = (int) self->maxlenof_name(); 00307 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00308 } 00309 } 00310 return 1; 00311 #ifndef TOLUA_RELEASE 00312 tolua_lerror: 00313 tolua_error(tolua_S,"#ferror in function 'maxlenof_name'.",&tolua_err); 00314 return 0; 00315 #endif 00316 } 00317 #endif //#ifndef TOLUA_DISABLE 00318 00319 /* method: new of class SetOpmodeMessage */ 00320 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new00 00321 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new00(lua_State* tolua_S) 00322 { 00323 #ifndef TOLUA_RELEASE 00324 tolua_Error tolua_err; 00325 if ( 00326 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::SetOpmodeMessage",0,&tolua_err) || 00327 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00328 !tolua_isnoobj(tolua_S,3,&tolua_err) 00329 ) 00330 goto tolua_lerror; 00331 else 00332 #endif 00333 { 00334 fawkes::FacerInterface::if_facer_opmode_t ini_opmode = ((fawkes::FacerInterface::if_facer_opmode_t) (int) tolua_tonumber(tolua_S,2,0)); 00335 { 00336 fawkes::FacerInterface::SetOpmodeMessage* tolua_ret = (fawkes::FacerInterface::SetOpmodeMessage*) Mtolua_new((fawkes::FacerInterface::SetOpmodeMessage)(ini_opmode)); 00337 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::SetOpmodeMessage"); 00338 } 00339 } 00340 return 1; 00341 #ifndef TOLUA_RELEASE 00342 tolua_lerror: 00343 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00344 return 0; 00345 #endif 00346 } 00347 #endif //#ifndef TOLUA_DISABLE 00348 00349 /* method: new_local of class SetOpmodeMessage */ 00350 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new00_local 00351 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new00_local(lua_State* tolua_S) 00352 { 00353 #ifndef TOLUA_RELEASE 00354 tolua_Error tolua_err; 00355 if ( 00356 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::SetOpmodeMessage",0,&tolua_err) || 00357 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00358 !tolua_isnoobj(tolua_S,3,&tolua_err) 00359 ) 00360 goto tolua_lerror; 00361 else 00362 #endif 00363 { 00364 fawkes::FacerInterface::if_facer_opmode_t ini_opmode = ((fawkes::FacerInterface::if_facer_opmode_t) (int) tolua_tonumber(tolua_S,2,0)); 00365 { 00366 fawkes::FacerInterface::SetOpmodeMessage* tolua_ret = (fawkes::FacerInterface::SetOpmodeMessage*) Mtolua_new((fawkes::FacerInterface::SetOpmodeMessage)(ini_opmode)); 00367 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::SetOpmodeMessage"); 00368 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00369 } 00370 } 00371 return 1; 00372 #ifndef TOLUA_RELEASE 00373 tolua_lerror: 00374 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00375 return 0; 00376 #endif 00377 } 00378 #endif //#ifndef TOLUA_DISABLE 00379 00380 /* method: new of class SetOpmodeMessage */ 00381 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new01 00382 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new01(lua_State* tolua_S) 00383 { 00384 tolua_Error tolua_err; 00385 if ( 00386 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::SetOpmodeMessage",0,&tolua_err) || 00387 !tolua_isnoobj(tolua_S,2,&tolua_err) 00388 ) 00389 goto tolua_lerror; 00390 else 00391 { 00392 { 00393 fawkes::FacerInterface::SetOpmodeMessage* tolua_ret = (fawkes::FacerInterface::SetOpmodeMessage*) Mtolua_new((fawkes::FacerInterface::SetOpmodeMessage)()); 00394 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::SetOpmodeMessage"); 00395 } 00396 } 00397 return 1; 00398 tolua_lerror: 00399 return tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new00(tolua_S); 00400 } 00401 #endif //#ifndef TOLUA_DISABLE 00402 00403 /* method: new_local of class SetOpmodeMessage */ 00404 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new01_local 00405 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new01_local(lua_State* tolua_S) 00406 { 00407 tolua_Error tolua_err; 00408 if ( 00409 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::SetOpmodeMessage",0,&tolua_err) || 00410 !tolua_isnoobj(tolua_S,2,&tolua_err) 00411 ) 00412 goto tolua_lerror; 00413 else 00414 { 00415 { 00416 fawkes::FacerInterface::SetOpmodeMessage* tolua_ret = (fawkes::FacerInterface::SetOpmodeMessage*) Mtolua_new((fawkes::FacerInterface::SetOpmodeMessage)()); 00417 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::SetOpmodeMessage"); 00418 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00419 } 00420 } 00421 return 1; 00422 tolua_lerror: 00423 return tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new00_local(tolua_S); 00424 } 00425 #endif //#ifndef TOLUA_DISABLE 00426 00427 /* method: delete of class SetOpmodeMessage */ 00428 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_delete00 00429 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_delete00(lua_State* tolua_S) 00430 { 00431 #ifndef TOLUA_RELEASE 00432 tolua_Error tolua_err; 00433 if ( 00434 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::SetOpmodeMessage",0,&tolua_err) || 00435 !tolua_isnoobj(tolua_S,2,&tolua_err) 00436 ) 00437 goto tolua_lerror; 00438 else 00439 #endif 00440 { 00441 fawkes::FacerInterface::SetOpmodeMessage* self = (fawkes::FacerInterface::SetOpmodeMessage*) tolua_tousertype(tolua_S,1,0); 00442 #ifndef TOLUA_RELEASE 00443 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00444 #endif 00445 Mtolua_delete(self); 00446 } 00447 return 0; 00448 #ifndef TOLUA_RELEASE 00449 tolua_lerror: 00450 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00451 return 0; 00452 #endif 00453 } 00454 #endif //#ifndef TOLUA_DISABLE 00455 00456 /* method: opmode of class SetOpmodeMessage */ 00457 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_opmode00 00458 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_opmode00(lua_State* tolua_S) 00459 { 00460 #ifndef TOLUA_RELEASE 00461 tolua_Error tolua_err; 00462 if ( 00463 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::SetOpmodeMessage",0,&tolua_err) || 00464 !tolua_isnoobj(tolua_S,2,&tolua_err) 00465 ) 00466 goto tolua_lerror; 00467 else 00468 #endif 00469 { 00470 fawkes::FacerInterface::SetOpmodeMessage* self = (fawkes::FacerInterface::SetOpmodeMessage*) tolua_tousertype(tolua_S,1,0); 00471 #ifndef TOLUA_RELEASE 00472 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'opmode'", NULL); 00473 #endif 00474 { 00475 fawkes::FacerInterface::if_facer_opmode_t tolua_ret = (fawkes::FacerInterface::if_facer_opmode_t) self->opmode(); 00476 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00477 } 00478 } 00479 return 1; 00480 #ifndef TOLUA_RELEASE 00481 tolua_lerror: 00482 tolua_error(tolua_S,"#ferror in function 'opmode'.",&tolua_err); 00483 return 0; 00484 #endif 00485 } 00486 #endif //#ifndef TOLUA_DISABLE 00487 00488 /* method: set_opmode of class SetOpmodeMessage */ 00489 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_set_opmode00 00490 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_set_opmode00(lua_State* tolua_S) 00491 { 00492 #ifndef TOLUA_RELEASE 00493 tolua_Error tolua_err; 00494 if ( 00495 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::SetOpmodeMessage",0,&tolua_err) || 00496 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00497 !tolua_isnoobj(tolua_S,3,&tolua_err) 00498 ) 00499 goto tolua_lerror; 00500 else 00501 #endif 00502 { 00503 fawkes::FacerInterface::SetOpmodeMessage* self = (fawkes::FacerInterface::SetOpmodeMessage*) tolua_tousertype(tolua_S,1,0); 00504 const fawkes::FacerInterface::if_facer_opmode_t new_opmode = ((const fawkes::FacerInterface::if_facer_opmode_t) (int) tolua_tonumber(tolua_S,2,0)); 00505 #ifndef TOLUA_RELEASE 00506 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_opmode'", NULL); 00507 #endif 00508 { 00509 self->set_opmode(new_opmode); 00510 } 00511 } 00512 return 0; 00513 #ifndef TOLUA_RELEASE 00514 tolua_lerror: 00515 tolua_error(tolua_S,"#ferror in function 'set_opmode'.",&tolua_err); 00516 return 0; 00517 #endif 00518 } 00519 #endif //#ifndef TOLUA_DISABLE 00520 00521 /* method: maxlenof_opmode of class SetOpmodeMessage */ 00522 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_maxlenof_opmode00 00523 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_maxlenof_opmode00(lua_State* tolua_S) 00524 { 00525 #ifndef TOLUA_RELEASE 00526 tolua_Error tolua_err; 00527 if ( 00528 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface::SetOpmodeMessage",0,&tolua_err) || 00529 !tolua_isnoobj(tolua_S,2,&tolua_err) 00530 ) 00531 goto tolua_lerror; 00532 else 00533 #endif 00534 { 00535 const fawkes::FacerInterface::SetOpmodeMessage* self = (const fawkes::FacerInterface::SetOpmodeMessage*) tolua_tousertype(tolua_S,1,0); 00536 #ifndef TOLUA_RELEASE 00537 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_opmode'", NULL); 00538 #endif 00539 { 00540 int tolua_ret = (int) self->maxlenof_opmode(); 00541 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00542 } 00543 } 00544 return 1; 00545 #ifndef TOLUA_RELEASE 00546 tolua_lerror: 00547 tolua_error(tolua_S,"#ferror in function 'maxlenof_opmode'.",&tolua_err); 00548 return 0; 00549 #endif 00550 } 00551 #endif //#ifndef TOLUA_DISABLE 00552 00553 /* method: new of class EnableIdentityMessage */ 00554 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new00 00555 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new00(lua_State* tolua_S) 00556 { 00557 #ifndef TOLUA_RELEASE 00558 tolua_Error tolua_err; 00559 if ( 00560 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::EnableIdentityMessage",0,&tolua_err) || 00561 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00562 !tolua_isboolean(tolua_S,3,0,&tolua_err) || 00563 !tolua_isnoobj(tolua_S,4,&tolua_err) 00564 ) 00565 goto tolua_lerror; 00566 else 00567 #endif 00568 { 00569 unsigned int ini_index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 00570 bool ini_enable = ((bool) tolua_toboolean(tolua_S,3,0)); 00571 { 00572 fawkes::FacerInterface::EnableIdentityMessage* tolua_ret = (fawkes::FacerInterface::EnableIdentityMessage*) Mtolua_new((fawkes::FacerInterface::EnableIdentityMessage)(ini_index,ini_enable)); 00573 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::EnableIdentityMessage"); 00574 } 00575 } 00576 return 1; 00577 #ifndef TOLUA_RELEASE 00578 tolua_lerror: 00579 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00580 return 0; 00581 #endif 00582 } 00583 #endif //#ifndef TOLUA_DISABLE 00584 00585 /* method: new_local of class EnableIdentityMessage */ 00586 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new00_local 00587 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new00_local(lua_State* tolua_S) 00588 { 00589 #ifndef TOLUA_RELEASE 00590 tolua_Error tolua_err; 00591 if ( 00592 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::EnableIdentityMessage",0,&tolua_err) || 00593 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00594 !tolua_isboolean(tolua_S,3,0,&tolua_err) || 00595 !tolua_isnoobj(tolua_S,4,&tolua_err) 00596 ) 00597 goto tolua_lerror; 00598 else 00599 #endif 00600 { 00601 unsigned int ini_index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 00602 bool ini_enable = ((bool) tolua_toboolean(tolua_S,3,0)); 00603 { 00604 fawkes::FacerInterface::EnableIdentityMessage* tolua_ret = (fawkes::FacerInterface::EnableIdentityMessage*) Mtolua_new((fawkes::FacerInterface::EnableIdentityMessage)(ini_index,ini_enable)); 00605 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::EnableIdentityMessage"); 00606 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00607 } 00608 } 00609 return 1; 00610 #ifndef TOLUA_RELEASE 00611 tolua_lerror: 00612 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00613 return 0; 00614 #endif 00615 } 00616 #endif //#ifndef TOLUA_DISABLE 00617 00618 /* method: new of class EnableIdentityMessage */ 00619 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new01 00620 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new01(lua_State* tolua_S) 00621 { 00622 tolua_Error tolua_err; 00623 if ( 00624 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::EnableIdentityMessage",0,&tolua_err) || 00625 !tolua_isnoobj(tolua_S,2,&tolua_err) 00626 ) 00627 goto tolua_lerror; 00628 else 00629 { 00630 { 00631 fawkes::FacerInterface::EnableIdentityMessage* tolua_ret = (fawkes::FacerInterface::EnableIdentityMessage*) Mtolua_new((fawkes::FacerInterface::EnableIdentityMessage)()); 00632 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::EnableIdentityMessage"); 00633 } 00634 } 00635 return 1; 00636 tolua_lerror: 00637 return tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new00(tolua_S); 00638 } 00639 #endif //#ifndef TOLUA_DISABLE 00640 00641 /* method: new_local of class EnableIdentityMessage */ 00642 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new01_local 00643 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new01_local(lua_State* tolua_S) 00644 { 00645 tolua_Error tolua_err; 00646 if ( 00647 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::EnableIdentityMessage",0,&tolua_err) || 00648 !tolua_isnoobj(tolua_S,2,&tolua_err) 00649 ) 00650 goto tolua_lerror; 00651 else 00652 { 00653 { 00654 fawkes::FacerInterface::EnableIdentityMessage* tolua_ret = (fawkes::FacerInterface::EnableIdentityMessage*) Mtolua_new((fawkes::FacerInterface::EnableIdentityMessage)()); 00655 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::EnableIdentityMessage"); 00656 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00657 } 00658 } 00659 return 1; 00660 tolua_lerror: 00661 return tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new00_local(tolua_S); 00662 } 00663 #endif //#ifndef TOLUA_DISABLE 00664 00665 /* method: delete of class EnableIdentityMessage */ 00666 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_delete00 00667 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_delete00(lua_State* tolua_S) 00668 { 00669 #ifndef TOLUA_RELEASE 00670 tolua_Error tolua_err; 00671 if ( 00672 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::EnableIdentityMessage",0,&tolua_err) || 00673 !tolua_isnoobj(tolua_S,2,&tolua_err) 00674 ) 00675 goto tolua_lerror; 00676 else 00677 #endif 00678 { 00679 fawkes::FacerInterface::EnableIdentityMessage* self = (fawkes::FacerInterface::EnableIdentityMessage*) tolua_tousertype(tolua_S,1,0); 00680 #ifndef TOLUA_RELEASE 00681 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00682 #endif 00683 Mtolua_delete(self); 00684 } 00685 return 0; 00686 #ifndef TOLUA_RELEASE 00687 tolua_lerror: 00688 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00689 return 0; 00690 #endif 00691 } 00692 #endif //#ifndef TOLUA_DISABLE 00693 00694 /* method: index of class EnableIdentityMessage */ 00695 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_index00 00696 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_index00(lua_State* tolua_S) 00697 { 00698 #ifndef TOLUA_RELEASE 00699 tolua_Error tolua_err; 00700 if ( 00701 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::EnableIdentityMessage",0,&tolua_err) || 00702 !tolua_isnoobj(tolua_S,2,&tolua_err) 00703 ) 00704 goto tolua_lerror; 00705 else 00706 #endif 00707 { 00708 fawkes::FacerInterface::EnableIdentityMessage* self = (fawkes::FacerInterface::EnableIdentityMessage*) tolua_tousertype(tolua_S,1,0); 00709 #ifndef TOLUA_RELEASE 00710 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'index'", NULL); 00711 #endif 00712 { 00713 unsigned int tolua_ret = (unsigned int) self->index(); 00714 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00715 } 00716 } 00717 return 1; 00718 #ifndef TOLUA_RELEASE 00719 tolua_lerror: 00720 tolua_error(tolua_S,"#ferror in function 'index'.",&tolua_err); 00721 return 0; 00722 #endif 00723 } 00724 #endif //#ifndef TOLUA_DISABLE 00725 00726 /* method: set_index of class EnableIdentityMessage */ 00727 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_set_index00 00728 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_set_index00(lua_State* tolua_S) 00729 { 00730 #ifndef TOLUA_RELEASE 00731 tolua_Error tolua_err; 00732 if ( 00733 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::EnableIdentityMessage",0,&tolua_err) || 00734 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00735 !tolua_isnoobj(tolua_S,3,&tolua_err) 00736 ) 00737 goto tolua_lerror; 00738 else 00739 #endif 00740 { 00741 fawkes::FacerInterface::EnableIdentityMessage* self = (fawkes::FacerInterface::EnableIdentityMessage*) tolua_tousertype(tolua_S,1,0); 00742 unsigned const int new_index = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 00743 #ifndef TOLUA_RELEASE 00744 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_index'", NULL); 00745 #endif 00746 { 00747 self->set_index(new_index); 00748 } 00749 } 00750 return 0; 00751 #ifndef TOLUA_RELEASE 00752 tolua_lerror: 00753 tolua_error(tolua_S,"#ferror in function 'set_index'.",&tolua_err); 00754 return 0; 00755 #endif 00756 } 00757 #endif //#ifndef TOLUA_DISABLE 00758 00759 /* method: maxlenof_index of class EnableIdentityMessage */ 00760 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_maxlenof_index00 00761 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_maxlenof_index00(lua_State* tolua_S) 00762 { 00763 #ifndef TOLUA_RELEASE 00764 tolua_Error tolua_err; 00765 if ( 00766 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface::EnableIdentityMessage",0,&tolua_err) || 00767 !tolua_isnoobj(tolua_S,2,&tolua_err) 00768 ) 00769 goto tolua_lerror; 00770 else 00771 #endif 00772 { 00773 const fawkes::FacerInterface::EnableIdentityMessage* self = (const fawkes::FacerInterface::EnableIdentityMessage*) tolua_tousertype(tolua_S,1,0); 00774 #ifndef TOLUA_RELEASE 00775 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_index'", NULL); 00776 #endif 00777 { 00778 int tolua_ret = (int) self->maxlenof_index(); 00779 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00780 } 00781 } 00782 return 1; 00783 #ifndef TOLUA_RELEASE 00784 tolua_lerror: 00785 tolua_error(tolua_S,"#ferror in function 'maxlenof_index'.",&tolua_err); 00786 return 0; 00787 #endif 00788 } 00789 #endif //#ifndef TOLUA_DISABLE 00790 00791 /* method: is_enable of class EnableIdentityMessage */ 00792 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_is_enable00 00793 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_is_enable00(lua_State* tolua_S) 00794 { 00795 #ifndef TOLUA_RELEASE 00796 tolua_Error tolua_err; 00797 if ( 00798 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::EnableIdentityMessage",0,&tolua_err) || 00799 !tolua_isnoobj(tolua_S,2,&tolua_err) 00800 ) 00801 goto tolua_lerror; 00802 else 00803 #endif 00804 { 00805 fawkes::FacerInterface::EnableIdentityMessage* self = (fawkes::FacerInterface::EnableIdentityMessage*) tolua_tousertype(tolua_S,1,0); 00806 #ifndef TOLUA_RELEASE 00807 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_enable'", NULL); 00808 #endif 00809 { 00810 bool tolua_ret = (bool) self->is_enable(); 00811 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00812 } 00813 } 00814 return 1; 00815 #ifndef TOLUA_RELEASE 00816 tolua_lerror: 00817 tolua_error(tolua_S,"#ferror in function 'is_enable'.",&tolua_err); 00818 return 0; 00819 #endif 00820 } 00821 #endif //#ifndef TOLUA_DISABLE 00822 00823 /* method: set_enable of class EnableIdentityMessage */ 00824 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_set_enable00 00825 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_set_enable00(lua_State* tolua_S) 00826 { 00827 #ifndef TOLUA_RELEASE 00828 tolua_Error tolua_err; 00829 if ( 00830 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::EnableIdentityMessage",0,&tolua_err) || 00831 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 00832 !tolua_isnoobj(tolua_S,3,&tolua_err) 00833 ) 00834 goto tolua_lerror; 00835 else 00836 #endif 00837 { 00838 fawkes::FacerInterface::EnableIdentityMessage* self = (fawkes::FacerInterface::EnableIdentityMessage*) tolua_tousertype(tolua_S,1,0); 00839 const bool new_enable = ((const bool) tolua_toboolean(tolua_S,2,0)); 00840 #ifndef TOLUA_RELEASE 00841 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_enable'", NULL); 00842 #endif 00843 { 00844 self->set_enable(new_enable); 00845 } 00846 } 00847 return 0; 00848 #ifndef TOLUA_RELEASE 00849 tolua_lerror: 00850 tolua_error(tolua_S,"#ferror in function 'set_enable'.",&tolua_err); 00851 return 0; 00852 #endif 00853 } 00854 #endif //#ifndef TOLUA_DISABLE 00855 00856 /* method: maxlenof_enable of class EnableIdentityMessage */ 00857 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_maxlenof_enable00 00858 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_maxlenof_enable00(lua_State* tolua_S) 00859 { 00860 #ifndef TOLUA_RELEASE 00861 tolua_Error tolua_err; 00862 if ( 00863 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface::EnableIdentityMessage",0,&tolua_err) || 00864 !tolua_isnoobj(tolua_S,2,&tolua_err) 00865 ) 00866 goto tolua_lerror; 00867 else 00868 #endif 00869 { 00870 const fawkes::FacerInterface::EnableIdentityMessage* self = (const fawkes::FacerInterface::EnableIdentityMessage*) tolua_tousertype(tolua_S,1,0); 00871 #ifndef TOLUA_RELEASE 00872 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_enable'", NULL); 00873 #endif 00874 { 00875 int tolua_ret = (int) self->maxlenof_enable(); 00876 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00877 } 00878 } 00879 return 1; 00880 #ifndef TOLUA_RELEASE 00881 tolua_lerror: 00882 tolua_error(tolua_S,"#ferror in function 'maxlenof_enable'.",&tolua_err); 00883 return 0; 00884 #endif 00885 } 00886 #endif //#ifndef TOLUA_DISABLE 00887 00888 /* method: new of class SetNameMessage */ 00889 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new00 00890 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new00(lua_State* tolua_S) 00891 { 00892 #ifndef TOLUA_RELEASE 00893 tolua_Error tolua_err; 00894 if ( 00895 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::SetNameMessage",0,&tolua_err) || 00896 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00897 !tolua_isstring(tolua_S,3,0,&tolua_err) || 00898 !tolua_isnoobj(tolua_S,4,&tolua_err) 00899 ) 00900 goto tolua_lerror; 00901 else 00902 #endif 00903 { 00904 unsigned int ini_index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 00905 char* ini_name = ((char*) tolua_tostring(tolua_S,3,0)); 00906 { 00907 fawkes::FacerInterface::SetNameMessage* tolua_ret = (fawkes::FacerInterface::SetNameMessage*) Mtolua_new((fawkes::FacerInterface::SetNameMessage)(ini_index,ini_name)); 00908 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::SetNameMessage"); 00909 } 00910 } 00911 return 1; 00912 #ifndef TOLUA_RELEASE 00913 tolua_lerror: 00914 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00915 return 0; 00916 #endif 00917 } 00918 #endif //#ifndef TOLUA_DISABLE 00919 00920 /* method: new_local of class SetNameMessage */ 00921 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new00_local 00922 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new00_local(lua_State* tolua_S) 00923 { 00924 #ifndef TOLUA_RELEASE 00925 tolua_Error tolua_err; 00926 if ( 00927 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::SetNameMessage",0,&tolua_err) || 00928 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00929 !tolua_isstring(tolua_S,3,0,&tolua_err) || 00930 !tolua_isnoobj(tolua_S,4,&tolua_err) 00931 ) 00932 goto tolua_lerror; 00933 else 00934 #endif 00935 { 00936 unsigned int ini_index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 00937 char* ini_name = ((char*) tolua_tostring(tolua_S,3,0)); 00938 { 00939 fawkes::FacerInterface::SetNameMessage* tolua_ret = (fawkes::FacerInterface::SetNameMessage*) Mtolua_new((fawkes::FacerInterface::SetNameMessage)(ini_index,ini_name)); 00940 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::SetNameMessage"); 00941 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00942 } 00943 } 00944 return 1; 00945 #ifndef TOLUA_RELEASE 00946 tolua_lerror: 00947 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00948 return 0; 00949 #endif 00950 } 00951 #endif //#ifndef TOLUA_DISABLE 00952 00953 /* method: new of class SetNameMessage */ 00954 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new01 00955 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new01(lua_State* tolua_S) 00956 { 00957 tolua_Error tolua_err; 00958 if ( 00959 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::SetNameMessage",0,&tolua_err) || 00960 !tolua_isnoobj(tolua_S,2,&tolua_err) 00961 ) 00962 goto tolua_lerror; 00963 else 00964 { 00965 { 00966 fawkes::FacerInterface::SetNameMessage* tolua_ret = (fawkes::FacerInterface::SetNameMessage*) Mtolua_new((fawkes::FacerInterface::SetNameMessage)()); 00967 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::SetNameMessage"); 00968 } 00969 } 00970 return 1; 00971 tolua_lerror: 00972 return tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new00(tolua_S); 00973 } 00974 #endif //#ifndef TOLUA_DISABLE 00975 00976 /* method: new_local of class SetNameMessage */ 00977 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new01_local 00978 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new01_local(lua_State* tolua_S) 00979 { 00980 tolua_Error tolua_err; 00981 if ( 00982 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::SetNameMessage",0,&tolua_err) || 00983 !tolua_isnoobj(tolua_S,2,&tolua_err) 00984 ) 00985 goto tolua_lerror; 00986 else 00987 { 00988 { 00989 fawkes::FacerInterface::SetNameMessage* tolua_ret = (fawkes::FacerInterface::SetNameMessage*) Mtolua_new((fawkes::FacerInterface::SetNameMessage)()); 00990 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::SetNameMessage"); 00991 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00992 } 00993 } 00994 return 1; 00995 tolua_lerror: 00996 return tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new00_local(tolua_S); 00997 } 00998 #endif //#ifndef TOLUA_DISABLE 00999 01000 /* method: delete of class SetNameMessage */ 01001 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_delete00 01002 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_delete00(lua_State* tolua_S) 01003 { 01004 #ifndef TOLUA_RELEASE 01005 tolua_Error tolua_err; 01006 if ( 01007 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::SetNameMessage",0,&tolua_err) || 01008 !tolua_isnoobj(tolua_S,2,&tolua_err) 01009 ) 01010 goto tolua_lerror; 01011 else 01012 #endif 01013 { 01014 fawkes::FacerInterface::SetNameMessage* self = (fawkes::FacerInterface::SetNameMessage*) tolua_tousertype(tolua_S,1,0); 01015 #ifndef TOLUA_RELEASE 01016 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 01017 #endif 01018 Mtolua_delete(self); 01019 } 01020 return 0; 01021 #ifndef TOLUA_RELEASE 01022 tolua_lerror: 01023 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 01024 return 0; 01025 #endif 01026 } 01027 #endif //#ifndef TOLUA_DISABLE 01028 01029 /* method: index of class SetNameMessage */ 01030 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_index00 01031 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_index00(lua_State* tolua_S) 01032 { 01033 #ifndef TOLUA_RELEASE 01034 tolua_Error tolua_err; 01035 if ( 01036 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::SetNameMessage",0,&tolua_err) || 01037 !tolua_isnoobj(tolua_S,2,&tolua_err) 01038 ) 01039 goto tolua_lerror; 01040 else 01041 #endif 01042 { 01043 fawkes::FacerInterface::SetNameMessage* self = (fawkes::FacerInterface::SetNameMessage*) tolua_tousertype(tolua_S,1,0); 01044 #ifndef TOLUA_RELEASE 01045 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'index'", NULL); 01046 #endif 01047 { 01048 unsigned int tolua_ret = (unsigned int) self->index(); 01049 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01050 } 01051 } 01052 return 1; 01053 #ifndef TOLUA_RELEASE 01054 tolua_lerror: 01055 tolua_error(tolua_S,"#ferror in function 'index'.",&tolua_err); 01056 return 0; 01057 #endif 01058 } 01059 #endif //#ifndef TOLUA_DISABLE 01060 01061 /* method: set_index of class SetNameMessage */ 01062 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_set_index00 01063 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_set_index00(lua_State* tolua_S) 01064 { 01065 #ifndef TOLUA_RELEASE 01066 tolua_Error tolua_err; 01067 if ( 01068 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::SetNameMessage",0,&tolua_err) || 01069 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01070 !tolua_isnoobj(tolua_S,3,&tolua_err) 01071 ) 01072 goto tolua_lerror; 01073 else 01074 #endif 01075 { 01076 fawkes::FacerInterface::SetNameMessage* self = (fawkes::FacerInterface::SetNameMessage*) tolua_tousertype(tolua_S,1,0); 01077 unsigned const int new_index = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 01078 #ifndef TOLUA_RELEASE 01079 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_index'", NULL); 01080 #endif 01081 { 01082 self->set_index(new_index); 01083 } 01084 } 01085 return 0; 01086 #ifndef TOLUA_RELEASE 01087 tolua_lerror: 01088 tolua_error(tolua_S,"#ferror in function 'set_index'.",&tolua_err); 01089 return 0; 01090 #endif 01091 } 01092 #endif //#ifndef TOLUA_DISABLE 01093 01094 /* method: maxlenof_index of class SetNameMessage */ 01095 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_maxlenof_index00 01096 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_maxlenof_index00(lua_State* tolua_S) 01097 { 01098 #ifndef TOLUA_RELEASE 01099 tolua_Error tolua_err; 01100 if ( 01101 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface::SetNameMessage",0,&tolua_err) || 01102 !tolua_isnoobj(tolua_S,2,&tolua_err) 01103 ) 01104 goto tolua_lerror; 01105 else 01106 #endif 01107 { 01108 const fawkes::FacerInterface::SetNameMessage* self = (const fawkes::FacerInterface::SetNameMessage*) tolua_tousertype(tolua_S,1,0); 01109 #ifndef TOLUA_RELEASE 01110 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_index'", NULL); 01111 #endif 01112 { 01113 int tolua_ret = (int) self->maxlenof_index(); 01114 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01115 } 01116 } 01117 return 1; 01118 #ifndef TOLUA_RELEASE 01119 tolua_lerror: 01120 tolua_error(tolua_S,"#ferror in function 'maxlenof_index'.",&tolua_err); 01121 return 0; 01122 #endif 01123 } 01124 #endif //#ifndef TOLUA_DISABLE 01125 01126 /* method: name of class SetNameMessage */ 01127 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_name00 01128 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_name00(lua_State* tolua_S) 01129 { 01130 #ifndef TOLUA_RELEASE 01131 tolua_Error tolua_err; 01132 if ( 01133 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::SetNameMessage",0,&tolua_err) || 01134 !tolua_isnoobj(tolua_S,2,&tolua_err) 01135 ) 01136 goto tolua_lerror; 01137 else 01138 #endif 01139 { 01140 fawkes::FacerInterface::SetNameMessage* self = (fawkes::FacerInterface::SetNameMessage*) tolua_tousertype(tolua_S,1,0); 01141 #ifndef TOLUA_RELEASE 01142 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL); 01143 #endif 01144 { 01145 char* tolua_ret = (char*) self->name(); 01146 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01147 } 01148 } 01149 return 1; 01150 #ifndef TOLUA_RELEASE 01151 tolua_lerror: 01152 tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err); 01153 return 0; 01154 #endif 01155 } 01156 #endif //#ifndef TOLUA_DISABLE 01157 01158 /* method: set_name of class SetNameMessage */ 01159 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_set_name00 01160 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_set_name00(lua_State* tolua_S) 01161 { 01162 #ifndef TOLUA_RELEASE 01163 tolua_Error tolua_err; 01164 if ( 01165 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::SetNameMessage",0,&tolua_err) || 01166 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01167 !tolua_isnoobj(tolua_S,3,&tolua_err) 01168 ) 01169 goto tolua_lerror; 01170 else 01171 #endif 01172 { 01173 fawkes::FacerInterface::SetNameMessage* self = (fawkes::FacerInterface::SetNameMessage*) tolua_tousertype(tolua_S,1,0); 01174 const char* new_name = ((const char*) tolua_tostring(tolua_S,2,0)); 01175 #ifndef TOLUA_RELEASE 01176 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_name'", NULL); 01177 #endif 01178 { 01179 self->set_name(new_name); 01180 } 01181 } 01182 return 0; 01183 #ifndef TOLUA_RELEASE 01184 tolua_lerror: 01185 tolua_error(tolua_S,"#ferror in function 'set_name'.",&tolua_err); 01186 return 0; 01187 #endif 01188 } 01189 #endif //#ifndef TOLUA_DISABLE 01190 01191 /* method: maxlenof_name of class SetNameMessage */ 01192 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_maxlenof_name00 01193 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_maxlenof_name00(lua_State* tolua_S) 01194 { 01195 #ifndef TOLUA_RELEASE 01196 tolua_Error tolua_err; 01197 if ( 01198 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface::SetNameMessage",0,&tolua_err) || 01199 !tolua_isnoobj(tolua_S,2,&tolua_err) 01200 ) 01201 goto tolua_lerror; 01202 else 01203 #endif 01204 { 01205 const fawkes::FacerInterface::SetNameMessage* self = (const fawkes::FacerInterface::SetNameMessage*) tolua_tousertype(tolua_S,1,0); 01206 #ifndef TOLUA_RELEASE 01207 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_name'", NULL); 01208 #endif 01209 { 01210 int tolua_ret = (int) self->maxlenof_name(); 01211 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01212 } 01213 } 01214 return 1; 01215 #ifndef TOLUA_RELEASE 01216 tolua_lerror: 01217 tolua_error(tolua_S,"#ferror in function 'maxlenof_name'.",&tolua_err); 01218 return 0; 01219 #endif 01220 } 01221 #endif //#ifndef TOLUA_DISABLE 01222 01223 /* method: new of class GetNameMessage */ 01224 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new00 01225 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new00(lua_State* tolua_S) 01226 { 01227 #ifndef TOLUA_RELEASE 01228 tolua_Error tolua_err; 01229 if ( 01230 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::GetNameMessage",0,&tolua_err) || 01231 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01232 !tolua_isnoobj(tolua_S,3,&tolua_err) 01233 ) 01234 goto tolua_lerror; 01235 else 01236 #endif 01237 { 01238 unsigned int ini_index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 01239 { 01240 fawkes::FacerInterface::GetNameMessage* tolua_ret = (fawkes::FacerInterface::GetNameMessage*) Mtolua_new((fawkes::FacerInterface::GetNameMessage)(ini_index)); 01241 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::GetNameMessage"); 01242 } 01243 } 01244 return 1; 01245 #ifndef TOLUA_RELEASE 01246 tolua_lerror: 01247 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01248 return 0; 01249 #endif 01250 } 01251 #endif //#ifndef TOLUA_DISABLE 01252 01253 /* method: new_local of class GetNameMessage */ 01254 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new00_local 01255 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new00_local(lua_State* tolua_S) 01256 { 01257 #ifndef TOLUA_RELEASE 01258 tolua_Error tolua_err; 01259 if ( 01260 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::GetNameMessage",0,&tolua_err) || 01261 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01262 !tolua_isnoobj(tolua_S,3,&tolua_err) 01263 ) 01264 goto tolua_lerror; 01265 else 01266 #endif 01267 { 01268 unsigned int ini_index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 01269 { 01270 fawkes::FacerInterface::GetNameMessage* tolua_ret = (fawkes::FacerInterface::GetNameMessage*) Mtolua_new((fawkes::FacerInterface::GetNameMessage)(ini_index)); 01271 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::GetNameMessage"); 01272 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01273 } 01274 } 01275 return 1; 01276 #ifndef TOLUA_RELEASE 01277 tolua_lerror: 01278 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01279 return 0; 01280 #endif 01281 } 01282 #endif //#ifndef TOLUA_DISABLE 01283 01284 /* method: new of class GetNameMessage */ 01285 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new01 01286 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new01(lua_State* tolua_S) 01287 { 01288 tolua_Error tolua_err; 01289 if ( 01290 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::GetNameMessage",0,&tolua_err) || 01291 !tolua_isnoobj(tolua_S,2,&tolua_err) 01292 ) 01293 goto tolua_lerror; 01294 else 01295 { 01296 { 01297 fawkes::FacerInterface::GetNameMessage* tolua_ret = (fawkes::FacerInterface::GetNameMessage*) Mtolua_new((fawkes::FacerInterface::GetNameMessage)()); 01298 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::GetNameMessage"); 01299 } 01300 } 01301 return 1; 01302 tolua_lerror: 01303 return tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new00(tolua_S); 01304 } 01305 #endif //#ifndef TOLUA_DISABLE 01306 01307 /* method: new_local of class GetNameMessage */ 01308 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new01_local 01309 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new01_local(lua_State* tolua_S) 01310 { 01311 tolua_Error tolua_err; 01312 if ( 01313 !tolua_isusertable(tolua_S,1,"fawkes::FacerInterface::GetNameMessage",0,&tolua_err) || 01314 !tolua_isnoobj(tolua_S,2,&tolua_err) 01315 ) 01316 goto tolua_lerror; 01317 else 01318 { 01319 { 01320 fawkes::FacerInterface::GetNameMessage* tolua_ret = (fawkes::FacerInterface::GetNameMessage*) Mtolua_new((fawkes::FacerInterface::GetNameMessage)()); 01321 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacerInterface::GetNameMessage"); 01322 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01323 } 01324 } 01325 return 1; 01326 tolua_lerror: 01327 return tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new00_local(tolua_S); 01328 } 01329 #endif //#ifndef TOLUA_DISABLE 01330 01331 /* method: delete of class GetNameMessage */ 01332 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_delete00 01333 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_delete00(lua_State* tolua_S) 01334 { 01335 #ifndef TOLUA_RELEASE 01336 tolua_Error tolua_err; 01337 if ( 01338 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::GetNameMessage",0,&tolua_err) || 01339 !tolua_isnoobj(tolua_S,2,&tolua_err) 01340 ) 01341 goto tolua_lerror; 01342 else 01343 #endif 01344 { 01345 fawkes::FacerInterface::GetNameMessage* self = (fawkes::FacerInterface::GetNameMessage*) tolua_tousertype(tolua_S,1,0); 01346 #ifndef TOLUA_RELEASE 01347 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 01348 #endif 01349 Mtolua_delete(self); 01350 } 01351 return 0; 01352 #ifndef TOLUA_RELEASE 01353 tolua_lerror: 01354 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 01355 return 0; 01356 #endif 01357 } 01358 #endif //#ifndef TOLUA_DISABLE 01359 01360 /* method: index of class GetNameMessage */ 01361 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_index00 01362 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_index00(lua_State* tolua_S) 01363 { 01364 #ifndef TOLUA_RELEASE 01365 tolua_Error tolua_err; 01366 if ( 01367 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::GetNameMessage",0,&tolua_err) || 01368 !tolua_isnoobj(tolua_S,2,&tolua_err) 01369 ) 01370 goto tolua_lerror; 01371 else 01372 #endif 01373 { 01374 fawkes::FacerInterface::GetNameMessage* self = (fawkes::FacerInterface::GetNameMessage*) tolua_tousertype(tolua_S,1,0); 01375 #ifndef TOLUA_RELEASE 01376 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'index'", NULL); 01377 #endif 01378 { 01379 unsigned int tolua_ret = (unsigned int) self->index(); 01380 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01381 } 01382 } 01383 return 1; 01384 #ifndef TOLUA_RELEASE 01385 tolua_lerror: 01386 tolua_error(tolua_S,"#ferror in function 'index'.",&tolua_err); 01387 return 0; 01388 #endif 01389 } 01390 #endif //#ifndef TOLUA_DISABLE 01391 01392 /* method: set_index of class GetNameMessage */ 01393 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_set_index00 01394 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_set_index00(lua_State* tolua_S) 01395 { 01396 #ifndef TOLUA_RELEASE 01397 tolua_Error tolua_err; 01398 if ( 01399 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface::GetNameMessage",0,&tolua_err) || 01400 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01401 !tolua_isnoobj(tolua_S,3,&tolua_err) 01402 ) 01403 goto tolua_lerror; 01404 else 01405 #endif 01406 { 01407 fawkes::FacerInterface::GetNameMessage* self = (fawkes::FacerInterface::GetNameMessage*) tolua_tousertype(tolua_S,1,0); 01408 unsigned const int new_index = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 01409 #ifndef TOLUA_RELEASE 01410 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_index'", NULL); 01411 #endif 01412 { 01413 self->set_index(new_index); 01414 } 01415 } 01416 return 0; 01417 #ifndef TOLUA_RELEASE 01418 tolua_lerror: 01419 tolua_error(tolua_S,"#ferror in function 'set_index'.",&tolua_err); 01420 return 0; 01421 #endif 01422 } 01423 #endif //#ifndef TOLUA_DISABLE 01424 01425 /* method: maxlenof_index of class GetNameMessage */ 01426 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_maxlenof_index00 01427 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_maxlenof_index00(lua_State* tolua_S) 01428 { 01429 #ifndef TOLUA_RELEASE 01430 tolua_Error tolua_err; 01431 if ( 01432 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface::GetNameMessage",0,&tolua_err) || 01433 !tolua_isnoobj(tolua_S,2,&tolua_err) 01434 ) 01435 goto tolua_lerror; 01436 else 01437 #endif 01438 { 01439 const fawkes::FacerInterface::GetNameMessage* self = (const fawkes::FacerInterface::GetNameMessage*) tolua_tousertype(tolua_S,1,0); 01440 #ifndef TOLUA_RELEASE 01441 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_index'", NULL); 01442 #endif 01443 { 01444 int tolua_ret = (int) self->maxlenof_index(); 01445 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01446 } 01447 } 01448 return 1; 01449 #ifndef TOLUA_RELEASE 01450 tolua_lerror: 01451 tolua_error(tolua_S,"#ferror in function 'maxlenof_index'.",&tolua_err); 01452 return 0; 01453 #endif 01454 } 01455 #endif //#ifndef TOLUA_DISABLE 01456 01457 /* method: opmode of class fawkes::FacerInterface */ 01458 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_opmode00 01459 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_opmode00(lua_State* tolua_S) 01460 { 01461 #ifndef TOLUA_RELEASE 01462 tolua_Error tolua_err; 01463 if ( 01464 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 01465 !tolua_isnoobj(tolua_S,2,&tolua_err) 01466 ) 01467 goto tolua_lerror; 01468 else 01469 #endif 01470 { 01471 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01472 #ifndef TOLUA_RELEASE 01473 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'opmode'", NULL); 01474 #endif 01475 { 01476 fawkes::FacerInterface::if_facer_opmode_t tolua_ret = (fawkes::FacerInterface::if_facer_opmode_t) self->opmode(); 01477 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01478 } 01479 } 01480 return 1; 01481 #ifndef TOLUA_RELEASE 01482 tolua_lerror: 01483 tolua_error(tolua_S,"#ferror in function 'opmode'.",&tolua_err); 01484 return 0; 01485 #endif 01486 } 01487 #endif //#ifndef TOLUA_DISABLE 01488 01489 /* method: set_opmode of class fawkes::FacerInterface */ 01490 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_opmode00 01491 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_opmode00(lua_State* tolua_S) 01492 { 01493 #ifndef TOLUA_RELEASE 01494 tolua_Error tolua_err; 01495 if ( 01496 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 01497 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01498 !tolua_isnoobj(tolua_S,3,&tolua_err) 01499 ) 01500 goto tolua_lerror; 01501 else 01502 #endif 01503 { 01504 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01505 const fawkes::FacerInterface::if_facer_opmode_t new_opmode = ((const fawkes::FacerInterface::if_facer_opmode_t) (int) tolua_tonumber(tolua_S,2,0)); 01506 #ifndef TOLUA_RELEASE 01507 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_opmode'", NULL); 01508 #endif 01509 { 01510 self->set_opmode(new_opmode); 01511 } 01512 } 01513 return 0; 01514 #ifndef TOLUA_RELEASE 01515 tolua_lerror: 01516 tolua_error(tolua_S,"#ferror in function 'set_opmode'.",&tolua_err); 01517 return 0; 01518 #endif 01519 } 01520 #endif //#ifndef TOLUA_DISABLE 01521 01522 /* method: maxlenof_opmode of class fawkes::FacerInterface */ 01523 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_opmode00 01524 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_opmode00(lua_State* tolua_S) 01525 { 01526 #ifndef TOLUA_RELEASE 01527 tolua_Error tolua_err; 01528 if ( 01529 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 01530 !tolua_isnoobj(tolua_S,2,&tolua_err) 01531 ) 01532 goto tolua_lerror; 01533 else 01534 #endif 01535 { 01536 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01537 #ifndef TOLUA_RELEASE 01538 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_opmode'", NULL); 01539 #endif 01540 { 01541 int tolua_ret = (int) self->maxlenof_opmode(); 01542 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01543 } 01544 } 01545 return 1; 01546 #ifndef TOLUA_RELEASE 01547 tolua_lerror: 01548 tolua_error(tolua_S,"#ferror in function 'maxlenof_opmode'.",&tolua_err); 01549 return 0; 01550 #endif 01551 } 01552 #endif //#ifndef TOLUA_DISABLE 01553 01554 /* method: num_identities of class fawkes::FacerInterface */ 01555 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_num_identities00 01556 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_num_identities00(lua_State* tolua_S) 01557 { 01558 #ifndef TOLUA_RELEASE 01559 tolua_Error tolua_err; 01560 if ( 01561 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 01562 !tolua_isnoobj(tolua_S,2,&tolua_err) 01563 ) 01564 goto tolua_lerror; 01565 else 01566 #endif 01567 { 01568 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01569 #ifndef TOLUA_RELEASE 01570 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_identities'", NULL); 01571 #endif 01572 { 01573 unsigned int tolua_ret = (unsigned int) self->num_identities(); 01574 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01575 } 01576 } 01577 return 1; 01578 #ifndef TOLUA_RELEASE 01579 tolua_lerror: 01580 tolua_error(tolua_S,"#ferror in function 'num_identities'.",&tolua_err); 01581 return 0; 01582 #endif 01583 } 01584 #endif //#ifndef TOLUA_DISABLE 01585 01586 /* method: set_num_identities of class fawkes::FacerInterface */ 01587 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_num_identities00 01588 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_num_identities00(lua_State* tolua_S) 01589 { 01590 #ifndef TOLUA_RELEASE 01591 tolua_Error tolua_err; 01592 if ( 01593 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 01594 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01595 !tolua_isnoobj(tolua_S,3,&tolua_err) 01596 ) 01597 goto tolua_lerror; 01598 else 01599 #endif 01600 { 01601 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01602 unsigned const int new_num_identities = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 01603 #ifndef TOLUA_RELEASE 01604 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_num_identities'", NULL); 01605 #endif 01606 { 01607 self->set_num_identities(new_num_identities); 01608 } 01609 } 01610 return 0; 01611 #ifndef TOLUA_RELEASE 01612 tolua_lerror: 01613 tolua_error(tolua_S,"#ferror in function 'set_num_identities'.",&tolua_err); 01614 return 0; 01615 #endif 01616 } 01617 #endif //#ifndef TOLUA_DISABLE 01618 01619 /* method: maxlenof_num_identities of class fawkes::FacerInterface */ 01620 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_num_identities00 01621 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_num_identities00(lua_State* tolua_S) 01622 { 01623 #ifndef TOLUA_RELEASE 01624 tolua_Error tolua_err; 01625 if ( 01626 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 01627 !tolua_isnoobj(tolua_S,2,&tolua_err) 01628 ) 01629 goto tolua_lerror; 01630 else 01631 #endif 01632 { 01633 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01634 #ifndef TOLUA_RELEASE 01635 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_num_identities'", NULL); 01636 #endif 01637 { 01638 int tolua_ret = (int) self->maxlenof_num_identities(); 01639 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01640 } 01641 } 01642 return 1; 01643 #ifndef TOLUA_RELEASE 01644 tolua_lerror: 01645 tolua_error(tolua_S,"#ferror in function 'maxlenof_num_identities'.",&tolua_err); 01646 return 0; 01647 #endif 01648 } 01649 #endif //#ifndef TOLUA_DISABLE 01650 01651 /* method: recognized_identity of class fawkes::FacerInterface */ 01652 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_recognized_identity00 01653 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_recognized_identity00(lua_State* tolua_S) 01654 { 01655 #ifndef TOLUA_RELEASE 01656 tolua_Error tolua_err; 01657 if ( 01658 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 01659 !tolua_isnoobj(tolua_S,2,&tolua_err) 01660 ) 01661 goto tolua_lerror; 01662 else 01663 #endif 01664 { 01665 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01666 #ifndef TOLUA_RELEASE 01667 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'recognized_identity'", NULL); 01668 #endif 01669 { 01670 unsigned int tolua_ret = (unsigned int) self->recognized_identity(); 01671 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01672 } 01673 } 01674 return 1; 01675 #ifndef TOLUA_RELEASE 01676 tolua_lerror: 01677 tolua_error(tolua_S,"#ferror in function 'recognized_identity'.",&tolua_err); 01678 return 0; 01679 #endif 01680 } 01681 #endif //#ifndef TOLUA_DISABLE 01682 01683 /* method: set_recognized_identity of class fawkes::FacerInterface */ 01684 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_recognized_identity00 01685 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_recognized_identity00(lua_State* tolua_S) 01686 { 01687 #ifndef TOLUA_RELEASE 01688 tolua_Error tolua_err; 01689 if ( 01690 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 01691 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01692 !tolua_isnoobj(tolua_S,3,&tolua_err) 01693 ) 01694 goto tolua_lerror; 01695 else 01696 #endif 01697 { 01698 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01699 unsigned const int new_recognized_identity = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 01700 #ifndef TOLUA_RELEASE 01701 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_recognized_identity'", NULL); 01702 #endif 01703 { 01704 self->set_recognized_identity(new_recognized_identity); 01705 } 01706 } 01707 return 0; 01708 #ifndef TOLUA_RELEASE 01709 tolua_lerror: 01710 tolua_error(tolua_S,"#ferror in function 'set_recognized_identity'.",&tolua_err); 01711 return 0; 01712 #endif 01713 } 01714 #endif //#ifndef TOLUA_DISABLE 01715 01716 /* method: maxlenof_recognized_identity of class fawkes::FacerInterface */ 01717 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_recognized_identity00 01718 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_recognized_identity00(lua_State* tolua_S) 01719 { 01720 #ifndef TOLUA_RELEASE 01721 tolua_Error tolua_err; 01722 if ( 01723 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 01724 !tolua_isnoobj(tolua_S,2,&tolua_err) 01725 ) 01726 goto tolua_lerror; 01727 else 01728 #endif 01729 { 01730 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01731 #ifndef TOLUA_RELEASE 01732 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_recognized_identity'", NULL); 01733 #endif 01734 { 01735 int tolua_ret = (int) self->maxlenof_recognized_identity(); 01736 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01737 } 01738 } 01739 return 1; 01740 #ifndef TOLUA_RELEASE 01741 tolua_lerror: 01742 tolua_error(tolua_S,"#ferror in function 'maxlenof_recognized_identity'.",&tolua_err); 01743 return 0; 01744 #endif 01745 } 01746 #endif //#ifndef TOLUA_DISABLE 01747 01748 /* method: recognized_name of class fawkes::FacerInterface */ 01749 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_recognized_name00 01750 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_recognized_name00(lua_State* tolua_S) 01751 { 01752 #ifndef TOLUA_RELEASE 01753 tolua_Error tolua_err; 01754 if ( 01755 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 01756 !tolua_isnoobj(tolua_S,2,&tolua_err) 01757 ) 01758 goto tolua_lerror; 01759 else 01760 #endif 01761 { 01762 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01763 #ifndef TOLUA_RELEASE 01764 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'recognized_name'", NULL); 01765 #endif 01766 { 01767 char* tolua_ret = (char*) self->recognized_name(); 01768 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01769 } 01770 } 01771 return 1; 01772 #ifndef TOLUA_RELEASE 01773 tolua_lerror: 01774 tolua_error(tolua_S,"#ferror in function 'recognized_name'.",&tolua_err); 01775 return 0; 01776 #endif 01777 } 01778 #endif //#ifndef TOLUA_DISABLE 01779 01780 /* method: set_recognized_name of class fawkes::FacerInterface */ 01781 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_recognized_name00 01782 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_recognized_name00(lua_State* tolua_S) 01783 { 01784 #ifndef TOLUA_RELEASE 01785 tolua_Error tolua_err; 01786 if ( 01787 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 01788 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01789 !tolua_isnoobj(tolua_S,3,&tolua_err) 01790 ) 01791 goto tolua_lerror; 01792 else 01793 #endif 01794 { 01795 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01796 const char* new_recognized_name = ((const char*) tolua_tostring(tolua_S,2,0)); 01797 #ifndef TOLUA_RELEASE 01798 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_recognized_name'", NULL); 01799 #endif 01800 { 01801 self->set_recognized_name(new_recognized_name); 01802 } 01803 } 01804 return 0; 01805 #ifndef TOLUA_RELEASE 01806 tolua_lerror: 01807 tolua_error(tolua_S,"#ferror in function 'set_recognized_name'.",&tolua_err); 01808 return 0; 01809 #endif 01810 } 01811 #endif //#ifndef TOLUA_DISABLE 01812 01813 /* method: maxlenof_recognized_name of class fawkes::FacerInterface */ 01814 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_recognized_name00 01815 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_recognized_name00(lua_State* tolua_S) 01816 { 01817 #ifndef TOLUA_RELEASE 01818 tolua_Error tolua_err; 01819 if ( 01820 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 01821 !tolua_isnoobj(tolua_S,2,&tolua_err) 01822 ) 01823 goto tolua_lerror; 01824 else 01825 #endif 01826 { 01827 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01828 #ifndef TOLUA_RELEASE 01829 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_recognized_name'", NULL); 01830 #endif 01831 { 01832 int tolua_ret = (int) self->maxlenof_recognized_name(); 01833 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01834 } 01835 } 01836 return 1; 01837 #ifndef TOLUA_RELEASE 01838 tolua_lerror: 01839 tolua_error(tolua_S,"#ferror in function 'maxlenof_recognized_name'.",&tolua_err); 01840 return 0; 01841 #endif 01842 } 01843 #endif //#ifndef TOLUA_DISABLE 01844 01845 /* method: num_detections of class fawkes::FacerInterface */ 01846 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_num_detections00 01847 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_num_detections00(lua_State* tolua_S) 01848 { 01849 #ifndef TOLUA_RELEASE 01850 tolua_Error tolua_err; 01851 if ( 01852 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 01853 !tolua_isnoobj(tolua_S,2,&tolua_err) 01854 ) 01855 goto tolua_lerror; 01856 else 01857 #endif 01858 { 01859 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01860 #ifndef TOLUA_RELEASE 01861 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_detections'", NULL); 01862 #endif 01863 { 01864 unsigned int tolua_ret = (unsigned int) self->num_detections(); 01865 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01866 } 01867 } 01868 return 1; 01869 #ifndef TOLUA_RELEASE 01870 tolua_lerror: 01871 tolua_error(tolua_S,"#ferror in function 'num_detections'.",&tolua_err); 01872 return 0; 01873 #endif 01874 } 01875 #endif //#ifndef TOLUA_DISABLE 01876 01877 /* method: set_num_detections of class fawkes::FacerInterface */ 01878 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_num_detections00 01879 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_num_detections00(lua_State* tolua_S) 01880 { 01881 #ifndef TOLUA_RELEASE 01882 tolua_Error tolua_err; 01883 if ( 01884 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 01885 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01886 !tolua_isnoobj(tolua_S,3,&tolua_err) 01887 ) 01888 goto tolua_lerror; 01889 else 01890 #endif 01891 { 01892 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01893 unsigned const int new_num_detections = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 01894 #ifndef TOLUA_RELEASE 01895 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_num_detections'", NULL); 01896 #endif 01897 { 01898 self->set_num_detections(new_num_detections); 01899 } 01900 } 01901 return 0; 01902 #ifndef TOLUA_RELEASE 01903 tolua_lerror: 01904 tolua_error(tolua_S,"#ferror in function 'set_num_detections'.",&tolua_err); 01905 return 0; 01906 #endif 01907 } 01908 #endif //#ifndef TOLUA_DISABLE 01909 01910 /* method: maxlenof_num_detections of class fawkes::FacerInterface */ 01911 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_num_detections00 01912 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_num_detections00(lua_State* tolua_S) 01913 { 01914 #ifndef TOLUA_RELEASE 01915 tolua_Error tolua_err; 01916 if ( 01917 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 01918 !tolua_isnoobj(tolua_S,2,&tolua_err) 01919 ) 01920 goto tolua_lerror; 01921 else 01922 #endif 01923 { 01924 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01925 #ifndef TOLUA_RELEASE 01926 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_num_detections'", NULL); 01927 #endif 01928 { 01929 int tolua_ret = (int) self->maxlenof_num_detections(); 01930 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01931 } 01932 } 01933 return 1; 01934 #ifndef TOLUA_RELEASE 01935 tolua_lerror: 01936 tolua_error(tolua_S,"#ferror in function 'maxlenof_num_detections'.",&tolua_err); 01937 return 0; 01938 #endif 01939 } 01940 #endif //#ifndef TOLUA_DISABLE 01941 01942 /* method: num_recognitions of class fawkes::FacerInterface */ 01943 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_num_recognitions00 01944 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_num_recognitions00(lua_State* tolua_S) 01945 { 01946 #ifndef TOLUA_RELEASE 01947 tolua_Error tolua_err; 01948 if ( 01949 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 01950 !tolua_isnoobj(tolua_S,2,&tolua_err) 01951 ) 01952 goto tolua_lerror; 01953 else 01954 #endif 01955 { 01956 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01957 #ifndef TOLUA_RELEASE 01958 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_recognitions'", NULL); 01959 #endif 01960 { 01961 unsigned int tolua_ret = (unsigned int) self->num_recognitions(); 01962 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01963 } 01964 } 01965 return 1; 01966 #ifndef TOLUA_RELEASE 01967 tolua_lerror: 01968 tolua_error(tolua_S,"#ferror in function 'num_recognitions'.",&tolua_err); 01969 return 0; 01970 #endif 01971 } 01972 #endif //#ifndef TOLUA_DISABLE 01973 01974 /* method: set_num_recognitions of class fawkes::FacerInterface */ 01975 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_num_recognitions00 01976 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_num_recognitions00(lua_State* tolua_S) 01977 { 01978 #ifndef TOLUA_RELEASE 01979 tolua_Error tolua_err; 01980 if ( 01981 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 01982 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01983 !tolua_isnoobj(tolua_S,3,&tolua_err) 01984 ) 01985 goto tolua_lerror; 01986 else 01987 #endif 01988 { 01989 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 01990 unsigned const int new_num_recognitions = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 01991 #ifndef TOLUA_RELEASE 01992 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_num_recognitions'", NULL); 01993 #endif 01994 { 01995 self->set_num_recognitions(new_num_recognitions); 01996 } 01997 } 01998 return 0; 01999 #ifndef TOLUA_RELEASE 02000 tolua_lerror: 02001 tolua_error(tolua_S,"#ferror in function 'set_num_recognitions'.",&tolua_err); 02002 return 0; 02003 #endif 02004 } 02005 #endif //#ifndef TOLUA_DISABLE 02006 02007 /* method: maxlenof_num_recognitions of class fawkes::FacerInterface */ 02008 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_num_recognitions00 02009 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_num_recognitions00(lua_State* tolua_S) 02010 { 02011 #ifndef TOLUA_RELEASE 02012 tolua_Error tolua_err; 02013 if ( 02014 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 02015 !tolua_isnoobj(tolua_S,2,&tolua_err) 02016 ) 02017 goto tolua_lerror; 02018 else 02019 #endif 02020 { 02021 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02022 #ifndef TOLUA_RELEASE 02023 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_num_recognitions'", NULL); 02024 #endif 02025 { 02026 int tolua_ret = (int) self->maxlenof_num_recognitions(); 02027 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02028 } 02029 } 02030 return 1; 02031 #ifndef TOLUA_RELEASE 02032 tolua_lerror: 02033 tolua_error(tolua_S,"#ferror in function 'maxlenof_num_recognitions'.",&tolua_err); 02034 return 0; 02035 #endif 02036 } 02037 #endif //#ifndef TOLUA_DISABLE 02038 02039 /* method: most_likely_identity of class fawkes::FacerInterface */ 02040 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_most_likely_identity00 02041 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_most_likely_identity00(lua_State* tolua_S) 02042 { 02043 #ifndef TOLUA_RELEASE 02044 tolua_Error tolua_err; 02045 if ( 02046 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02047 !tolua_isnoobj(tolua_S,2,&tolua_err) 02048 ) 02049 goto tolua_lerror; 02050 else 02051 #endif 02052 { 02053 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02054 #ifndef TOLUA_RELEASE 02055 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'most_likely_identity'", NULL); 02056 #endif 02057 { 02058 unsigned int tolua_ret = (unsigned int) self->most_likely_identity(); 02059 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02060 } 02061 } 02062 return 1; 02063 #ifndef TOLUA_RELEASE 02064 tolua_lerror: 02065 tolua_error(tolua_S,"#ferror in function 'most_likely_identity'.",&tolua_err); 02066 return 0; 02067 #endif 02068 } 02069 #endif //#ifndef TOLUA_DISABLE 02070 02071 /* method: set_most_likely_identity of class fawkes::FacerInterface */ 02072 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_most_likely_identity00 02073 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_most_likely_identity00(lua_State* tolua_S) 02074 { 02075 #ifndef TOLUA_RELEASE 02076 tolua_Error tolua_err; 02077 if ( 02078 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02079 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02080 !tolua_isnoobj(tolua_S,3,&tolua_err) 02081 ) 02082 goto tolua_lerror; 02083 else 02084 #endif 02085 { 02086 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02087 unsigned const int new_most_likely_identity = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 02088 #ifndef TOLUA_RELEASE 02089 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_most_likely_identity'", NULL); 02090 #endif 02091 { 02092 self->set_most_likely_identity(new_most_likely_identity); 02093 } 02094 } 02095 return 0; 02096 #ifndef TOLUA_RELEASE 02097 tolua_lerror: 02098 tolua_error(tolua_S,"#ferror in function 'set_most_likely_identity'.",&tolua_err); 02099 return 0; 02100 #endif 02101 } 02102 #endif //#ifndef TOLUA_DISABLE 02103 02104 /* method: maxlenof_most_likely_identity of class fawkes::FacerInterface */ 02105 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_most_likely_identity00 02106 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_most_likely_identity00(lua_State* tolua_S) 02107 { 02108 #ifndef TOLUA_RELEASE 02109 tolua_Error tolua_err; 02110 if ( 02111 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 02112 !tolua_isnoobj(tolua_S,2,&tolua_err) 02113 ) 02114 goto tolua_lerror; 02115 else 02116 #endif 02117 { 02118 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02119 #ifndef TOLUA_RELEASE 02120 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_most_likely_identity'", NULL); 02121 #endif 02122 { 02123 int tolua_ret = (int) self->maxlenof_most_likely_identity(); 02124 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02125 } 02126 } 02127 return 1; 02128 #ifndef TOLUA_RELEASE 02129 tolua_lerror: 02130 tolua_error(tolua_S,"#ferror in function 'maxlenof_most_likely_identity'.",&tolua_err); 02131 return 0; 02132 #endif 02133 } 02134 #endif //#ifndef TOLUA_DISABLE 02135 02136 /* method: history_ratio of class fawkes::FacerInterface */ 02137 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_history_ratio00 02138 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_history_ratio00(lua_State* tolua_S) 02139 { 02140 #ifndef TOLUA_RELEASE 02141 tolua_Error tolua_err; 02142 if ( 02143 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02144 !tolua_isnoobj(tolua_S,2,&tolua_err) 02145 ) 02146 goto tolua_lerror; 02147 else 02148 #endif 02149 { 02150 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02151 #ifndef TOLUA_RELEASE 02152 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'history_ratio'", NULL); 02153 #endif 02154 { 02155 float tolua_ret = (float) self->history_ratio(); 02156 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02157 } 02158 } 02159 return 1; 02160 #ifndef TOLUA_RELEASE 02161 tolua_lerror: 02162 tolua_error(tolua_S,"#ferror in function 'history_ratio'.",&tolua_err); 02163 return 0; 02164 #endif 02165 } 02166 #endif //#ifndef TOLUA_DISABLE 02167 02168 /* method: set_history_ratio of class fawkes::FacerInterface */ 02169 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_history_ratio00 02170 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_history_ratio00(lua_State* tolua_S) 02171 { 02172 #ifndef TOLUA_RELEASE 02173 tolua_Error tolua_err; 02174 if ( 02175 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02176 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02177 !tolua_isnoobj(tolua_S,3,&tolua_err) 02178 ) 02179 goto tolua_lerror; 02180 else 02181 #endif 02182 { 02183 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02184 const float new_history_ratio = ((const float) tolua_tonumber(tolua_S,2,0)); 02185 #ifndef TOLUA_RELEASE 02186 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_history_ratio'", NULL); 02187 #endif 02188 { 02189 self->set_history_ratio(new_history_ratio); 02190 } 02191 } 02192 return 0; 02193 #ifndef TOLUA_RELEASE 02194 tolua_lerror: 02195 tolua_error(tolua_S,"#ferror in function 'set_history_ratio'.",&tolua_err); 02196 return 0; 02197 #endif 02198 } 02199 #endif //#ifndef TOLUA_DISABLE 02200 02201 /* method: maxlenof_history_ratio of class fawkes::FacerInterface */ 02202 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_history_ratio00 02203 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_history_ratio00(lua_State* tolua_S) 02204 { 02205 #ifndef TOLUA_RELEASE 02206 tolua_Error tolua_err; 02207 if ( 02208 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 02209 !tolua_isnoobj(tolua_S,2,&tolua_err) 02210 ) 02211 goto tolua_lerror; 02212 else 02213 #endif 02214 { 02215 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02216 #ifndef TOLUA_RELEASE 02217 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_history_ratio'", NULL); 02218 #endif 02219 { 02220 int tolua_ret = (int) self->maxlenof_history_ratio(); 02221 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02222 } 02223 } 02224 return 1; 02225 #ifndef TOLUA_RELEASE 02226 tolua_lerror: 02227 tolua_error(tolua_S,"#ferror in function 'maxlenof_history_ratio'.",&tolua_err); 02228 return 0; 02229 #endif 02230 } 02231 #endif //#ifndef TOLUA_DISABLE 02232 02233 /* method: sec_since_detection of class fawkes::FacerInterface */ 02234 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_sec_since_detection00 02235 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_sec_since_detection00(lua_State* tolua_S) 02236 { 02237 #ifndef TOLUA_RELEASE 02238 tolua_Error tolua_err; 02239 if ( 02240 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02241 !tolua_isnoobj(tolua_S,2,&tolua_err) 02242 ) 02243 goto tolua_lerror; 02244 else 02245 #endif 02246 { 02247 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02248 #ifndef TOLUA_RELEASE 02249 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sec_since_detection'", NULL); 02250 #endif 02251 { 02252 float tolua_ret = (float) self->sec_since_detection(); 02253 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02254 } 02255 } 02256 return 1; 02257 #ifndef TOLUA_RELEASE 02258 tolua_lerror: 02259 tolua_error(tolua_S,"#ferror in function 'sec_since_detection'.",&tolua_err); 02260 return 0; 02261 #endif 02262 } 02263 #endif //#ifndef TOLUA_DISABLE 02264 02265 /* method: set_sec_since_detection of class fawkes::FacerInterface */ 02266 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_sec_since_detection00 02267 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_sec_since_detection00(lua_State* tolua_S) 02268 { 02269 #ifndef TOLUA_RELEASE 02270 tolua_Error tolua_err; 02271 if ( 02272 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02273 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02274 !tolua_isnoobj(tolua_S,3,&tolua_err) 02275 ) 02276 goto tolua_lerror; 02277 else 02278 #endif 02279 { 02280 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02281 const float new_sec_since_detection = ((const float) tolua_tonumber(tolua_S,2,0)); 02282 #ifndef TOLUA_RELEASE 02283 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_sec_since_detection'", NULL); 02284 #endif 02285 { 02286 self->set_sec_since_detection(new_sec_since_detection); 02287 } 02288 } 02289 return 0; 02290 #ifndef TOLUA_RELEASE 02291 tolua_lerror: 02292 tolua_error(tolua_S,"#ferror in function 'set_sec_since_detection'.",&tolua_err); 02293 return 0; 02294 #endif 02295 } 02296 #endif //#ifndef TOLUA_DISABLE 02297 02298 /* method: maxlenof_sec_since_detection of class fawkes::FacerInterface */ 02299 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_sec_since_detection00 02300 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_sec_since_detection00(lua_State* tolua_S) 02301 { 02302 #ifndef TOLUA_RELEASE 02303 tolua_Error tolua_err; 02304 if ( 02305 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 02306 !tolua_isnoobj(tolua_S,2,&tolua_err) 02307 ) 02308 goto tolua_lerror; 02309 else 02310 #endif 02311 { 02312 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02313 #ifndef TOLUA_RELEASE 02314 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_sec_since_detection'", NULL); 02315 #endif 02316 { 02317 int tolua_ret = (int) self->maxlenof_sec_since_detection(); 02318 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02319 } 02320 } 02321 return 1; 02322 #ifndef TOLUA_RELEASE 02323 tolua_lerror: 02324 tolua_error(tolua_S,"#ferror in function 'maxlenof_sec_since_detection'.",&tolua_err); 02325 return 0; 02326 #endif 02327 } 02328 #endif //#ifndef TOLUA_DISABLE 02329 02330 /* method: visibility_history of class fawkes::FacerInterface */ 02331 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_visibility_history00 02332 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_visibility_history00(lua_State* tolua_S) 02333 { 02334 #ifndef TOLUA_RELEASE 02335 tolua_Error tolua_err; 02336 if ( 02337 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02338 !tolua_isnoobj(tolua_S,2,&tolua_err) 02339 ) 02340 goto tolua_lerror; 02341 else 02342 #endif 02343 { 02344 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02345 #ifndef TOLUA_RELEASE 02346 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'visibility_history'", NULL); 02347 #endif 02348 { 02349 int tolua_ret = (int) self->visibility_history(); 02350 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02351 } 02352 } 02353 return 1; 02354 #ifndef TOLUA_RELEASE 02355 tolua_lerror: 02356 tolua_error(tolua_S,"#ferror in function 'visibility_history'.",&tolua_err); 02357 return 0; 02358 #endif 02359 } 02360 #endif //#ifndef TOLUA_DISABLE 02361 02362 /* method: set_visibility_history of class fawkes::FacerInterface */ 02363 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_visibility_history00 02364 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_visibility_history00(lua_State* tolua_S) 02365 { 02366 #ifndef TOLUA_RELEASE 02367 tolua_Error tolua_err; 02368 if ( 02369 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02370 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02371 !tolua_isnoobj(tolua_S,3,&tolua_err) 02372 ) 02373 goto tolua_lerror; 02374 else 02375 #endif 02376 { 02377 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02378 const int new_visibility_history = ((const int) tolua_tonumber(tolua_S,2,0)); 02379 #ifndef TOLUA_RELEASE 02380 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_visibility_history'", NULL); 02381 #endif 02382 { 02383 self->set_visibility_history(new_visibility_history); 02384 } 02385 } 02386 return 0; 02387 #ifndef TOLUA_RELEASE 02388 tolua_lerror: 02389 tolua_error(tolua_S,"#ferror in function 'set_visibility_history'.",&tolua_err); 02390 return 0; 02391 #endif 02392 } 02393 #endif //#ifndef TOLUA_DISABLE 02394 02395 /* method: maxlenof_visibility_history of class fawkes::FacerInterface */ 02396 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_visibility_history00 02397 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_visibility_history00(lua_State* tolua_S) 02398 { 02399 #ifndef TOLUA_RELEASE 02400 tolua_Error tolua_err; 02401 if ( 02402 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 02403 !tolua_isnoobj(tolua_S,2,&tolua_err) 02404 ) 02405 goto tolua_lerror; 02406 else 02407 #endif 02408 { 02409 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02410 #ifndef TOLUA_RELEASE 02411 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_visibility_history'", NULL); 02412 #endif 02413 { 02414 int tolua_ret = (int) self->maxlenof_visibility_history(); 02415 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02416 } 02417 } 02418 return 1; 02419 #ifndef TOLUA_RELEASE 02420 tolua_lerror: 02421 tolua_error(tolua_S,"#ferror in function 'maxlenof_visibility_history'.",&tolua_err); 02422 return 0; 02423 #endif 02424 } 02425 #endif //#ifndef TOLUA_DISABLE 02426 02427 /* method: is_learning_in_progress of class fawkes::FacerInterface */ 02428 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_is_learning_in_progress00 02429 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_is_learning_in_progress00(lua_State* tolua_S) 02430 { 02431 #ifndef TOLUA_RELEASE 02432 tolua_Error tolua_err; 02433 if ( 02434 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02435 !tolua_isnoobj(tolua_S,2,&tolua_err) 02436 ) 02437 goto tolua_lerror; 02438 else 02439 #endif 02440 { 02441 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02442 #ifndef TOLUA_RELEASE 02443 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_learning_in_progress'", NULL); 02444 #endif 02445 { 02446 bool tolua_ret = (bool) self->is_learning_in_progress(); 02447 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02448 } 02449 } 02450 return 1; 02451 #ifndef TOLUA_RELEASE 02452 tolua_lerror: 02453 tolua_error(tolua_S,"#ferror in function 'is_learning_in_progress'.",&tolua_err); 02454 return 0; 02455 #endif 02456 } 02457 #endif //#ifndef TOLUA_DISABLE 02458 02459 /* method: set_learning_in_progress of class fawkes::FacerInterface */ 02460 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_learning_in_progress00 02461 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_learning_in_progress00(lua_State* tolua_S) 02462 { 02463 #ifndef TOLUA_RELEASE 02464 tolua_Error tolua_err; 02465 if ( 02466 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02467 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 02468 !tolua_isnoobj(tolua_S,3,&tolua_err) 02469 ) 02470 goto tolua_lerror; 02471 else 02472 #endif 02473 { 02474 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02475 const bool new_learning_in_progress = ((const bool) tolua_toboolean(tolua_S,2,0)); 02476 #ifndef TOLUA_RELEASE 02477 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_learning_in_progress'", NULL); 02478 #endif 02479 { 02480 self->set_learning_in_progress(new_learning_in_progress); 02481 } 02482 } 02483 return 0; 02484 #ifndef TOLUA_RELEASE 02485 tolua_lerror: 02486 tolua_error(tolua_S,"#ferror in function 'set_learning_in_progress'.",&tolua_err); 02487 return 0; 02488 #endif 02489 } 02490 #endif //#ifndef TOLUA_DISABLE 02491 02492 /* method: maxlenof_learning_in_progress of class fawkes::FacerInterface */ 02493 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_learning_in_progress00 02494 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_learning_in_progress00(lua_State* tolua_S) 02495 { 02496 #ifndef TOLUA_RELEASE 02497 tolua_Error tolua_err; 02498 if ( 02499 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 02500 !tolua_isnoobj(tolua_S,2,&tolua_err) 02501 ) 02502 goto tolua_lerror; 02503 else 02504 #endif 02505 { 02506 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02507 #ifndef TOLUA_RELEASE 02508 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_learning_in_progress'", NULL); 02509 #endif 02510 { 02511 int tolua_ret = (int) self->maxlenof_learning_in_progress(); 02512 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02513 } 02514 } 02515 return 1; 02516 #ifndef TOLUA_RELEASE 02517 tolua_lerror: 02518 tolua_error(tolua_S,"#ferror in function 'maxlenof_learning_in_progress'.",&tolua_err); 02519 return 0; 02520 #endif 02521 } 02522 #endif //#ifndef TOLUA_DISABLE 02523 02524 /* method: recording_progress of class fawkes::FacerInterface */ 02525 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_recording_progress00 02526 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_recording_progress00(lua_State* tolua_S) 02527 { 02528 #ifndef TOLUA_RELEASE 02529 tolua_Error tolua_err; 02530 if ( 02531 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02532 !tolua_isnoobj(tolua_S,2,&tolua_err) 02533 ) 02534 goto tolua_lerror; 02535 else 02536 #endif 02537 { 02538 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02539 #ifndef TOLUA_RELEASE 02540 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'recording_progress'", NULL); 02541 #endif 02542 { 02543 float tolua_ret = (float) self->recording_progress(); 02544 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02545 } 02546 } 02547 return 1; 02548 #ifndef TOLUA_RELEASE 02549 tolua_lerror: 02550 tolua_error(tolua_S,"#ferror in function 'recording_progress'.",&tolua_err); 02551 return 0; 02552 #endif 02553 } 02554 #endif //#ifndef TOLUA_DISABLE 02555 02556 /* method: set_recording_progress of class fawkes::FacerInterface */ 02557 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_recording_progress00 02558 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_recording_progress00(lua_State* tolua_S) 02559 { 02560 #ifndef TOLUA_RELEASE 02561 tolua_Error tolua_err; 02562 if ( 02563 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02564 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02565 !tolua_isnoobj(tolua_S,3,&tolua_err) 02566 ) 02567 goto tolua_lerror; 02568 else 02569 #endif 02570 { 02571 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02572 const float new_recording_progress = ((const float) tolua_tonumber(tolua_S,2,0)); 02573 #ifndef TOLUA_RELEASE 02574 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_recording_progress'", NULL); 02575 #endif 02576 { 02577 self->set_recording_progress(new_recording_progress); 02578 } 02579 } 02580 return 0; 02581 #ifndef TOLUA_RELEASE 02582 tolua_lerror: 02583 tolua_error(tolua_S,"#ferror in function 'set_recording_progress'.",&tolua_err); 02584 return 0; 02585 #endif 02586 } 02587 #endif //#ifndef TOLUA_DISABLE 02588 02589 /* method: maxlenof_recording_progress of class fawkes::FacerInterface */ 02590 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_recording_progress00 02591 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_recording_progress00(lua_State* tolua_S) 02592 { 02593 #ifndef TOLUA_RELEASE 02594 tolua_Error tolua_err; 02595 if ( 02596 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 02597 !tolua_isnoobj(tolua_S,2,&tolua_err) 02598 ) 02599 goto tolua_lerror; 02600 else 02601 #endif 02602 { 02603 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02604 #ifndef TOLUA_RELEASE 02605 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_recording_progress'", NULL); 02606 #endif 02607 { 02608 int tolua_ret = (int) self->maxlenof_recording_progress(); 02609 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02610 } 02611 } 02612 return 1; 02613 #ifndef TOLUA_RELEASE 02614 tolua_lerror: 02615 tolua_error(tolua_S,"#ferror in function 'maxlenof_recording_progress'.",&tolua_err); 02616 return 0; 02617 #endif 02618 } 02619 #endif //#ifndef TOLUA_DISABLE 02620 02621 /* method: bearing of class fawkes::FacerInterface */ 02622 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_bearing00 02623 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_bearing00(lua_State* tolua_S) 02624 { 02625 #ifndef TOLUA_RELEASE 02626 tolua_Error tolua_err; 02627 if ( 02628 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02629 !tolua_isnoobj(tolua_S,2,&tolua_err) 02630 ) 02631 goto tolua_lerror; 02632 else 02633 #endif 02634 { 02635 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02636 #ifndef TOLUA_RELEASE 02637 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'bearing'", NULL); 02638 #endif 02639 { 02640 float tolua_ret = (float) self->bearing(); 02641 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02642 } 02643 } 02644 return 1; 02645 #ifndef TOLUA_RELEASE 02646 tolua_lerror: 02647 tolua_error(tolua_S,"#ferror in function 'bearing'.",&tolua_err); 02648 return 0; 02649 #endif 02650 } 02651 #endif //#ifndef TOLUA_DISABLE 02652 02653 /* method: set_bearing of class fawkes::FacerInterface */ 02654 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_bearing00 02655 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_bearing00(lua_State* tolua_S) 02656 { 02657 #ifndef TOLUA_RELEASE 02658 tolua_Error tolua_err; 02659 if ( 02660 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02661 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02662 !tolua_isnoobj(tolua_S,3,&tolua_err) 02663 ) 02664 goto tolua_lerror; 02665 else 02666 #endif 02667 { 02668 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02669 const float new_bearing = ((const float) tolua_tonumber(tolua_S,2,0)); 02670 #ifndef TOLUA_RELEASE 02671 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bearing'", NULL); 02672 #endif 02673 { 02674 self->set_bearing(new_bearing); 02675 } 02676 } 02677 return 0; 02678 #ifndef TOLUA_RELEASE 02679 tolua_lerror: 02680 tolua_error(tolua_S,"#ferror in function 'set_bearing'.",&tolua_err); 02681 return 0; 02682 #endif 02683 } 02684 #endif //#ifndef TOLUA_DISABLE 02685 02686 /* method: maxlenof_bearing of class fawkes::FacerInterface */ 02687 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_bearing00 02688 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_bearing00(lua_State* tolua_S) 02689 { 02690 #ifndef TOLUA_RELEASE 02691 tolua_Error tolua_err; 02692 if ( 02693 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 02694 !tolua_isnoobj(tolua_S,2,&tolua_err) 02695 ) 02696 goto tolua_lerror; 02697 else 02698 #endif 02699 { 02700 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02701 #ifndef TOLUA_RELEASE 02702 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_bearing'", NULL); 02703 #endif 02704 { 02705 int tolua_ret = (int) self->maxlenof_bearing(); 02706 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02707 } 02708 } 02709 return 1; 02710 #ifndef TOLUA_RELEASE 02711 tolua_lerror: 02712 tolua_error(tolua_S,"#ferror in function 'maxlenof_bearing'.",&tolua_err); 02713 return 0; 02714 #endif 02715 } 02716 #endif //#ifndef TOLUA_DISABLE 02717 02718 /* method: slope of class fawkes::FacerInterface */ 02719 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_slope00 02720 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_slope00(lua_State* tolua_S) 02721 { 02722 #ifndef TOLUA_RELEASE 02723 tolua_Error tolua_err; 02724 if ( 02725 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02726 !tolua_isnoobj(tolua_S,2,&tolua_err) 02727 ) 02728 goto tolua_lerror; 02729 else 02730 #endif 02731 { 02732 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02733 #ifndef TOLUA_RELEASE 02734 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'slope'", NULL); 02735 #endif 02736 { 02737 float tolua_ret = (float) self->slope(); 02738 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02739 } 02740 } 02741 return 1; 02742 #ifndef TOLUA_RELEASE 02743 tolua_lerror: 02744 tolua_error(tolua_S,"#ferror in function 'slope'.",&tolua_err); 02745 return 0; 02746 #endif 02747 } 02748 #endif //#ifndef TOLUA_DISABLE 02749 02750 /* method: set_slope of class fawkes::FacerInterface */ 02751 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_slope00 02752 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_slope00(lua_State* tolua_S) 02753 { 02754 #ifndef TOLUA_RELEASE 02755 tolua_Error tolua_err; 02756 if ( 02757 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02758 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02759 !tolua_isnoobj(tolua_S,3,&tolua_err) 02760 ) 02761 goto tolua_lerror; 02762 else 02763 #endif 02764 { 02765 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02766 const float new_slope = ((const float) tolua_tonumber(tolua_S,2,0)); 02767 #ifndef TOLUA_RELEASE 02768 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_slope'", NULL); 02769 #endif 02770 { 02771 self->set_slope(new_slope); 02772 } 02773 } 02774 return 0; 02775 #ifndef TOLUA_RELEASE 02776 tolua_lerror: 02777 tolua_error(tolua_S,"#ferror in function 'set_slope'.",&tolua_err); 02778 return 0; 02779 #endif 02780 } 02781 #endif //#ifndef TOLUA_DISABLE 02782 02783 /* method: maxlenof_slope of class fawkes::FacerInterface */ 02784 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_slope00 02785 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_slope00(lua_State* tolua_S) 02786 { 02787 #ifndef TOLUA_RELEASE 02788 tolua_Error tolua_err; 02789 if ( 02790 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 02791 !tolua_isnoobj(tolua_S,2,&tolua_err) 02792 ) 02793 goto tolua_lerror; 02794 else 02795 #endif 02796 { 02797 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02798 #ifndef TOLUA_RELEASE 02799 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_slope'", NULL); 02800 #endif 02801 { 02802 int tolua_ret = (int) self->maxlenof_slope(); 02803 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02804 } 02805 } 02806 return 1; 02807 #ifndef TOLUA_RELEASE 02808 tolua_lerror: 02809 tolua_error(tolua_S,"#ferror in function 'maxlenof_slope'.",&tolua_err); 02810 return 0; 02811 #endif 02812 } 02813 #endif //#ifndef TOLUA_DISABLE 02814 02815 /* method: requested_index of class fawkes::FacerInterface */ 02816 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_requested_index00 02817 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_requested_index00(lua_State* tolua_S) 02818 { 02819 #ifndef TOLUA_RELEASE 02820 tolua_Error tolua_err; 02821 if ( 02822 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02823 !tolua_isnoobj(tolua_S,2,&tolua_err) 02824 ) 02825 goto tolua_lerror; 02826 else 02827 #endif 02828 { 02829 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02830 #ifndef TOLUA_RELEASE 02831 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'requested_index'", NULL); 02832 #endif 02833 { 02834 unsigned int tolua_ret = (unsigned int) self->requested_index(); 02835 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02836 } 02837 } 02838 return 1; 02839 #ifndef TOLUA_RELEASE 02840 tolua_lerror: 02841 tolua_error(tolua_S,"#ferror in function 'requested_index'.",&tolua_err); 02842 return 0; 02843 #endif 02844 } 02845 #endif //#ifndef TOLUA_DISABLE 02846 02847 /* method: set_requested_index of class fawkes::FacerInterface */ 02848 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_requested_index00 02849 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_requested_index00(lua_State* tolua_S) 02850 { 02851 #ifndef TOLUA_RELEASE 02852 tolua_Error tolua_err; 02853 if ( 02854 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02855 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02856 !tolua_isnoobj(tolua_S,3,&tolua_err) 02857 ) 02858 goto tolua_lerror; 02859 else 02860 #endif 02861 { 02862 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02863 unsigned const int new_requested_index = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 02864 #ifndef TOLUA_RELEASE 02865 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_requested_index'", NULL); 02866 #endif 02867 { 02868 self->set_requested_index(new_requested_index); 02869 } 02870 } 02871 return 0; 02872 #ifndef TOLUA_RELEASE 02873 tolua_lerror: 02874 tolua_error(tolua_S,"#ferror in function 'set_requested_index'.",&tolua_err); 02875 return 0; 02876 #endif 02877 } 02878 #endif //#ifndef TOLUA_DISABLE 02879 02880 /* method: maxlenof_requested_index of class fawkes::FacerInterface */ 02881 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_requested_index00 02882 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_requested_index00(lua_State* tolua_S) 02883 { 02884 #ifndef TOLUA_RELEASE 02885 tolua_Error tolua_err; 02886 if ( 02887 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 02888 !tolua_isnoobj(tolua_S,2,&tolua_err) 02889 ) 02890 goto tolua_lerror; 02891 else 02892 #endif 02893 { 02894 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02895 #ifndef TOLUA_RELEASE 02896 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_requested_index'", NULL); 02897 #endif 02898 { 02899 int tolua_ret = (int) self->maxlenof_requested_index(); 02900 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02901 } 02902 } 02903 return 1; 02904 #ifndef TOLUA_RELEASE 02905 tolua_lerror: 02906 tolua_error(tolua_S,"#ferror in function 'maxlenof_requested_index'.",&tolua_err); 02907 return 0; 02908 #endif 02909 } 02910 #endif //#ifndef TOLUA_DISABLE 02911 02912 /* method: requested_name of class fawkes::FacerInterface */ 02913 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_requested_name00 02914 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_requested_name00(lua_State* tolua_S) 02915 { 02916 #ifndef TOLUA_RELEASE 02917 tolua_Error tolua_err; 02918 if ( 02919 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02920 !tolua_isnoobj(tolua_S,2,&tolua_err) 02921 ) 02922 goto tolua_lerror; 02923 else 02924 #endif 02925 { 02926 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02927 #ifndef TOLUA_RELEASE 02928 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'requested_name'", NULL); 02929 #endif 02930 { 02931 char* tolua_ret = (char*) self->requested_name(); 02932 tolua_pushstring(tolua_S,(const char*)tolua_ret); 02933 } 02934 } 02935 return 1; 02936 #ifndef TOLUA_RELEASE 02937 tolua_lerror: 02938 tolua_error(tolua_S,"#ferror in function 'requested_name'.",&tolua_err); 02939 return 0; 02940 #endif 02941 } 02942 #endif //#ifndef TOLUA_DISABLE 02943 02944 /* method: set_requested_name of class fawkes::FacerInterface */ 02945 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_requested_name00 02946 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_requested_name00(lua_State* tolua_S) 02947 { 02948 #ifndef TOLUA_RELEASE 02949 tolua_Error tolua_err; 02950 if ( 02951 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 02952 !tolua_isstring(tolua_S,2,0,&tolua_err) || 02953 !tolua_isnoobj(tolua_S,3,&tolua_err) 02954 ) 02955 goto tolua_lerror; 02956 else 02957 #endif 02958 { 02959 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02960 const char* new_requested_name = ((const char*) tolua_tostring(tolua_S,2,0)); 02961 #ifndef TOLUA_RELEASE 02962 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_requested_name'", NULL); 02963 #endif 02964 { 02965 self->set_requested_name(new_requested_name); 02966 } 02967 } 02968 return 0; 02969 #ifndef TOLUA_RELEASE 02970 tolua_lerror: 02971 tolua_error(tolua_S,"#ferror in function 'set_requested_name'.",&tolua_err); 02972 return 0; 02973 #endif 02974 } 02975 #endif //#ifndef TOLUA_DISABLE 02976 02977 /* method: maxlenof_requested_name of class fawkes::FacerInterface */ 02978 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_requested_name00 02979 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_requested_name00(lua_State* tolua_S) 02980 { 02981 #ifndef TOLUA_RELEASE 02982 tolua_Error tolua_err; 02983 if ( 02984 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 02985 !tolua_isnoobj(tolua_S,2,&tolua_err) 02986 ) 02987 goto tolua_lerror; 02988 else 02989 #endif 02990 { 02991 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 02992 #ifndef TOLUA_RELEASE 02993 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_requested_name'", NULL); 02994 #endif 02995 { 02996 int tolua_ret = (int) self->maxlenof_requested_name(); 02997 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02998 } 02999 } 03000 return 1; 03001 #ifndef TOLUA_RELEASE 03002 tolua_lerror: 03003 tolua_error(tolua_S,"#ferror in function 'maxlenof_requested_name'.",&tolua_err); 03004 return 0; 03005 #endif 03006 } 03007 #endif //#ifndef TOLUA_DISABLE 03008 03009 /* method: oftype of class fawkes::FacerInterface */ 03010 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_oftype00 03011 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_oftype00(lua_State* tolua_S) 03012 { 03013 #ifndef TOLUA_RELEASE 03014 tolua_Error tolua_err; 03015 if ( 03016 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03017 !tolua_isstring(tolua_S,2,0,&tolua_err) || 03018 !tolua_isnoobj(tolua_S,3,&tolua_err) 03019 ) 03020 goto tolua_lerror; 03021 else 03022 #endif 03023 { 03024 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03025 const char* interface_type = ((const char*) tolua_tostring(tolua_S,2,0)); 03026 #ifndef TOLUA_RELEASE 03027 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL); 03028 #endif 03029 { 03030 bool tolua_ret = (bool) self->oftype(interface_type); 03031 tolua_pushboolean(tolua_S,(bool)tolua_ret); 03032 } 03033 } 03034 return 1; 03035 #ifndef TOLUA_RELEASE 03036 tolua_lerror: 03037 tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err); 03038 return 0; 03039 #endif 03040 } 03041 #endif //#ifndef TOLUA_DISABLE 03042 03043 /* method: datachunk of class fawkes::FacerInterface */ 03044 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_datachunk00 03045 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_datachunk00(lua_State* tolua_S) 03046 { 03047 #ifndef TOLUA_RELEASE 03048 tolua_Error tolua_err; 03049 if ( 03050 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03051 !tolua_isnoobj(tolua_S,2,&tolua_err) 03052 ) 03053 goto tolua_lerror; 03054 else 03055 #endif 03056 { 03057 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03058 #ifndef TOLUA_RELEASE 03059 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL); 03060 #endif 03061 { 03062 const void* tolua_ret = (const void*) self->datachunk(); 03063 tolua_pushuserdata(tolua_S,(void*)tolua_ret); 03064 } 03065 } 03066 return 1; 03067 #ifndef TOLUA_RELEASE 03068 tolua_lerror: 03069 tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err); 03070 return 0; 03071 #endif 03072 } 03073 #endif //#ifndef TOLUA_DISABLE 03074 03075 /* method: datasize of class fawkes::FacerInterface */ 03076 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_datasize00 03077 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_datasize00(lua_State* tolua_S) 03078 { 03079 #ifndef TOLUA_RELEASE 03080 tolua_Error tolua_err; 03081 if ( 03082 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03083 !tolua_isnoobj(tolua_S,2,&tolua_err) 03084 ) 03085 goto tolua_lerror; 03086 else 03087 #endif 03088 { 03089 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03090 #ifndef TOLUA_RELEASE 03091 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL); 03092 #endif 03093 { 03094 unsigned int tolua_ret = (unsigned int) self->datasize(); 03095 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03096 } 03097 } 03098 return 1; 03099 #ifndef TOLUA_RELEASE 03100 tolua_lerror: 03101 tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err); 03102 return 0; 03103 #endif 03104 } 03105 #endif //#ifndef TOLUA_DISABLE 03106 03107 /* method: type of class fawkes::FacerInterface */ 03108 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_type00 03109 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_type00(lua_State* tolua_S) 03110 { 03111 #ifndef TOLUA_RELEASE 03112 tolua_Error tolua_err; 03113 if ( 03114 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03115 !tolua_isnoobj(tolua_S,2,&tolua_err) 03116 ) 03117 goto tolua_lerror; 03118 else 03119 #endif 03120 { 03121 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03122 #ifndef TOLUA_RELEASE 03123 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL); 03124 #endif 03125 { 03126 const char* tolua_ret = (const char*) self->type(); 03127 tolua_pushstring(tolua_S,(const char*)tolua_ret); 03128 } 03129 } 03130 return 1; 03131 #ifndef TOLUA_RELEASE 03132 tolua_lerror: 03133 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err); 03134 return 0; 03135 #endif 03136 } 03137 #endif //#ifndef TOLUA_DISABLE 03138 03139 /* method: id of class fawkes::FacerInterface */ 03140 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_id00 03141 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_id00(lua_State* tolua_S) 03142 { 03143 #ifndef TOLUA_RELEASE 03144 tolua_Error tolua_err; 03145 if ( 03146 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03147 !tolua_isnoobj(tolua_S,2,&tolua_err) 03148 ) 03149 goto tolua_lerror; 03150 else 03151 #endif 03152 { 03153 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03154 #ifndef TOLUA_RELEASE 03155 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL); 03156 #endif 03157 { 03158 const char* tolua_ret = (const char*) self->id(); 03159 tolua_pushstring(tolua_S,(const char*)tolua_ret); 03160 } 03161 } 03162 return 1; 03163 #ifndef TOLUA_RELEASE 03164 tolua_lerror: 03165 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err); 03166 return 0; 03167 #endif 03168 } 03169 #endif //#ifndef TOLUA_DISABLE 03170 03171 /* method: uid of class fawkes::FacerInterface */ 03172 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_uid00 03173 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_uid00(lua_State* tolua_S) 03174 { 03175 #ifndef TOLUA_RELEASE 03176 tolua_Error tolua_err; 03177 if ( 03178 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03179 !tolua_isnoobj(tolua_S,2,&tolua_err) 03180 ) 03181 goto tolua_lerror; 03182 else 03183 #endif 03184 { 03185 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03186 #ifndef TOLUA_RELEASE 03187 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL); 03188 #endif 03189 { 03190 const char* tolua_ret = (const char*) self->uid(); 03191 tolua_pushstring(tolua_S,(const char*)tolua_ret); 03192 } 03193 } 03194 return 1; 03195 #ifndef TOLUA_RELEASE 03196 tolua_lerror: 03197 tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err); 03198 return 0; 03199 #endif 03200 } 03201 #endif //#ifndef TOLUA_DISABLE 03202 03203 /* method: serial of class fawkes::FacerInterface */ 03204 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_serial00 03205 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_serial00(lua_State* tolua_S) 03206 { 03207 #ifndef TOLUA_RELEASE 03208 tolua_Error tolua_err; 03209 if ( 03210 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03211 !tolua_isnoobj(tolua_S,2,&tolua_err) 03212 ) 03213 goto tolua_lerror; 03214 else 03215 #endif 03216 { 03217 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03218 #ifndef TOLUA_RELEASE 03219 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL); 03220 #endif 03221 { 03222 unsigned int tolua_ret = (unsigned int) self->serial(); 03223 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03224 } 03225 } 03226 return 1; 03227 #ifndef TOLUA_RELEASE 03228 tolua_lerror: 03229 tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err); 03230 return 0; 03231 #endif 03232 } 03233 #endif //#ifndef TOLUA_DISABLE 03234 03235 /* method: mem_serial of class fawkes::FacerInterface */ 03236 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_mem_serial00 03237 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_mem_serial00(lua_State* tolua_S) 03238 { 03239 #ifndef TOLUA_RELEASE 03240 tolua_Error tolua_err; 03241 if ( 03242 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03243 !tolua_isnoobj(tolua_S,2,&tolua_err) 03244 ) 03245 goto tolua_lerror; 03246 else 03247 #endif 03248 { 03249 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03250 #ifndef TOLUA_RELEASE 03251 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL); 03252 #endif 03253 { 03254 unsigned int tolua_ret = (unsigned int) self->mem_serial(); 03255 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03256 } 03257 } 03258 return 1; 03259 #ifndef TOLUA_RELEASE 03260 tolua_lerror: 03261 tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err); 03262 return 0; 03263 #endif 03264 } 03265 #endif //#ifndef TOLUA_DISABLE 03266 03267 /* method: operator== of class fawkes::FacerInterface */ 03268 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface__eq00 03269 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface__eq00(lua_State* tolua_S) 03270 { 03271 #ifndef TOLUA_RELEASE 03272 tolua_Error tolua_err; 03273 if ( 03274 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03275 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) || 03276 !tolua_isnoobj(tolua_S,3,&tolua_err) 03277 ) 03278 goto tolua_lerror; 03279 else 03280 #endif 03281 { 03282 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03283 Interface* comp = ((Interface*) tolua_tousertype(tolua_S,2,0)); 03284 #ifndef TOLUA_RELEASE 03285 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL); 03286 #endif 03287 { 03288 bool tolua_ret = (bool) self->operator==(*comp); 03289 tolua_pushboolean(tolua_S,(bool)tolua_ret); 03290 } 03291 } 03292 return 1; 03293 #ifndef TOLUA_RELEASE 03294 tolua_lerror: 03295 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err); 03296 return 0; 03297 #endif 03298 } 03299 #endif //#ifndef TOLUA_DISABLE 03300 03301 /* method: hash of class fawkes::FacerInterface */ 03302 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_hash00 03303 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_hash00(lua_State* tolua_S) 03304 { 03305 #ifndef TOLUA_RELEASE 03306 tolua_Error tolua_err; 03307 if ( 03308 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03309 !tolua_isnoobj(tolua_S,2,&tolua_err) 03310 ) 03311 goto tolua_lerror; 03312 else 03313 #endif 03314 { 03315 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03316 #ifndef TOLUA_RELEASE 03317 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL); 03318 #endif 03319 { 03320 unsigned const char* tolua_ret = ( unsigned const char*) self->hash(); 03321 tolua_pushstring(tolua_S,(const char*)tolua_ret); 03322 } 03323 } 03324 return 1; 03325 #ifndef TOLUA_RELEASE 03326 tolua_lerror: 03327 tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err); 03328 return 0; 03329 #endif 03330 } 03331 #endif //#ifndef TOLUA_DISABLE 03332 03333 /* method: hash_size of class fawkes::FacerInterface */ 03334 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_hash_size00 03335 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_hash_size00(lua_State* tolua_S) 03336 { 03337 #ifndef TOLUA_RELEASE 03338 tolua_Error tolua_err; 03339 if ( 03340 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03341 !tolua_isnoobj(tolua_S,2,&tolua_err) 03342 ) 03343 goto tolua_lerror; 03344 else 03345 #endif 03346 { 03347 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03348 #ifndef TOLUA_RELEASE 03349 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL); 03350 #endif 03351 { 03352 int tolua_ret = (int) self->hash_size(); 03353 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03354 } 03355 } 03356 return 1; 03357 #ifndef TOLUA_RELEASE 03358 tolua_lerror: 03359 tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err); 03360 return 0; 03361 #endif 03362 } 03363 #endif //#ifndef TOLUA_DISABLE 03364 03365 /* method: hash_printable of class fawkes::FacerInterface */ 03366 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_hash_printable00 03367 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_hash_printable00(lua_State* tolua_S) 03368 { 03369 #ifndef TOLUA_RELEASE 03370 tolua_Error tolua_err; 03371 if ( 03372 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03373 !tolua_isnoobj(tolua_S,2,&tolua_err) 03374 ) 03375 goto tolua_lerror; 03376 else 03377 #endif 03378 { 03379 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03380 #ifndef TOLUA_RELEASE 03381 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL); 03382 #endif 03383 { 03384 const char* tolua_ret = (const char*) self->hash_printable(); 03385 tolua_pushstring(tolua_S,(const char*)tolua_ret); 03386 } 03387 } 03388 return 1; 03389 #ifndef TOLUA_RELEASE 03390 tolua_lerror: 03391 tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err); 03392 return 0; 03393 #endif 03394 } 03395 #endif //#ifndef TOLUA_DISABLE 03396 03397 /* method: is_writer of class fawkes::FacerInterface */ 03398 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_is_writer00 03399 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_is_writer00(lua_State* tolua_S) 03400 { 03401 #ifndef TOLUA_RELEASE 03402 tolua_Error tolua_err; 03403 if ( 03404 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03405 !tolua_isnoobj(tolua_S,2,&tolua_err) 03406 ) 03407 goto tolua_lerror; 03408 else 03409 #endif 03410 { 03411 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03412 #ifndef TOLUA_RELEASE 03413 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL); 03414 #endif 03415 { 03416 bool tolua_ret = (bool) self->is_writer(); 03417 tolua_pushboolean(tolua_S,(bool)tolua_ret); 03418 } 03419 } 03420 return 1; 03421 #ifndef TOLUA_RELEASE 03422 tolua_lerror: 03423 tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err); 03424 return 0; 03425 #endif 03426 } 03427 #endif //#ifndef TOLUA_DISABLE 03428 03429 /* method: set_from_chunk of class fawkes::FacerInterface */ 03430 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_from_chunk00 03431 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_from_chunk00(lua_State* tolua_S) 03432 { 03433 #ifndef TOLUA_RELEASE 03434 tolua_Error tolua_err; 03435 if ( 03436 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 03437 !tolua_isuserdata(tolua_S,2,0,&tolua_err) || 03438 !tolua_isnoobj(tolua_S,3,&tolua_err) 03439 ) 03440 goto tolua_lerror; 03441 else 03442 #endif 03443 { 03444 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03445 void* chunk = ((void*) tolua_touserdata(tolua_S,2,0)); 03446 #ifndef TOLUA_RELEASE 03447 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL); 03448 #endif 03449 { 03450 self->set_from_chunk(chunk); 03451 } 03452 } 03453 return 0; 03454 #ifndef TOLUA_RELEASE 03455 tolua_lerror: 03456 tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err); 03457 return 0; 03458 #endif 03459 } 03460 #endif //#ifndef TOLUA_DISABLE 03461 03462 /* method: create_message of class fawkes::FacerInterface */ 03463 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_create_message00 03464 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_create_message00(lua_State* tolua_S) 03465 { 03466 #ifndef TOLUA_RELEASE 03467 tolua_Error tolua_err; 03468 if ( 03469 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03470 !tolua_isstring(tolua_S,2,0,&tolua_err) || 03471 !tolua_isnoobj(tolua_S,3,&tolua_err) 03472 ) 03473 goto tolua_lerror; 03474 else 03475 #endif 03476 { 03477 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03478 const char* type = ((const char*) tolua_tostring(tolua_S,2,0)); 03479 #ifndef TOLUA_RELEASE 03480 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL); 03481 #endif 03482 { 03483 Message* tolua_ret = (Message*) self->create_message(type); 03484 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 03485 } 03486 } 03487 return 1; 03488 #ifndef TOLUA_RELEASE 03489 tolua_lerror: 03490 tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err); 03491 return 0; 03492 #endif 03493 } 03494 #endif //#ifndef TOLUA_DISABLE 03495 03496 /* method: read of class fawkes::FacerInterface */ 03497 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_read00 03498 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_read00(lua_State* tolua_S) 03499 { 03500 #ifndef TOLUA_RELEASE 03501 tolua_Error tolua_err; 03502 if ( 03503 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 03504 !tolua_isnoobj(tolua_S,2,&tolua_err) 03505 ) 03506 goto tolua_lerror; 03507 else 03508 #endif 03509 { 03510 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03511 #ifndef TOLUA_RELEASE 03512 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL); 03513 #endif 03514 { 03515 self->read(); 03516 } 03517 } 03518 return 0; 03519 #ifndef TOLUA_RELEASE 03520 tolua_lerror: 03521 tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err); 03522 return 0; 03523 #endif 03524 } 03525 #endif //#ifndef TOLUA_DISABLE 03526 03527 /* method: write of class fawkes::FacerInterface */ 03528 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_write00 03529 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_write00(lua_State* tolua_S) 03530 { 03531 #ifndef TOLUA_RELEASE 03532 tolua_Error tolua_err; 03533 if ( 03534 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 03535 !tolua_isnoobj(tolua_S,2,&tolua_err) 03536 ) 03537 goto tolua_lerror; 03538 else 03539 #endif 03540 { 03541 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03542 #ifndef TOLUA_RELEASE 03543 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL); 03544 #endif 03545 { 03546 self->write(); 03547 } 03548 } 03549 return 0; 03550 #ifndef TOLUA_RELEASE 03551 tolua_lerror: 03552 tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err); 03553 return 0; 03554 #endif 03555 } 03556 #endif //#ifndef TOLUA_DISABLE 03557 03558 /* method: has_writer of class fawkes::FacerInterface */ 03559 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_has_writer00 03560 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_has_writer00(lua_State* tolua_S) 03561 { 03562 #ifndef TOLUA_RELEASE 03563 tolua_Error tolua_err; 03564 if ( 03565 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03566 !tolua_isnoobj(tolua_S,2,&tolua_err) 03567 ) 03568 goto tolua_lerror; 03569 else 03570 #endif 03571 { 03572 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03573 #ifndef TOLUA_RELEASE 03574 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL); 03575 #endif 03576 { 03577 bool tolua_ret = (bool) self->has_writer(); 03578 tolua_pushboolean(tolua_S,(bool)tolua_ret); 03579 } 03580 } 03581 return 1; 03582 #ifndef TOLUA_RELEASE 03583 tolua_lerror: 03584 tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err); 03585 return 0; 03586 #endif 03587 } 03588 #endif //#ifndef TOLUA_DISABLE 03589 03590 /* method: num_readers of class fawkes::FacerInterface */ 03591 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_num_readers00 03592 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_num_readers00(lua_State* tolua_S) 03593 { 03594 #ifndef TOLUA_RELEASE 03595 tolua_Error tolua_err; 03596 if ( 03597 !tolua_isusertype(tolua_S,1,"const fawkes::FacerInterface",0,&tolua_err) || 03598 !tolua_isnoobj(tolua_S,2,&tolua_err) 03599 ) 03600 goto tolua_lerror; 03601 else 03602 #endif 03603 { 03604 const fawkes::FacerInterface* self = (const fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03605 #ifndef TOLUA_RELEASE 03606 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL); 03607 #endif 03608 { 03609 unsigned int tolua_ret = (unsigned int) self->num_readers(); 03610 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03611 } 03612 } 03613 return 1; 03614 #ifndef TOLUA_RELEASE 03615 tolua_lerror: 03616 tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err); 03617 return 0; 03618 #endif 03619 } 03620 #endif //#ifndef TOLUA_DISABLE 03621 03622 /* method: msgq_enqueue_copy of class fawkes::FacerInterface */ 03623 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_enqueue_copy00 03624 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_enqueue_copy00(lua_State* tolua_S) 03625 { 03626 #ifndef TOLUA_RELEASE 03627 tolua_Error tolua_err; 03628 if ( 03629 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 03630 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 03631 !tolua_isnoobj(tolua_S,3,&tolua_err) 03632 ) 03633 goto tolua_lerror; 03634 else 03635 #endif 03636 { 03637 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03638 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 03639 #ifndef TOLUA_RELEASE 03640 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL); 03641 #endif 03642 { 03643 unsigned int tolua_ret = (unsigned int) self->msgq_enqueue_copy(message); 03644 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03645 } 03646 } 03647 return 1; 03648 #ifndef TOLUA_RELEASE 03649 tolua_lerror: 03650 tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err); 03651 return 0; 03652 #endif 03653 } 03654 #endif //#ifndef TOLUA_DISABLE 03655 03656 /* method: msgq_remove of class fawkes::FacerInterface */ 03657 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_remove00 03658 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_remove00(lua_State* tolua_S) 03659 { 03660 #ifndef TOLUA_RELEASE 03661 tolua_Error tolua_err; 03662 if ( 03663 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 03664 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 03665 !tolua_isnoobj(tolua_S,3,&tolua_err) 03666 ) 03667 goto tolua_lerror; 03668 else 03669 #endif 03670 { 03671 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03672 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 03673 #ifndef TOLUA_RELEASE 03674 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 03675 #endif 03676 { 03677 self->msgq_remove(message); 03678 } 03679 } 03680 return 0; 03681 #ifndef TOLUA_RELEASE 03682 tolua_lerror: 03683 tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err); 03684 return 0; 03685 #endif 03686 } 03687 #endif //#ifndef TOLUA_DISABLE 03688 03689 /* method: msgq_remove of class fawkes::FacerInterface */ 03690 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_remove01 03691 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_remove01(lua_State* tolua_S) 03692 { 03693 tolua_Error tolua_err; 03694 if ( 03695 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 03696 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 03697 !tolua_isnoobj(tolua_S,3,&tolua_err) 03698 ) 03699 goto tolua_lerror; 03700 else 03701 { 03702 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03703 unsigned int message_id = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 03704 #ifndef TOLUA_RELEASE 03705 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 03706 #endif 03707 { 03708 self->msgq_remove(message_id); 03709 } 03710 } 03711 return 0; 03712 tolua_lerror: 03713 return tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_remove00(tolua_S); 03714 } 03715 #endif //#ifndef TOLUA_DISABLE 03716 03717 /* method: msgq_size of class fawkes::FacerInterface */ 03718 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_size00 03719 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_size00(lua_State* tolua_S) 03720 { 03721 #ifndef TOLUA_RELEASE 03722 tolua_Error tolua_err; 03723 if ( 03724 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 03725 !tolua_isnoobj(tolua_S,2,&tolua_err) 03726 ) 03727 goto tolua_lerror; 03728 else 03729 #endif 03730 { 03731 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03732 #ifndef TOLUA_RELEASE 03733 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL); 03734 #endif 03735 { 03736 unsigned int tolua_ret = (unsigned int) self->msgq_size(); 03737 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03738 } 03739 } 03740 return 1; 03741 #ifndef TOLUA_RELEASE 03742 tolua_lerror: 03743 tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err); 03744 return 0; 03745 #endif 03746 } 03747 #endif //#ifndef TOLUA_DISABLE 03748 03749 /* method: msgq_flush of class fawkes::FacerInterface */ 03750 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_flush00 03751 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_flush00(lua_State* tolua_S) 03752 { 03753 #ifndef TOLUA_RELEASE 03754 tolua_Error tolua_err; 03755 if ( 03756 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 03757 !tolua_isnoobj(tolua_S,2,&tolua_err) 03758 ) 03759 goto tolua_lerror; 03760 else 03761 #endif 03762 { 03763 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03764 #ifndef TOLUA_RELEASE 03765 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL); 03766 #endif 03767 { 03768 self->msgq_flush(); 03769 } 03770 } 03771 return 0; 03772 #ifndef TOLUA_RELEASE 03773 tolua_lerror: 03774 tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err); 03775 return 0; 03776 #endif 03777 } 03778 #endif //#ifndef TOLUA_DISABLE 03779 03780 /* method: msgq_lock of class fawkes::FacerInterface */ 03781 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_lock00 03782 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_lock00(lua_State* tolua_S) 03783 { 03784 #ifndef TOLUA_RELEASE 03785 tolua_Error tolua_err; 03786 if ( 03787 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 03788 !tolua_isnoobj(tolua_S,2,&tolua_err) 03789 ) 03790 goto tolua_lerror; 03791 else 03792 #endif 03793 { 03794 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03795 #ifndef TOLUA_RELEASE 03796 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL); 03797 #endif 03798 { 03799 self->msgq_lock(); 03800 } 03801 } 03802 return 0; 03803 #ifndef TOLUA_RELEASE 03804 tolua_lerror: 03805 tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err); 03806 return 0; 03807 #endif 03808 } 03809 #endif //#ifndef TOLUA_DISABLE 03810 03811 /* method: msgq_try_lock of class fawkes::FacerInterface */ 03812 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_try_lock00 03813 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_try_lock00(lua_State* tolua_S) 03814 { 03815 #ifndef TOLUA_RELEASE 03816 tolua_Error tolua_err; 03817 if ( 03818 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 03819 !tolua_isnoobj(tolua_S,2,&tolua_err) 03820 ) 03821 goto tolua_lerror; 03822 else 03823 #endif 03824 { 03825 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03826 #ifndef TOLUA_RELEASE 03827 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL); 03828 #endif 03829 { 03830 bool tolua_ret = (bool) self->msgq_try_lock(); 03831 tolua_pushboolean(tolua_S,(bool)tolua_ret); 03832 } 03833 } 03834 return 1; 03835 #ifndef TOLUA_RELEASE 03836 tolua_lerror: 03837 tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err); 03838 return 0; 03839 #endif 03840 } 03841 #endif //#ifndef TOLUA_DISABLE 03842 03843 /* method: msgq_unlock of class fawkes::FacerInterface */ 03844 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_unlock00 03845 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_unlock00(lua_State* tolua_S) 03846 { 03847 #ifndef TOLUA_RELEASE 03848 tolua_Error tolua_err; 03849 if ( 03850 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 03851 !tolua_isnoobj(tolua_S,2,&tolua_err) 03852 ) 03853 goto tolua_lerror; 03854 else 03855 #endif 03856 { 03857 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03858 #ifndef TOLUA_RELEASE 03859 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL); 03860 #endif 03861 { 03862 self->msgq_unlock(); 03863 } 03864 } 03865 return 0; 03866 #ifndef TOLUA_RELEASE 03867 tolua_lerror: 03868 tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err); 03869 return 0; 03870 #endif 03871 } 03872 #endif //#ifndef TOLUA_DISABLE 03873 03874 /* method: msgq_pop of class fawkes::FacerInterface */ 03875 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_pop00 03876 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_pop00(lua_State* tolua_S) 03877 { 03878 #ifndef TOLUA_RELEASE 03879 tolua_Error tolua_err; 03880 if ( 03881 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 03882 !tolua_isnoobj(tolua_S,2,&tolua_err) 03883 ) 03884 goto tolua_lerror; 03885 else 03886 #endif 03887 { 03888 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03889 #ifndef TOLUA_RELEASE 03890 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL); 03891 #endif 03892 { 03893 self->msgq_pop(); 03894 } 03895 } 03896 return 0; 03897 #ifndef TOLUA_RELEASE 03898 tolua_lerror: 03899 tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err); 03900 return 0; 03901 #endif 03902 } 03903 #endif //#ifndef TOLUA_DISABLE 03904 03905 /* method: msgq_first of class fawkes::FacerInterface */ 03906 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_first00 03907 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_first00(lua_State* tolua_S) 03908 { 03909 #ifndef TOLUA_RELEASE 03910 tolua_Error tolua_err; 03911 if ( 03912 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 03913 !tolua_isnoobj(tolua_S,2,&tolua_err) 03914 ) 03915 goto tolua_lerror; 03916 else 03917 #endif 03918 { 03919 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03920 #ifndef TOLUA_RELEASE 03921 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL); 03922 #endif 03923 { 03924 Message* tolua_ret = (Message*) self->msgq_first(); 03925 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 03926 } 03927 } 03928 return 1; 03929 #ifndef TOLUA_RELEASE 03930 tolua_lerror: 03931 tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err); 03932 return 0; 03933 #endif 03934 } 03935 #endif //#ifndef TOLUA_DISABLE 03936 03937 /* method: msgq_empty of class fawkes::FacerInterface */ 03938 #ifndef TOLUA_DISABLE_tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_empty00 03939 static int tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_empty00(lua_State* tolua_S) 03940 { 03941 #ifndef TOLUA_RELEASE 03942 tolua_Error tolua_err; 03943 if ( 03944 !tolua_isusertype(tolua_S,1,"fawkes::FacerInterface",0,&tolua_err) || 03945 !tolua_isnoobj(tolua_S,2,&tolua_err) 03946 ) 03947 goto tolua_lerror; 03948 else 03949 #endif 03950 { 03951 fawkes::FacerInterface* self = (fawkes::FacerInterface*) tolua_tousertype(tolua_S,1,0); 03952 #ifndef TOLUA_RELEASE 03953 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL); 03954 #endif 03955 { 03956 bool tolua_ret = (bool) self->msgq_empty(); 03957 tolua_pushboolean(tolua_S,(bool)tolua_ret); 03958 } 03959 } 03960 return 1; 03961 #ifndef TOLUA_RELEASE 03962 tolua_lerror: 03963 tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err); 03964 return 0; 03965 #endif 03966 } 03967 #endif //#ifndef TOLUA_DISABLE 03968 03969 /* Open function */ 03970 TOLUA_API int tolua_interfaces_FacerInterface_open (lua_State* tolua_S) 03971 { 03972 tolua_open(tolua_S); 03973 tolua_reg_types(tolua_S); 03974 tolua_module(tolua_S,NULL,0); 03975 tolua_beginmodule(tolua_S,NULL); 03976 tolua_module(tolua_S,"fawkes",0); 03977 tolua_beginmodule(tolua_S,"fawkes"); 03978 tolua_cclass(tolua_S,"FacerInterface","fawkes::FacerInterface","Interface",NULL); 03979 tolua_beginmodule(tolua_S,"FacerInterface"); 03980 tolua_constant(tolua_S,"OPMODE_DISABLED",fawkes::FacerInterface::OPMODE_DISABLED); 03981 tolua_constant(tolua_S,"OPMODE_DETECTION",fawkes::FacerInterface::OPMODE_DETECTION); 03982 tolua_constant(tolua_S,"OPMODE_RECOGNITION",fawkes::FacerInterface::OPMODE_RECOGNITION); 03983 tolua_constant(tolua_S,"OPMODE_LEARNING",fawkes::FacerInterface::OPMODE_LEARNING); 03984 #ifdef __cplusplus 03985 tolua_cclass(tolua_S,"LearnFaceMessage","fawkes::FacerInterface::LearnFaceMessage","Message",tolua_collect_fawkes__FacerInterface__LearnFaceMessage); 03986 #else 03987 tolua_cclass(tolua_S,"LearnFaceMessage","fawkes::FacerInterface::LearnFaceMessage","Message",NULL); 03988 #endif 03989 tolua_beginmodule(tolua_S,"LearnFaceMessage"); 03990 tolua_function(tolua_S,"new",tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new00); 03991 tolua_function(tolua_S,"new_local",tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new00_local); 03992 tolua_function(tolua_S,".call",tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new00_local); 03993 tolua_function(tolua_S,"new",tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new01); 03994 tolua_function(tolua_S,"new_local",tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new01_local); 03995 tolua_function(tolua_S,".call",tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_new01_local); 03996 tolua_function(tolua_S,"delete",tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_delete00); 03997 tolua_function(tolua_S,"name",tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_name00); 03998 tolua_function(tolua_S,"set_name",tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_set_name00); 03999 tolua_function(tolua_S,"maxlenof_name",tolua_interfaces_FacerInterface_fawkes_FacerInterface_LearnFaceMessage_maxlenof_name00); 04000 tolua_endmodule(tolua_S); 04001 #ifdef __cplusplus 04002 tolua_cclass(tolua_S,"SetOpmodeMessage","fawkes::FacerInterface::SetOpmodeMessage","Message",tolua_collect_fawkes__FacerInterface__SetOpmodeMessage); 04003 #else 04004 tolua_cclass(tolua_S,"SetOpmodeMessage","fawkes::FacerInterface::SetOpmodeMessage","Message",NULL); 04005 #endif 04006 tolua_beginmodule(tolua_S,"SetOpmodeMessage"); 04007 tolua_function(tolua_S,"new",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new00); 04008 tolua_function(tolua_S,"new_local",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new00_local); 04009 tolua_function(tolua_S,".call",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new00_local); 04010 tolua_function(tolua_S,"new",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new01); 04011 tolua_function(tolua_S,"new_local",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new01_local); 04012 tolua_function(tolua_S,".call",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_new01_local); 04013 tolua_function(tolua_S,"delete",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_delete00); 04014 tolua_function(tolua_S,"opmode",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_opmode00); 04015 tolua_function(tolua_S,"set_opmode",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_set_opmode00); 04016 tolua_function(tolua_S,"maxlenof_opmode",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetOpmodeMessage_maxlenof_opmode00); 04017 tolua_endmodule(tolua_S); 04018 #ifdef __cplusplus 04019 tolua_cclass(tolua_S,"EnableIdentityMessage","fawkes::FacerInterface::EnableIdentityMessage","Message",tolua_collect_fawkes__FacerInterface__EnableIdentityMessage); 04020 #else 04021 tolua_cclass(tolua_S,"EnableIdentityMessage","fawkes::FacerInterface::EnableIdentityMessage","Message",NULL); 04022 #endif 04023 tolua_beginmodule(tolua_S,"EnableIdentityMessage"); 04024 tolua_function(tolua_S,"new",tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new00); 04025 tolua_function(tolua_S,"new_local",tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new00_local); 04026 tolua_function(tolua_S,".call",tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new00_local); 04027 tolua_function(tolua_S,"new",tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new01); 04028 tolua_function(tolua_S,"new_local",tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new01_local); 04029 tolua_function(tolua_S,".call",tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_new01_local); 04030 tolua_function(tolua_S,"delete",tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_delete00); 04031 tolua_function(tolua_S,"index",tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_index00); 04032 tolua_function(tolua_S,"set_index",tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_set_index00); 04033 tolua_function(tolua_S,"maxlenof_index",tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_maxlenof_index00); 04034 tolua_function(tolua_S,"is_enable",tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_is_enable00); 04035 tolua_function(tolua_S,"set_enable",tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_set_enable00); 04036 tolua_function(tolua_S,"maxlenof_enable",tolua_interfaces_FacerInterface_fawkes_FacerInterface_EnableIdentityMessage_maxlenof_enable00); 04037 tolua_endmodule(tolua_S); 04038 #ifdef __cplusplus 04039 tolua_cclass(tolua_S,"SetNameMessage","fawkes::FacerInterface::SetNameMessage","Message",tolua_collect_fawkes__FacerInterface__SetNameMessage); 04040 #else 04041 tolua_cclass(tolua_S,"SetNameMessage","fawkes::FacerInterface::SetNameMessage","Message",NULL); 04042 #endif 04043 tolua_beginmodule(tolua_S,"SetNameMessage"); 04044 tolua_function(tolua_S,"new",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new00); 04045 tolua_function(tolua_S,"new_local",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new00_local); 04046 tolua_function(tolua_S,".call",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new00_local); 04047 tolua_function(tolua_S,"new",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new01); 04048 tolua_function(tolua_S,"new_local",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new01_local); 04049 tolua_function(tolua_S,".call",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_new01_local); 04050 tolua_function(tolua_S,"delete",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_delete00); 04051 tolua_function(tolua_S,"index",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_index00); 04052 tolua_function(tolua_S,"set_index",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_set_index00); 04053 tolua_function(tolua_S,"maxlenof_index",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_maxlenof_index00); 04054 tolua_function(tolua_S,"name",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_name00); 04055 tolua_function(tolua_S,"set_name",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_set_name00); 04056 tolua_function(tolua_S,"maxlenof_name",tolua_interfaces_FacerInterface_fawkes_FacerInterface_SetNameMessage_maxlenof_name00); 04057 tolua_endmodule(tolua_S); 04058 #ifdef __cplusplus 04059 tolua_cclass(tolua_S,"GetNameMessage","fawkes::FacerInterface::GetNameMessage","Message",tolua_collect_fawkes__FacerInterface__GetNameMessage); 04060 #else 04061 tolua_cclass(tolua_S,"GetNameMessage","fawkes::FacerInterface::GetNameMessage","Message",NULL); 04062 #endif 04063 tolua_beginmodule(tolua_S,"GetNameMessage"); 04064 tolua_function(tolua_S,"new",tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new00); 04065 tolua_function(tolua_S,"new_local",tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new00_local); 04066 tolua_function(tolua_S,".call",tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new00_local); 04067 tolua_function(tolua_S,"new",tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new01); 04068 tolua_function(tolua_S,"new_local",tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new01_local); 04069 tolua_function(tolua_S,".call",tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_new01_local); 04070 tolua_function(tolua_S,"delete",tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_delete00); 04071 tolua_function(tolua_S,"index",tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_index00); 04072 tolua_function(tolua_S,"set_index",tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_set_index00); 04073 tolua_function(tolua_S,"maxlenof_index",tolua_interfaces_FacerInterface_fawkes_FacerInterface_GetNameMessage_maxlenof_index00); 04074 tolua_endmodule(tolua_S); 04075 tolua_function(tolua_S,"opmode",tolua_interfaces_FacerInterface_fawkes_FacerInterface_opmode00); 04076 tolua_function(tolua_S,"set_opmode",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_opmode00); 04077 tolua_function(tolua_S,"maxlenof_opmode",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_opmode00); 04078 tolua_function(tolua_S,"num_identities",tolua_interfaces_FacerInterface_fawkes_FacerInterface_num_identities00); 04079 tolua_function(tolua_S,"set_num_identities",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_num_identities00); 04080 tolua_function(tolua_S,"maxlenof_num_identities",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_num_identities00); 04081 tolua_function(tolua_S,"recognized_identity",tolua_interfaces_FacerInterface_fawkes_FacerInterface_recognized_identity00); 04082 tolua_function(tolua_S,"set_recognized_identity",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_recognized_identity00); 04083 tolua_function(tolua_S,"maxlenof_recognized_identity",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_recognized_identity00); 04084 tolua_function(tolua_S,"recognized_name",tolua_interfaces_FacerInterface_fawkes_FacerInterface_recognized_name00); 04085 tolua_function(tolua_S,"set_recognized_name",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_recognized_name00); 04086 tolua_function(tolua_S,"maxlenof_recognized_name",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_recognized_name00); 04087 tolua_function(tolua_S,"num_detections",tolua_interfaces_FacerInterface_fawkes_FacerInterface_num_detections00); 04088 tolua_function(tolua_S,"set_num_detections",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_num_detections00); 04089 tolua_function(tolua_S,"maxlenof_num_detections",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_num_detections00); 04090 tolua_function(tolua_S,"num_recognitions",tolua_interfaces_FacerInterface_fawkes_FacerInterface_num_recognitions00); 04091 tolua_function(tolua_S,"set_num_recognitions",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_num_recognitions00); 04092 tolua_function(tolua_S,"maxlenof_num_recognitions",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_num_recognitions00); 04093 tolua_function(tolua_S,"most_likely_identity",tolua_interfaces_FacerInterface_fawkes_FacerInterface_most_likely_identity00); 04094 tolua_function(tolua_S,"set_most_likely_identity",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_most_likely_identity00); 04095 tolua_function(tolua_S,"maxlenof_most_likely_identity",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_most_likely_identity00); 04096 tolua_function(tolua_S,"history_ratio",tolua_interfaces_FacerInterface_fawkes_FacerInterface_history_ratio00); 04097 tolua_function(tolua_S,"set_history_ratio",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_history_ratio00); 04098 tolua_function(tolua_S,"maxlenof_history_ratio",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_history_ratio00); 04099 tolua_function(tolua_S,"sec_since_detection",tolua_interfaces_FacerInterface_fawkes_FacerInterface_sec_since_detection00); 04100 tolua_function(tolua_S,"set_sec_since_detection",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_sec_since_detection00); 04101 tolua_function(tolua_S,"maxlenof_sec_since_detection",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_sec_since_detection00); 04102 tolua_function(tolua_S,"visibility_history",tolua_interfaces_FacerInterface_fawkes_FacerInterface_visibility_history00); 04103 tolua_function(tolua_S,"set_visibility_history",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_visibility_history00); 04104 tolua_function(tolua_S,"maxlenof_visibility_history",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_visibility_history00); 04105 tolua_function(tolua_S,"is_learning_in_progress",tolua_interfaces_FacerInterface_fawkes_FacerInterface_is_learning_in_progress00); 04106 tolua_function(tolua_S,"set_learning_in_progress",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_learning_in_progress00); 04107 tolua_function(tolua_S,"maxlenof_learning_in_progress",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_learning_in_progress00); 04108 tolua_function(tolua_S,"recording_progress",tolua_interfaces_FacerInterface_fawkes_FacerInterface_recording_progress00); 04109 tolua_function(tolua_S,"set_recording_progress",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_recording_progress00); 04110 tolua_function(tolua_S,"maxlenof_recording_progress",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_recording_progress00); 04111 tolua_function(tolua_S,"bearing",tolua_interfaces_FacerInterface_fawkes_FacerInterface_bearing00); 04112 tolua_function(tolua_S,"set_bearing",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_bearing00); 04113 tolua_function(tolua_S,"maxlenof_bearing",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_bearing00); 04114 tolua_function(tolua_S,"slope",tolua_interfaces_FacerInterface_fawkes_FacerInterface_slope00); 04115 tolua_function(tolua_S,"set_slope",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_slope00); 04116 tolua_function(tolua_S,"maxlenof_slope",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_slope00); 04117 tolua_function(tolua_S,"requested_index",tolua_interfaces_FacerInterface_fawkes_FacerInterface_requested_index00); 04118 tolua_function(tolua_S,"set_requested_index",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_requested_index00); 04119 tolua_function(tolua_S,"maxlenof_requested_index",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_requested_index00); 04120 tolua_function(tolua_S,"requested_name",tolua_interfaces_FacerInterface_fawkes_FacerInterface_requested_name00); 04121 tolua_function(tolua_S,"set_requested_name",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_requested_name00); 04122 tolua_function(tolua_S,"maxlenof_requested_name",tolua_interfaces_FacerInterface_fawkes_FacerInterface_maxlenof_requested_name00); 04123 tolua_function(tolua_S,"oftype",tolua_interfaces_FacerInterface_fawkes_FacerInterface_oftype00); 04124 tolua_function(tolua_S,"datachunk",tolua_interfaces_FacerInterface_fawkes_FacerInterface_datachunk00); 04125 tolua_function(tolua_S,"datasize",tolua_interfaces_FacerInterface_fawkes_FacerInterface_datasize00); 04126 tolua_function(tolua_S,"type",tolua_interfaces_FacerInterface_fawkes_FacerInterface_type00); 04127 tolua_function(tolua_S,"id",tolua_interfaces_FacerInterface_fawkes_FacerInterface_id00); 04128 tolua_function(tolua_S,"uid",tolua_interfaces_FacerInterface_fawkes_FacerInterface_uid00); 04129 tolua_function(tolua_S,"serial",tolua_interfaces_FacerInterface_fawkes_FacerInterface_serial00); 04130 tolua_function(tolua_S,"mem_serial",tolua_interfaces_FacerInterface_fawkes_FacerInterface_mem_serial00); 04131 tolua_function(tolua_S,".eq",tolua_interfaces_FacerInterface_fawkes_FacerInterface__eq00); 04132 tolua_function(tolua_S,"hash",tolua_interfaces_FacerInterface_fawkes_FacerInterface_hash00); 04133 tolua_function(tolua_S,"hash_size",tolua_interfaces_FacerInterface_fawkes_FacerInterface_hash_size00); 04134 tolua_function(tolua_S,"hash_printable",tolua_interfaces_FacerInterface_fawkes_FacerInterface_hash_printable00); 04135 tolua_function(tolua_S,"is_writer",tolua_interfaces_FacerInterface_fawkes_FacerInterface_is_writer00); 04136 tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_FacerInterface_fawkes_FacerInterface_set_from_chunk00); 04137 tolua_function(tolua_S,"create_message",tolua_interfaces_FacerInterface_fawkes_FacerInterface_create_message00); 04138 tolua_function(tolua_S,"read",tolua_interfaces_FacerInterface_fawkes_FacerInterface_read00); 04139 tolua_function(tolua_S,"write",tolua_interfaces_FacerInterface_fawkes_FacerInterface_write00); 04140 tolua_function(tolua_S,"has_writer",tolua_interfaces_FacerInterface_fawkes_FacerInterface_has_writer00); 04141 tolua_function(tolua_S,"num_readers",tolua_interfaces_FacerInterface_fawkes_FacerInterface_num_readers00); 04142 tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_enqueue_copy00); 04143 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_remove00); 04144 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_remove01); 04145 tolua_function(tolua_S,"msgq_size",tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_size00); 04146 tolua_function(tolua_S,"msgq_flush",tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_flush00); 04147 tolua_function(tolua_S,"msgq_lock",tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_lock00); 04148 tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_try_lock00); 04149 tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_unlock00); 04150 tolua_function(tolua_S,"msgq_pop",tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_pop00); 04151 tolua_function(tolua_S,"msgq_first",tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_first00); 04152 tolua_function(tolua_S,"msgq_empty",tolua_interfaces_FacerInterface_fawkes_FacerInterface_msgq_empty00); 04153 tolua_endmodule(tolua_S); 04154 tolua_endmodule(tolua_S); 04155 tolua_endmodule(tolua_S); 04156 return 1; 04157 } 04158 04159 04160 extern "C" { 04161 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501 04162 TOLUA_API int luaopen_interfaces_FacerInterface (lua_State* tolua_S) { 04163 return tolua_interfaces_FacerInterface_open(tolua_S); 04164 }; 04165 #endif 04166 } 04167 04168