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