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