Fawkes API Fawkes Development Version

KickerInterface_tolua.cpp

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