Fawkes API  Fawkes Development Version
HumanoidMotionInterface_tolua.cpp
00001 /*
00002 ** Lua binding: interfaces_HumanoidMotionInterface
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_HumanoidMotionInterface_open (lua_State* tolua_S);
00028 
00029 #include <interfaces/HumanoidMotionInterface.h>
00030 using namespace fawkes;
00031 
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__HumanoidMotionInterface__StopMessage (lua_State* tolua_S)
00036 {
00037  fawkes::HumanoidMotionInterface::StopMessage* self = (fawkes::HumanoidMotionInterface::StopMessage*) tolua_tousertype(tolua_S,1,0);
00038         Mtolua_delete(self);
00039         return 0;
00040 }
00041 
00042 static int tolua_collect_fawkes__HumanoidMotionInterface__WalkArcMessage (lua_State* tolua_S)
00043 {
00044  fawkes::HumanoidMotionInterface::WalkArcMessage* self = (fawkes::HumanoidMotionInterface::WalkArcMessage*) tolua_tousertype(tolua_S,1,0);
00045         Mtolua_delete(self);
00046         return 0;
00047 }
00048 
00049 static int tolua_collect_fawkes__HumanoidMotionInterface__WalkSidewaysMessage (lua_State* tolua_S)
00050 {
00051  fawkes::HumanoidMotionInterface::WalkSidewaysMessage* self = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*) tolua_tousertype(tolua_S,1,0);
00052         Mtolua_delete(self);
00053         return 0;
00054 }
00055 
00056 static int tolua_collect_fawkes__HumanoidMotionInterface__MoveHeadMessage (lua_State* tolua_S)
00057 {
00058  fawkes::HumanoidMotionInterface::MoveHeadMessage* self = (fawkes::HumanoidMotionInterface::MoveHeadMessage*) tolua_tousertype(tolua_S,1,0);
00059         Mtolua_delete(self);
00060         return 0;
00061 }
00062 
00063 static int tolua_collect_fawkes__HumanoidMotionInterface__StandupMessage (lua_State* tolua_S)
00064 {
00065  fawkes::HumanoidMotionInterface::StandupMessage* self = (fawkes::HumanoidMotionInterface::StandupMessage*) tolua_tousertype(tolua_S,1,0);
00066         Mtolua_delete(self);
00067         return 0;
00068 }
00069 
00070 static int tolua_collect_fawkes__HumanoidMotionInterface__WalkVelocityMessage (lua_State* tolua_S)
00071 {
00072  fawkes::HumanoidMotionInterface::WalkVelocityMessage* self = (fawkes::HumanoidMotionInterface::WalkVelocityMessage*) tolua_tousertype(tolua_S,1,0);
00073         Mtolua_delete(self);
00074         return 0;
00075 }
00076 
00077 static int tolua_collect_fawkes__HumanoidMotionInterface__GetUpMessage (lua_State* tolua_S)
00078 {
00079  fawkes::HumanoidMotionInterface::GetUpMessage* self = (fawkes::HumanoidMotionInterface::GetUpMessage*) tolua_tousertype(tolua_S,1,0);
00080         Mtolua_delete(self);
00081         return 0;
00082 }
00083 
00084 static int tolua_collect_fawkes__HumanoidMotionInterface__ParkMessage (lua_State* tolua_S)
00085 {
00086  fawkes::HumanoidMotionInterface::ParkMessage* self = (fawkes::HumanoidMotionInterface::ParkMessage*) tolua_tousertype(tolua_S,1,0);
00087         Mtolua_delete(self);
00088         return 0;
00089 }
00090 
00091 static int tolua_collect_fawkes__HumanoidMotionInterface__WalkStraightMessage (lua_State* tolua_S)
00092 {
00093  fawkes::HumanoidMotionInterface::WalkStraightMessage* self = (fawkes::HumanoidMotionInterface::WalkStraightMessage*) tolua_tousertype(tolua_S,1,0);
00094         Mtolua_delete(self);
00095         return 0;
00096 }
00097 
00098 static int tolua_collect_fawkes__HumanoidMotionInterface__KickMessage (lua_State* tolua_S)
00099 {
00100  fawkes::HumanoidMotionInterface::KickMessage* self = (fawkes::HumanoidMotionInterface::KickMessage*) tolua_tousertype(tolua_S,1,0);
00101         Mtolua_delete(self);
00102         return 0;
00103 }
00104 
00105 static int tolua_collect_fawkes__HumanoidMotionInterface__TurnMessage (lua_State* tolua_S)
00106 {
00107  fawkes::HumanoidMotionInterface::TurnMessage* self = (fawkes::HumanoidMotionInterface::TurnMessage*) tolua_tousertype(tolua_S,1,0);
00108         Mtolua_delete(self);
00109         return 0;
00110 }
00111 #endif
00112 
00113 
00114 /* function to register type */
00115 static void tolua_reg_types (lua_State* tolua_S)
00116 {
00117  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::MoveHeadMessage");
00118  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::StandupMessage");
00119  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::StopMessage");
00120  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::WalkStraightMessage");
00121  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::GetUpMessage");
00122  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage");
00123  tolua_usertype(tolua_S,"Message");
00124  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::WalkArcMessage");
00125  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::WalkVelocityMessage");
00126  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface");
00127  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::ParkMessage");
00128  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::TurnMessage");
00129  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::KickMessage");
00130  tolua_usertype(tolua_S,"Interface");
00131 }
00132 
00133 /* method: new of class  StopMessage */
00134 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_new00
00135 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_new00(lua_State* tolua_S)
00136 {
00137 #ifndef TOLUA_RELEASE
00138  tolua_Error tolua_err;
00139  if (
00140      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::StopMessage",0,&tolua_err) ||
00141      !tolua_isnoobj(tolua_S,2,&tolua_err)
00142  )
00143   goto tolua_lerror;
00144  else
00145 #endif
00146  {
00147   {
00148    fawkes::HumanoidMotionInterface::StopMessage* tolua_ret = (fawkes::HumanoidMotionInterface::StopMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::StopMessage)());
00149     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::StopMessage");
00150   }
00151  }
00152  return 1;
00153 #ifndef TOLUA_RELEASE
00154  tolua_lerror:
00155  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00156  return 0;
00157 #endif
00158 }
00159 #endif //#ifndef TOLUA_DISABLE
00160 
00161 /* method: new_local of class  StopMessage */
00162 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_new00_local
00163 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_new00_local(lua_State* tolua_S)
00164 {
00165 #ifndef TOLUA_RELEASE
00166  tolua_Error tolua_err;
00167  if (
00168      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::StopMessage",0,&tolua_err) ||
00169      !tolua_isnoobj(tolua_S,2,&tolua_err)
00170  )
00171   goto tolua_lerror;
00172  else
00173 #endif
00174  {
00175   {
00176    fawkes::HumanoidMotionInterface::StopMessage* tolua_ret = (fawkes::HumanoidMotionInterface::StopMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::StopMessage)());
00177     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::StopMessage");
00178     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00179   }
00180  }
00181  return 1;
00182 #ifndef TOLUA_RELEASE
00183  tolua_lerror:
00184  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00185  return 0;
00186 #endif
00187 }
00188 #endif //#ifndef TOLUA_DISABLE
00189 
00190 /* method: delete of class  StopMessage */
00191 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_delete00
00192 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_delete00(lua_State* tolua_S)
00193 {
00194 #ifndef TOLUA_RELEASE
00195  tolua_Error tolua_err;
00196  if (
00197      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::StopMessage",0,&tolua_err) ||
00198      !tolua_isnoobj(tolua_S,2,&tolua_err)
00199  )
00200   goto tolua_lerror;
00201  else
00202 #endif
00203  {
00204   fawkes::HumanoidMotionInterface::StopMessage* self = (fawkes::HumanoidMotionInterface::StopMessage*)  tolua_tousertype(tolua_S,1,0);
00205 #ifndef TOLUA_RELEASE
00206   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00207 #endif
00208   Mtolua_delete(self);
00209  }
00210  return 0;
00211 #ifndef TOLUA_RELEASE
00212  tolua_lerror:
00213  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00214  return 0;
00215 #endif
00216 }
00217 #endif //#ifndef TOLUA_DISABLE
00218 
00219 /* method: new of class  WalkStraightMessage */
00220 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00
00221 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00(lua_State* tolua_S)
00222 {
00223 #ifndef TOLUA_RELEASE
00224  tolua_Error tolua_err;
00225  if (
00226      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
00227      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00228      !tolua_isnoobj(tolua_S,3,&tolua_err)
00229  )
00230   goto tolua_lerror;
00231  else
00232 #endif
00233  {
00234   float ini_distance = ((float)  tolua_tonumber(tolua_S,2,0));
00235   {
00236    fawkes::HumanoidMotionInterface::WalkStraightMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkStraightMessage)(ini_distance));
00237     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkStraightMessage");
00238   }
00239  }
00240  return 1;
00241 #ifndef TOLUA_RELEASE
00242  tolua_lerror:
00243  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00244  return 0;
00245 #endif
00246 }
00247 #endif //#ifndef TOLUA_DISABLE
00248 
00249 /* method: new_local of class  WalkStraightMessage */
00250 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00_local
00251 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00_local(lua_State* tolua_S)
00252 {
00253 #ifndef TOLUA_RELEASE
00254  tolua_Error tolua_err;
00255  if (
00256      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
00257      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00258      !tolua_isnoobj(tolua_S,3,&tolua_err)
00259  )
00260   goto tolua_lerror;
00261  else
00262 #endif
00263  {
00264   float ini_distance = ((float)  tolua_tonumber(tolua_S,2,0));
00265   {
00266    fawkes::HumanoidMotionInterface::WalkStraightMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkStraightMessage)(ini_distance));
00267     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkStraightMessage");
00268     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00269   }
00270  }
00271  return 1;
00272 #ifndef TOLUA_RELEASE
00273  tolua_lerror:
00274  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00275  return 0;
00276 #endif
00277 }
00278 #endif //#ifndef TOLUA_DISABLE
00279 
00280 /* method: new of class  WalkStraightMessage */
00281 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new01
00282 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new01(lua_State* tolua_S)
00283 {
00284  tolua_Error tolua_err;
00285  if (
00286      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
00287      !tolua_isnoobj(tolua_S,2,&tolua_err)
00288  )
00289   goto tolua_lerror;
00290  else
00291  {
00292   {
00293    fawkes::HumanoidMotionInterface::WalkStraightMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkStraightMessage)());
00294     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkStraightMessage");
00295   }
00296  }
00297  return 1;
00298 tolua_lerror:
00299  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00(tolua_S);
00300 }
00301 #endif //#ifndef TOLUA_DISABLE
00302 
00303 /* method: new_local of class  WalkStraightMessage */
00304 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new01_local
00305 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new01_local(lua_State* tolua_S)
00306 {
00307  tolua_Error tolua_err;
00308  if (
00309      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
00310      !tolua_isnoobj(tolua_S,2,&tolua_err)
00311  )
00312   goto tolua_lerror;
00313  else
00314  {
00315   {
00316    fawkes::HumanoidMotionInterface::WalkStraightMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkStraightMessage)());
00317     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkStraightMessage");
00318     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00319   }
00320  }
00321  return 1;
00322 tolua_lerror:
00323  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00_local(tolua_S);
00324 }
00325 #endif //#ifndef TOLUA_DISABLE
00326 
00327 /* method: delete of class  WalkStraightMessage */
00328 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_delete00
00329 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_delete00(lua_State* tolua_S)
00330 {
00331 #ifndef TOLUA_RELEASE
00332  tolua_Error tolua_err;
00333  if (
00334      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
00335      !tolua_isnoobj(tolua_S,2,&tolua_err)
00336  )
00337   goto tolua_lerror;
00338  else
00339 #endif
00340  {
00341   fawkes::HumanoidMotionInterface::WalkStraightMessage* self = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  tolua_tousertype(tolua_S,1,0);
00342 #ifndef TOLUA_RELEASE
00343   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00344 #endif
00345   Mtolua_delete(self);
00346  }
00347  return 0;
00348 #ifndef TOLUA_RELEASE
00349  tolua_lerror:
00350  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00351  return 0;
00352 #endif
00353 }
00354 #endif //#ifndef TOLUA_DISABLE
00355 
00356 /* method: distance of class  WalkStraightMessage */
00357 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_distance00
00358 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_distance00(lua_State* tolua_S)
00359 {
00360 #ifndef TOLUA_RELEASE
00361  tolua_Error tolua_err;
00362  if (
00363      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
00364      !tolua_isnoobj(tolua_S,2,&tolua_err)
00365  )
00366   goto tolua_lerror;
00367  else
00368 #endif
00369  {
00370   fawkes::HumanoidMotionInterface::WalkStraightMessage* self = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  tolua_tousertype(tolua_S,1,0);
00371 #ifndef TOLUA_RELEASE
00372   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'distance'", NULL);
00373 #endif
00374   {
00375    float tolua_ret = (float)  self->distance();
00376    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00377   }
00378  }
00379  return 1;
00380 #ifndef TOLUA_RELEASE
00381  tolua_lerror:
00382  tolua_error(tolua_S,"#ferror in function 'distance'.",&tolua_err);
00383  return 0;
00384 #endif
00385 }
00386 #endif //#ifndef TOLUA_DISABLE
00387 
00388 /* method: set_distance of class  WalkStraightMessage */
00389 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_set_distance00
00390 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_set_distance00(lua_State* tolua_S)
00391 {
00392 #ifndef TOLUA_RELEASE
00393  tolua_Error tolua_err;
00394  if (
00395      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
00396      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00397      !tolua_isnoobj(tolua_S,3,&tolua_err)
00398  )
00399   goto tolua_lerror;
00400  else
00401 #endif
00402  {
00403   fawkes::HumanoidMotionInterface::WalkStraightMessage* self = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  tolua_tousertype(tolua_S,1,0);
00404   const float new_distance = ((const float)  tolua_tonumber(tolua_S,2,0));
00405 #ifndef TOLUA_RELEASE
00406   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_distance'", NULL);
00407 #endif
00408   {
00409    self->set_distance(new_distance);
00410   }
00411  }
00412  return 0;
00413 #ifndef TOLUA_RELEASE
00414  tolua_lerror:
00415  tolua_error(tolua_S,"#ferror in function 'set_distance'.",&tolua_err);
00416  return 0;
00417 #endif
00418 }
00419 #endif //#ifndef TOLUA_DISABLE
00420 
00421 /* method: maxlenof_distance of class  WalkStraightMessage */
00422 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_maxlenof_distance00
00423 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_maxlenof_distance00(lua_State* tolua_S)
00424 {
00425 #ifndef TOLUA_RELEASE
00426  tolua_Error tolua_err;
00427  if (
00428      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
00429      !tolua_isnoobj(tolua_S,2,&tolua_err)
00430  )
00431   goto tolua_lerror;
00432  else
00433 #endif
00434  {
00435   const fawkes::HumanoidMotionInterface::WalkStraightMessage* self = (const fawkes::HumanoidMotionInterface::WalkStraightMessage*)  tolua_tousertype(tolua_S,1,0);
00436 #ifndef TOLUA_RELEASE
00437   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_distance'", NULL);
00438 #endif
00439   {
00440    int tolua_ret = (int)  self->maxlenof_distance();
00441    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00442   }
00443  }
00444  return 1;
00445 #ifndef TOLUA_RELEASE
00446  tolua_lerror:
00447  tolua_error(tolua_S,"#ferror in function 'maxlenof_distance'.",&tolua_err);
00448  return 0;
00449 #endif
00450 }
00451 #endif //#ifndef TOLUA_DISABLE
00452 
00453 /* method: new of class  WalkSidewaysMessage */
00454 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00
00455 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00(lua_State* tolua_S)
00456 {
00457 #ifndef TOLUA_RELEASE
00458  tolua_Error tolua_err;
00459  if (
00460      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
00461      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00462      !tolua_isnoobj(tolua_S,3,&tolua_err)
00463  )
00464   goto tolua_lerror;
00465  else
00466 #endif
00467  {
00468   float ini_distance = ((float)  tolua_tonumber(tolua_S,2,0));
00469   {
00470    fawkes::HumanoidMotionInterface::WalkSidewaysMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkSidewaysMessage)(ini_distance));
00471     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage");
00472   }
00473  }
00474  return 1;
00475 #ifndef TOLUA_RELEASE
00476  tolua_lerror:
00477  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00478  return 0;
00479 #endif
00480 }
00481 #endif //#ifndef TOLUA_DISABLE
00482 
00483 /* method: new_local of class  WalkSidewaysMessage */
00484 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00_local
00485 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00_local(lua_State* tolua_S)
00486 {
00487 #ifndef TOLUA_RELEASE
00488  tolua_Error tolua_err;
00489  if (
00490      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
00491      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00492      !tolua_isnoobj(tolua_S,3,&tolua_err)
00493  )
00494   goto tolua_lerror;
00495  else
00496 #endif
00497  {
00498   float ini_distance = ((float)  tolua_tonumber(tolua_S,2,0));
00499   {
00500    fawkes::HumanoidMotionInterface::WalkSidewaysMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkSidewaysMessage)(ini_distance));
00501     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage");
00502     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00503   }
00504  }
00505  return 1;
00506 #ifndef TOLUA_RELEASE
00507  tolua_lerror:
00508  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00509  return 0;
00510 #endif
00511 }
00512 #endif //#ifndef TOLUA_DISABLE
00513 
00514 /* method: new of class  WalkSidewaysMessage */
00515 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new01
00516 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new01(lua_State* tolua_S)
00517 {
00518  tolua_Error tolua_err;
00519  if (
00520      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
00521      !tolua_isnoobj(tolua_S,2,&tolua_err)
00522  )
00523   goto tolua_lerror;
00524  else
00525  {
00526   {
00527    fawkes::HumanoidMotionInterface::WalkSidewaysMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkSidewaysMessage)());
00528     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage");
00529   }
00530  }
00531  return 1;
00532 tolua_lerror:
00533  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00(tolua_S);
00534 }
00535 #endif //#ifndef TOLUA_DISABLE
00536 
00537 /* method: new_local of class  WalkSidewaysMessage */
00538 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new01_local
00539 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new01_local(lua_State* tolua_S)
00540 {
00541  tolua_Error tolua_err;
00542  if (
00543      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
00544      !tolua_isnoobj(tolua_S,2,&tolua_err)
00545  )
00546   goto tolua_lerror;
00547  else
00548  {
00549   {
00550    fawkes::HumanoidMotionInterface::WalkSidewaysMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkSidewaysMessage)());
00551     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage");
00552     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00553   }
00554  }
00555  return 1;
00556 tolua_lerror:
00557  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00_local(tolua_S);
00558 }
00559 #endif //#ifndef TOLUA_DISABLE
00560 
00561 /* method: delete of class  WalkSidewaysMessage */
00562 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_delete00
00563 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_delete00(lua_State* tolua_S)
00564 {
00565 #ifndef TOLUA_RELEASE
00566  tolua_Error tolua_err;
00567  if (
00568      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
00569      !tolua_isnoobj(tolua_S,2,&tolua_err)
00570  )
00571   goto tolua_lerror;
00572  else
00573 #endif
00574  {
00575   fawkes::HumanoidMotionInterface::WalkSidewaysMessage* self = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  tolua_tousertype(tolua_S,1,0);
00576 #ifndef TOLUA_RELEASE
00577   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00578 #endif
00579   Mtolua_delete(self);
00580  }
00581  return 0;
00582 #ifndef TOLUA_RELEASE
00583  tolua_lerror:
00584  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00585  return 0;
00586 #endif
00587 }
00588 #endif //#ifndef TOLUA_DISABLE
00589 
00590 /* method: distance of class  WalkSidewaysMessage */
00591 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_distance00
00592 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_distance00(lua_State* tolua_S)
00593 {
00594 #ifndef TOLUA_RELEASE
00595  tolua_Error tolua_err;
00596  if (
00597      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
00598      !tolua_isnoobj(tolua_S,2,&tolua_err)
00599  )
00600   goto tolua_lerror;
00601  else
00602 #endif
00603  {
00604   fawkes::HumanoidMotionInterface::WalkSidewaysMessage* self = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  tolua_tousertype(tolua_S,1,0);
00605 #ifndef TOLUA_RELEASE
00606   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'distance'", NULL);
00607 #endif
00608   {
00609    float tolua_ret = (float)  self->distance();
00610    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00611   }
00612  }
00613  return 1;
00614 #ifndef TOLUA_RELEASE
00615  tolua_lerror:
00616  tolua_error(tolua_S,"#ferror in function 'distance'.",&tolua_err);
00617  return 0;
00618 #endif
00619 }
00620 #endif //#ifndef TOLUA_DISABLE
00621 
00622 /* method: set_distance of class  WalkSidewaysMessage */
00623 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_set_distance00
00624 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_set_distance00(lua_State* tolua_S)
00625 {
00626 #ifndef TOLUA_RELEASE
00627  tolua_Error tolua_err;
00628  if (
00629      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
00630      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00631      !tolua_isnoobj(tolua_S,3,&tolua_err)
00632  )
00633   goto tolua_lerror;
00634  else
00635 #endif
00636  {
00637   fawkes::HumanoidMotionInterface::WalkSidewaysMessage* self = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  tolua_tousertype(tolua_S,1,0);
00638   const float new_distance = ((const float)  tolua_tonumber(tolua_S,2,0));
00639 #ifndef TOLUA_RELEASE
00640   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_distance'", NULL);
00641 #endif
00642   {
00643    self->set_distance(new_distance);
00644   }
00645  }
00646  return 0;
00647 #ifndef TOLUA_RELEASE
00648  tolua_lerror:
00649  tolua_error(tolua_S,"#ferror in function 'set_distance'.",&tolua_err);
00650  return 0;
00651 #endif
00652 }
00653 #endif //#ifndef TOLUA_DISABLE
00654 
00655 /* method: maxlenof_distance of class  WalkSidewaysMessage */
00656 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_maxlenof_distance00
00657 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_maxlenof_distance00(lua_State* tolua_S)
00658 {
00659 #ifndef TOLUA_RELEASE
00660  tolua_Error tolua_err;
00661  if (
00662      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
00663      !tolua_isnoobj(tolua_S,2,&tolua_err)
00664  )
00665   goto tolua_lerror;
00666  else
00667 #endif
00668  {
00669   const fawkes::HumanoidMotionInterface::WalkSidewaysMessage* self = (const fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  tolua_tousertype(tolua_S,1,0);
00670 #ifndef TOLUA_RELEASE
00671   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_distance'", NULL);
00672 #endif
00673   {
00674    int tolua_ret = (int)  self->maxlenof_distance();
00675    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00676   }
00677  }
00678  return 1;
00679 #ifndef TOLUA_RELEASE
00680  tolua_lerror:
00681  tolua_error(tolua_S,"#ferror in function 'maxlenof_distance'.",&tolua_err);
00682  return 0;
00683 #endif
00684 }
00685 #endif //#ifndef TOLUA_DISABLE
00686 
00687 /* method: new of class  WalkArcMessage */
00688 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00
00689 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00(lua_State* tolua_S)
00690 {
00691 #ifndef TOLUA_RELEASE
00692  tolua_Error tolua_err;
00693  if (
00694      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
00695      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00696      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00697      !tolua_isnoobj(tolua_S,4,&tolua_err)
00698  )
00699   goto tolua_lerror;
00700  else
00701 #endif
00702  {
00703   float ini_angle = ((float)  tolua_tonumber(tolua_S,2,0));
00704   float ini_radius = ((float)  tolua_tonumber(tolua_S,3,0));
00705   {
00706    fawkes::HumanoidMotionInterface::WalkArcMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkArcMessage)(ini_angle,ini_radius));
00707     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkArcMessage");
00708   }
00709  }
00710  return 1;
00711 #ifndef TOLUA_RELEASE
00712  tolua_lerror:
00713  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00714  return 0;
00715 #endif
00716 }
00717 #endif //#ifndef TOLUA_DISABLE
00718 
00719 /* method: new_local of class  WalkArcMessage */
00720 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00_local
00721 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00_local(lua_State* tolua_S)
00722 {
00723 #ifndef TOLUA_RELEASE
00724  tolua_Error tolua_err;
00725  if (
00726      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
00727      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00728      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00729      !tolua_isnoobj(tolua_S,4,&tolua_err)
00730  )
00731   goto tolua_lerror;
00732  else
00733 #endif
00734  {
00735   float ini_angle = ((float)  tolua_tonumber(tolua_S,2,0));
00736   float ini_radius = ((float)  tolua_tonumber(tolua_S,3,0));
00737   {
00738    fawkes::HumanoidMotionInterface::WalkArcMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkArcMessage)(ini_angle,ini_radius));
00739     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkArcMessage");
00740     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00741   }
00742  }
00743  return 1;
00744 #ifndef TOLUA_RELEASE
00745  tolua_lerror:
00746  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00747  return 0;
00748 #endif
00749 }
00750 #endif //#ifndef TOLUA_DISABLE
00751 
00752 /* method: new of class  WalkArcMessage */
00753 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new01
00754 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new01(lua_State* tolua_S)
00755 {
00756  tolua_Error tolua_err;
00757  if (
00758      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
00759      !tolua_isnoobj(tolua_S,2,&tolua_err)
00760  )
00761   goto tolua_lerror;
00762  else
00763  {
00764   {
00765    fawkes::HumanoidMotionInterface::WalkArcMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkArcMessage)());
00766     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkArcMessage");
00767   }
00768  }
00769  return 1;
00770 tolua_lerror:
00771  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00(tolua_S);
00772 }
00773 #endif //#ifndef TOLUA_DISABLE
00774 
00775 /* method: new_local of class  WalkArcMessage */
00776 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new01_local
00777 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new01_local(lua_State* tolua_S)
00778 {
00779  tolua_Error tolua_err;
00780  if (
00781      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
00782      !tolua_isnoobj(tolua_S,2,&tolua_err)
00783  )
00784   goto tolua_lerror;
00785  else
00786  {
00787   {
00788    fawkes::HumanoidMotionInterface::WalkArcMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkArcMessage)());
00789     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkArcMessage");
00790     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00791   }
00792  }
00793  return 1;
00794 tolua_lerror:
00795  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00_local(tolua_S);
00796 }
00797 #endif //#ifndef TOLUA_DISABLE
00798 
00799 /* method: delete of class  WalkArcMessage */
00800 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_delete00
00801 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_delete00(lua_State* tolua_S)
00802 {
00803 #ifndef TOLUA_RELEASE
00804  tolua_Error tolua_err;
00805  if (
00806      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
00807      !tolua_isnoobj(tolua_S,2,&tolua_err)
00808  )
00809   goto tolua_lerror;
00810  else
00811 #endif
00812  {
00813   fawkes::HumanoidMotionInterface::WalkArcMessage* self = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
00814 #ifndef TOLUA_RELEASE
00815   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00816 #endif
00817   Mtolua_delete(self);
00818  }
00819  return 0;
00820 #ifndef TOLUA_RELEASE
00821  tolua_lerror:
00822  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00823  return 0;
00824 #endif
00825 }
00826 #endif //#ifndef TOLUA_DISABLE
00827 
00828 /* method: angle of class  WalkArcMessage */
00829 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_angle00
00830 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_angle00(lua_State* tolua_S)
00831 {
00832 #ifndef TOLUA_RELEASE
00833  tolua_Error tolua_err;
00834  if (
00835      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
00836      !tolua_isnoobj(tolua_S,2,&tolua_err)
00837  )
00838   goto tolua_lerror;
00839  else
00840 #endif
00841  {
00842   fawkes::HumanoidMotionInterface::WalkArcMessage* self = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
00843 #ifndef TOLUA_RELEASE
00844   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'angle'", NULL);
00845 #endif
00846   {
00847    float tolua_ret = (float)  self->angle();
00848    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00849   }
00850  }
00851  return 1;
00852 #ifndef TOLUA_RELEASE
00853  tolua_lerror:
00854  tolua_error(tolua_S,"#ferror in function 'angle'.",&tolua_err);
00855  return 0;
00856 #endif
00857 }
00858 #endif //#ifndef TOLUA_DISABLE
00859 
00860 /* method: set_angle of class  WalkArcMessage */
00861 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_angle00
00862 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_angle00(lua_State* tolua_S)
00863 {
00864 #ifndef TOLUA_RELEASE
00865  tolua_Error tolua_err;
00866  if (
00867      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
00868      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00869      !tolua_isnoobj(tolua_S,3,&tolua_err)
00870  )
00871   goto tolua_lerror;
00872  else
00873 #endif
00874  {
00875   fawkes::HumanoidMotionInterface::WalkArcMessage* self = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
00876   const float new_angle = ((const float)  tolua_tonumber(tolua_S,2,0));
00877 #ifndef TOLUA_RELEASE
00878   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_angle'", NULL);
00879 #endif
00880   {
00881    self->set_angle(new_angle);
00882   }
00883  }
00884  return 0;
00885 #ifndef TOLUA_RELEASE
00886  tolua_lerror:
00887  tolua_error(tolua_S,"#ferror in function 'set_angle'.",&tolua_err);
00888  return 0;
00889 #endif
00890 }
00891 #endif //#ifndef TOLUA_DISABLE
00892 
00893 /* method: maxlenof_angle of class  WalkArcMessage */
00894 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_angle00
00895 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_angle00(lua_State* tolua_S)
00896 {
00897 #ifndef TOLUA_RELEASE
00898  tolua_Error tolua_err;
00899  if (
00900      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
00901      !tolua_isnoobj(tolua_S,2,&tolua_err)
00902  )
00903   goto tolua_lerror;
00904  else
00905 #endif
00906  {
00907   const fawkes::HumanoidMotionInterface::WalkArcMessage* self = (const fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
00908 #ifndef TOLUA_RELEASE
00909   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_angle'", NULL);
00910 #endif
00911   {
00912    int tolua_ret = (int)  self->maxlenof_angle();
00913    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00914   }
00915  }
00916  return 1;
00917 #ifndef TOLUA_RELEASE
00918  tolua_lerror:
00919  tolua_error(tolua_S,"#ferror in function 'maxlenof_angle'.",&tolua_err);
00920  return 0;
00921 #endif
00922 }
00923 #endif //#ifndef TOLUA_DISABLE
00924 
00925 /* method: radius of class  WalkArcMessage */
00926 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_radius00
00927 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_radius00(lua_State* tolua_S)
00928 {
00929 #ifndef TOLUA_RELEASE
00930  tolua_Error tolua_err;
00931  if (
00932      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
00933      !tolua_isnoobj(tolua_S,2,&tolua_err)
00934  )
00935   goto tolua_lerror;
00936  else
00937 #endif
00938  {
00939   fawkes::HumanoidMotionInterface::WalkArcMessage* self = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
00940 #ifndef TOLUA_RELEASE
00941   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'radius'", NULL);
00942 #endif
00943   {
00944    float tolua_ret = (float)  self->radius();
00945    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00946   }
00947  }
00948  return 1;
00949 #ifndef TOLUA_RELEASE
00950  tolua_lerror:
00951  tolua_error(tolua_S,"#ferror in function 'radius'.",&tolua_err);
00952  return 0;
00953 #endif
00954 }
00955 #endif //#ifndef TOLUA_DISABLE
00956 
00957 /* method: set_radius of class  WalkArcMessage */
00958 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_radius00
00959 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_radius00(lua_State* tolua_S)
00960 {
00961 #ifndef TOLUA_RELEASE
00962  tolua_Error tolua_err;
00963  if (
00964      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
00965      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00966      !tolua_isnoobj(tolua_S,3,&tolua_err)
00967  )
00968   goto tolua_lerror;
00969  else
00970 #endif
00971  {
00972   fawkes::HumanoidMotionInterface::WalkArcMessage* self = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
00973   const float new_radius = ((const float)  tolua_tonumber(tolua_S,2,0));
00974 #ifndef TOLUA_RELEASE
00975   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_radius'", NULL);
00976 #endif
00977   {
00978    self->set_radius(new_radius);
00979   }
00980  }
00981  return 0;
00982 #ifndef TOLUA_RELEASE
00983  tolua_lerror:
00984  tolua_error(tolua_S,"#ferror in function 'set_radius'.",&tolua_err);
00985  return 0;
00986 #endif
00987 }
00988 #endif //#ifndef TOLUA_DISABLE
00989 
00990 /* method: maxlenof_radius of class  WalkArcMessage */
00991 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_radius00
00992 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_radius00(lua_State* tolua_S)
00993 {
00994 #ifndef TOLUA_RELEASE
00995  tolua_Error tolua_err;
00996  if (
00997      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
00998      !tolua_isnoobj(tolua_S,2,&tolua_err)
00999  )
01000   goto tolua_lerror;
01001  else
01002 #endif
01003  {
01004   const fawkes::HumanoidMotionInterface::WalkArcMessage* self = (const fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
01005 #ifndef TOLUA_RELEASE
01006   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_radius'", NULL);
01007 #endif
01008   {
01009    int tolua_ret = (int)  self->maxlenof_radius();
01010    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01011   }
01012  }
01013  return 1;
01014 #ifndef TOLUA_RELEASE
01015  tolua_lerror:
01016  tolua_error(tolua_S,"#ferror in function 'maxlenof_radius'.",&tolua_err);
01017  return 0;
01018 #endif
01019 }
01020 #endif //#ifndef TOLUA_DISABLE
01021 
01022 /* method: new of class  WalkVelocityMessage */
01023 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new00
01024 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new00(lua_State* tolua_S)
01025 {
01026 #ifndef TOLUA_RELEASE
01027  tolua_Error tolua_err;
01028  if (
01029      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01030      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01031      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01032      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01033      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
01034      !tolua_isnoobj(tolua_S,6,&tolua_err)
01035  )
01036   goto tolua_lerror;
01037  else
01038 #endif
01039  {
01040   float ini_x = ((float)  tolua_tonumber(tolua_S,2,0));
01041   float ini_y = ((float)  tolua_tonumber(tolua_S,3,0));
01042   float ini_theta = ((float)  tolua_tonumber(tolua_S,4,0));
01043   float ini_speed = ((float)  tolua_tonumber(tolua_S,5,0));
01044   {
01045    fawkes::HumanoidMotionInterface::WalkVelocityMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkVelocityMessage)(ini_x,ini_y,ini_theta,ini_speed));
01046     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkVelocityMessage");
01047   }
01048  }
01049  return 1;
01050 #ifndef TOLUA_RELEASE
01051  tolua_lerror:
01052  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01053  return 0;
01054 #endif
01055 }
01056 #endif //#ifndef TOLUA_DISABLE
01057 
01058 /* method: new_local of class  WalkVelocityMessage */
01059 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new00_local
01060 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new00_local(lua_State* tolua_S)
01061 {
01062 #ifndef TOLUA_RELEASE
01063  tolua_Error tolua_err;
01064  if (
01065      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01066      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01067      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01068      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01069      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
01070      !tolua_isnoobj(tolua_S,6,&tolua_err)
01071  )
01072   goto tolua_lerror;
01073  else
01074 #endif
01075  {
01076   float ini_x = ((float)  tolua_tonumber(tolua_S,2,0));
01077   float ini_y = ((float)  tolua_tonumber(tolua_S,3,0));
01078   float ini_theta = ((float)  tolua_tonumber(tolua_S,4,0));
01079   float ini_speed = ((float)  tolua_tonumber(tolua_S,5,0));
01080   {
01081    fawkes::HumanoidMotionInterface::WalkVelocityMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkVelocityMessage)(ini_x,ini_y,ini_theta,ini_speed));
01082     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkVelocityMessage");
01083     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01084   }
01085  }
01086  return 1;
01087 #ifndef TOLUA_RELEASE
01088  tolua_lerror:
01089  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01090  return 0;
01091 #endif
01092 }
01093 #endif //#ifndef TOLUA_DISABLE
01094 
01095 /* method: new of class  WalkVelocityMessage */
01096 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new01
01097 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new01(lua_State* tolua_S)
01098 {
01099  tolua_Error tolua_err;
01100  if (
01101      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01102      !tolua_isnoobj(tolua_S,2,&tolua_err)
01103  )
01104   goto tolua_lerror;
01105  else
01106  {
01107   {
01108    fawkes::HumanoidMotionInterface::WalkVelocityMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkVelocityMessage)());
01109     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkVelocityMessage");
01110   }
01111  }
01112  return 1;
01113 tolua_lerror:
01114  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new00(tolua_S);
01115 }
01116 #endif //#ifndef TOLUA_DISABLE
01117 
01118 /* method: new_local of class  WalkVelocityMessage */
01119 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new01_local
01120 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new01_local(lua_State* tolua_S)
01121 {
01122  tolua_Error tolua_err;
01123  if (
01124      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01125      !tolua_isnoobj(tolua_S,2,&tolua_err)
01126  )
01127   goto tolua_lerror;
01128  else
01129  {
01130   {
01131    fawkes::HumanoidMotionInterface::WalkVelocityMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkVelocityMessage)());
01132     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkVelocityMessage");
01133     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01134   }
01135  }
01136  return 1;
01137 tolua_lerror:
01138  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new00_local(tolua_S);
01139 }
01140 #endif //#ifndef TOLUA_DISABLE
01141 
01142 /* method: delete of class  WalkVelocityMessage */
01143 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_delete00
01144 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_delete00(lua_State* tolua_S)
01145 {
01146 #ifndef TOLUA_RELEASE
01147  tolua_Error tolua_err;
01148  if (
01149      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01150      !tolua_isnoobj(tolua_S,2,&tolua_err)
01151  )
01152   goto tolua_lerror;
01153  else
01154 #endif
01155  {
01156   fawkes::HumanoidMotionInterface::WalkVelocityMessage* self = (fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01157 #ifndef TOLUA_RELEASE
01158   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01159 #endif
01160   Mtolua_delete(self);
01161  }
01162  return 0;
01163 #ifndef TOLUA_RELEASE
01164  tolua_lerror:
01165  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01166  return 0;
01167 #endif
01168 }
01169 #endif //#ifndef TOLUA_DISABLE
01170 
01171 /* method: x of class  WalkVelocityMessage */
01172 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_x00
01173 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_x00(lua_State* tolua_S)
01174 {
01175 #ifndef TOLUA_RELEASE
01176  tolua_Error tolua_err;
01177  if (
01178      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01179      !tolua_isnoobj(tolua_S,2,&tolua_err)
01180  )
01181   goto tolua_lerror;
01182  else
01183 #endif
01184  {
01185   fawkes::HumanoidMotionInterface::WalkVelocityMessage* self = (fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01186 #ifndef TOLUA_RELEASE
01187   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
01188 #endif
01189   {
01190    float tolua_ret = (float)  self->x();
01191    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01192   }
01193  }
01194  return 1;
01195 #ifndef TOLUA_RELEASE
01196  tolua_lerror:
01197  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
01198  return 0;
01199 #endif
01200 }
01201 #endif //#ifndef TOLUA_DISABLE
01202 
01203 /* method: set_x of class  WalkVelocityMessage */
01204 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_set_x00
01205 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_set_x00(lua_State* tolua_S)
01206 {
01207 #ifndef TOLUA_RELEASE
01208  tolua_Error tolua_err;
01209  if (
01210      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01211      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01212      !tolua_isnoobj(tolua_S,3,&tolua_err)
01213  )
01214   goto tolua_lerror;
01215  else
01216 #endif
01217  {
01218   fawkes::HumanoidMotionInterface::WalkVelocityMessage* self = (fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01219   const float new_x = ((const float)  tolua_tonumber(tolua_S,2,0));
01220 #ifndef TOLUA_RELEASE
01221   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_x'", NULL);
01222 #endif
01223   {
01224    self->set_x(new_x);
01225   }
01226  }
01227  return 0;
01228 #ifndef TOLUA_RELEASE
01229  tolua_lerror:
01230  tolua_error(tolua_S,"#ferror in function 'set_x'.",&tolua_err);
01231  return 0;
01232 #endif
01233 }
01234 #endif //#ifndef TOLUA_DISABLE
01235 
01236 /* method: maxlenof_x of class  WalkVelocityMessage */
01237 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_maxlenof_x00
01238 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_maxlenof_x00(lua_State* tolua_S)
01239 {
01240 #ifndef TOLUA_RELEASE
01241  tolua_Error tolua_err;
01242  if (
01243      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01244      !tolua_isnoobj(tolua_S,2,&tolua_err)
01245  )
01246   goto tolua_lerror;
01247  else
01248 #endif
01249  {
01250   const fawkes::HumanoidMotionInterface::WalkVelocityMessage* self = (const fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01251 #ifndef TOLUA_RELEASE
01252   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_x'", NULL);
01253 #endif
01254   {
01255    int tolua_ret = (int)  self->maxlenof_x();
01256    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01257   }
01258  }
01259  return 1;
01260 #ifndef TOLUA_RELEASE
01261  tolua_lerror:
01262  tolua_error(tolua_S,"#ferror in function 'maxlenof_x'.",&tolua_err);
01263  return 0;
01264 #endif
01265 }
01266 #endif //#ifndef TOLUA_DISABLE
01267 
01268 /* method: y of class  WalkVelocityMessage */
01269 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_y00
01270 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_y00(lua_State* tolua_S)
01271 {
01272 #ifndef TOLUA_RELEASE
01273  tolua_Error tolua_err;
01274  if (
01275      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01276      !tolua_isnoobj(tolua_S,2,&tolua_err)
01277  )
01278   goto tolua_lerror;
01279  else
01280 #endif
01281  {
01282   fawkes::HumanoidMotionInterface::WalkVelocityMessage* self = (fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01283 #ifndef TOLUA_RELEASE
01284   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
01285 #endif
01286   {
01287    float tolua_ret = (float)  self->y();
01288    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01289   }
01290  }
01291  return 1;
01292 #ifndef TOLUA_RELEASE
01293  tolua_lerror:
01294  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
01295  return 0;
01296 #endif
01297 }
01298 #endif //#ifndef TOLUA_DISABLE
01299 
01300 /* method: set_y of class  WalkVelocityMessage */
01301 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_set_y00
01302 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_set_y00(lua_State* tolua_S)
01303 {
01304 #ifndef TOLUA_RELEASE
01305  tolua_Error tolua_err;
01306  if (
01307      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01308      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01309      !tolua_isnoobj(tolua_S,3,&tolua_err)
01310  )
01311   goto tolua_lerror;
01312  else
01313 #endif
01314  {
01315   fawkes::HumanoidMotionInterface::WalkVelocityMessage* self = (fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01316   const float new_y = ((const float)  tolua_tonumber(tolua_S,2,0));
01317 #ifndef TOLUA_RELEASE
01318   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_y'", NULL);
01319 #endif
01320   {
01321    self->set_y(new_y);
01322   }
01323  }
01324  return 0;
01325 #ifndef TOLUA_RELEASE
01326  tolua_lerror:
01327  tolua_error(tolua_S,"#ferror in function 'set_y'.",&tolua_err);
01328  return 0;
01329 #endif
01330 }
01331 #endif //#ifndef TOLUA_DISABLE
01332 
01333 /* method: maxlenof_y of class  WalkVelocityMessage */
01334 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_maxlenof_y00
01335 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_maxlenof_y00(lua_State* tolua_S)
01336 {
01337 #ifndef TOLUA_RELEASE
01338  tolua_Error tolua_err;
01339  if (
01340      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01341      !tolua_isnoobj(tolua_S,2,&tolua_err)
01342  )
01343   goto tolua_lerror;
01344  else
01345 #endif
01346  {
01347   const fawkes::HumanoidMotionInterface::WalkVelocityMessage* self = (const fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01348 #ifndef TOLUA_RELEASE
01349   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_y'", NULL);
01350 #endif
01351   {
01352    int tolua_ret = (int)  self->maxlenof_y();
01353    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01354   }
01355  }
01356  return 1;
01357 #ifndef TOLUA_RELEASE
01358  tolua_lerror:
01359  tolua_error(tolua_S,"#ferror in function 'maxlenof_y'.",&tolua_err);
01360  return 0;
01361 #endif
01362 }
01363 #endif //#ifndef TOLUA_DISABLE
01364 
01365 /* method: theta of class  WalkVelocityMessage */
01366 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_theta00
01367 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_theta00(lua_State* tolua_S)
01368 {
01369 #ifndef TOLUA_RELEASE
01370  tolua_Error tolua_err;
01371  if (
01372      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01373      !tolua_isnoobj(tolua_S,2,&tolua_err)
01374  )
01375   goto tolua_lerror;
01376  else
01377 #endif
01378  {
01379   fawkes::HumanoidMotionInterface::WalkVelocityMessage* self = (fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01380 #ifndef TOLUA_RELEASE
01381   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'theta'", NULL);
01382 #endif
01383   {
01384    float tolua_ret = (float)  self->theta();
01385    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01386   }
01387  }
01388  return 1;
01389 #ifndef TOLUA_RELEASE
01390  tolua_lerror:
01391  tolua_error(tolua_S,"#ferror in function 'theta'.",&tolua_err);
01392  return 0;
01393 #endif
01394 }
01395 #endif //#ifndef TOLUA_DISABLE
01396 
01397 /* method: set_theta of class  WalkVelocityMessage */
01398 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_set_theta00
01399 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_set_theta00(lua_State* tolua_S)
01400 {
01401 #ifndef TOLUA_RELEASE
01402  tolua_Error tolua_err;
01403  if (
01404      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01405      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01406      !tolua_isnoobj(tolua_S,3,&tolua_err)
01407  )
01408   goto tolua_lerror;
01409  else
01410 #endif
01411  {
01412   fawkes::HumanoidMotionInterface::WalkVelocityMessage* self = (fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01413   const float new_theta = ((const float)  tolua_tonumber(tolua_S,2,0));
01414 #ifndef TOLUA_RELEASE
01415   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_theta'", NULL);
01416 #endif
01417   {
01418    self->set_theta(new_theta);
01419   }
01420  }
01421  return 0;
01422 #ifndef TOLUA_RELEASE
01423  tolua_lerror:
01424  tolua_error(tolua_S,"#ferror in function 'set_theta'.",&tolua_err);
01425  return 0;
01426 #endif
01427 }
01428 #endif //#ifndef TOLUA_DISABLE
01429 
01430 /* method: maxlenof_theta of class  WalkVelocityMessage */
01431 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_maxlenof_theta00
01432 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_maxlenof_theta00(lua_State* tolua_S)
01433 {
01434 #ifndef TOLUA_RELEASE
01435  tolua_Error tolua_err;
01436  if (
01437      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01438      !tolua_isnoobj(tolua_S,2,&tolua_err)
01439  )
01440   goto tolua_lerror;
01441  else
01442 #endif
01443  {
01444   const fawkes::HumanoidMotionInterface::WalkVelocityMessage* self = (const fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01445 #ifndef TOLUA_RELEASE
01446   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_theta'", NULL);
01447 #endif
01448   {
01449    int tolua_ret = (int)  self->maxlenof_theta();
01450    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01451   }
01452  }
01453  return 1;
01454 #ifndef TOLUA_RELEASE
01455  tolua_lerror:
01456  tolua_error(tolua_S,"#ferror in function 'maxlenof_theta'.",&tolua_err);
01457  return 0;
01458 #endif
01459 }
01460 #endif //#ifndef TOLUA_DISABLE
01461 
01462 /* method: speed of class  WalkVelocityMessage */
01463 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_speed00
01464 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_speed00(lua_State* tolua_S)
01465 {
01466 #ifndef TOLUA_RELEASE
01467  tolua_Error tolua_err;
01468  if (
01469      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01470      !tolua_isnoobj(tolua_S,2,&tolua_err)
01471  )
01472   goto tolua_lerror;
01473  else
01474 #endif
01475  {
01476   fawkes::HumanoidMotionInterface::WalkVelocityMessage* self = (fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01477 #ifndef TOLUA_RELEASE
01478   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'speed'", NULL);
01479 #endif
01480   {
01481    float tolua_ret = (float)  self->speed();
01482    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01483   }
01484  }
01485  return 1;
01486 #ifndef TOLUA_RELEASE
01487  tolua_lerror:
01488  tolua_error(tolua_S,"#ferror in function 'speed'.",&tolua_err);
01489  return 0;
01490 #endif
01491 }
01492 #endif //#ifndef TOLUA_DISABLE
01493 
01494 /* method: set_speed of class  WalkVelocityMessage */
01495 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_set_speed00
01496 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_set_speed00(lua_State* tolua_S)
01497 {
01498 #ifndef TOLUA_RELEASE
01499  tolua_Error tolua_err;
01500  if (
01501      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01502      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01503      !tolua_isnoobj(tolua_S,3,&tolua_err)
01504  )
01505   goto tolua_lerror;
01506  else
01507 #endif
01508  {
01509   fawkes::HumanoidMotionInterface::WalkVelocityMessage* self = (fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01510   const float new_speed = ((const float)  tolua_tonumber(tolua_S,2,0));
01511 #ifndef TOLUA_RELEASE
01512   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_speed'", NULL);
01513 #endif
01514   {
01515    self->set_speed(new_speed);
01516   }
01517  }
01518  return 0;
01519 #ifndef TOLUA_RELEASE
01520  tolua_lerror:
01521  tolua_error(tolua_S,"#ferror in function 'set_speed'.",&tolua_err);
01522  return 0;
01523 #endif
01524 }
01525 #endif //#ifndef TOLUA_DISABLE
01526 
01527 /* method: maxlenof_speed of class  WalkVelocityMessage */
01528 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_maxlenof_speed00
01529 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_maxlenof_speed00(lua_State* tolua_S)
01530 {
01531 #ifndef TOLUA_RELEASE
01532  tolua_Error tolua_err;
01533  if (
01534      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkVelocityMessage",0,&tolua_err) ||
01535      !tolua_isnoobj(tolua_S,2,&tolua_err)
01536  )
01537   goto tolua_lerror;
01538  else
01539 #endif
01540  {
01541   const fawkes::HumanoidMotionInterface::WalkVelocityMessage* self = (const fawkes::HumanoidMotionInterface::WalkVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01542 #ifndef TOLUA_RELEASE
01543   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_speed'", NULL);
01544 #endif
01545   {
01546    int tolua_ret = (int)  self->maxlenof_speed();
01547    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01548   }
01549  }
01550  return 1;
01551 #ifndef TOLUA_RELEASE
01552  tolua_lerror:
01553  tolua_error(tolua_S,"#ferror in function 'maxlenof_speed'.",&tolua_err);
01554  return 0;
01555 #endif
01556 }
01557 #endif //#ifndef TOLUA_DISABLE
01558 
01559 /* method: new of class  TurnMessage */
01560 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00
01561 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00(lua_State* tolua_S)
01562 {
01563 #ifndef TOLUA_RELEASE
01564  tolua_Error tolua_err;
01565  if (
01566      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
01567      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01568      !tolua_isnoobj(tolua_S,3,&tolua_err)
01569  )
01570   goto tolua_lerror;
01571  else
01572 #endif
01573  {
01574   float ini_angle = ((float)  tolua_tonumber(tolua_S,2,0));
01575   {
01576    fawkes::HumanoidMotionInterface::TurnMessage* tolua_ret = (fawkes::HumanoidMotionInterface::TurnMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::TurnMessage)(ini_angle));
01577     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::TurnMessage");
01578   }
01579  }
01580  return 1;
01581 #ifndef TOLUA_RELEASE
01582  tolua_lerror:
01583  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01584  return 0;
01585 #endif
01586 }
01587 #endif //#ifndef TOLUA_DISABLE
01588 
01589 /* method: new_local of class  TurnMessage */
01590 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00_local
01591 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00_local(lua_State* tolua_S)
01592 {
01593 #ifndef TOLUA_RELEASE
01594  tolua_Error tolua_err;
01595  if (
01596      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
01597      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01598      !tolua_isnoobj(tolua_S,3,&tolua_err)
01599  )
01600   goto tolua_lerror;
01601  else
01602 #endif
01603  {
01604   float ini_angle = ((float)  tolua_tonumber(tolua_S,2,0));
01605   {
01606    fawkes::HumanoidMotionInterface::TurnMessage* tolua_ret = (fawkes::HumanoidMotionInterface::TurnMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::TurnMessage)(ini_angle));
01607     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::TurnMessage");
01608     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01609   }
01610  }
01611  return 1;
01612 #ifndef TOLUA_RELEASE
01613  tolua_lerror:
01614  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01615  return 0;
01616 #endif
01617 }
01618 #endif //#ifndef TOLUA_DISABLE
01619 
01620 /* method: new of class  TurnMessage */
01621 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new01
01622 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new01(lua_State* tolua_S)
01623 {
01624  tolua_Error tolua_err;
01625  if (
01626      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
01627      !tolua_isnoobj(tolua_S,2,&tolua_err)
01628  )
01629   goto tolua_lerror;
01630  else
01631  {
01632   {
01633    fawkes::HumanoidMotionInterface::TurnMessage* tolua_ret = (fawkes::HumanoidMotionInterface::TurnMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::TurnMessage)());
01634     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::TurnMessage");
01635   }
01636  }
01637  return 1;
01638 tolua_lerror:
01639  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00(tolua_S);
01640 }
01641 #endif //#ifndef TOLUA_DISABLE
01642 
01643 /* method: new_local of class  TurnMessage */
01644 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new01_local
01645 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new01_local(lua_State* tolua_S)
01646 {
01647  tolua_Error tolua_err;
01648  if (
01649      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
01650      !tolua_isnoobj(tolua_S,2,&tolua_err)
01651  )
01652   goto tolua_lerror;
01653  else
01654  {
01655   {
01656    fawkes::HumanoidMotionInterface::TurnMessage* tolua_ret = (fawkes::HumanoidMotionInterface::TurnMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::TurnMessage)());
01657     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::TurnMessage");
01658     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01659   }
01660  }
01661  return 1;
01662 tolua_lerror:
01663  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00_local(tolua_S);
01664 }
01665 #endif //#ifndef TOLUA_DISABLE
01666 
01667 /* method: delete of class  TurnMessage */
01668 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_delete00
01669 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_delete00(lua_State* tolua_S)
01670 {
01671 #ifndef TOLUA_RELEASE
01672  tolua_Error tolua_err;
01673  if (
01674      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
01675      !tolua_isnoobj(tolua_S,2,&tolua_err)
01676  )
01677   goto tolua_lerror;
01678  else
01679 #endif
01680  {
01681   fawkes::HumanoidMotionInterface::TurnMessage* self = (fawkes::HumanoidMotionInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
01682 #ifndef TOLUA_RELEASE
01683   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01684 #endif
01685   Mtolua_delete(self);
01686  }
01687  return 0;
01688 #ifndef TOLUA_RELEASE
01689  tolua_lerror:
01690  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01691  return 0;
01692 #endif
01693 }
01694 #endif //#ifndef TOLUA_DISABLE
01695 
01696 /* method: angle of class  TurnMessage */
01697 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_angle00
01698 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_angle00(lua_State* tolua_S)
01699 {
01700 #ifndef TOLUA_RELEASE
01701  tolua_Error tolua_err;
01702  if (
01703      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
01704      !tolua_isnoobj(tolua_S,2,&tolua_err)
01705  )
01706   goto tolua_lerror;
01707  else
01708 #endif
01709  {
01710   fawkes::HumanoidMotionInterface::TurnMessage* self = (fawkes::HumanoidMotionInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
01711 #ifndef TOLUA_RELEASE
01712   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'angle'", NULL);
01713 #endif
01714   {
01715    float tolua_ret = (float)  self->angle();
01716    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01717   }
01718  }
01719  return 1;
01720 #ifndef TOLUA_RELEASE
01721  tolua_lerror:
01722  tolua_error(tolua_S,"#ferror in function 'angle'.",&tolua_err);
01723  return 0;
01724 #endif
01725 }
01726 #endif //#ifndef TOLUA_DISABLE
01727 
01728 /* method: set_angle of class  TurnMessage */
01729 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_set_angle00
01730 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_set_angle00(lua_State* tolua_S)
01731 {
01732 #ifndef TOLUA_RELEASE
01733  tolua_Error tolua_err;
01734  if (
01735      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
01736      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01737      !tolua_isnoobj(tolua_S,3,&tolua_err)
01738  )
01739   goto tolua_lerror;
01740  else
01741 #endif
01742  {
01743   fawkes::HumanoidMotionInterface::TurnMessage* self = (fawkes::HumanoidMotionInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
01744   const float new_angle = ((const float)  tolua_tonumber(tolua_S,2,0));
01745 #ifndef TOLUA_RELEASE
01746   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_angle'", NULL);
01747 #endif
01748   {
01749    self->set_angle(new_angle);
01750   }
01751  }
01752  return 0;
01753 #ifndef TOLUA_RELEASE
01754  tolua_lerror:
01755  tolua_error(tolua_S,"#ferror in function 'set_angle'.",&tolua_err);
01756  return 0;
01757 #endif
01758 }
01759 #endif //#ifndef TOLUA_DISABLE
01760 
01761 /* method: maxlenof_angle of class  TurnMessage */
01762 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_maxlenof_angle00
01763 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_maxlenof_angle00(lua_State* tolua_S)
01764 {
01765 #ifndef TOLUA_RELEASE
01766  tolua_Error tolua_err;
01767  if (
01768      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
01769      !tolua_isnoobj(tolua_S,2,&tolua_err)
01770  )
01771   goto tolua_lerror;
01772  else
01773 #endif
01774  {
01775   const fawkes::HumanoidMotionInterface::TurnMessage* self = (const fawkes::HumanoidMotionInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
01776 #ifndef TOLUA_RELEASE
01777   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_angle'", NULL);
01778 #endif
01779   {
01780    int tolua_ret = (int)  self->maxlenof_angle();
01781    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01782   }
01783  }
01784  return 1;
01785 #ifndef TOLUA_RELEASE
01786  tolua_lerror:
01787  tolua_error(tolua_S,"#ferror in function 'maxlenof_angle'.",&tolua_err);
01788  return 0;
01789 #endif
01790 }
01791 #endif //#ifndef TOLUA_DISABLE
01792 
01793 /* method: new of class  KickMessage */
01794 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00
01795 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00(lua_State* tolua_S)
01796 {
01797 #ifndef TOLUA_RELEASE
01798  tolua_Error tolua_err;
01799  if (
01800      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
01801      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01802      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01803      !tolua_isnoobj(tolua_S,4,&tolua_err)
01804  )
01805   goto tolua_lerror;
01806  else
01807 #endif
01808  {
01809   fawkes::HumanoidMotionInterface::LegEnum ini_leg = ((fawkes::HumanoidMotionInterface::LegEnum) (int)  tolua_tonumber(tolua_S,2,0));
01810   float ini_strength = ((float)  tolua_tonumber(tolua_S,3,0));
01811   {
01812    fawkes::HumanoidMotionInterface::KickMessage* tolua_ret = (fawkes::HumanoidMotionInterface::KickMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::KickMessage)(ini_leg,ini_strength));
01813     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::KickMessage");
01814   }
01815  }
01816  return 1;
01817 #ifndef TOLUA_RELEASE
01818  tolua_lerror:
01819  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01820  return 0;
01821 #endif
01822 }
01823 #endif //#ifndef TOLUA_DISABLE
01824 
01825 /* method: new_local of class  KickMessage */
01826 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00_local
01827 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00_local(lua_State* tolua_S)
01828 {
01829 #ifndef TOLUA_RELEASE
01830  tolua_Error tolua_err;
01831  if (
01832      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
01833      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01834      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01835      !tolua_isnoobj(tolua_S,4,&tolua_err)
01836  )
01837   goto tolua_lerror;
01838  else
01839 #endif
01840  {
01841   fawkes::HumanoidMotionInterface::LegEnum ini_leg = ((fawkes::HumanoidMotionInterface::LegEnum) (int)  tolua_tonumber(tolua_S,2,0));
01842   float ini_strength = ((float)  tolua_tonumber(tolua_S,3,0));
01843   {
01844    fawkes::HumanoidMotionInterface::KickMessage* tolua_ret = (fawkes::HumanoidMotionInterface::KickMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::KickMessage)(ini_leg,ini_strength));
01845     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::KickMessage");
01846     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01847   }
01848  }
01849  return 1;
01850 #ifndef TOLUA_RELEASE
01851  tolua_lerror:
01852  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01853  return 0;
01854 #endif
01855 }
01856 #endif //#ifndef TOLUA_DISABLE
01857 
01858 /* method: new of class  KickMessage */
01859 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new01
01860 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new01(lua_State* tolua_S)
01861 {
01862  tolua_Error tolua_err;
01863  if (
01864      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
01865      !tolua_isnoobj(tolua_S,2,&tolua_err)
01866  )
01867   goto tolua_lerror;
01868  else
01869  {
01870   {
01871    fawkes::HumanoidMotionInterface::KickMessage* tolua_ret = (fawkes::HumanoidMotionInterface::KickMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::KickMessage)());
01872     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::KickMessage");
01873   }
01874  }
01875  return 1;
01876 tolua_lerror:
01877  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00(tolua_S);
01878 }
01879 #endif //#ifndef TOLUA_DISABLE
01880 
01881 /* method: new_local of class  KickMessage */
01882 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new01_local
01883 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new01_local(lua_State* tolua_S)
01884 {
01885  tolua_Error tolua_err;
01886  if (
01887      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
01888      !tolua_isnoobj(tolua_S,2,&tolua_err)
01889  )
01890   goto tolua_lerror;
01891  else
01892  {
01893   {
01894    fawkes::HumanoidMotionInterface::KickMessage* tolua_ret = (fawkes::HumanoidMotionInterface::KickMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::KickMessage)());
01895     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::KickMessage");
01896     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01897   }
01898  }
01899  return 1;
01900 tolua_lerror:
01901  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00_local(tolua_S);
01902 }
01903 #endif //#ifndef TOLUA_DISABLE
01904 
01905 /* method: delete of class  KickMessage */
01906 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_delete00
01907 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_delete00(lua_State* tolua_S)
01908 {
01909 #ifndef TOLUA_RELEASE
01910  tolua_Error tolua_err;
01911  if (
01912      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
01913      !tolua_isnoobj(tolua_S,2,&tolua_err)
01914  )
01915   goto tolua_lerror;
01916  else
01917 #endif
01918  {
01919   fawkes::HumanoidMotionInterface::KickMessage* self = (fawkes::HumanoidMotionInterface::KickMessage*)  tolua_tousertype(tolua_S,1,0);
01920 #ifndef TOLUA_RELEASE
01921   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01922 #endif
01923   Mtolua_delete(self);
01924  }
01925  return 0;
01926 #ifndef TOLUA_RELEASE
01927  tolua_lerror:
01928  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01929  return 0;
01930 #endif
01931 }
01932 #endif //#ifndef TOLUA_DISABLE
01933 
01934 /* method: leg of class  KickMessage */
01935 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_leg00
01936 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_leg00(lua_State* tolua_S)
01937 {
01938 #ifndef TOLUA_RELEASE
01939  tolua_Error tolua_err;
01940  if (
01941      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
01942      !tolua_isnoobj(tolua_S,2,&tolua_err)
01943  )
01944   goto tolua_lerror;
01945  else
01946 #endif
01947  {
01948   fawkes::HumanoidMotionInterface::KickMessage* self = (fawkes::HumanoidMotionInterface::KickMessage*)  tolua_tousertype(tolua_S,1,0);
01949 #ifndef TOLUA_RELEASE
01950   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'leg'", NULL);
01951 #endif
01952   {
01953    fawkes::HumanoidMotionInterface::LegEnum tolua_ret = (fawkes::HumanoidMotionInterface::LegEnum)  self->leg();
01954    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01955   }
01956  }
01957  return 1;
01958 #ifndef TOLUA_RELEASE
01959  tolua_lerror:
01960  tolua_error(tolua_S,"#ferror in function 'leg'.",&tolua_err);
01961  return 0;
01962 #endif
01963 }
01964 #endif //#ifndef TOLUA_DISABLE
01965 
01966 /* method: set_leg of class  KickMessage */
01967 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_set_leg00
01968 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_set_leg00(lua_State* tolua_S)
01969 {
01970 #ifndef TOLUA_RELEASE
01971  tolua_Error tolua_err;
01972  if (
01973      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
01974      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01975      !tolua_isnoobj(tolua_S,3,&tolua_err)
01976  )
01977   goto tolua_lerror;
01978  else
01979 #endif
01980  {
01981   fawkes::HumanoidMotionInterface::KickMessage* self = (fawkes::HumanoidMotionInterface::KickMessage*)  tolua_tousertype(tolua_S,1,0);
01982   const fawkes::HumanoidMotionInterface::LegEnum new_leg = ((const fawkes::HumanoidMotionInterface::LegEnum) (int)  tolua_tonumber(tolua_S,2,0));
01983 #ifndef TOLUA_RELEASE
01984   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_leg'", NULL);
01985 #endif
01986   {
01987    self->set_leg(new_leg);
01988   }
01989  }
01990  return 0;
01991 #ifndef TOLUA_RELEASE
01992  tolua_lerror:
01993  tolua_error(tolua_S,"#ferror in function 'set_leg'.",&tolua_err);
01994  return 0;
01995 #endif
01996 }
01997 #endif //#ifndef TOLUA_DISABLE
01998 
01999 /* method: maxlenof_leg of class  KickMessage */
02000 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_maxlenof_leg00
02001 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_maxlenof_leg00(lua_State* tolua_S)
02002 {
02003 #ifndef TOLUA_RELEASE
02004  tolua_Error tolua_err;
02005  if (
02006      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
02007      !tolua_isnoobj(tolua_S,2,&tolua_err)
02008  )
02009   goto tolua_lerror;
02010  else
02011 #endif
02012  {
02013   const fawkes::HumanoidMotionInterface::KickMessage* self = (const fawkes::HumanoidMotionInterface::KickMessage*)  tolua_tousertype(tolua_S,1,0);
02014 #ifndef TOLUA_RELEASE
02015   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_leg'", NULL);
02016 #endif
02017   {
02018    int tolua_ret = (int)  self->maxlenof_leg();
02019    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02020   }
02021  }
02022  return 1;
02023 #ifndef TOLUA_RELEASE
02024  tolua_lerror:
02025  tolua_error(tolua_S,"#ferror in function 'maxlenof_leg'.",&tolua_err);
02026  return 0;
02027 #endif
02028 }
02029 #endif //#ifndef TOLUA_DISABLE
02030 
02031 /* method: strength of class  KickMessage */
02032 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_strength00
02033 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_strength00(lua_State* tolua_S)
02034 {
02035 #ifndef TOLUA_RELEASE
02036  tolua_Error tolua_err;
02037  if (
02038      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
02039      !tolua_isnoobj(tolua_S,2,&tolua_err)
02040  )
02041   goto tolua_lerror;
02042  else
02043 #endif
02044  {
02045   fawkes::HumanoidMotionInterface::KickMessage* self = (fawkes::HumanoidMotionInterface::KickMessage*)  tolua_tousertype(tolua_S,1,0);
02046 #ifndef TOLUA_RELEASE
02047   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'strength'", NULL);
02048 #endif
02049   {
02050    float tolua_ret = (float)  self->strength();
02051    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02052   }
02053  }
02054  return 1;
02055 #ifndef TOLUA_RELEASE
02056  tolua_lerror:
02057  tolua_error(tolua_S,"#ferror in function 'strength'.",&tolua_err);
02058  return 0;
02059 #endif
02060 }
02061 #endif //#ifndef TOLUA_DISABLE
02062 
02063 /* method: set_strength of class  KickMessage */
02064 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_set_strength00
02065 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_set_strength00(lua_State* tolua_S)
02066 {
02067 #ifndef TOLUA_RELEASE
02068  tolua_Error tolua_err;
02069  if (
02070      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
02071      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02072      !tolua_isnoobj(tolua_S,3,&tolua_err)
02073  )
02074   goto tolua_lerror;
02075  else
02076 #endif
02077  {
02078   fawkes::HumanoidMotionInterface::KickMessage* self = (fawkes::HumanoidMotionInterface::KickMessage*)  tolua_tousertype(tolua_S,1,0);
02079   const float new_strength = ((const float)  tolua_tonumber(tolua_S,2,0));
02080 #ifndef TOLUA_RELEASE
02081   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_strength'", NULL);
02082 #endif
02083   {
02084    self->set_strength(new_strength);
02085   }
02086  }
02087  return 0;
02088 #ifndef TOLUA_RELEASE
02089  tolua_lerror:
02090  tolua_error(tolua_S,"#ferror in function 'set_strength'.",&tolua_err);
02091  return 0;
02092 #endif
02093 }
02094 #endif //#ifndef TOLUA_DISABLE
02095 
02096 /* method: maxlenof_strength of class  KickMessage */
02097 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_maxlenof_strength00
02098 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_maxlenof_strength00(lua_State* tolua_S)
02099 {
02100 #ifndef TOLUA_RELEASE
02101  tolua_Error tolua_err;
02102  if (
02103      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
02104      !tolua_isnoobj(tolua_S,2,&tolua_err)
02105  )
02106   goto tolua_lerror;
02107  else
02108 #endif
02109  {
02110   const fawkes::HumanoidMotionInterface::KickMessage* self = (const fawkes::HumanoidMotionInterface::KickMessage*)  tolua_tousertype(tolua_S,1,0);
02111 #ifndef TOLUA_RELEASE
02112   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_strength'", NULL);
02113 #endif
02114   {
02115    int tolua_ret = (int)  self->maxlenof_strength();
02116    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02117   }
02118  }
02119  return 1;
02120 #ifndef TOLUA_RELEASE
02121  tolua_lerror:
02122  tolua_error(tolua_S,"#ferror in function 'maxlenof_strength'.",&tolua_err);
02123  return 0;
02124 #endif
02125 }
02126 #endif //#ifndef TOLUA_DISABLE
02127 
02128 /* method: new of class  ParkMessage */
02129 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00
02130 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00(lua_State* tolua_S)
02131 {
02132 #ifndef TOLUA_RELEASE
02133  tolua_Error tolua_err;
02134  if (
02135      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::ParkMessage",0,&tolua_err) ||
02136      !tolua_isnoobj(tolua_S,2,&tolua_err)
02137  )
02138   goto tolua_lerror;
02139  else
02140 #endif
02141  {
02142   {
02143    fawkes::HumanoidMotionInterface::ParkMessage* tolua_ret = (fawkes::HumanoidMotionInterface::ParkMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::ParkMessage)());
02144     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::ParkMessage");
02145   }
02146  }
02147  return 1;
02148 #ifndef TOLUA_RELEASE
02149  tolua_lerror:
02150  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02151  return 0;
02152 #endif
02153 }
02154 #endif //#ifndef TOLUA_DISABLE
02155 
02156 /* method: new_local of class  ParkMessage */
02157 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00_local
02158 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00_local(lua_State* tolua_S)
02159 {
02160 #ifndef TOLUA_RELEASE
02161  tolua_Error tolua_err;
02162  if (
02163      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::ParkMessage",0,&tolua_err) ||
02164      !tolua_isnoobj(tolua_S,2,&tolua_err)
02165  )
02166   goto tolua_lerror;
02167  else
02168 #endif
02169  {
02170   {
02171    fawkes::HumanoidMotionInterface::ParkMessage* tolua_ret = (fawkes::HumanoidMotionInterface::ParkMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::ParkMessage)());
02172     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::ParkMessage");
02173     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02174   }
02175  }
02176  return 1;
02177 #ifndef TOLUA_RELEASE
02178  tolua_lerror:
02179  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02180  return 0;
02181 #endif
02182 }
02183 #endif //#ifndef TOLUA_DISABLE
02184 
02185 /* method: delete of class  ParkMessage */
02186 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_delete00
02187 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_delete00(lua_State* tolua_S)
02188 {
02189 #ifndef TOLUA_RELEASE
02190  tolua_Error tolua_err;
02191  if (
02192      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::ParkMessage",0,&tolua_err) ||
02193      !tolua_isnoobj(tolua_S,2,&tolua_err)
02194  )
02195   goto tolua_lerror;
02196  else
02197 #endif
02198  {
02199   fawkes::HumanoidMotionInterface::ParkMessage* self = (fawkes::HumanoidMotionInterface::ParkMessage*)  tolua_tousertype(tolua_S,1,0);
02200 #ifndef TOLUA_RELEASE
02201   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
02202 #endif
02203   Mtolua_delete(self);
02204  }
02205  return 0;
02206 #ifndef TOLUA_RELEASE
02207  tolua_lerror:
02208  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02209  return 0;
02210 #endif
02211 }
02212 #endif //#ifndef TOLUA_DISABLE
02213 
02214 /* method: new of class  GetUpMessage */
02215 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00
02216 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00(lua_State* tolua_S)
02217 {
02218 #ifndef TOLUA_RELEASE
02219  tolua_Error tolua_err;
02220  if (
02221      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::GetUpMessage",0,&tolua_err) ||
02222      !tolua_isnoobj(tolua_S,2,&tolua_err)
02223  )
02224   goto tolua_lerror;
02225  else
02226 #endif
02227  {
02228   {
02229    fawkes::HumanoidMotionInterface::GetUpMessage* tolua_ret = (fawkes::HumanoidMotionInterface::GetUpMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::GetUpMessage)());
02230     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::GetUpMessage");
02231   }
02232  }
02233  return 1;
02234 #ifndef TOLUA_RELEASE
02235  tolua_lerror:
02236  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02237  return 0;
02238 #endif
02239 }
02240 #endif //#ifndef TOLUA_DISABLE
02241 
02242 /* method: new_local of class  GetUpMessage */
02243 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00_local
02244 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00_local(lua_State* tolua_S)
02245 {
02246 #ifndef TOLUA_RELEASE
02247  tolua_Error tolua_err;
02248  if (
02249      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::GetUpMessage",0,&tolua_err) ||
02250      !tolua_isnoobj(tolua_S,2,&tolua_err)
02251  )
02252   goto tolua_lerror;
02253  else
02254 #endif
02255  {
02256   {
02257    fawkes::HumanoidMotionInterface::GetUpMessage* tolua_ret = (fawkes::HumanoidMotionInterface::GetUpMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::GetUpMessage)());
02258     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::GetUpMessage");
02259     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02260   }
02261  }
02262  return 1;
02263 #ifndef TOLUA_RELEASE
02264  tolua_lerror:
02265  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02266  return 0;
02267 #endif
02268 }
02269 #endif //#ifndef TOLUA_DISABLE
02270 
02271 /* method: delete of class  GetUpMessage */
02272 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_delete00
02273 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_delete00(lua_State* tolua_S)
02274 {
02275 #ifndef TOLUA_RELEASE
02276  tolua_Error tolua_err;
02277  if (
02278      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::GetUpMessage",0,&tolua_err) ||
02279      !tolua_isnoobj(tolua_S,2,&tolua_err)
02280  )
02281   goto tolua_lerror;
02282  else
02283 #endif
02284  {
02285   fawkes::HumanoidMotionInterface::GetUpMessage* self = (fawkes::HumanoidMotionInterface::GetUpMessage*)  tolua_tousertype(tolua_S,1,0);
02286 #ifndef TOLUA_RELEASE
02287   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
02288 #endif
02289   Mtolua_delete(self);
02290  }
02291  return 0;
02292 #ifndef TOLUA_RELEASE
02293  tolua_lerror:
02294  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02295  return 0;
02296 #endif
02297 }
02298 #endif //#ifndef TOLUA_DISABLE
02299 
02300 /* method: new of class  StandupMessage */
02301 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00
02302 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00(lua_State* tolua_S)
02303 {
02304 #ifndef TOLUA_RELEASE
02305  tolua_Error tolua_err;
02306  if (
02307      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
02308      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02309      !tolua_isnoobj(tolua_S,3,&tolua_err)
02310  )
02311   goto tolua_lerror;
02312  else
02313 #endif
02314  {
02315   fawkes::HumanoidMotionInterface::StandupEnum ini_from_pos = ((fawkes::HumanoidMotionInterface::StandupEnum) (int)  tolua_tonumber(tolua_S,2,0));
02316   {
02317    fawkes::HumanoidMotionInterface::StandupMessage* tolua_ret = (fawkes::HumanoidMotionInterface::StandupMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::StandupMessage)(ini_from_pos));
02318     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::StandupMessage");
02319   }
02320  }
02321  return 1;
02322 #ifndef TOLUA_RELEASE
02323  tolua_lerror:
02324  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02325  return 0;
02326 #endif
02327 }
02328 #endif //#ifndef TOLUA_DISABLE
02329 
02330 /* method: new_local of class  StandupMessage */
02331 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00_local
02332 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00_local(lua_State* tolua_S)
02333 {
02334 #ifndef TOLUA_RELEASE
02335  tolua_Error tolua_err;
02336  if (
02337      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
02338      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02339      !tolua_isnoobj(tolua_S,3,&tolua_err)
02340  )
02341   goto tolua_lerror;
02342  else
02343 #endif
02344  {
02345   fawkes::HumanoidMotionInterface::StandupEnum ini_from_pos = ((fawkes::HumanoidMotionInterface::StandupEnum) (int)  tolua_tonumber(tolua_S,2,0));
02346   {
02347    fawkes::HumanoidMotionInterface::StandupMessage* tolua_ret = (fawkes::HumanoidMotionInterface::StandupMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::StandupMessage)(ini_from_pos));
02348     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::StandupMessage");
02349     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02350   }
02351  }
02352  return 1;
02353 #ifndef TOLUA_RELEASE
02354  tolua_lerror:
02355  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02356  return 0;
02357 #endif
02358 }
02359 #endif //#ifndef TOLUA_DISABLE
02360 
02361 /* method: new of class  StandupMessage */
02362 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new01
02363 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new01(lua_State* tolua_S)
02364 {
02365  tolua_Error tolua_err;
02366  if (
02367      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
02368      !tolua_isnoobj(tolua_S,2,&tolua_err)
02369  )
02370   goto tolua_lerror;
02371  else
02372  {
02373   {
02374    fawkes::HumanoidMotionInterface::StandupMessage* tolua_ret = (fawkes::HumanoidMotionInterface::StandupMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::StandupMessage)());
02375     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::StandupMessage");
02376   }
02377  }
02378  return 1;
02379 tolua_lerror:
02380  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00(tolua_S);
02381 }
02382 #endif //#ifndef TOLUA_DISABLE
02383 
02384 /* method: new_local of class  StandupMessage */
02385 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new01_local
02386 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new01_local(lua_State* tolua_S)
02387 {
02388  tolua_Error tolua_err;
02389  if (
02390      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
02391      !tolua_isnoobj(tolua_S,2,&tolua_err)
02392  )
02393   goto tolua_lerror;
02394  else
02395  {
02396   {
02397    fawkes::HumanoidMotionInterface::StandupMessage* tolua_ret = (fawkes::HumanoidMotionInterface::StandupMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::StandupMessage)());
02398     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::StandupMessage");
02399     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02400   }
02401  }
02402  return 1;
02403 tolua_lerror:
02404  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00_local(tolua_S);
02405 }
02406 #endif //#ifndef TOLUA_DISABLE
02407 
02408 /* method: delete of class  StandupMessage */
02409 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_delete00
02410 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_delete00(lua_State* tolua_S)
02411 {
02412 #ifndef TOLUA_RELEASE
02413  tolua_Error tolua_err;
02414  if (
02415      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
02416      !tolua_isnoobj(tolua_S,2,&tolua_err)
02417  )
02418   goto tolua_lerror;
02419  else
02420 #endif
02421  {
02422   fawkes::HumanoidMotionInterface::StandupMessage* self = (fawkes::HumanoidMotionInterface::StandupMessage*)  tolua_tousertype(tolua_S,1,0);
02423 #ifndef TOLUA_RELEASE
02424   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
02425 #endif
02426   Mtolua_delete(self);
02427  }
02428  return 0;
02429 #ifndef TOLUA_RELEASE
02430  tolua_lerror:
02431  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02432  return 0;
02433 #endif
02434 }
02435 #endif //#ifndef TOLUA_DISABLE
02436 
02437 /* method: from_pos of class  StandupMessage */
02438 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_from_pos00
02439 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_from_pos00(lua_State* tolua_S)
02440 {
02441 #ifndef TOLUA_RELEASE
02442  tolua_Error tolua_err;
02443  if (
02444      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
02445      !tolua_isnoobj(tolua_S,2,&tolua_err)
02446  )
02447   goto tolua_lerror;
02448  else
02449 #endif
02450  {
02451   fawkes::HumanoidMotionInterface::StandupMessage* self = (fawkes::HumanoidMotionInterface::StandupMessage*)  tolua_tousertype(tolua_S,1,0);
02452 #ifndef TOLUA_RELEASE
02453   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'from_pos'", NULL);
02454 #endif
02455   {
02456    fawkes::HumanoidMotionInterface::StandupEnum tolua_ret = (fawkes::HumanoidMotionInterface::StandupEnum)  self->from_pos();
02457    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02458   }
02459  }
02460  return 1;
02461 #ifndef TOLUA_RELEASE
02462  tolua_lerror:
02463  tolua_error(tolua_S,"#ferror in function 'from_pos'.",&tolua_err);
02464  return 0;
02465 #endif
02466 }
02467 #endif //#ifndef TOLUA_DISABLE
02468 
02469 /* method: set_from_pos of class  StandupMessage */
02470 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_set_from_pos00
02471 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_set_from_pos00(lua_State* tolua_S)
02472 {
02473 #ifndef TOLUA_RELEASE
02474  tolua_Error tolua_err;
02475  if (
02476      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
02477      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02478      !tolua_isnoobj(tolua_S,3,&tolua_err)
02479  )
02480   goto tolua_lerror;
02481  else
02482 #endif
02483  {
02484   fawkes::HumanoidMotionInterface::StandupMessage* self = (fawkes::HumanoidMotionInterface::StandupMessage*)  tolua_tousertype(tolua_S,1,0);
02485   const fawkes::HumanoidMotionInterface::StandupEnum new_from_pos = ((const fawkes::HumanoidMotionInterface::StandupEnum) (int)  tolua_tonumber(tolua_S,2,0));
02486 #ifndef TOLUA_RELEASE
02487   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_pos'", NULL);
02488 #endif
02489   {
02490    self->set_from_pos(new_from_pos);
02491   }
02492  }
02493  return 0;
02494 #ifndef TOLUA_RELEASE
02495  tolua_lerror:
02496  tolua_error(tolua_S,"#ferror in function 'set_from_pos'.",&tolua_err);
02497  return 0;
02498 #endif
02499 }
02500 #endif //#ifndef TOLUA_DISABLE
02501 
02502 /* method: maxlenof_from_pos of class  StandupMessage */
02503 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_maxlenof_from_pos00
02504 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_maxlenof_from_pos00(lua_State* tolua_S)
02505 {
02506 #ifndef TOLUA_RELEASE
02507  tolua_Error tolua_err;
02508  if (
02509      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
02510      !tolua_isnoobj(tolua_S,2,&tolua_err)
02511  )
02512   goto tolua_lerror;
02513  else
02514 #endif
02515  {
02516   const fawkes::HumanoidMotionInterface::StandupMessage* self = (const fawkes::HumanoidMotionInterface::StandupMessage*)  tolua_tousertype(tolua_S,1,0);
02517 #ifndef TOLUA_RELEASE
02518   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_from_pos'", NULL);
02519 #endif
02520   {
02521    int tolua_ret = (int)  self->maxlenof_from_pos();
02522    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02523   }
02524  }
02525  return 1;
02526 #ifndef TOLUA_RELEASE
02527  tolua_lerror:
02528  tolua_error(tolua_S,"#ferror in function 'maxlenof_from_pos'.",&tolua_err);
02529  return 0;
02530 #endif
02531 }
02532 #endif //#ifndef TOLUA_DISABLE
02533 
02534 /* method: new of class  MoveHeadMessage */
02535 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new00
02536 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new00(lua_State* tolua_S)
02537 {
02538 #ifndef TOLUA_RELEASE
02539  tolua_Error tolua_err;
02540  if (
02541      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::MoveHeadMessage",0,&tolua_err) ||
02542      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02543      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02544      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02545      !tolua_isnoobj(tolua_S,5,&tolua_err)
02546  )
02547   goto tolua_lerror;
02548  else
02549 #endif
02550  {
02551   float ini_yaw = ((float)  tolua_tonumber(tolua_S,2,0));
02552   float ini_pitch = ((float)  tolua_tonumber(tolua_S,3,0));
02553   float ini_speed = ((float)  tolua_tonumber(tolua_S,4,0));
02554   {
02555    fawkes::HumanoidMotionInterface::MoveHeadMessage* tolua_ret = (fawkes::HumanoidMotionInterface::MoveHeadMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::MoveHeadMessage)(ini_yaw,ini_pitch,ini_speed));
02556     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::MoveHeadMessage");
02557   }
02558  }
02559  return 1;
02560 #ifndef TOLUA_RELEASE
02561  tolua_lerror:
02562  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02563  return 0;
02564 #endif
02565 }
02566 #endif //#ifndef TOLUA_DISABLE
02567 
02568 /* method: new_local of class  MoveHeadMessage */
02569 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new00_local
02570 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new00_local(lua_State* tolua_S)
02571 {
02572 #ifndef TOLUA_RELEASE
02573  tolua_Error tolua_err;
02574  if (
02575      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::MoveHeadMessage",0,&tolua_err) ||
02576      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02577      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02578      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02579      !tolua_isnoobj(tolua_S,5,&tolua_err)
02580  )
02581   goto tolua_lerror;
02582  else
02583 #endif
02584  {
02585   float ini_yaw = ((float)  tolua_tonumber(tolua_S,2,0));
02586   float ini_pitch = ((float)  tolua_tonumber(tolua_S,3,0));
02587   float ini_speed = ((float)  tolua_tonumber(tolua_S,4,0));
02588   {
02589    fawkes::HumanoidMotionInterface::MoveHeadMessage* tolua_ret = (fawkes::HumanoidMotionInterface::MoveHeadMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::MoveHeadMessage)(ini_yaw,ini_pitch,ini_speed));
02590     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::MoveHeadMessage");
02591     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02592   }
02593  }
02594  return 1;
02595 #ifndef TOLUA_RELEASE
02596  tolua_lerror:
02597  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02598  return 0;
02599 #endif
02600 }
02601 #endif //#ifndef TOLUA_DISABLE
02602 
02603 /* method: new of class  MoveHeadMessage */
02604 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new01
02605 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new01(lua_State* tolua_S)
02606 {
02607  tolua_Error tolua_err;
02608  if (
02609      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::MoveHeadMessage",0,&tolua_err) ||
02610      !tolua_isnoobj(tolua_S,2,&tolua_err)
02611  )
02612   goto tolua_lerror;
02613  else
02614  {
02615   {
02616    fawkes::HumanoidMotionInterface::MoveHeadMessage* tolua_ret = (fawkes::HumanoidMotionInterface::MoveHeadMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::MoveHeadMessage)());
02617     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::MoveHeadMessage");
02618   }
02619  }
02620  return 1;
02621 tolua_lerror:
02622  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new00(tolua_S);
02623 }
02624 #endif //#ifndef TOLUA_DISABLE
02625 
02626 /* method: new_local of class  MoveHeadMessage */
02627 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new01_local
02628 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new01_local(lua_State* tolua_S)
02629 {
02630  tolua_Error tolua_err;
02631  if (
02632      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::MoveHeadMessage",0,&tolua_err) ||
02633      !tolua_isnoobj(tolua_S,2,&tolua_err)
02634  )
02635   goto tolua_lerror;
02636  else
02637  {
02638   {
02639    fawkes::HumanoidMotionInterface::MoveHeadMessage* tolua_ret = (fawkes::HumanoidMotionInterface::MoveHeadMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::MoveHeadMessage)());
02640     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::MoveHeadMessage");
02641     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02642   }
02643  }
02644  return 1;
02645 tolua_lerror:
02646  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new00_local(tolua_S);
02647 }
02648 #endif //#ifndef TOLUA_DISABLE
02649 
02650 /* method: delete of class  MoveHeadMessage */
02651 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_delete00
02652 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_delete00(lua_State* tolua_S)
02653 {
02654 #ifndef TOLUA_RELEASE
02655  tolua_Error tolua_err;
02656  if (
02657      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::MoveHeadMessage",0,&tolua_err) ||
02658      !tolua_isnoobj(tolua_S,2,&tolua_err)
02659  )
02660   goto tolua_lerror;
02661  else
02662 #endif
02663  {
02664   fawkes::HumanoidMotionInterface::MoveHeadMessage* self = (fawkes::HumanoidMotionInterface::MoveHeadMessage*)  tolua_tousertype(tolua_S,1,0);
02665 #ifndef TOLUA_RELEASE
02666   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
02667 #endif
02668   Mtolua_delete(self);
02669  }
02670  return 0;
02671 #ifndef TOLUA_RELEASE
02672  tolua_lerror:
02673  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02674  return 0;
02675 #endif
02676 }
02677 #endif //#ifndef TOLUA_DISABLE
02678 
02679 /* method: yaw of class  MoveHeadMessage */
02680 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_yaw00
02681 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_yaw00(lua_State* tolua_S)
02682 {
02683 #ifndef TOLUA_RELEASE
02684  tolua_Error tolua_err;
02685  if (
02686      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::MoveHeadMessage",0,&tolua_err) ||
02687      !tolua_isnoobj(tolua_S,2,&tolua_err)
02688  )
02689   goto tolua_lerror;
02690  else
02691 #endif
02692  {
02693   fawkes::HumanoidMotionInterface::MoveHeadMessage* self = (fawkes::HumanoidMotionInterface::MoveHeadMessage*)  tolua_tousertype(tolua_S,1,0);
02694 #ifndef TOLUA_RELEASE
02695   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'yaw'", NULL);
02696 #endif
02697   {
02698    float tolua_ret = (float)  self->yaw();
02699    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02700   }
02701  }
02702  return 1;
02703 #ifndef TOLUA_RELEASE
02704  tolua_lerror:
02705  tolua_error(tolua_S,"#ferror in function 'yaw'.",&tolua_err);
02706  return 0;
02707 #endif
02708 }
02709 #endif //#ifndef TOLUA_DISABLE
02710 
02711 /* method: set_yaw of class  MoveHeadMessage */
02712 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_set_yaw00
02713 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_set_yaw00(lua_State* tolua_S)
02714 {
02715 #ifndef TOLUA_RELEASE
02716  tolua_Error tolua_err;
02717  if (
02718      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::MoveHeadMessage",0,&tolua_err) ||
02719      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02720      !tolua_isnoobj(tolua_S,3,&tolua_err)
02721  )
02722   goto tolua_lerror;
02723  else
02724 #endif
02725  {
02726   fawkes::HumanoidMotionInterface::MoveHeadMessage* self = (fawkes::HumanoidMotionInterface::MoveHeadMessage*)  tolua_tousertype(tolua_S,1,0);
02727   const float new_yaw = ((const float)  tolua_tonumber(tolua_S,2,0));
02728 #ifndef TOLUA_RELEASE
02729   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_yaw'", NULL);
02730 #endif
02731   {
02732    self->set_yaw(new_yaw);
02733   }
02734  }
02735  return 0;
02736 #ifndef TOLUA_RELEASE
02737  tolua_lerror:
02738  tolua_error(tolua_S,"#ferror in function 'set_yaw'.",&tolua_err);
02739  return 0;
02740 #endif
02741 }
02742 #endif //#ifndef TOLUA_DISABLE
02743 
02744 /* method: maxlenof_yaw of class  MoveHeadMessage */
02745 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_maxlenof_yaw00
02746 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_maxlenof_yaw00(lua_State* tolua_S)
02747 {
02748 #ifndef TOLUA_RELEASE
02749  tolua_Error tolua_err;
02750  if (
02751      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::MoveHeadMessage",0,&tolua_err) ||
02752      !tolua_isnoobj(tolua_S,2,&tolua_err)
02753  )
02754   goto tolua_lerror;
02755  else
02756 #endif
02757  {
02758   const fawkes::HumanoidMotionInterface::MoveHeadMessage* self = (const fawkes::HumanoidMotionInterface::MoveHeadMessage*)  tolua_tousertype(tolua_S,1,0);
02759 #ifndef TOLUA_RELEASE
02760   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_yaw'", NULL);
02761 #endif
02762   {
02763    int tolua_ret = (int)  self->maxlenof_yaw();
02764    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02765   }
02766  }
02767  return 1;
02768 #ifndef TOLUA_RELEASE
02769  tolua_lerror:
02770  tolua_error(tolua_S,"#ferror in function 'maxlenof_yaw'.",&tolua_err);
02771  return 0;
02772 #endif
02773 }
02774 #endif //#ifndef TOLUA_DISABLE
02775 
02776 /* method: pitch of class  MoveHeadMessage */
02777 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_pitch00
02778 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_pitch00(lua_State* tolua_S)
02779 {
02780 #ifndef TOLUA_RELEASE
02781  tolua_Error tolua_err;
02782  if (
02783      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::MoveHeadMessage",0,&tolua_err) ||
02784      !tolua_isnoobj(tolua_S,2,&tolua_err)
02785  )
02786   goto tolua_lerror;
02787  else
02788 #endif
02789  {
02790   fawkes::HumanoidMotionInterface::MoveHeadMessage* self = (fawkes::HumanoidMotionInterface::MoveHeadMessage*)  tolua_tousertype(tolua_S,1,0);
02791 #ifndef TOLUA_RELEASE
02792   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pitch'", NULL);
02793 #endif
02794   {
02795    float tolua_ret = (float)  self->pitch();
02796    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02797   }
02798  }
02799  return 1;
02800 #ifndef TOLUA_RELEASE
02801  tolua_lerror:
02802  tolua_error(tolua_S,"#ferror in function 'pitch'.",&tolua_err);
02803  return 0;
02804 #endif
02805 }
02806 #endif //#ifndef TOLUA_DISABLE
02807 
02808 /* method: set_pitch of class  MoveHeadMessage */
02809 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_set_pitch00
02810 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_set_pitch00(lua_State* tolua_S)
02811 {
02812 #ifndef TOLUA_RELEASE
02813  tolua_Error tolua_err;
02814  if (
02815      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::MoveHeadMessage",0,&tolua_err) ||
02816      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02817      !tolua_isnoobj(tolua_S,3,&tolua_err)
02818  )
02819   goto tolua_lerror;
02820  else
02821 #endif
02822  {
02823   fawkes::HumanoidMotionInterface::MoveHeadMessage* self = (fawkes::HumanoidMotionInterface::MoveHeadMessage*)  tolua_tousertype(tolua_S,1,0);
02824   const float new_pitch = ((const float)  tolua_tonumber(tolua_S,2,0));
02825 #ifndef TOLUA_RELEASE
02826   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_pitch'", NULL);
02827 #endif
02828   {
02829    self->set_pitch(new_pitch);
02830   }
02831  }
02832  return 0;
02833 #ifndef TOLUA_RELEASE
02834  tolua_lerror:
02835  tolua_error(tolua_S,"#ferror in function 'set_pitch'.",&tolua_err);
02836  return 0;
02837 #endif
02838 }
02839 #endif //#ifndef TOLUA_DISABLE
02840 
02841 /* method: maxlenof_pitch of class  MoveHeadMessage */
02842 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_maxlenof_pitch00
02843 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_maxlenof_pitch00(lua_State* tolua_S)
02844 {
02845 #ifndef TOLUA_RELEASE
02846  tolua_Error tolua_err;
02847  if (
02848      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::MoveHeadMessage",0,&tolua_err) ||
02849      !tolua_isnoobj(tolua_S,2,&tolua_err)
02850  )
02851   goto tolua_lerror;
02852  else
02853 #endif
02854  {
02855   const fawkes::HumanoidMotionInterface::MoveHeadMessage* self = (const fawkes::HumanoidMotionInterface::MoveHeadMessage*)  tolua_tousertype(tolua_S,1,0);
02856 #ifndef TOLUA_RELEASE
02857   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_pitch'", NULL);
02858 #endif
02859   {
02860    int tolua_ret = (int)  self->maxlenof_pitch();
02861    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02862   }
02863  }
02864  return 1;
02865 #ifndef TOLUA_RELEASE
02866  tolua_lerror:
02867  tolua_error(tolua_S,"#ferror in function 'maxlenof_pitch'.",&tolua_err);
02868  return 0;
02869 #endif
02870 }
02871 #endif //#ifndef TOLUA_DISABLE
02872 
02873 /* method: speed of class  MoveHeadMessage */
02874 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_speed00
02875 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_speed00(lua_State* tolua_S)
02876 {
02877 #ifndef TOLUA_RELEASE
02878  tolua_Error tolua_err;
02879  if (
02880      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::MoveHeadMessage",0,&tolua_err) ||
02881      !tolua_isnoobj(tolua_S,2,&tolua_err)
02882  )
02883   goto tolua_lerror;
02884  else
02885 #endif
02886  {
02887   fawkes::HumanoidMotionInterface::MoveHeadMessage* self = (fawkes::HumanoidMotionInterface::MoveHeadMessage*)  tolua_tousertype(tolua_S,1,0);
02888 #ifndef TOLUA_RELEASE
02889   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'speed'", NULL);
02890 #endif
02891   {
02892    float tolua_ret = (float)  self->speed();
02893    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02894   }
02895  }
02896  return 1;
02897 #ifndef TOLUA_RELEASE
02898  tolua_lerror:
02899  tolua_error(tolua_S,"#ferror in function 'speed'.",&tolua_err);
02900  return 0;
02901 #endif
02902 }
02903 #endif //#ifndef TOLUA_DISABLE
02904 
02905 /* method: set_speed of class  MoveHeadMessage */
02906 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_set_speed00
02907 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_set_speed00(lua_State* tolua_S)
02908 {
02909 #ifndef TOLUA_RELEASE
02910  tolua_Error tolua_err;
02911  if (
02912      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::MoveHeadMessage",0,&tolua_err) ||
02913      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02914      !tolua_isnoobj(tolua_S,3,&tolua_err)
02915  )
02916   goto tolua_lerror;
02917  else
02918 #endif
02919  {
02920   fawkes::HumanoidMotionInterface::MoveHeadMessage* self = (fawkes::HumanoidMotionInterface::MoveHeadMessage*)  tolua_tousertype(tolua_S,1,0);
02921   const float new_speed = ((const float)  tolua_tonumber(tolua_S,2,0));
02922 #ifndef TOLUA_RELEASE
02923   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_speed'", NULL);
02924 #endif
02925   {
02926    self->set_speed(new_speed);
02927   }
02928  }
02929  return 0;
02930 #ifndef TOLUA_RELEASE
02931  tolua_lerror:
02932  tolua_error(tolua_S,"#ferror in function 'set_speed'.",&tolua_err);
02933  return 0;
02934 #endif
02935 }
02936 #endif //#ifndef TOLUA_DISABLE
02937 
02938 /* method: maxlenof_speed of class  MoveHeadMessage */
02939 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_maxlenof_speed00
02940 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_maxlenof_speed00(lua_State* tolua_S)
02941 {
02942 #ifndef TOLUA_RELEASE
02943  tolua_Error tolua_err;
02944  if (
02945      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::MoveHeadMessage",0,&tolua_err) ||
02946      !tolua_isnoobj(tolua_S,2,&tolua_err)
02947  )
02948   goto tolua_lerror;
02949  else
02950 #endif
02951  {
02952   const fawkes::HumanoidMotionInterface::MoveHeadMessage* self = (const fawkes::HumanoidMotionInterface::MoveHeadMessage*)  tolua_tousertype(tolua_S,1,0);
02953 #ifndef TOLUA_RELEASE
02954   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_speed'", NULL);
02955 #endif
02956   {
02957    int tolua_ret = (int)  self->maxlenof_speed();
02958    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02959   }
02960  }
02961  return 1;
02962 #ifndef TOLUA_RELEASE
02963  tolua_lerror:
02964  tolua_error(tolua_S,"#ferror in function 'maxlenof_speed'.",&tolua_err);
02965  return 0;
02966 #endif
02967 }
02968 #endif //#ifndef TOLUA_DISABLE
02969 
02970 /* method: is_moving of class  fawkes::HumanoidMotionInterface */
02971 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_moving00
02972 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_moving00(lua_State* tolua_S)
02973 {
02974 #ifndef TOLUA_RELEASE
02975  tolua_Error tolua_err;
02976  if (
02977      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
02978      !tolua_isnoobj(tolua_S,2,&tolua_err)
02979  )
02980   goto tolua_lerror;
02981  else
02982 #endif
02983  {
02984   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
02985 #ifndef TOLUA_RELEASE
02986   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_moving'", NULL);
02987 #endif
02988   {
02989    bool tolua_ret = (bool)  self->is_moving();
02990    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02991   }
02992  }
02993  return 1;
02994 #ifndef TOLUA_RELEASE
02995  tolua_lerror:
02996  tolua_error(tolua_S,"#ferror in function 'is_moving'.",&tolua_err);
02997  return 0;
02998 #endif
02999 }
03000 #endif //#ifndef TOLUA_DISABLE
03001 
03002 /* method: set_moving of class  fawkes::HumanoidMotionInterface */
03003 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_moving00
03004 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_moving00(lua_State* tolua_S)
03005 {
03006 #ifndef TOLUA_RELEASE
03007  tolua_Error tolua_err;
03008  if (
03009      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03010      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
03011      !tolua_isnoobj(tolua_S,3,&tolua_err)
03012  )
03013   goto tolua_lerror;
03014  else
03015 #endif
03016  {
03017   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03018   const bool new_moving = ((const bool)  tolua_toboolean(tolua_S,2,0));
03019 #ifndef TOLUA_RELEASE
03020   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_moving'", NULL);
03021 #endif
03022   {
03023    self->set_moving(new_moving);
03024   }
03025  }
03026  return 0;
03027 #ifndef TOLUA_RELEASE
03028  tolua_lerror:
03029  tolua_error(tolua_S,"#ferror in function 'set_moving'.",&tolua_err);
03030  return 0;
03031 #endif
03032 }
03033 #endif //#ifndef TOLUA_DISABLE
03034 
03035 /* method: maxlenof_moving of class  fawkes::HumanoidMotionInterface */
03036 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_moving00
03037 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_moving00(lua_State* tolua_S)
03038 {
03039 #ifndef TOLUA_RELEASE
03040  tolua_Error tolua_err;
03041  if (
03042      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03043      !tolua_isnoobj(tolua_S,2,&tolua_err)
03044  )
03045   goto tolua_lerror;
03046  else
03047 #endif
03048  {
03049   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03050 #ifndef TOLUA_RELEASE
03051   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_moving'", NULL);
03052 #endif
03053   {
03054    int tolua_ret = (int)  self->maxlenof_moving();
03055    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03056   }
03057  }
03058  return 1;
03059 #ifndef TOLUA_RELEASE
03060  tolua_lerror:
03061  tolua_error(tolua_S,"#ferror in function 'maxlenof_moving'.",&tolua_err);
03062  return 0;
03063 #endif
03064 }
03065 #endif //#ifndef TOLUA_DISABLE
03066 
03067 /* method: is_arms_enabled of class  fawkes::HumanoidMotionInterface */
03068 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_arms_enabled00
03069 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_arms_enabled00(lua_State* tolua_S)
03070 {
03071 #ifndef TOLUA_RELEASE
03072  tolua_Error tolua_err;
03073  if (
03074      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03075      !tolua_isnoobj(tolua_S,2,&tolua_err)
03076  )
03077   goto tolua_lerror;
03078  else
03079 #endif
03080  {
03081   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03082 #ifndef TOLUA_RELEASE
03083   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_arms_enabled'", NULL);
03084 #endif
03085   {
03086    bool tolua_ret = (bool)  self->is_arms_enabled();
03087    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03088   }
03089  }
03090  return 1;
03091 #ifndef TOLUA_RELEASE
03092  tolua_lerror:
03093  tolua_error(tolua_S,"#ferror in function 'is_arms_enabled'.",&tolua_err);
03094  return 0;
03095 #endif
03096 }
03097 #endif //#ifndef TOLUA_DISABLE
03098 
03099 /* method: set_arms_enabled of class  fawkes::HumanoidMotionInterface */
03100 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_arms_enabled00
03101 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_arms_enabled00(lua_State* tolua_S)
03102 {
03103 #ifndef TOLUA_RELEASE
03104  tolua_Error tolua_err;
03105  if (
03106      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03107      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
03108      !tolua_isnoobj(tolua_S,3,&tolua_err)
03109  )
03110   goto tolua_lerror;
03111  else
03112 #endif
03113  {
03114   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03115   const bool new_arms_enabled = ((const bool)  tolua_toboolean(tolua_S,2,0));
03116 #ifndef TOLUA_RELEASE
03117   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_arms_enabled'", NULL);
03118 #endif
03119   {
03120    self->set_arms_enabled(new_arms_enabled);
03121   }
03122  }
03123  return 0;
03124 #ifndef TOLUA_RELEASE
03125  tolua_lerror:
03126  tolua_error(tolua_S,"#ferror in function 'set_arms_enabled'.",&tolua_err);
03127  return 0;
03128 #endif
03129 }
03130 #endif //#ifndef TOLUA_DISABLE
03131 
03132 /* method: maxlenof_arms_enabled of class  fawkes::HumanoidMotionInterface */
03133 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_arms_enabled00
03134 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_arms_enabled00(lua_State* tolua_S)
03135 {
03136 #ifndef TOLUA_RELEASE
03137  tolua_Error tolua_err;
03138  if (
03139      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03140      !tolua_isnoobj(tolua_S,2,&tolua_err)
03141  )
03142   goto tolua_lerror;
03143  else
03144 #endif
03145  {
03146   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03147 #ifndef TOLUA_RELEASE
03148   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_arms_enabled'", NULL);
03149 #endif
03150   {
03151    int tolua_ret = (int)  self->maxlenof_arms_enabled();
03152    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03153   }
03154  }
03155  return 1;
03156 #ifndef TOLUA_RELEASE
03157  tolua_lerror:
03158  tolua_error(tolua_S,"#ferror in function 'maxlenof_arms_enabled'.",&tolua_err);
03159  return 0;
03160 #endif
03161 }
03162 #endif //#ifndef TOLUA_DISABLE
03163 
03164 /* method: msgid of class  fawkes::HumanoidMotionInterface */
03165 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgid00
03166 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgid00(lua_State* tolua_S)
03167 {
03168 #ifndef TOLUA_RELEASE
03169  tolua_Error tolua_err;
03170  if (
03171      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03172      !tolua_isnoobj(tolua_S,2,&tolua_err)
03173  )
03174   goto tolua_lerror;
03175  else
03176 #endif
03177  {
03178   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03179 #ifndef TOLUA_RELEASE
03180   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgid'", NULL);
03181 #endif
03182   {
03183    unsigned int tolua_ret = (unsigned int)  self->msgid();
03184    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03185   }
03186  }
03187  return 1;
03188 #ifndef TOLUA_RELEASE
03189  tolua_lerror:
03190  tolua_error(tolua_S,"#ferror in function 'msgid'.",&tolua_err);
03191  return 0;
03192 #endif
03193 }
03194 #endif //#ifndef TOLUA_DISABLE
03195 
03196 /* method: set_msgid of class  fawkes::HumanoidMotionInterface */
03197 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_msgid00
03198 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_msgid00(lua_State* tolua_S)
03199 {
03200 #ifndef TOLUA_RELEASE
03201  tolua_Error tolua_err;
03202  if (
03203      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03204      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03205      !tolua_isnoobj(tolua_S,3,&tolua_err)
03206  )
03207   goto tolua_lerror;
03208  else
03209 #endif
03210  {
03211   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03212   unsigned const int new_msgid = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
03213 #ifndef TOLUA_RELEASE
03214   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_msgid'", NULL);
03215 #endif
03216   {
03217    self->set_msgid(new_msgid);
03218   }
03219  }
03220  return 0;
03221 #ifndef TOLUA_RELEASE
03222  tolua_lerror:
03223  tolua_error(tolua_S,"#ferror in function 'set_msgid'.",&tolua_err);
03224  return 0;
03225 #endif
03226 }
03227 #endif //#ifndef TOLUA_DISABLE
03228 
03229 /* method: maxlenof_msgid of class  fawkes::HumanoidMotionInterface */
03230 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_msgid00
03231 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_msgid00(lua_State* tolua_S)
03232 {
03233 #ifndef TOLUA_RELEASE
03234  tolua_Error tolua_err;
03235  if (
03236      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03237      !tolua_isnoobj(tolua_S,2,&tolua_err)
03238  )
03239   goto tolua_lerror;
03240  else
03241 #endif
03242  {
03243   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03244 #ifndef TOLUA_RELEASE
03245   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_msgid'", NULL);
03246 #endif
03247   {
03248    int tolua_ret = (int)  self->maxlenof_msgid();
03249    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03250   }
03251  }
03252  return 1;
03253 #ifndef TOLUA_RELEASE
03254  tolua_lerror:
03255  tolua_error(tolua_S,"#ferror in function 'maxlenof_msgid'.",&tolua_err);
03256  return 0;
03257 #endif
03258 }
03259 #endif //#ifndef TOLUA_DISABLE
03260 
03261 /* method: oftype of class  fawkes::HumanoidMotionInterface */
03262 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_oftype00
03263 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_oftype00(lua_State* tolua_S)
03264 {
03265 #ifndef TOLUA_RELEASE
03266  tolua_Error tolua_err;
03267  if (
03268      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03269      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
03270      !tolua_isnoobj(tolua_S,3,&tolua_err)
03271  )
03272   goto tolua_lerror;
03273  else
03274 #endif
03275  {
03276   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03277   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
03278 #ifndef TOLUA_RELEASE
03279   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL);
03280 #endif
03281   {
03282    bool tolua_ret = (bool)  self->oftype(interface_type);
03283    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03284   }
03285  }
03286  return 1;
03287 #ifndef TOLUA_RELEASE
03288  tolua_lerror:
03289  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
03290  return 0;
03291 #endif
03292 }
03293 #endif //#ifndef TOLUA_DISABLE
03294 
03295 /* method: datachunk of class  fawkes::HumanoidMotionInterface */
03296 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_datachunk00
03297 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_datachunk00(lua_State* tolua_S)
03298 {
03299 #ifndef TOLUA_RELEASE
03300  tolua_Error tolua_err;
03301  if (
03302      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03303      !tolua_isnoobj(tolua_S,2,&tolua_err)
03304  )
03305   goto tolua_lerror;
03306  else
03307 #endif
03308  {
03309   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03310 #ifndef TOLUA_RELEASE
03311   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL);
03312 #endif
03313   {
03314    const void* tolua_ret = (const void*)  self->datachunk();
03315    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
03316   }
03317  }
03318  return 1;
03319 #ifndef TOLUA_RELEASE
03320  tolua_lerror:
03321  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
03322  return 0;
03323 #endif
03324 }
03325 #endif //#ifndef TOLUA_DISABLE
03326 
03327 /* method: datasize of class  fawkes::HumanoidMotionInterface */
03328 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_datasize00
03329 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_datasize00(lua_State* tolua_S)
03330 {
03331 #ifndef TOLUA_RELEASE
03332  tolua_Error tolua_err;
03333  if (
03334      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03335      !tolua_isnoobj(tolua_S,2,&tolua_err)
03336  )
03337   goto tolua_lerror;
03338  else
03339 #endif
03340  {
03341   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03342 #ifndef TOLUA_RELEASE
03343   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL);
03344 #endif
03345   {
03346    unsigned int tolua_ret = (unsigned int)  self->datasize();
03347    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03348   }
03349  }
03350  return 1;
03351 #ifndef TOLUA_RELEASE
03352  tolua_lerror:
03353  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
03354  return 0;
03355 #endif
03356 }
03357 #endif //#ifndef TOLUA_DISABLE
03358 
03359 /* method: type of class  fawkes::HumanoidMotionInterface */
03360 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_type00
03361 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_type00(lua_State* tolua_S)
03362 {
03363 #ifndef TOLUA_RELEASE
03364  tolua_Error tolua_err;
03365  if (
03366      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03367      !tolua_isnoobj(tolua_S,2,&tolua_err)
03368  )
03369   goto tolua_lerror;
03370  else
03371 #endif
03372  {
03373   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03374 #ifndef TOLUA_RELEASE
03375   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
03376 #endif
03377   {
03378    const char* tolua_ret = (const char*)  self->type();
03379    tolua_pushstring(tolua_S,(const char*)tolua_ret);
03380   }
03381  }
03382  return 1;
03383 #ifndef TOLUA_RELEASE
03384  tolua_lerror:
03385  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
03386  return 0;
03387 #endif
03388 }
03389 #endif //#ifndef TOLUA_DISABLE
03390 
03391 /* method: id of class  fawkes::HumanoidMotionInterface */
03392 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_id00
03393 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_id00(lua_State* tolua_S)
03394 {
03395 #ifndef TOLUA_RELEASE
03396  tolua_Error tolua_err;
03397  if (
03398      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03399      !tolua_isnoobj(tolua_S,2,&tolua_err)
03400  )
03401   goto tolua_lerror;
03402  else
03403 #endif
03404  {
03405   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03406 #ifndef TOLUA_RELEASE
03407   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL);
03408 #endif
03409   {
03410    const char* tolua_ret = (const char*)  self->id();
03411    tolua_pushstring(tolua_S,(const char*)tolua_ret);
03412   }
03413  }
03414  return 1;
03415 #ifndef TOLUA_RELEASE
03416  tolua_lerror:
03417  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
03418  return 0;
03419 #endif
03420 }
03421 #endif //#ifndef TOLUA_DISABLE
03422 
03423 /* method: uid of class  fawkes::HumanoidMotionInterface */
03424 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_uid00
03425 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_uid00(lua_State* tolua_S)
03426 {
03427 #ifndef TOLUA_RELEASE
03428  tolua_Error tolua_err;
03429  if (
03430      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03431      !tolua_isnoobj(tolua_S,2,&tolua_err)
03432  )
03433   goto tolua_lerror;
03434  else
03435 #endif
03436  {
03437   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03438 #ifndef TOLUA_RELEASE
03439   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL);
03440 #endif
03441   {
03442    const char* tolua_ret = (const char*)  self->uid();
03443    tolua_pushstring(tolua_S,(const char*)tolua_ret);
03444   }
03445  }
03446  return 1;
03447 #ifndef TOLUA_RELEASE
03448  tolua_lerror:
03449  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
03450  return 0;
03451 #endif
03452 }
03453 #endif //#ifndef TOLUA_DISABLE
03454 
03455 /* method: serial of class  fawkes::HumanoidMotionInterface */
03456 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_serial00
03457 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_serial00(lua_State* tolua_S)
03458 {
03459 #ifndef TOLUA_RELEASE
03460  tolua_Error tolua_err;
03461  if (
03462      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03463      !tolua_isnoobj(tolua_S,2,&tolua_err)
03464  )
03465   goto tolua_lerror;
03466  else
03467 #endif
03468  {
03469   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03470 #ifndef TOLUA_RELEASE
03471   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL);
03472 #endif
03473   {
03474    unsigned int tolua_ret = (unsigned int)  self->serial();
03475    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03476   }
03477  }
03478  return 1;
03479 #ifndef TOLUA_RELEASE
03480  tolua_lerror:
03481  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
03482  return 0;
03483 #endif
03484 }
03485 #endif //#ifndef TOLUA_DISABLE
03486 
03487 /* method: mem_serial of class  fawkes::HumanoidMotionInterface */
03488 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_mem_serial00
03489 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_mem_serial00(lua_State* tolua_S)
03490 {
03491 #ifndef TOLUA_RELEASE
03492  tolua_Error tolua_err;
03493  if (
03494      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03495      !tolua_isnoobj(tolua_S,2,&tolua_err)
03496  )
03497   goto tolua_lerror;
03498  else
03499 #endif
03500  {
03501   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03502 #ifndef TOLUA_RELEASE
03503   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL);
03504 #endif
03505   {
03506    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
03507    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03508   }
03509  }
03510  return 1;
03511 #ifndef TOLUA_RELEASE
03512  tolua_lerror:
03513  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
03514  return 0;
03515 #endif
03516 }
03517 #endif //#ifndef TOLUA_DISABLE
03518 
03519 /* method: operator== of class  fawkes::HumanoidMotionInterface */
03520 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface__eq00
03521 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface__eq00(lua_State* tolua_S)
03522 {
03523 #ifndef TOLUA_RELEASE
03524  tolua_Error tolua_err;
03525  if (
03526      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03527      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) ||
03528      !tolua_isnoobj(tolua_S,3,&tolua_err)
03529  )
03530   goto tolua_lerror;
03531  else
03532 #endif
03533  {
03534   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03535   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
03536 #ifndef TOLUA_RELEASE
03537   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
03538 #endif
03539   {
03540    bool tolua_ret = (bool)  self->operator==(*comp);
03541    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03542   }
03543  }
03544  return 1;
03545 #ifndef TOLUA_RELEASE
03546  tolua_lerror:
03547  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
03548  return 0;
03549 #endif
03550 }
03551 #endif //#ifndef TOLUA_DISABLE
03552 
03553 /* method: hash of class  fawkes::HumanoidMotionInterface */
03554 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash00
03555 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash00(lua_State* tolua_S)
03556 {
03557 #ifndef TOLUA_RELEASE
03558  tolua_Error tolua_err;
03559  if (
03560      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03561      !tolua_isnoobj(tolua_S,2,&tolua_err)
03562  )
03563   goto tolua_lerror;
03564  else
03565 #endif
03566  {
03567   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03568 #ifndef TOLUA_RELEASE
03569   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL);
03570 #endif
03571   {
03572    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
03573    tolua_pushstring(tolua_S,(const char*)tolua_ret);
03574   }
03575  }
03576  return 1;
03577 #ifndef TOLUA_RELEASE
03578  tolua_lerror:
03579  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
03580  return 0;
03581 #endif
03582 }
03583 #endif //#ifndef TOLUA_DISABLE
03584 
03585 /* method: hash_size of class  fawkes::HumanoidMotionInterface */
03586 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash_size00
03587 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash_size00(lua_State* tolua_S)
03588 {
03589 #ifndef TOLUA_RELEASE
03590  tolua_Error tolua_err;
03591  if (
03592      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03593      !tolua_isnoobj(tolua_S,2,&tolua_err)
03594  )
03595   goto tolua_lerror;
03596  else
03597 #endif
03598  {
03599   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03600 #ifndef TOLUA_RELEASE
03601   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL);
03602 #endif
03603   {
03604    int tolua_ret = (int)  self->hash_size();
03605    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03606   }
03607  }
03608  return 1;
03609 #ifndef TOLUA_RELEASE
03610  tolua_lerror:
03611  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
03612  return 0;
03613 #endif
03614 }
03615 #endif //#ifndef TOLUA_DISABLE
03616 
03617 /* method: hash_printable of class  fawkes::HumanoidMotionInterface */
03618 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash_printable00
03619 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash_printable00(lua_State* tolua_S)
03620 {
03621 #ifndef TOLUA_RELEASE
03622  tolua_Error tolua_err;
03623  if (
03624      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03625      !tolua_isnoobj(tolua_S,2,&tolua_err)
03626  )
03627   goto tolua_lerror;
03628  else
03629 #endif
03630  {
03631   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03632 #ifndef TOLUA_RELEASE
03633   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL);
03634 #endif
03635   {
03636    const char* tolua_ret = (const char*)  self->hash_printable();
03637    tolua_pushstring(tolua_S,(const char*)tolua_ret);
03638   }
03639  }
03640  return 1;
03641 #ifndef TOLUA_RELEASE
03642  tolua_lerror:
03643  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
03644  return 0;
03645 #endif
03646 }
03647 #endif //#ifndef TOLUA_DISABLE
03648 
03649 /* method: is_writer of class  fawkes::HumanoidMotionInterface */
03650 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_writer00
03651 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_writer00(lua_State* tolua_S)
03652 {
03653 #ifndef TOLUA_RELEASE
03654  tolua_Error tolua_err;
03655  if (
03656      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03657      !tolua_isnoobj(tolua_S,2,&tolua_err)
03658  )
03659   goto tolua_lerror;
03660  else
03661 #endif
03662  {
03663   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03664 #ifndef TOLUA_RELEASE
03665   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL);
03666 #endif
03667   {
03668    bool tolua_ret = (bool)  self->is_writer();
03669    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03670   }
03671  }
03672  return 1;
03673 #ifndef TOLUA_RELEASE
03674  tolua_lerror:
03675  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
03676  return 0;
03677 #endif
03678 }
03679 #endif //#ifndef TOLUA_DISABLE
03680 
03681 /* method: set_from_chunk of class  fawkes::HumanoidMotionInterface */
03682 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_from_chunk00
03683 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_from_chunk00(lua_State* tolua_S)
03684 {
03685 #ifndef TOLUA_RELEASE
03686  tolua_Error tolua_err;
03687  if (
03688      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03689      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
03690      !tolua_isnoobj(tolua_S,3,&tolua_err)
03691  )
03692   goto tolua_lerror;
03693  else
03694 #endif
03695  {
03696   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03697   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
03698 #ifndef TOLUA_RELEASE
03699   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL);
03700 #endif
03701   {
03702    self->set_from_chunk(chunk);
03703   }
03704  }
03705  return 0;
03706 #ifndef TOLUA_RELEASE
03707  tolua_lerror:
03708  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
03709  return 0;
03710 #endif
03711 }
03712 #endif //#ifndef TOLUA_DISABLE
03713 
03714 /* method: create_message of class  fawkes::HumanoidMotionInterface */
03715 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_create_message00
03716 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_create_message00(lua_State* tolua_S)
03717 {
03718 #ifndef TOLUA_RELEASE
03719  tolua_Error tolua_err;
03720  if (
03721      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03722      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
03723      !tolua_isnoobj(tolua_S,3,&tolua_err)
03724  )
03725   goto tolua_lerror;
03726  else
03727 #endif
03728  {
03729   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03730   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
03731 #ifndef TOLUA_RELEASE
03732   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL);
03733 #endif
03734   {
03735    Message* tolua_ret = (Message*)  self->create_message(type);
03736     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
03737   }
03738  }
03739  return 1;
03740 #ifndef TOLUA_RELEASE
03741  tolua_lerror:
03742  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
03743  return 0;
03744 #endif
03745 }
03746 #endif //#ifndef TOLUA_DISABLE
03747 
03748 /* method: read of class  fawkes::HumanoidMotionInterface */
03749 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_read00
03750 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_read00(lua_State* tolua_S)
03751 {
03752 #ifndef TOLUA_RELEASE
03753  tolua_Error tolua_err;
03754  if (
03755      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03756      !tolua_isnoobj(tolua_S,2,&tolua_err)
03757  )
03758   goto tolua_lerror;
03759  else
03760 #endif
03761  {
03762   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03763 #ifndef TOLUA_RELEASE
03764   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
03765 #endif
03766   {
03767    self->read();
03768   }
03769  }
03770  return 0;
03771 #ifndef TOLUA_RELEASE
03772  tolua_lerror:
03773  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
03774  return 0;
03775 #endif
03776 }
03777 #endif //#ifndef TOLUA_DISABLE
03778 
03779 /* method: write of class  fawkes::HumanoidMotionInterface */
03780 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_write00
03781 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_write00(lua_State* tolua_S)
03782 {
03783 #ifndef TOLUA_RELEASE
03784  tolua_Error tolua_err;
03785  if (
03786      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03787      !tolua_isnoobj(tolua_S,2,&tolua_err)
03788  )
03789   goto tolua_lerror;
03790  else
03791 #endif
03792  {
03793   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03794 #ifndef TOLUA_RELEASE
03795   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
03796 #endif
03797   {
03798    self->write();
03799   }
03800  }
03801  return 0;
03802 #ifndef TOLUA_RELEASE
03803  tolua_lerror:
03804  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
03805  return 0;
03806 #endif
03807 }
03808 #endif //#ifndef TOLUA_DISABLE
03809 
03810 /* method: has_writer of class  fawkes::HumanoidMotionInterface */
03811 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_has_writer00
03812 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_has_writer00(lua_State* tolua_S)
03813 {
03814 #ifndef TOLUA_RELEASE
03815  tolua_Error tolua_err;
03816  if (
03817      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03818      !tolua_isnoobj(tolua_S,2,&tolua_err)
03819  )
03820   goto tolua_lerror;
03821  else
03822 #endif
03823  {
03824   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03825 #ifndef TOLUA_RELEASE
03826   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL);
03827 #endif
03828   {
03829    bool tolua_ret = (bool)  self->has_writer();
03830    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03831   }
03832  }
03833  return 1;
03834 #ifndef TOLUA_RELEASE
03835  tolua_lerror:
03836  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
03837  return 0;
03838 #endif
03839 }
03840 #endif //#ifndef TOLUA_DISABLE
03841 
03842 /* method: num_readers of class  fawkes::HumanoidMotionInterface */
03843 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_num_readers00
03844 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_num_readers00(lua_State* tolua_S)
03845 {
03846 #ifndef TOLUA_RELEASE
03847  tolua_Error tolua_err;
03848  if (
03849      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03850      !tolua_isnoobj(tolua_S,2,&tolua_err)
03851  )
03852   goto tolua_lerror;
03853  else
03854 #endif
03855  {
03856   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03857 #ifndef TOLUA_RELEASE
03858   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL);
03859 #endif
03860   {
03861    unsigned int tolua_ret = (unsigned int)  self->num_readers();
03862    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03863   }
03864  }
03865  return 1;
03866 #ifndef TOLUA_RELEASE
03867  tolua_lerror:
03868  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
03869  return 0;
03870 #endif
03871 }
03872 #endif //#ifndef TOLUA_DISABLE
03873 
03874 /* method: msgq_enqueue_copy of class  fawkes::HumanoidMotionInterface */
03875 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_enqueue_copy00
03876 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_enqueue_copy00(lua_State* tolua_S)
03877 {
03878 #ifndef TOLUA_RELEASE
03879  tolua_Error tolua_err;
03880  if (
03881      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03882      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
03883      !tolua_isnoobj(tolua_S,3,&tolua_err)
03884  )
03885   goto tolua_lerror;
03886  else
03887 #endif
03888  {
03889   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03890   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
03891 #ifndef TOLUA_RELEASE
03892   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL);
03893 #endif
03894   {
03895    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
03896    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03897   }
03898  }
03899  return 1;
03900 #ifndef TOLUA_RELEASE
03901  tolua_lerror:
03902  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
03903  return 0;
03904 #endif
03905 }
03906 #endif //#ifndef TOLUA_DISABLE
03907 
03908 /* method: msgq_remove of class  fawkes::HumanoidMotionInterface */
03909 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_remove00
03910 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_remove00(lua_State* tolua_S)
03911 {
03912 #ifndef TOLUA_RELEASE
03913  tolua_Error tolua_err;
03914  if (
03915      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03916      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
03917      !tolua_isnoobj(tolua_S,3,&tolua_err)
03918  )
03919   goto tolua_lerror;
03920  else
03921 #endif
03922  {
03923   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03924   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
03925 #ifndef TOLUA_RELEASE
03926   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
03927 #endif
03928   {
03929    self->msgq_remove(message);
03930   }
03931  }
03932  return 0;
03933 #ifndef TOLUA_RELEASE
03934  tolua_lerror:
03935  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
03936  return 0;
03937 #endif
03938 }
03939 #endif //#ifndef TOLUA_DISABLE
03940 
03941 /* method: msgq_remove of class  fawkes::HumanoidMotionInterface */
03942 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_remove01
03943 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_remove01(lua_State* tolua_S)
03944 {
03945  tolua_Error tolua_err;
03946  if (
03947      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03948      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03949      !tolua_isnoobj(tolua_S,3,&tolua_err)
03950  )
03951   goto tolua_lerror;
03952  else
03953  {
03954   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03955   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
03956 #ifndef TOLUA_RELEASE
03957   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
03958 #endif
03959   {
03960    self->msgq_remove(message_id);
03961   }
03962  }
03963  return 0;
03964 tolua_lerror:
03965  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_remove00(tolua_S);
03966 }
03967 #endif //#ifndef TOLUA_DISABLE
03968 
03969 /* method: msgq_size of class  fawkes::HumanoidMotionInterface */
03970 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_size00
03971 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_size00(lua_State* tolua_S)
03972 {
03973 #ifndef TOLUA_RELEASE
03974  tolua_Error tolua_err;
03975  if (
03976      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
03977      !tolua_isnoobj(tolua_S,2,&tolua_err)
03978  )
03979   goto tolua_lerror;
03980  else
03981 #endif
03982  {
03983   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
03984 #ifndef TOLUA_RELEASE
03985   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL);
03986 #endif
03987   {
03988    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
03989    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03990   }
03991  }
03992  return 1;
03993 #ifndef TOLUA_RELEASE
03994  tolua_lerror:
03995  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
03996  return 0;
03997 #endif
03998 }
03999 #endif //#ifndef TOLUA_DISABLE
04000 
04001 /* method: msgq_flush of class  fawkes::HumanoidMotionInterface */
04002 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_flush00
04003 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_flush00(lua_State* tolua_S)
04004 {
04005 #ifndef TOLUA_RELEASE
04006  tolua_Error tolua_err;
04007  if (
04008      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
04009      !tolua_isnoobj(tolua_S,2,&tolua_err)
04010  )
04011   goto tolua_lerror;
04012  else
04013 #endif
04014  {
04015   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
04016 #ifndef TOLUA_RELEASE
04017   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL);
04018 #endif
04019   {
04020    self->msgq_flush();
04021   }
04022  }
04023  return 0;
04024 #ifndef TOLUA_RELEASE
04025  tolua_lerror:
04026  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
04027  return 0;
04028 #endif
04029 }
04030 #endif //#ifndef TOLUA_DISABLE
04031 
04032 /* method: msgq_lock of class  fawkes::HumanoidMotionInterface */
04033 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_lock00
04034 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_lock00(lua_State* tolua_S)
04035 {
04036 #ifndef TOLUA_RELEASE
04037  tolua_Error tolua_err;
04038  if (
04039      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
04040      !tolua_isnoobj(tolua_S,2,&tolua_err)
04041  )
04042   goto tolua_lerror;
04043  else
04044 #endif
04045  {
04046   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
04047 #ifndef TOLUA_RELEASE
04048   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL);
04049 #endif
04050   {
04051    self->msgq_lock();
04052   }
04053  }
04054  return 0;
04055 #ifndef TOLUA_RELEASE
04056  tolua_lerror:
04057  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
04058  return 0;
04059 #endif
04060 }
04061 #endif //#ifndef TOLUA_DISABLE
04062 
04063 /* method: msgq_try_lock of class  fawkes::HumanoidMotionInterface */
04064 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_try_lock00
04065 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_try_lock00(lua_State* tolua_S)
04066 {
04067 #ifndef TOLUA_RELEASE
04068  tolua_Error tolua_err;
04069  if (
04070      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
04071      !tolua_isnoobj(tolua_S,2,&tolua_err)
04072  )
04073   goto tolua_lerror;
04074  else
04075 #endif
04076  {
04077   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
04078 #ifndef TOLUA_RELEASE
04079   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL);
04080 #endif
04081   {
04082    bool tolua_ret = (bool)  self->msgq_try_lock();
04083    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04084   }
04085  }
04086  return 1;
04087 #ifndef TOLUA_RELEASE
04088  tolua_lerror:
04089  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
04090  return 0;
04091 #endif
04092 }
04093 #endif //#ifndef TOLUA_DISABLE
04094 
04095 /* method: msgq_unlock of class  fawkes::HumanoidMotionInterface */
04096 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_unlock00
04097 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_unlock00(lua_State* tolua_S)
04098 {
04099 #ifndef TOLUA_RELEASE
04100  tolua_Error tolua_err;
04101  if (
04102      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
04103      !tolua_isnoobj(tolua_S,2,&tolua_err)
04104  )
04105   goto tolua_lerror;
04106  else
04107 #endif
04108  {
04109   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
04110 #ifndef TOLUA_RELEASE
04111   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL);
04112 #endif
04113   {
04114    self->msgq_unlock();
04115   }
04116  }
04117  return 0;
04118 #ifndef TOLUA_RELEASE
04119  tolua_lerror:
04120  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
04121  return 0;
04122 #endif
04123 }
04124 #endif //#ifndef TOLUA_DISABLE
04125 
04126 /* method: msgq_pop of class  fawkes::HumanoidMotionInterface */
04127 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_pop00
04128 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_pop00(lua_State* tolua_S)
04129 {
04130 #ifndef TOLUA_RELEASE
04131  tolua_Error tolua_err;
04132  if (
04133      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
04134      !tolua_isnoobj(tolua_S,2,&tolua_err)
04135  )
04136   goto tolua_lerror;
04137  else
04138 #endif
04139  {
04140   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
04141 #ifndef TOLUA_RELEASE
04142   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL);
04143 #endif
04144   {
04145    self->msgq_pop();
04146   }
04147  }
04148  return 0;
04149 #ifndef TOLUA_RELEASE
04150  tolua_lerror:
04151  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
04152  return 0;
04153 #endif
04154 }
04155 #endif //#ifndef TOLUA_DISABLE
04156 
04157 /* method: msgq_first of class  fawkes::HumanoidMotionInterface */
04158 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_first00
04159 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_first00(lua_State* tolua_S)
04160 {
04161 #ifndef TOLUA_RELEASE
04162  tolua_Error tolua_err;
04163  if (
04164      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
04165      !tolua_isnoobj(tolua_S,2,&tolua_err)
04166  )
04167   goto tolua_lerror;
04168  else
04169 #endif
04170  {
04171   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
04172 #ifndef TOLUA_RELEASE
04173   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL);
04174 #endif
04175   {
04176    Message* tolua_ret = (Message*)  self->msgq_first();
04177     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
04178   }
04179  }
04180  return 1;
04181 #ifndef TOLUA_RELEASE
04182  tolua_lerror:
04183  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
04184  return 0;
04185 #endif
04186 }
04187 #endif //#ifndef TOLUA_DISABLE
04188 
04189 /* method: msgq_empty of class  fawkes::HumanoidMotionInterface */
04190 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_empty00
04191 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_empty00(lua_State* tolua_S)
04192 {
04193 #ifndef TOLUA_RELEASE
04194  tolua_Error tolua_err;
04195  if (
04196      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
04197      !tolua_isnoobj(tolua_S,2,&tolua_err)
04198  )
04199   goto tolua_lerror;
04200  else
04201 #endif
04202  {
04203   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
04204 #ifndef TOLUA_RELEASE
04205   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL);
04206 #endif
04207   {
04208    bool tolua_ret = (bool)  self->msgq_empty();
04209    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04210   }
04211  }
04212  return 1;
04213 #ifndef TOLUA_RELEASE
04214  tolua_lerror:
04215  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
04216  return 0;
04217 #endif
04218 }
04219 #endif //#ifndef TOLUA_DISABLE
04220 
04221 /* Open function */
04222 TOLUA_API int tolua_interfaces_HumanoidMotionInterface_open (lua_State* tolua_S)
04223 {
04224  tolua_open(tolua_S);
04225  tolua_reg_types(tolua_S);
04226  tolua_module(tolua_S,NULL,0);
04227  tolua_beginmodule(tolua_S,NULL);
04228   tolua_module(tolua_S,"fawkes",0);
04229   tolua_beginmodule(tolua_S,"fawkes");
04230    tolua_cclass(tolua_S,"HumanoidMotionInterface","fawkes::HumanoidMotionInterface","Interface",NULL);
04231    tolua_beginmodule(tolua_S,"HumanoidMotionInterface");
04232     tolua_constant(tolua_S,"LEG_LEFT",fawkes::HumanoidMotionInterface::LEG_LEFT);
04233     tolua_constant(tolua_S,"LEG_RIGHT",fawkes::HumanoidMotionInterface::LEG_RIGHT);
04234     tolua_constant(tolua_S,"STANDUP_DETECT",fawkes::HumanoidMotionInterface::STANDUP_DETECT);
04235     tolua_constant(tolua_S,"STANDUP_BACK",fawkes::HumanoidMotionInterface::STANDUP_BACK);
04236     tolua_constant(tolua_S,"STANDUP_FRONT",fawkes::HumanoidMotionInterface::STANDUP_FRONT);
04237     #ifdef __cplusplus
04238     tolua_cclass(tolua_S,"StopMessage","fawkes::HumanoidMotionInterface::StopMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__StopMessage);
04239     #else
04240     tolua_cclass(tolua_S,"StopMessage","fawkes::HumanoidMotionInterface::StopMessage","Message",NULL);
04241     #endif
04242     tolua_beginmodule(tolua_S,"StopMessage");
04243      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_new00);
04244      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_new00_local);
04245      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_new00_local);
04246      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_delete00);
04247     tolua_endmodule(tolua_S);
04248     #ifdef __cplusplus
04249     tolua_cclass(tolua_S,"WalkStraightMessage","fawkes::HumanoidMotionInterface::WalkStraightMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__WalkStraightMessage);
04250     #else
04251     tolua_cclass(tolua_S,"WalkStraightMessage","fawkes::HumanoidMotionInterface::WalkStraightMessage","Message",NULL);
04252     #endif
04253     tolua_beginmodule(tolua_S,"WalkStraightMessage");
04254      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00);
04255      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00_local);
04256      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00_local);
04257      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new01);
04258      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new01_local);
04259      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new01_local);
04260      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_delete00);
04261      tolua_function(tolua_S,"distance",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_distance00);
04262      tolua_function(tolua_S,"set_distance",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_set_distance00);
04263      tolua_function(tolua_S,"maxlenof_distance",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_maxlenof_distance00);
04264     tolua_endmodule(tolua_S);
04265     #ifdef __cplusplus
04266     tolua_cclass(tolua_S,"WalkSidewaysMessage","fawkes::HumanoidMotionInterface::WalkSidewaysMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__WalkSidewaysMessage);
04267     #else
04268     tolua_cclass(tolua_S,"WalkSidewaysMessage","fawkes::HumanoidMotionInterface::WalkSidewaysMessage","Message",NULL);
04269     #endif
04270     tolua_beginmodule(tolua_S,"WalkSidewaysMessage");
04271      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00);
04272      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00_local);
04273      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00_local);
04274      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new01);
04275      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new01_local);
04276      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new01_local);
04277      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_delete00);
04278      tolua_function(tolua_S,"distance",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_distance00);
04279      tolua_function(tolua_S,"set_distance",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_set_distance00);
04280      tolua_function(tolua_S,"maxlenof_distance",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_maxlenof_distance00);
04281     tolua_endmodule(tolua_S);
04282     #ifdef __cplusplus
04283     tolua_cclass(tolua_S,"WalkArcMessage","fawkes::HumanoidMotionInterface::WalkArcMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__WalkArcMessage);
04284     #else
04285     tolua_cclass(tolua_S,"WalkArcMessage","fawkes::HumanoidMotionInterface::WalkArcMessage","Message",NULL);
04286     #endif
04287     tolua_beginmodule(tolua_S,"WalkArcMessage");
04288      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00);
04289      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00_local);
04290      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00_local);
04291      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new01);
04292      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new01_local);
04293      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new01_local);
04294      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_delete00);
04295      tolua_function(tolua_S,"angle",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_angle00);
04296      tolua_function(tolua_S,"set_angle",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_angle00);
04297      tolua_function(tolua_S,"maxlenof_angle",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_angle00);
04298      tolua_function(tolua_S,"radius",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_radius00);
04299      tolua_function(tolua_S,"set_radius",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_radius00);
04300      tolua_function(tolua_S,"maxlenof_radius",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_radius00);
04301     tolua_endmodule(tolua_S);
04302     #ifdef __cplusplus
04303     tolua_cclass(tolua_S,"WalkVelocityMessage","fawkes::HumanoidMotionInterface::WalkVelocityMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__WalkVelocityMessage);
04304     #else
04305     tolua_cclass(tolua_S,"WalkVelocityMessage","fawkes::HumanoidMotionInterface::WalkVelocityMessage","Message",NULL);
04306     #endif
04307     tolua_beginmodule(tolua_S,"WalkVelocityMessage");
04308      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new00);
04309      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new00_local);
04310      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new00_local);
04311      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new01);
04312      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new01_local);
04313      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_new01_local);
04314      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_delete00);
04315      tolua_function(tolua_S,"x",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_x00);
04316      tolua_function(tolua_S,"set_x",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_set_x00);
04317      tolua_function(tolua_S,"maxlenof_x",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_maxlenof_x00);
04318      tolua_function(tolua_S,"y",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_y00);
04319      tolua_function(tolua_S,"set_y",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_set_y00);
04320      tolua_function(tolua_S,"maxlenof_y",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_maxlenof_y00);
04321      tolua_function(tolua_S,"theta",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_theta00);
04322      tolua_function(tolua_S,"set_theta",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_set_theta00);
04323      tolua_function(tolua_S,"maxlenof_theta",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_maxlenof_theta00);
04324      tolua_function(tolua_S,"speed",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_speed00);
04325      tolua_function(tolua_S,"set_speed",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_set_speed00);
04326      tolua_function(tolua_S,"maxlenof_speed",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkVelocityMessage_maxlenof_speed00);
04327     tolua_endmodule(tolua_S);
04328     #ifdef __cplusplus
04329     tolua_cclass(tolua_S,"TurnMessage","fawkes::HumanoidMotionInterface::TurnMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__TurnMessage);
04330     #else
04331     tolua_cclass(tolua_S,"TurnMessage","fawkes::HumanoidMotionInterface::TurnMessage","Message",NULL);
04332     #endif
04333     tolua_beginmodule(tolua_S,"TurnMessage");
04334      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00);
04335      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00_local);
04336      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00_local);
04337      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new01);
04338      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new01_local);
04339      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new01_local);
04340      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_delete00);
04341      tolua_function(tolua_S,"angle",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_angle00);
04342      tolua_function(tolua_S,"set_angle",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_set_angle00);
04343      tolua_function(tolua_S,"maxlenof_angle",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_maxlenof_angle00);
04344     tolua_endmodule(tolua_S);
04345     #ifdef __cplusplus
04346     tolua_cclass(tolua_S,"KickMessage","fawkes::HumanoidMotionInterface::KickMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__KickMessage);
04347     #else
04348     tolua_cclass(tolua_S,"KickMessage","fawkes::HumanoidMotionInterface::KickMessage","Message",NULL);
04349     #endif
04350     tolua_beginmodule(tolua_S,"KickMessage");
04351      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00);
04352      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00_local);
04353      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00_local);
04354      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new01);
04355      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new01_local);
04356      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new01_local);
04357      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_delete00);
04358      tolua_function(tolua_S,"leg",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_leg00);
04359      tolua_function(tolua_S,"set_leg",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_set_leg00);
04360      tolua_function(tolua_S,"maxlenof_leg",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_maxlenof_leg00);
04361      tolua_function(tolua_S,"strength",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_strength00);
04362      tolua_function(tolua_S,"set_strength",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_set_strength00);
04363      tolua_function(tolua_S,"maxlenof_strength",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_maxlenof_strength00);
04364     tolua_endmodule(tolua_S);
04365     #ifdef __cplusplus
04366     tolua_cclass(tolua_S,"ParkMessage","fawkes::HumanoidMotionInterface::ParkMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__ParkMessage);
04367     #else
04368     tolua_cclass(tolua_S,"ParkMessage","fawkes::HumanoidMotionInterface::ParkMessage","Message",NULL);
04369     #endif
04370     tolua_beginmodule(tolua_S,"ParkMessage");
04371      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00);
04372      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00_local);
04373      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00_local);
04374      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_delete00);
04375     tolua_endmodule(tolua_S);
04376     #ifdef __cplusplus
04377     tolua_cclass(tolua_S,"GetUpMessage","fawkes::HumanoidMotionInterface::GetUpMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__GetUpMessage);
04378     #else
04379     tolua_cclass(tolua_S,"GetUpMessage","fawkes::HumanoidMotionInterface::GetUpMessage","Message",NULL);
04380     #endif
04381     tolua_beginmodule(tolua_S,"GetUpMessage");
04382      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00);
04383      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00_local);
04384      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00_local);
04385      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_delete00);
04386     tolua_endmodule(tolua_S);
04387     #ifdef __cplusplus
04388     tolua_cclass(tolua_S,"StandupMessage","fawkes::HumanoidMotionInterface::StandupMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__StandupMessage);
04389     #else
04390     tolua_cclass(tolua_S,"StandupMessage","fawkes::HumanoidMotionInterface::StandupMessage","Message",NULL);
04391     #endif
04392     tolua_beginmodule(tolua_S,"StandupMessage");
04393      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00);
04394      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00_local);
04395      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00_local);
04396      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new01);
04397      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new01_local);
04398      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new01_local);
04399      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_delete00);
04400      tolua_function(tolua_S,"from_pos",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_from_pos00);
04401      tolua_function(tolua_S,"set_from_pos",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_set_from_pos00);
04402      tolua_function(tolua_S,"maxlenof_from_pos",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_maxlenof_from_pos00);
04403     tolua_endmodule(tolua_S);
04404     #ifdef __cplusplus
04405     tolua_cclass(tolua_S,"MoveHeadMessage","fawkes::HumanoidMotionInterface::MoveHeadMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__MoveHeadMessage);
04406     #else
04407     tolua_cclass(tolua_S,"MoveHeadMessage","fawkes::HumanoidMotionInterface::MoveHeadMessage","Message",NULL);
04408     #endif
04409     tolua_beginmodule(tolua_S,"MoveHeadMessage");
04410      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new00);
04411      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new00_local);
04412      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new00_local);
04413      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new01);
04414      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new01_local);
04415      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_new01_local);
04416      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_delete00);
04417      tolua_function(tolua_S,"yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_yaw00);
04418      tolua_function(tolua_S,"set_yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_set_yaw00);
04419      tolua_function(tolua_S,"maxlenof_yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_maxlenof_yaw00);
04420      tolua_function(tolua_S,"pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_pitch00);
04421      tolua_function(tolua_S,"set_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_set_pitch00);
04422      tolua_function(tolua_S,"maxlenof_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_maxlenof_pitch00);
04423      tolua_function(tolua_S,"speed",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_speed00);
04424      tolua_function(tolua_S,"set_speed",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_set_speed00);
04425      tolua_function(tolua_S,"maxlenof_speed",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_MoveHeadMessage_maxlenof_speed00);
04426     tolua_endmodule(tolua_S);
04427     tolua_function(tolua_S,"is_moving",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_moving00);
04428     tolua_function(tolua_S,"set_moving",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_moving00);
04429     tolua_function(tolua_S,"maxlenof_moving",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_moving00);
04430     tolua_function(tolua_S,"is_arms_enabled",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_arms_enabled00);
04431     tolua_function(tolua_S,"set_arms_enabled",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_arms_enabled00);
04432     tolua_function(tolua_S,"maxlenof_arms_enabled",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_arms_enabled00);
04433     tolua_function(tolua_S,"msgid",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgid00);
04434     tolua_function(tolua_S,"set_msgid",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_msgid00);
04435     tolua_function(tolua_S,"maxlenof_msgid",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_msgid00);
04436     tolua_function(tolua_S,"oftype",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_oftype00);
04437     tolua_function(tolua_S,"datachunk",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_datachunk00);
04438     tolua_function(tolua_S,"datasize",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_datasize00);
04439     tolua_function(tolua_S,"type",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_type00);
04440     tolua_function(tolua_S,"id",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_id00);
04441     tolua_function(tolua_S,"uid",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_uid00);
04442     tolua_function(tolua_S,"serial",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_serial00);
04443     tolua_function(tolua_S,"mem_serial",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_mem_serial00);
04444     tolua_function(tolua_S,".eq",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface__eq00);
04445     tolua_function(tolua_S,"hash",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash00);
04446     tolua_function(tolua_S,"hash_size",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash_size00);
04447     tolua_function(tolua_S,"hash_printable",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash_printable00);
04448     tolua_function(tolua_S,"is_writer",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_writer00);
04449     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_from_chunk00);
04450     tolua_function(tolua_S,"create_message",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_create_message00);
04451     tolua_function(tolua_S,"read",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_read00);
04452     tolua_function(tolua_S,"write",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_write00);
04453     tolua_function(tolua_S,"has_writer",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_has_writer00);
04454     tolua_function(tolua_S,"num_readers",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_num_readers00);
04455     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_enqueue_copy00);
04456     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_remove00);
04457     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_remove01);
04458     tolua_function(tolua_S,"msgq_size",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_size00);
04459     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_flush00);
04460     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_lock00);
04461     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_try_lock00);
04462     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_unlock00);
04463     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_pop00);
04464     tolua_function(tolua_S,"msgq_first",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_first00);
04465     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_empty00);
04466    tolua_endmodule(tolua_S);
04467   tolua_endmodule(tolua_S);
04468  tolua_endmodule(tolua_S);
04469  return 1;
04470 }
04471 
04472 
04473 extern "C" {
04474 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
04475  TOLUA_API int luaopen_interfaces_HumanoidMotionInterface (lua_State* tolua_S) {
04476  return tolua_interfaces_HumanoidMotionInterface_open(tolua_S);
04477 };
04478 #endif
04479 }
04480 
04481