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