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