SkillerInterface_tolua.cpp

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

Generated on 1 Mar 2011 for Fawkes API by  doxygen 1.6.1