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__SetStiffnessParamsMessage (lua_State* tolua_S)
00036 {
00037  fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*) tolua_tousertype(tolua_S,1,0);
00038         Mtolua_delete(self);
00039         return 0;
00040 }
00041 
00042 static int tolua_collect_fawkes__HumanoidMotionInterface__StopMessage (lua_State* tolua_S)
00043 {
00044  fawkes::HumanoidMotionInterface::StopMessage* self = (fawkes::HumanoidMotionInterface::StopMessage*) tolua_tousertype(tolua_S,1,0);
00045         Mtolua_delete(self);
00046         return 0;
00047 }
00048 
00049 static int tolua_collect_fawkes__HumanoidMotionInterface__WalkStraightMessage (lua_State* tolua_S)
00050 {
00051  fawkes::HumanoidMotionInterface::WalkStraightMessage* self = (fawkes::HumanoidMotionInterface::WalkStraightMessage*) tolua_tousertype(tolua_S,1,0);
00052         Mtolua_delete(self);
00053         return 0;
00054 }
00055 
00056 static int tolua_collect_fawkes__HumanoidMotionInterface__SetWalkParamsMessage (lua_State* tolua_S)
00057 {
00058  fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*) tolua_tousertype(tolua_S,1,0);
00059         Mtolua_delete(self);
00060         return 0;
00061 }
00062 
00063 static int tolua_collect_fawkes__HumanoidMotionInterface__SetWalkArmsParamsMessage (lua_State* tolua_S)
00064 {
00065  fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*) tolua_tousertype(tolua_S,1,0);
00066         Mtolua_delete(self);
00067         return 0;
00068 }
00069 
00070 static int tolua_collect_fawkes__HumanoidMotionInterface__StandupMessage (lua_State* tolua_S)
00071 {
00072  fawkes::HumanoidMotionInterface::StandupMessage* self = (fawkes::HumanoidMotionInterface::StandupMessage*) tolua_tousertype(tolua_S,1,0);
00073         Mtolua_delete(self);
00074         return 0;
00075 }
00076 
00077 static int tolua_collect_fawkes__HumanoidMotionInterface__YawPitchHeadMessage (lua_State* tolua_S)
00078 {
00079  fawkes::HumanoidMotionInterface::YawPitchHeadMessage* self = (fawkes::HumanoidMotionInterface::YawPitchHeadMessage*) tolua_tousertype(tolua_S,1,0);
00080         Mtolua_delete(self);
00081         return 0;
00082 }
00083 
00084 static int tolua_collect_fawkes__HumanoidMotionInterface__GetUpMessage (lua_State* tolua_S)
00085 {
00086  fawkes::HumanoidMotionInterface::GetUpMessage* self = (fawkes::HumanoidMotionInterface::GetUpMessage*) tolua_tousertype(tolua_S,1,0);
00087         Mtolua_delete(self);
00088         return 0;
00089 }
00090 
00091 static int tolua_collect_fawkes__HumanoidMotionInterface__WalkArcMessage (lua_State* tolua_S)
00092 {
00093  fawkes::HumanoidMotionInterface::WalkArcMessage* self = (fawkes::HumanoidMotionInterface::WalkArcMessage*) tolua_tousertype(tolua_S,1,0);
00094         Mtolua_delete(self);
00095         return 0;
00096 }
00097 
00098 static int tolua_collect_fawkes__HumanoidMotionInterface__ParkMessage (lua_State* tolua_S)
00099 {
00100  fawkes::HumanoidMotionInterface::ParkMessage* self = (fawkes::HumanoidMotionInterface::ParkMessage*) tolua_tousertype(tolua_S,1,0);
00101         Mtolua_delete(self);
00102         return 0;
00103 }
00104 
00105 static int tolua_collect_fawkes__HumanoidMotionInterface__WalkSidewaysMessage (lua_State* tolua_S)
00106 {
00107  fawkes::HumanoidMotionInterface::WalkSidewaysMessage* self = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*) tolua_tousertype(tolua_S,1,0);
00108         Mtolua_delete(self);
00109         return 0;
00110 }
00111 
00112 static int tolua_collect_fawkes__HumanoidMotionInterface__KickMessage (lua_State* tolua_S)
00113 {
00114  fawkes::HumanoidMotionInterface::KickMessage* self = (fawkes::HumanoidMotionInterface::KickMessage*) tolua_tousertype(tolua_S,1,0);
00115         Mtolua_delete(self);
00116         return 0;
00117 }
00118 
00119 static int tolua_collect_fawkes__HumanoidMotionInterface__TurnMessage (lua_State* tolua_S)
00120 {
00121  fawkes::HumanoidMotionInterface::TurnMessage* self = (fawkes::HumanoidMotionInterface::TurnMessage*) tolua_tousertype(tolua_S,1,0);
00122         Mtolua_delete(self);
00123         return 0;
00124 }
00125 #endif
00126 
00127 
00128 /* function to register type */
00129 static void tolua_reg_types (lua_State* tolua_S)
00130 {
00131  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage");
00132  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::TurnMessage");
00133  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::StandupMessage");
00134  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::GetUpMessage");
00135  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::StopMessage");
00136  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::WalkStraightMessage");
00137  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage");
00138  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage");
00139  tolua_usertype(tolua_S,"Message");
00140  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage");
00141  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage");
00142  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface");
00143  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::ParkMessage");
00144  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::WalkArcMessage");
00145  tolua_usertype(tolua_S,"fawkes::HumanoidMotionInterface::KickMessage");
00146  tolua_usertype(tolua_S,"Interface");
00147 }
00148 
00149 /* method: new of class  SetWalkParamsMessage */
00150 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new00
00151 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new00(lua_State* tolua_S)
00152 {
00153 #ifndef TOLUA_RELEASE
00154  tolua_Error tolua_err;
00155  if (
00156      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00157      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00158      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00159      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00160      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
00161      !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
00162      !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
00163      !tolua_isnumber(tolua_S,8,0,&tolua_err) ||
00164      !tolua_isnumber(tolua_S,9,0,&tolua_err) ||
00165      !tolua_isnumber(tolua_S,10,0,&tolua_err) ||
00166      !tolua_isnumber(tolua_S,11,0,&tolua_err) ||
00167      !tolua_isnoobj(tolua_S,12,&tolua_err)
00168  )
00169   goto tolua_lerror;
00170  else
00171 #endif
00172  {
00173   float ini_max_step_length = ((float)  tolua_tonumber(tolua_S,2,0));
00174   float ini_max_step_height = ((float)  tolua_tonumber(tolua_S,3,0));
00175   float ini_max_step_side = ((float)  tolua_tonumber(tolua_S,4,0));
00176   float ini_max_step_turn = ((float)  tolua_tonumber(tolua_S,5,0));
00177   float ini_zmp_offset_forward = ((float)  tolua_tonumber(tolua_S,6,0));
00178   float ini_zmp_offset_sideward = ((float)  tolua_tonumber(tolua_S,7,0));
00179   float ini_l_hip_roll_compensation = ((float)  tolua_tonumber(tolua_S,8,0));
00180   float ini_r_hip_roll_compensation = ((float)  tolua_tonumber(tolua_S,9,0));
00181   float ini_hip_height = ((float)  tolua_tonumber(tolua_S,10,0));
00182   float ini_torso_sideward_orientation = ((float)  tolua_tonumber(tolua_S,11,0));
00183   {
00184    fawkes::HumanoidMotionInterface::SetWalkParamsMessage* tolua_ret = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::SetWalkParamsMessage)(ini_max_step_length,ini_max_step_height,ini_max_step_side,ini_max_step_turn,ini_zmp_offset_forward,ini_zmp_offset_sideward,ini_l_hip_roll_compensation,ini_r_hip_roll_compensation,ini_hip_height,ini_torso_sideward_orientation));
00185     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage");
00186   }
00187  }
00188  return 1;
00189 #ifndef TOLUA_RELEASE
00190  tolua_lerror:
00191  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00192  return 0;
00193 #endif
00194 }
00195 #endif //#ifndef TOLUA_DISABLE
00196 
00197 /* method: new_local of class  SetWalkParamsMessage */
00198 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new00_local
00199 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new00_local(lua_State* tolua_S)
00200 {
00201 #ifndef TOLUA_RELEASE
00202  tolua_Error tolua_err;
00203  if (
00204      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00205      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00206      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00207      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00208      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
00209      !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
00210      !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
00211      !tolua_isnumber(tolua_S,8,0,&tolua_err) ||
00212      !tolua_isnumber(tolua_S,9,0,&tolua_err) ||
00213      !tolua_isnumber(tolua_S,10,0,&tolua_err) ||
00214      !tolua_isnumber(tolua_S,11,0,&tolua_err) ||
00215      !tolua_isnoobj(tolua_S,12,&tolua_err)
00216  )
00217   goto tolua_lerror;
00218  else
00219 #endif
00220  {
00221   float ini_max_step_length = ((float)  tolua_tonumber(tolua_S,2,0));
00222   float ini_max_step_height = ((float)  tolua_tonumber(tolua_S,3,0));
00223   float ini_max_step_side = ((float)  tolua_tonumber(tolua_S,4,0));
00224   float ini_max_step_turn = ((float)  tolua_tonumber(tolua_S,5,0));
00225   float ini_zmp_offset_forward = ((float)  tolua_tonumber(tolua_S,6,0));
00226   float ini_zmp_offset_sideward = ((float)  tolua_tonumber(tolua_S,7,0));
00227   float ini_l_hip_roll_compensation = ((float)  tolua_tonumber(tolua_S,8,0));
00228   float ini_r_hip_roll_compensation = ((float)  tolua_tonumber(tolua_S,9,0));
00229   float ini_hip_height = ((float)  tolua_tonumber(tolua_S,10,0));
00230   float ini_torso_sideward_orientation = ((float)  tolua_tonumber(tolua_S,11,0));
00231   {
00232    fawkes::HumanoidMotionInterface::SetWalkParamsMessage* tolua_ret = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::SetWalkParamsMessage)(ini_max_step_length,ini_max_step_height,ini_max_step_side,ini_max_step_turn,ini_zmp_offset_forward,ini_zmp_offset_sideward,ini_l_hip_roll_compensation,ini_r_hip_roll_compensation,ini_hip_height,ini_torso_sideward_orientation));
00233     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage");
00234     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00235   }
00236  }
00237  return 1;
00238 #ifndef TOLUA_RELEASE
00239  tolua_lerror:
00240  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00241  return 0;
00242 #endif
00243 }
00244 #endif //#ifndef TOLUA_DISABLE
00245 
00246 /* method: new of class  SetWalkParamsMessage */
00247 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new01
00248 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new01(lua_State* tolua_S)
00249 {
00250  tolua_Error tolua_err;
00251  if (
00252      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00253      !tolua_isnoobj(tolua_S,2,&tolua_err)
00254  )
00255   goto tolua_lerror;
00256  else
00257  {
00258   {
00259    fawkes::HumanoidMotionInterface::SetWalkParamsMessage* tolua_ret = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::SetWalkParamsMessage)());
00260     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage");
00261   }
00262  }
00263  return 1;
00264 tolua_lerror:
00265  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new00(tolua_S);
00266 }
00267 #endif //#ifndef TOLUA_DISABLE
00268 
00269 /* method: new_local of class  SetWalkParamsMessage */
00270 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new01_local
00271 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new01_local(lua_State* tolua_S)
00272 {
00273  tolua_Error tolua_err;
00274  if (
00275      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00276      !tolua_isnoobj(tolua_S,2,&tolua_err)
00277  )
00278   goto tolua_lerror;
00279  else
00280  {
00281   {
00282    fawkes::HumanoidMotionInterface::SetWalkParamsMessage* tolua_ret = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::SetWalkParamsMessage)());
00283     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage");
00284     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00285   }
00286  }
00287  return 1;
00288 tolua_lerror:
00289  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new00_local(tolua_S);
00290 }
00291 #endif //#ifndef TOLUA_DISABLE
00292 
00293 /* method: delete of class  SetWalkParamsMessage */
00294 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_delete00
00295 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_delete00(lua_State* tolua_S)
00296 {
00297 #ifndef TOLUA_RELEASE
00298  tolua_Error tolua_err;
00299  if (
00300      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00301      !tolua_isnoobj(tolua_S,2,&tolua_err)
00302  )
00303   goto tolua_lerror;
00304  else
00305 #endif
00306  {
00307   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00308 #ifndef TOLUA_RELEASE
00309   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00310 #endif
00311   Mtolua_delete(self);
00312  }
00313  return 0;
00314 #ifndef TOLUA_RELEASE
00315  tolua_lerror:
00316  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00317  return 0;
00318 #endif
00319 }
00320 #endif //#ifndef TOLUA_DISABLE
00321 
00322 /* method: max_step_length of class  SetWalkParamsMessage */
00323 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_max_step_length00
00324 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_max_step_length00(lua_State* tolua_S)
00325 {
00326 #ifndef TOLUA_RELEASE
00327  tolua_Error tolua_err;
00328  if (
00329      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00330      !tolua_isnoobj(tolua_S,2,&tolua_err)
00331  )
00332   goto tolua_lerror;
00333  else
00334 #endif
00335  {
00336   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00337 #ifndef TOLUA_RELEASE
00338   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_step_length'", NULL);
00339 #endif
00340   {
00341    float tolua_ret = (float)  self->max_step_length();
00342    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00343   }
00344  }
00345  return 1;
00346 #ifndef TOLUA_RELEASE
00347  tolua_lerror:
00348  tolua_error(tolua_S,"#ferror in function 'max_step_length'.",&tolua_err);
00349  return 0;
00350 #endif
00351 }
00352 #endif //#ifndef TOLUA_DISABLE
00353 
00354 /* method: set_max_step_length of class  SetWalkParamsMessage */
00355 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_max_step_length00
00356 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_max_step_length00(lua_State* tolua_S)
00357 {
00358 #ifndef TOLUA_RELEASE
00359  tolua_Error tolua_err;
00360  if (
00361      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00362      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00363      !tolua_isnoobj(tolua_S,3,&tolua_err)
00364  )
00365   goto tolua_lerror;
00366  else
00367 #endif
00368  {
00369   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00370   const float new_max_step_length = ((const float)  tolua_tonumber(tolua_S,2,0));
00371 #ifndef TOLUA_RELEASE
00372   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_step_length'", NULL);
00373 #endif
00374   {
00375    self->set_max_step_length(new_max_step_length);
00376   }
00377  }
00378  return 0;
00379 #ifndef TOLUA_RELEASE
00380  tolua_lerror:
00381  tolua_error(tolua_S,"#ferror in function 'set_max_step_length'.",&tolua_err);
00382  return 0;
00383 #endif
00384 }
00385 #endif //#ifndef TOLUA_DISABLE
00386 
00387 /* method: maxlenof_max_step_length of class  SetWalkParamsMessage */
00388 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_max_step_length00
00389 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_max_step_length00(lua_State* tolua_S)
00390 {
00391 #ifndef TOLUA_RELEASE
00392  tolua_Error tolua_err;
00393  if (
00394      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00395      !tolua_isnoobj(tolua_S,2,&tolua_err)
00396  )
00397   goto tolua_lerror;
00398  else
00399 #endif
00400  {
00401   const fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00402 #ifndef TOLUA_RELEASE
00403   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_step_length'", NULL);
00404 #endif
00405   {
00406    int tolua_ret = (int)  self->maxlenof_max_step_length();
00407    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00408   }
00409  }
00410  return 1;
00411 #ifndef TOLUA_RELEASE
00412  tolua_lerror:
00413  tolua_error(tolua_S,"#ferror in function 'maxlenof_max_step_length'.",&tolua_err);
00414  return 0;
00415 #endif
00416 }
00417 #endif //#ifndef TOLUA_DISABLE
00418 
00419 /* method: max_step_height of class  SetWalkParamsMessage */
00420 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_max_step_height00
00421 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_max_step_height00(lua_State* tolua_S)
00422 {
00423 #ifndef TOLUA_RELEASE
00424  tolua_Error tolua_err;
00425  if (
00426      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00427      !tolua_isnoobj(tolua_S,2,&tolua_err)
00428  )
00429   goto tolua_lerror;
00430  else
00431 #endif
00432  {
00433   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00434 #ifndef TOLUA_RELEASE
00435   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_step_height'", NULL);
00436 #endif
00437   {
00438    float tolua_ret = (float)  self->max_step_height();
00439    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00440   }
00441  }
00442  return 1;
00443 #ifndef TOLUA_RELEASE
00444  tolua_lerror:
00445  tolua_error(tolua_S,"#ferror in function 'max_step_height'.",&tolua_err);
00446  return 0;
00447 #endif
00448 }
00449 #endif //#ifndef TOLUA_DISABLE
00450 
00451 /* method: set_max_step_height of class  SetWalkParamsMessage */
00452 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_max_step_height00
00453 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_max_step_height00(lua_State* tolua_S)
00454 {
00455 #ifndef TOLUA_RELEASE
00456  tolua_Error tolua_err;
00457  if (
00458      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00459      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00460      !tolua_isnoobj(tolua_S,3,&tolua_err)
00461  )
00462   goto tolua_lerror;
00463  else
00464 #endif
00465  {
00466   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00467   const float new_max_step_height = ((const float)  tolua_tonumber(tolua_S,2,0));
00468 #ifndef TOLUA_RELEASE
00469   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_step_height'", NULL);
00470 #endif
00471   {
00472    self->set_max_step_height(new_max_step_height);
00473   }
00474  }
00475  return 0;
00476 #ifndef TOLUA_RELEASE
00477  tolua_lerror:
00478  tolua_error(tolua_S,"#ferror in function 'set_max_step_height'.",&tolua_err);
00479  return 0;
00480 #endif
00481 }
00482 #endif //#ifndef TOLUA_DISABLE
00483 
00484 /* method: maxlenof_max_step_height of class  SetWalkParamsMessage */
00485 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_max_step_height00
00486 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_max_step_height00(lua_State* tolua_S)
00487 {
00488 #ifndef TOLUA_RELEASE
00489  tolua_Error tolua_err;
00490  if (
00491      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00492      !tolua_isnoobj(tolua_S,2,&tolua_err)
00493  )
00494   goto tolua_lerror;
00495  else
00496 #endif
00497  {
00498   const fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00499 #ifndef TOLUA_RELEASE
00500   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_step_height'", NULL);
00501 #endif
00502   {
00503    int tolua_ret = (int)  self->maxlenof_max_step_height();
00504    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00505   }
00506  }
00507  return 1;
00508 #ifndef TOLUA_RELEASE
00509  tolua_lerror:
00510  tolua_error(tolua_S,"#ferror in function 'maxlenof_max_step_height'.",&tolua_err);
00511  return 0;
00512 #endif
00513 }
00514 #endif //#ifndef TOLUA_DISABLE
00515 
00516 /* method: max_step_side of class  SetWalkParamsMessage */
00517 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_max_step_side00
00518 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_max_step_side00(lua_State* tolua_S)
00519 {
00520 #ifndef TOLUA_RELEASE
00521  tolua_Error tolua_err;
00522  if (
00523      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00524      !tolua_isnoobj(tolua_S,2,&tolua_err)
00525  )
00526   goto tolua_lerror;
00527  else
00528 #endif
00529  {
00530   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00531 #ifndef TOLUA_RELEASE
00532   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_step_side'", NULL);
00533 #endif
00534   {
00535    float tolua_ret = (float)  self->max_step_side();
00536    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00537   }
00538  }
00539  return 1;
00540 #ifndef TOLUA_RELEASE
00541  tolua_lerror:
00542  tolua_error(tolua_S,"#ferror in function 'max_step_side'.",&tolua_err);
00543  return 0;
00544 #endif
00545 }
00546 #endif //#ifndef TOLUA_DISABLE
00547 
00548 /* method: set_max_step_side of class  SetWalkParamsMessage */
00549 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_max_step_side00
00550 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_max_step_side00(lua_State* tolua_S)
00551 {
00552 #ifndef TOLUA_RELEASE
00553  tolua_Error tolua_err;
00554  if (
00555      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00556      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00557      !tolua_isnoobj(tolua_S,3,&tolua_err)
00558  )
00559   goto tolua_lerror;
00560  else
00561 #endif
00562  {
00563   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00564   const float new_max_step_side = ((const float)  tolua_tonumber(tolua_S,2,0));
00565 #ifndef TOLUA_RELEASE
00566   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_step_side'", NULL);
00567 #endif
00568   {
00569    self->set_max_step_side(new_max_step_side);
00570   }
00571  }
00572  return 0;
00573 #ifndef TOLUA_RELEASE
00574  tolua_lerror:
00575  tolua_error(tolua_S,"#ferror in function 'set_max_step_side'.",&tolua_err);
00576  return 0;
00577 #endif
00578 }
00579 #endif //#ifndef TOLUA_DISABLE
00580 
00581 /* method: maxlenof_max_step_side of class  SetWalkParamsMessage */
00582 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_max_step_side00
00583 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_max_step_side00(lua_State* tolua_S)
00584 {
00585 #ifndef TOLUA_RELEASE
00586  tolua_Error tolua_err;
00587  if (
00588      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00589      !tolua_isnoobj(tolua_S,2,&tolua_err)
00590  )
00591   goto tolua_lerror;
00592  else
00593 #endif
00594  {
00595   const fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00596 #ifndef TOLUA_RELEASE
00597   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_step_side'", NULL);
00598 #endif
00599   {
00600    int tolua_ret = (int)  self->maxlenof_max_step_side();
00601    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00602   }
00603  }
00604  return 1;
00605 #ifndef TOLUA_RELEASE
00606  tolua_lerror:
00607  tolua_error(tolua_S,"#ferror in function 'maxlenof_max_step_side'.",&tolua_err);
00608  return 0;
00609 #endif
00610 }
00611 #endif //#ifndef TOLUA_DISABLE
00612 
00613 /* method: max_step_turn of class  SetWalkParamsMessage */
00614 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_max_step_turn00
00615 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_max_step_turn00(lua_State* tolua_S)
00616 {
00617 #ifndef TOLUA_RELEASE
00618  tolua_Error tolua_err;
00619  if (
00620      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00621      !tolua_isnoobj(tolua_S,2,&tolua_err)
00622  )
00623   goto tolua_lerror;
00624  else
00625 #endif
00626  {
00627   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00628 #ifndef TOLUA_RELEASE
00629   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_step_turn'", NULL);
00630 #endif
00631   {
00632    float tolua_ret = (float)  self->max_step_turn();
00633    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00634   }
00635  }
00636  return 1;
00637 #ifndef TOLUA_RELEASE
00638  tolua_lerror:
00639  tolua_error(tolua_S,"#ferror in function 'max_step_turn'.",&tolua_err);
00640  return 0;
00641 #endif
00642 }
00643 #endif //#ifndef TOLUA_DISABLE
00644 
00645 /* method: set_max_step_turn of class  SetWalkParamsMessage */
00646 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_max_step_turn00
00647 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_max_step_turn00(lua_State* tolua_S)
00648 {
00649 #ifndef TOLUA_RELEASE
00650  tolua_Error tolua_err;
00651  if (
00652      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00653      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00654      !tolua_isnoobj(tolua_S,3,&tolua_err)
00655  )
00656   goto tolua_lerror;
00657  else
00658 #endif
00659  {
00660   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00661   const float new_max_step_turn = ((const float)  tolua_tonumber(tolua_S,2,0));
00662 #ifndef TOLUA_RELEASE
00663   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_step_turn'", NULL);
00664 #endif
00665   {
00666    self->set_max_step_turn(new_max_step_turn);
00667   }
00668  }
00669  return 0;
00670 #ifndef TOLUA_RELEASE
00671  tolua_lerror:
00672  tolua_error(tolua_S,"#ferror in function 'set_max_step_turn'.",&tolua_err);
00673  return 0;
00674 #endif
00675 }
00676 #endif //#ifndef TOLUA_DISABLE
00677 
00678 /* method: maxlenof_max_step_turn of class  SetWalkParamsMessage */
00679 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_max_step_turn00
00680 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_max_step_turn00(lua_State* tolua_S)
00681 {
00682 #ifndef TOLUA_RELEASE
00683  tolua_Error tolua_err;
00684  if (
00685      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00686      !tolua_isnoobj(tolua_S,2,&tolua_err)
00687  )
00688   goto tolua_lerror;
00689  else
00690 #endif
00691  {
00692   const fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00693 #ifndef TOLUA_RELEASE
00694   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_step_turn'", NULL);
00695 #endif
00696   {
00697    int tolua_ret = (int)  self->maxlenof_max_step_turn();
00698    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00699   }
00700  }
00701  return 1;
00702 #ifndef TOLUA_RELEASE
00703  tolua_lerror:
00704  tolua_error(tolua_S,"#ferror in function 'maxlenof_max_step_turn'.",&tolua_err);
00705  return 0;
00706 #endif
00707 }
00708 #endif //#ifndef TOLUA_DISABLE
00709 
00710 /* method: zmp_offset_forward of class  SetWalkParamsMessage */
00711 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_zmp_offset_forward00
00712 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_zmp_offset_forward00(lua_State* tolua_S)
00713 {
00714 #ifndef TOLUA_RELEASE
00715  tolua_Error tolua_err;
00716  if (
00717      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00718      !tolua_isnoobj(tolua_S,2,&tolua_err)
00719  )
00720   goto tolua_lerror;
00721  else
00722 #endif
00723  {
00724   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00725 #ifndef TOLUA_RELEASE
00726   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'zmp_offset_forward'", NULL);
00727 #endif
00728   {
00729    float tolua_ret = (float)  self->zmp_offset_forward();
00730    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00731   }
00732  }
00733  return 1;
00734 #ifndef TOLUA_RELEASE
00735  tolua_lerror:
00736  tolua_error(tolua_S,"#ferror in function 'zmp_offset_forward'.",&tolua_err);
00737  return 0;
00738 #endif
00739 }
00740 #endif //#ifndef TOLUA_DISABLE
00741 
00742 /* method: set_zmp_offset_forward of class  SetWalkParamsMessage */
00743 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_zmp_offset_forward00
00744 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_zmp_offset_forward00(lua_State* tolua_S)
00745 {
00746 #ifndef TOLUA_RELEASE
00747  tolua_Error tolua_err;
00748  if (
00749      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00750      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00751      !tolua_isnoobj(tolua_S,3,&tolua_err)
00752  )
00753   goto tolua_lerror;
00754  else
00755 #endif
00756  {
00757   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00758   const float new_zmp_offset_forward = ((const float)  tolua_tonumber(tolua_S,2,0));
00759 #ifndef TOLUA_RELEASE
00760   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_zmp_offset_forward'", NULL);
00761 #endif
00762   {
00763    self->set_zmp_offset_forward(new_zmp_offset_forward);
00764   }
00765  }
00766  return 0;
00767 #ifndef TOLUA_RELEASE
00768  tolua_lerror:
00769  tolua_error(tolua_S,"#ferror in function 'set_zmp_offset_forward'.",&tolua_err);
00770  return 0;
00771 #endif
00772 }
00773 #endif //#ifndef TOLUA_DISABLE
00774 
00775 /* method: maxlenof_zmp_offset_forward of class  SetWalkParamsMessage */
00776 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_zmp_offset_forward00
00777 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_zmp_offset_forward00(lua_State* tolua_S)
00778 {
00779 #ifndef TOLUA_RELEASE
00780  tolua_Error tolua_err;
00781  if (
00782      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00783      !tolua_isnoobj(tolua_S,2,&tolua_err)
00784  )
00785   goto tolua_lerror;
00786  else
00787 #endif
00788  {
00789   const fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00790 #ifndef TOLUA_RELEASE
00791   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_zmp_offset_forward'", NULL);
00792 #endif
00793   {
00794    int tolua_ret = (int)  self->maxlenof_zmp_offset_forward();
00795    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00796   }
00797  }
00798  return 1;
00799 #ifndef TOLUA_RELEASE
00800  tolua_lerror:
00801  tolua_error(tolua_S,"#ferror in function 'maxlenof_zmp_offset_forward'.",&tolua_err);
00802  return 0;
00803 #endif
00804 }
00805 #endif //#ifndef TOLUA_DISABLE
00806 
00807 /* method: zmp_offset_sideward of class  SetWalkParamsMessage */
00808 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_zmp_offset_sideward00
00809 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_zmp_offset_sideward00(lua_State* tolua_S)
00810 {
00811 #ifndef TOLUA_RELEASE
00812  tolua_Error tolua_err;
00813  if (
00814      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00815      !tolua_isnoobj(tolua_S,2,&tolua_err)
00816  )
00817   goto tolua_lerror;
00818  else
00819 #endif
00820  {
00821   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00822 #ifndef TOLUA_RELEASE
00823   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'zmp_offset_sideward'", NULL);
00824 #endif
00825   {
00826    float tolua_ret = (float)  self->zmp_offset_sideward();
00827    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00828   }
00829  }
00830  return 1;
00831 #ifndef TOLUA_RELEASE
00832  tolua_lerror:
00833  tolua_error(tolua_S,"#ferror in function 'zmp_offset_sideward'.",&tolua_err);
00834  return 0;
00835 #endif
00836 }
00837 #endif //#ifndef TOLUA_DISABLE
00838 
00839 /* method: set_zmp_offset_sideward of class  SetWalkParamsMessage */
00840 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_zmp_offset_sideward00
00841 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_zmp_offset_sideward00(lua_State* tolua_S)
00842 {
00843 #ifndef TOLUA_RELEASE
00844  tolua_Error tolua_err;
00845  if (
00846      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00847      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00848      !tolua_isnoobj(tolua_S,3,&tolua_err)
00849  )
00850   goto tolua_lerror;
00851  else
00852 #endif
00853  {
00854   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00855   const float new_zmp_offset_sideward = ((const float)  tolua_tonumber(tolua_S,2,0));
00856 #ifndef TOLUA_RELEASE
00857   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_zmp_offset_sideward'", NULL);
00858 #endif
00859   {
00860    self->set_zmp_offset_sideward(new_zmp_offset_sideward);
00861   }
00862  }
00863  return 0;
00864 #ifndef TOLUA_RELEASE
00865  tolua_lerror:
00866  tolua_error(tolua_S,"#ferror in function 'set_zmp_offset_sideward'.",&tolua_err);
00867  return 0;
00868 #endif
00869 }
00870 #endif //#ifndef TOLUA_DISABLE
00871 
00872 /* method: maxlenof_zmp_offset_sideward of class  SetWalkParamsMessage */
00873 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_zmp_offset_sideward00
00874 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_zmp_offset_sideward00(lua_State* tolua_S)
00875 {
00876 #ifndef TOLUA_RELEASE
00877  tolua_Error tolua_err;
00878  if (
00879      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00880      !tolua_isnoobj(tolua_S,2,&tolua_err)
00881  )
00882   goto tolua_lerror;
00883  else
00884 #endif
00885  {
00886   const fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00887 #ifndef TOLUA_RELEASE
00888   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_zmp_offset_sideward'", NULL);
00889 #endif
00890   {
00891    int tolua_ret = (int)  self->maxlenof_zmp_offset_sideward();
00892    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00893   }
00894  }
00895  return 1;
00896 #ifndef TOLUA_RELEASE
00897  tolua_lerror:
00898  tolua_error(tolua_S,"#ferror in function 'maxlenof_zmp_offset_sideward'.",&tolua_err);
00899  return 0;
00900 #endif
00901 }
00902 #endif //#ifndef TOLUA_DISABLE
00903 
00904 /* method: l_hip_roll_compensation of class  SetWalkParamsMessage */
00905 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_l_hip_roll_compensation00
00906 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_l_hip_roll_compensation00(lua_State* tolua_S)
00907 {
00908 #ifndef TOLUA_RELEASE
00909  tolua_Error tolua_err;
00910  if (
00911      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00912      !tolua_isnoobj(tolua_S,2,&tolua_err)
00913  )
00914   goto tolua_lerror;
00915  else
00916 #endif
00917  {
00918   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00919 #ifndef TOLUA_RELEASE
00920   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'l_hip_roll_compensation'", NULL);
00921 #endif
00922   {
00923    float tolua_ret = (float)  self->l_hip_roll_compensation();
00924    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00925   }
00926  }
00927  return 1;
00928 #ifndef TOLUA_RELEASE
00929  tolua_lerror:
00930  tolua_error(tolua_S,"#ferror in function 'l_hip_roll_compensation'.",&tolua_err);
00931  return 0;
00932 #endif
00933 }
00934 #endif //#ifndef TOLUA_DISABLE
00935 
00936 /* method: set_l_hip_roll_compensation of class  SetWalkParamsMessage */
00937 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_l_hip_roll_compensation00
00938 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_l_hip_roll_compensation00(lua_State* tolua_S)
00939 {
00940 #ifndef TOLUA_RELEASE
00941  tolua_Error tolua_err;
00942  if (
00943      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00944      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00945      !tolua_isnoobj(tolua_S,3,&tolua_err)
00946  )
00947   goto tolua_lerror;
00948  else
00949 #endif
00950  {
00951   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00952   const float new_l_hip_roll_compensation = ((const float)  tolua_tonumber(tolua_S,2,0));
00953 #ifndef TOLUA_RELEASE
00954   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_l_hip_roll_compensation'", NULL);
00955 #endif
00956   {
00957    self->set_l_hip_roll_compensation(new_l_hip_roll_compensation);
00958   }
00959  }
00960  return 0;
00961 #ifndef TOLUA_RELEASE
00962  tolua_lerror:
00963  tolua_error(tolua_S,"#ferror in function 'set_l_hip_roll_compensation'.",&tolua_err);
00964  return 0;
00965 #endif
00966 }
00967 #endif //#ifndef TOLUA_DISABLE
00968 
00969 /* method: maxlenof_l_hip_roll_compensation of class  SetWalkParamsMessage */
00970 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_l_hip_roll_compensation00
00971 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_l_hip_roll_compensation00(lua_State* tolua_S)
00972 {
00973 #ifndef TOLUA_RELEASE
00974  tolua_Error tolua_err;
00975  if (
00976      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
00977      !tolua_isnoobj(tolua_S,2,&tolua_err)
00978  )
00979   goto tolua_lerror;
00980  else
00981 #endif
00982  {
00983   const fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
00984 #ifndef TOLUA_RELEASE
00985   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_l_hip_roll_compensation'", NULL);
00986 #endif
00987   {
00988    int tolua_ret = (int)  self->maxlenof_l_hip_roll_compensation();
00989    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00990   }
00991  }
00992  return 1;
00993 #ifndef TOLUA_RELEASE
00994  tolua_lerror:
00995  tolua_error(tolua_S,"#ferror in function 'maxlenof_l_hip_roll_compensation'.",&tolua_err);
00996  return 0;
00997 #endif
00998 }
00999 #endif //#ifndef TOLUA_DISABLE
01000 
01001 /* method: r_hip_roll_compensation of class  SetWalkParamsMessage */
01002 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_r_hip_roll_compensation00
01003 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_r_hip_roll_compensation00(lua_State* tolua_S)
01004 {
01005 #ifndef TOLUA_RELEASE
01006  tolua_Error tolua_err;
01007  if (
01008      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
01009      !tolua_isnoobj(tolua_S,2,&tolua_err)
01010  )
01011   goto tolua_lerror;
01012  else
01013 #endif
01014  {
01015   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01016 #ifndef TOLUA_RELEASE
01017   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'r_hip_roll_compensation'", NULL);
01018 #endif
01019   {
01020    float tolua_ret = (float)  self->r_hip_roll_compensation();
01021    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01022   }
01023  }
01024  return 1;
01025 #ifndef TOLUA_RELEASE
01026  tolua_lerror:
01027  tolua_error(tolua_S,"#ferror in function 'r_hip_roll_compensation'.",&tolua_err);
01028  return 0;
01029 #endif
01030 }
01031 #endif //#ifndef TOLUA_DISABLE
01032 
01033 /* method: set_r_hip_roll_compensation of class  SetWalkParamsMessage */
01034 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_r_hip_roll_compensation00
01035 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_r_hip_roll_compensation00(lua_State* tolua_S)
01036 {
01037 #ifndef TOLUA_RELEASE
01038  tolua_Error tolua_err;
01039  if (
01040      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
01041      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01042      !tolua_isnoobj(tolua_S,3,&tolua_err)
01043  )
01044   goto tolua_lerror;
01045  else
01046 #endif
01047  {
01048   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01049   const float new_r_hip_roll_compensation = ((const float)  tolua_tonumber(tolua_S,2,0));
01050 #ifndef TOLUA_RELEASE
01051   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_r_hip_roll_compensation'", NULL);
01052 #endif
01053   {
01054    self->set_r_hip_roll_compensation(new_r_hip_roll_compensation);
01055   }
01056  }
01057  return 0;
01058 #ifndef TOLUA_RELEASE
01059  tolua_lerror:
01060  tolua_error(tolua_S,"#ferror in function 'set_r_hip_roll_compensation'.",&tolua_err);
01061  return 0;
01062 #endif
01063 }
01064 #endif //#ifndef TOLUA_DISABLE
01065 
01066 /* method: maxlenof_r_hip_roll_compensation of class  SetWalkParamsMessage */
01067 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_r_hip_roll_compensation00
01068 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_r_hip_roll_compensation00(lua_State* tolua_S)
01069 {
01070 #ifndef TOLUA_RELEASE
01071  tolua_Error tolua_err;
01072  if (
01073      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
01074      !tolua_isnoobj(tolua_S,2,&tolua_err)
01075  )
01076   goto tolua_lerror;
01077  else
01078 #endif
01079  {
01080   const fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01081 #ifndef TOLUA_RELEASE
01082   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_r_hip_roll_compensation'", NULL);
01083 #endif
01084   {
01085    int tolua_ret = (int)  self->maxlenof_r_hip_roll_compensation();
01086    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01087   }
01088  }
01089  return 1;
01090 #ifndef TOLUA_RELEASE
01091  tolua_lerror:
01092  tolua_error(tolua_S,"#ferror in function 'maxlenof_r_hip_roll_compensation'.",&tolua_err);
01093  return 0;
01094 #endif
01095 }
01096 #endif //#ifndef TOLUA_DISABLE
01097 
01098 /* method: hip_height of class  SetWalkParamsMessage */
01099 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_hip_height00
01100 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_hip_height00(lua_State* tolua_S)
01101 {
01102 #ifndef TOLUA_RELEASE
01103  tolua_Error tolua_err;
01104  if (
01105      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
01106      !tolua_isnoobj(tolua_S,2,&tolua_err)
01107  )
01108   goto tolua_lerror;
01109  else
01110 #endif
01111  {
01112   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01113 #ifndef TOLUA_RELEASE
01114   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hip_height'", NULL);
01115 #endif
01116   {
01117    float tolua_ret = (float)  self->hip_height();
01118    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01119   }
01120  }
01121  return 1;
01122 #ifndef TOLUA_RELEASE
01123  tolua_lerror:
01124  tolua_error(tolua_S,"#ferror in function 'hip_height'.",&tolua_err);
01125  return 0;
01126 #endif
01127 }
01128 #endif //#ifndef TOLUA_DISABLE
01129 
01130 /* method: set_hip_height of class  SetWalkParamsMessage */
01131 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_hip_height00
01132 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_hip_height00(lua_State* tolua_S)
01133 {
01134 #ifndef TOLUA_RELEASE
01135  tolua_Error tolua_err;
01136  if (
01137      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
01138      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01139      !tolua_isnoobj(tolua_S,3,&tolua_err)
01140  )
01141   goto tolua_lerror;
01142  else
01143 #endif
01144  {
01145   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01146   const float new_hip_height = ((const float)  tolua_tonumber(tolua_S,2,0));
01147 #ifndef TOLUA_RELEASE
01148   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_hip_height'", NULL);
01149 #endif
01150   {
01151    self->set_hip_height(new_hip_height);
01152   }
01153  }
01154  return 0;
01155 #ifndef TOLUA_RELEASE
01156  tolua_lerror:
01157  tolua_error(tolua_S,"#ferror in function 'set_hip_height'.",&tolua_err);
01158  return 0;
01159 #endif
01160 }
01161 #endif //#ifndef TOLUA_DISABLE
01162 
01163 /* method: maxlenof_hip_height of class  SetWalkParamsMessage */
01164 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_hip_height00
01165 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_hip_height00(lua_State* tolua_S)
01166 {
01167 #ifndef TOLUA_RELEASE
01168  tolua_Error tolua_err;
01169  if (
01170      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
01171      !tolua_isnoobj(tolua_S,2,&tolua_err)
01172  )
01173   goto tolua_lerror;
01174  else
01175 #endif
01176  {
01177   const fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01178 #ifndef TOLUA_RELEASE
01179   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_hip_height'", NULL);
01180 #endif
01181   {
01182    int tolua_ret = (int)  self->maxlenof_hip_height();
01183    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01184   }
01185  }
01186  return 1;
01187 #ifndef TOLUA_RELEASE
01188  tolua_lerror:
01189  tolua_error(tolua_S,"#ferror in function 'maxlenof_hip_height'.",&tolua_err);
01190  return 0;
01191 #endif
01192 }
01193 #endif //#ifndef TOLUA_DISABLE
01194 
01195 /* method: torso_sideward_orientation of class  SetWalkParamsMessage */
01196 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_torso_sideward_orientation00
01197 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_torso_sideward_orientation00(lua_State* tolua_S)
01198 {
01199 #ifndef TOLUA_RELEASE
01200  tolua_Error tolua_err;
01201  if (
01202      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
01203      !tolua_isnoobj(tolua_S,2,&tolua_err)
01204  )
01205   goto tolua_lerror;
01206  else
01207 #endif
01208  {
01209   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01210 #ifndef TOLUA_RELEASE
01211   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'torso_sideward_orientation'", NULL);
01212 #endif
01213   {
01214    float tolua_ret = (float)  self->torso_sideward_orientation();
01215    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01216   }
01217  }
01218  return 1;
01219 #ifndef TOLUA_RELEASE
01220  tolua_lerror:
01221  tolua_error(tolua_S,"#ferror in function 'torso_sideward_orientation'.",&tolua_err);
01222  return 0;
01223 #endif
01224 }
01225 #endif //#ifndef TOLUA_DISABLE
01226 
01227 /* method: set_torso_sideward_orientation of class  SetWalkParamsMessage */
01228 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_torso_sideward_orientation00
01229 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_torso_sideward_orientation00(lua_State* tolua_S)
01230 {
01231 #ifndef TOLUA_RELEASE
01232  tolua_Error tolua_err;
01233  if (
01234      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
01235      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01236      !tolua_isnoobj(tolua_S,3,&tolua_err)
01237  )
01238   goto tolua_lerror;
01239  else
01240 #endif
01241  {
01242   fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01243   const float new_torso_sideward_orientation = ((const float)  tolua_tonumber(tolua_S,2,0));
01244 #ifndef TOLUA_RELEASE
01245   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_torso_sideward_orientation'", NULL);
01246 #endif
01247   {
01248    self->set_torso_sideward_orientation(new_torso_sideward_orientation);
01249   }
01250  }
01251  return 0;
01252 #ifndef TOLUA_RELEASE
01253  tolua_lerror:
01254  tolua_error(tolua_S,"#ferror in function 'set_torso_sideward_orientation'.",&tolua_err);
01255  return 0;
01256 #endif
01257 }
01258 #endif //#ifndef TOLUA_DISABLE
01259 
01260 /* method: maxlenof_torso_sideward_orientation of class  SetWalkParamsMessage */
01261 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_torso_sideward_orientation00
01262 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_torso_sideward_orientation00(lua_State* tolua_S)
01263 {
01264 #ifndef TOLUA_RELEASE
01265  tolua_Error tolua_err;
01266  if (
01267      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkParamsMessage",0,&tolua_err) ||
01268      !tolua_isnoobj(tolua_S,2,&tolua_err)
01269  )
01270   goto tolua_lerror;
01271  else
01272 #endif
01273  {
01274   const fawkes::HumanoidMotionInterface::SetWalkParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01275 #ifndef TOLUA_RELEASE
01276   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_torso_sideward_orientation'", NULL);
01277 #endif
01278   {
01279    int tolua_ret = (int)  self->maxlenof_torso_sideward_orientation();
01280    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01281   }
01282  }
01283  return 1;
01284 #ifndef TOLUA_RELEASE
01285  tolua_lerror:
01286  tolua_error(tolua_S,"#ferror in function 'maxlenof_torso_sideward_orientation'.",&tolua_err);
01287  return 0;
01288 #endif
01289 }
01290 #endif //#ifndef TOLUA_DISABLE
01291 
01292 /* method: new of class  SetWalkArmsParamsMessage */
01293 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new00
01294 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new00(lua_State* tolua_S)
01295 {
01296 #ifndef TOLUA_RELEASE
01297  tolua_Error tolua_err;
01298  if (
01299      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01300      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
01301      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01302      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01303      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
01304      !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
01305      !tolua_isnoobj(tolua_S,7,&tolua_err)
01306  )
01307   goto tolua_lerror;
01308  else
01309 #endif
01310  {
01311   bool ini_arms_enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
01312   float ini_shoulder_pitch_median = ((float)  tolua_tonumber(tolua_S,3,0));
01313   float ini_shoulder_pitch_amplitude = ((float)  tolua_tonumber(tolua_S,4,0));
01314   float ini_elbow_roll_median = ((float)  tolua_tonumber(tolua_S,5,0));
01315   float ini_elbow_roll_amplitude = ((float)  tolua_tonumber(tolua_S,6,0));
01316   {
01317    fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* tolua_ret = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage)(ini_arms_enabled,ini_shoulder_pitch_median,ini_shoulder_pitch_amplitude,ini_elbow_roll_median,ini_elbow_roll_amplitude));
01318     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage");
01319   }
01320  }
01321  return 1;
01322 #ifndef TOLUA_RELEASE
01323  tolua_lerror:
01324  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01325  return 0;
01326 #endif
01327 }
01328 #endif //#ifndef TOLUA_DISABLE
01329 
01330 /* method: new_local of class  SetWalkArmsParamsMessage */
01331 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new00_local
01332 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new00_local(lua_State* tolua_S)
01333 {
01334 #ifndef TOLUA_RELEASE
01335  tolua_Error tolua_err;
01336  if (
01337      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01338      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
01339      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01340      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01341      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
01342      !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
01343      !tolua_isnoobj(tolua_S,7,&tolua_err)
01344  )
01345   goto tolua_lerror;
01346  else
01347 #endif
01348  {
01349   bool ini_arms_enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
01350   float ini_shoulder_pitch_median = ((float)  tolua_tonumber(tolua_S,3,0));
01351   float ini_shoulder_pitch_amplitude = ((float)  tolua_tonumber(tolua_S,4,0));
01352   float ini_elbow_roll_median = ((float)  tolua_tonumber(tolua_S,5,0));
01353   float ini_elbow_roll_amplitude = ((float)  tolua_tonumber(tolua_S,6,0));
01354   {
01355    fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* tolua_ret = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage)(ini_arms_enabled,ini_shoulder_pitch_median,ini_shoulder_pitch_amplitude,ini_elbow_roll_median,ini_elbow_roll_amplitude));
01356     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage");
01357     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01358   }
01359  }
01360  return 1;
01361 #ifndef TOLUA_RELEASE
01362  tolua_lerror:
01363  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01364  return 0;
01365 #endif
01366 }
01367 #endif //#ifndef TOLUA_DISABLE
01368 
01369 /* method: new of class  SetWalkArmsParamsMessage */
01370 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new01
01371 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new01(lua_State* tolua_S)
01372 {
01373  tolua_Error tolua_err;
01374  if (
01375      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01376      !tolua_isnoobj(tolua_S,2,&tolua_err)
01377  )
01378   goto tolua_lerror;
01379  else
01380  {
01381   {
01382    fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* tolua_ret = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage)());
01383     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage");
01384   }
01385  }
01386  return 1;
01387 tolua_lerror:
01388  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new00(tolua_S);
01389 }
01390 #endif //#ifndef TOLUA_DISABLE
01391 
01392 /* method: new_local of class  SetWalkArmsParamsMessage */
01393 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new01_local
01394 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new01_local(lua_State* tolua_S)
01395 {
01396  tolua_Error tolua_err;
01397  if (
01398      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01399      !tolua_isnoobj(tolua_S,2,&tolua_err)
01400  )
01401   goto tolua_lerror;
01402  else
01403  {
01404   {
01405    fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* tolua_ret = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage)());
01406     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage");
01407     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01408   }
01409  }
01410  return 1;
01411 tolua_lerror:
01412  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new00_local(tolua_S);
01413 }
01414 #endif //#ifndef TOLUA_DISABLE
01415 
01416 /* method: delete of class  SetWalkArmsParamsMessage */
01417 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_delete00
01418 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_delete00(lua_State* tolua_S)
01419 {
01420 #ifndef TOLUA_RELEASE
01421  tolua_Error tolua_err;
01422  if (
01423      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01424      !tolua_isnoobj(tolua_S,2,&tolua_err)
01425  )
01426   goto tolua_lerror;
01427  else
01428 #endif
01429  {
01430   fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01431 #ifndef TOLUA_RELEASE
01432   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01433 #endif
01434   Mtolua_delete(self);
01435  }
01436  return 0;
01437 #ifndef TOLUA_RELEASE
01438  tolua_lerror:
01439  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01440  return 0;
01441 #endif
01442 }
01443 #endif //#ifndef TOLUA_DISABLE
01444 
01445 /* method: is_arms_enabled of class  SetWalkArmsParamsMessage */
01446 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_is_arms_enabled00
01447 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_is_arms_enabled00(lua_State* tolua_S)
01448 {
01449 #ifndef TOLUA_RELEASE
01450  tolua_Error tolua_err;
01451  if (
01452      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01453      !tolua_isnoobj(tolua_S,2,&tolua_err)
01454  )
01455   goto tolua_lerror;
01456  else
01457 #endif
01458  {
01459   fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01460 #ifndef TOLUA_RELEASE
01461   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_arms_enabled'", NULL);
01462 #endif
01463   {
01464    bool tolua_ret = (bool)  self->is_arms_enabled();
01465    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01466   }
01467  }
01468  return 1;
01469 #ifndef TOLUA_RELEASE
01470  tolua_lerror:
01471  tolua_error(tolua_S,"#ferror in function 'is_arms_enabled'.",&tolua_err);
01472  return 0;
01473 #endif
01474 }
01475 #endif //#ifndef TOLUA_DISABLE
01476 
01477 /* method: set_arms_enabled of class  SetWalkArmsParamsMessage */
01478 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_arms_enabled00
01479 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_arms_enabled00(lua_State* tolua_S)
01480 {
01481 #ifndef TOLUA_RELEASE
01482  tolua_Error tolua_err;
01483  if (
01484      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01485      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
01486      !tolua_isnoobj(tolua_S,3,&tolua_err)
01487  )
01488   goto tolua_lerror;
01489  else
01490 #endif
01491  {
01492   fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01493   const bool new_arms_enabled = ((const bool)  tolua_toboolean(tolua_S,2,0));
01494 #ifndef TOLUA_RELEASE
01495   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_arms_enabled'", NULL);
01496 #endif
01497   {
01498    self->set_arms_enabled(new_arms_enabled);
01499   }
01500  }
01501  return 0;
01502 #ifndef TOLUA_RELEASE
01503  tolua_lerror:
01504  tolua_error(tolua_S,"#ferror in function 'set_arms_enabled'.",&tolua_err);
01505  return 0;
01506 #endif
01507 }
01508 #endif //#ifndef TOLUA_DISABLE
01509 
01510 /* method: maxlenof_arms_enabled of class  SetWalkArmsParamsMessage */
01511 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_arms_enabled00
01512 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_arms_enabled00(lua_State* tolua_S)
01513 {
01514 #ifndef TOLUA_RELEASE
01515  tolua_Error tolua_err;
01516  if (
01517      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01518      !tolua_isnoobj(tolua_S,2,&tolua_err)
01519  )
01520   goto tolua_lerror;
01521  else
01522 #endif
01523  {
01524   const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01525 #ifndef TOLUA_RELEASE
01526   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_arms_enabled'", NULL);
01527 #endif
01528   {
01529    int tolua_ret = (int)  self->maxlenof_arms_enabled();
01530    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01531   }
01532  }
01533  return 1;
01534 #ifndef TOLUA_RELEASE
01535  tolua_lerror:
01536  tolua_error(tolua_S,"#ferror in function 'maxlenof_arms_enabled'.",&tolua_err);
01537  return 0;
01538 #endif
01539 }
01540 #endif //#ifndef TOLUA_DISABLE
01541 
01542 /* method: shoulder_pitch_median of class  SetWalkArmsParamsMessage */
01543 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_shoulder_pitch_median00
01544 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_shoulder_pitch_median00(lua_State* tolua_S)
01545 {
01546 #ifndef TOLUA_RELEASE
01547  tolua_Error tolua_err;
01548  if (
01549      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01550      !tolua_isnoobj(tolua_S,2,&tolua_err)
01551  )
01552   goto tolua_lerror;
01553  else
01554 #endif
01555  {
01556   fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01557 #ifndef TOLUA_RELEASE
01558   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'shoulder_pitch_median'", NULL);
01559 #endif
01560   {
01561    float tolua_ret = (float)  self->shoulder_pitch_median();
01562    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01563   }
01564  }
01565  return 1;
01566 #ifndef TOLUA_RELEASE
01567  tolua_lerror:
01568  tolua_error(tolua_S,"#ferror in function 'shoulder_pitch_median'.",&tolua_err);
01569  return 0;
01570 #endif
01571 }
01572 #endif //#ifndef TOLUA_DISABLE
01573 
01574 /* method: set_shoulder_pitch_median of class  SetWalkArmsParamsMessage */
01575 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_shoulder_pitch_median00
01576 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_shoulder_pitch_median00(lua_State* tolua_S)
01577 {
01578 #ifndef TOLUA_RELEASE
01579  tolua_Error tolua_err;
01580  if (
01581      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01582      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01583      !tolua_isnoobj(tolua_S,3,&tolua_err)
01584  )
01585   goto tolua_lerror;
01586  else
01587 #endif
01588  {
01589   fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01590   const float new_shoulder_pitch_median = ((const float)  tolua_tonumber(tolua_S,2,0));
01591 #ifndef TOLUA_RELEASE
01592   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_shoulder_pitch_median'", NULL);
01593 #endif
01594   {
01595    self->set_shoulder_pitch_median(new_shoulder_pitch_median);
01596   }
01597  }
01598  return 0;
01599 #ifndef TOLUA_RELEASE
01600  tolua_lerror:
01601  tolua_error(tolua_S,"#ferror in function 'set_shoulder_pitch_median'.",&tolua_err);
01602  return 0;
01603 #endif
01604 }
01605 #endif //#ifndef TOLUA_DISABLE
01606 
01607 /* method: maxlenof_shoulder_pitch_median of class  SetWalkArmsParamsMessage */
01608 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_shoulder_pitch_median00
01609 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_shoulder_pitch_median00(lua_State* tolua_S)
01610 {
01611 #ifndef TOLUA_RELEASE
01612  tolua_Error tolua_err;
01613  if (
01614      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01615      !tolua_isnoobj(tolua_S,2,&tolua_err)
01616  )
01617   goto tolua_lerror;
01618  else
01619 #endif
01620  {
01621   const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01622 #ifndef TOLUA_RELEASE
01623   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_shoulder_pitch_median'", NULL);
01624 #endif
01625   {
01626    int tolua_ret = (int)  self->maxlenof_shoulder_pitch_median();
01627    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01628   }
01629  }
01630  return 1;
01631 #ifndef TOLUA_RELEASE
01632  tolua_lerror:
01633  tolua_error(tolua_S,"#ferror in function 'maxlenof_shoulder_pitch_median'.",&tolua_err);
01634  return 0;
01635 #endif
01636 }
01637 #endif //#ifndef TOLUA_DISABLE
01638 
01639 /* method: shoulder_pitch_amplitude of class  SetWalkArmsParamsMessage */
01640 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_shoulder_pitch_amplitude00
01641 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_shoulder_pitch_amplitude00(lua_State* tolua_S)
01642 {
01643 #ifndef TOLUA_RELEASE
01644  tolua_Error tolua_err;
01645  if (
01646      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01647      !tolua_isnoobj(tolua_S,2,&tolua_err)
01648  )
01649   goto tolua_lerror;
01650  else
01651 #endif
01652  {
01653   fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01654 #ifndef TOLUA_RELEASE
01655   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'shoulder_pitch_amplitude'", NULL);
01656 #endif
01657   {
01658    float tolua_ret = (float)  self->shoulder_pitch_amplitude();
01659    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01660   }
01661  }
01662  return 1;
01663 #ifndef TOLUA_RELEASE
01664  tolua_lerror:
01665  tolua_error(tolua_S,"#ferror in function 'shoulder_pitch_amplitude'.",&tolua_err);
01666  return 0;
01667 #endif
01668 }
01669 #endif //#ifndef TOLUA_DISABLE
01670 
01671 /* method: set_shoulder_pitch_amplitude of class  SetWalkArmsParamsMessage */
01672 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_shoulder_pitch_amplitude00
01673 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_shoulder_pitch_amplitude00(lua_State* tolua_S)
01674 {
01675 #ifndef TOLUA_RELEASE
01676  tolua_Error tolua_err;
01677  if (
01678      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01679      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01680      !tolua_isnoobj(tolua_S,3,&tolua_err)
01681  )
01682   goto tolua_lerror;
01683  else
01684 #endif
01685  {
01686   fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01687   const float new_shoulder_pitch_amplitude = ((const float)  tolua_tonumber(tolua_S,2,0));
01688 #ifndef TOLUA_RELEASE
01689   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_shoulder_pitch_amplitude'", NULL);
01690 #endif
01691   {
01692    self->set_shoulder_pitch_amplitude(new_shoulder_pitch_amplitude);
01693   }
01694  }
01695  return 0;
01696 #ifndef TOLUA_RELEASE
01697  tolua_lerror:
01698  tolua_error(tolua_S,"#ferror in function 'set_shoulder_pitch_amplitude'.",&tolua_err);
01699  return 0;
01700 #endif
01701 }
01702 #endif //#ifndef TOLUA_DISABLE
01703 
01704 /* method: maxlenof_shoulder_pitch_amplitude of class  SetWalkArmsParamsMessage */
01705 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_shoulder_pitch_amplitude00
01706 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_shoulder_pitch_amplitude00(lua_State* tolua_S)
01707 {
01708 #ifndef TOLUA_RELEASE
01709  tolua_Error tolua_err;
01710  if (
01711      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01712      !tolua_isnoobj(tolua_S,2,&tolua_err)
01713  )
01714   goto tolua_lerror;
01715  else
01716 #endif
01717  {
01718   const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01719 #ifndef TOLUA_RELEASE
01720   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_shoulder_pitch_amplitude'", NULL);
01721 #endif
01722   {
01723    int tolua_ret = (int)  self->maxlenof_shoulder_pitch_amplitude();
01724    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01725   }
01726  }
01727  return 1;
01728 #ifndef TOLUA_RELEASE
01729  tolua_lerror:
01730  tolua_error(tolua_S,"#ferror in function 'maxlenof_shoulder_pitch_amplitude'.",&tolua_err);
01731  return 0;
01732 #endif
01733 }
01734 #endif //#ifndef TOLUA_DISABLE
01735 
01736 /* method: elbow_roll_median of class  SetWalkArmsParamsMessage */
01737 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_elbow_roll_median00
01738 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_elbow_roll_median00(lua_State* tolua_S)
01739 {
01740 #ifndef TOLUA_RELEASE
01741  tolua_Error tolua_err;
01742  if (
01743      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01744      !tolua_isnoobj(tolua_S,2,&tolua_err)
01745  )
01746   goto tolua_lerror;
01747  else
01748 #endif
01749  {
01750   fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01751 #ifndef TOLUA_RELEASE
01752   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'elbow_roll_median'", NULL);
01753 #endif
01754   {
01755    float tolua_ret = (float)  self->elbow_roll_median();
01756    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01757   }
01758  }
01759  return 1;
01760 #ifndef TOLUA_RELEASE
01761  tolua_lerror:
01762  tolua_error(tolua_S,"#ferror in function 'elbow_roll_median'.",&tolua_err);
01763  return 0;
01764 #endif
01765 }
01766 #endif //#ifndef TOLUA_DISABLE
01767 
01768 /* method: set_elbow_roll_median of class  SetWalkArmsParamsMessage */
01769 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_elbow_roll_median00
01770 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_elbow_roll_median00(lua_State* tolua_S)
01771 {
01772 #ifndef TOLUA_RELEASE
01773  tolua_Error tolua_err;
01774  if (
01775      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01776      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01777      !tolua_isnoobj(tolua_S,3,&tolua_err)
01778  )
01779   goto tolua_lerror;
01780  else
01781 #endif
01782  {
01783   fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01784   const float new_elbow_roll_median = ((const float)  tolua_tonumber(tolua_S,2,0));
01785 #ifndef TOLUA_RELEASE
01786   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_elbow_roll_median'", NULL);
01787 #endif
01788   {
01789    self->set_elbow_roll_median(new_elbow_roll_median);
01790   }
01791  }
01792  return 0;
01793 #ifndef TOLUA_RELEASE
01794  tolua_lerror:
01795  tolua_error(tolua_S,"#ferror in function 'set_elbow_roll_median'.",&tolua_err);
01796  return 0;
01797 #endif
01798 }
01799 #endif //#ifndef TOLUA_DISABLE
01800 
01801 /* method: maxlenof_elbow_roll_median of class  SetWalkArmsParamsMessage */
01802 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_elbow_roll_median00
01803 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_elbow_roll_median00(lua_State* tolua_S)
01804 {
01805 #ifndef TOLUA_RELEASE
01806  tolua_Error tolua_err;
01807  if (
01808      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01809      !tolua_isnoobj(tolua_S,2,&tolua_err)
01810  )
01811   goto tolua_lerror;
01812  else
01813 #endif
01814  {
01815   const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01816 #ifndef TOLUA_RELEASE
01817   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_elbow_roll_median'", NULL);
01818 #endif
01819   {
01820    int tolua_ret = (int)  self->maxlenof_elbow_roll_median();
01821    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01822   }
01823  }
01824  return 1;
01825 #ifndef TOLUA_RELEASE
01826  tolua_lerror:
01827  tolua_error(tolua_S,"#ferror in function 'maxlenof_elbow_roll_median'.",&tolua_err);
01828  return 0;
01829 #endif
01830 }
01831 #endif //#ifndef TOLUA_DISABLE
01832 
01833 /* method: elbow_roll_amplitude of class  SetWalkArmsParamsMessage */
01834 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_elbow_roll_amplitude00
01835 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_elbow_roll_amplitude00(lua_State* tolua_S)
01836 {
01837 #ifndef TOLUA_RELEASE
01838  tolua_Error tolua_err;
01839  if (
01840      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01841      !tolua_isnoobj(tolua_S,2,&tolua_err)
01842  )
01843   goto tolua_lerror;
01844  else
01845 #endif
01846  {
01847   fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01848 #ifndef TOLUA_RELEASE
01849   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'elbow_roll_amplitude'", NULL);
01850 #endif
01851   {
01852    float tolua_ret = (float)  self->elbow_roll_amplitude();
01853    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01854   }
01855  }
01856  return 1;
01857 #ifndef TOLUA_RELEASE
01858  tolua_lerror:
01859  tolua_error(tolua_S,"#ferror in function 'elbow_roll_amplitude'.",&tolua_err);
01860  return 0;
01861 #endif
01862 }
01863 #endif //#ifndef TOLUA_DISABLE
01864 
01865 /* method: set_elbow_roll_amplitude of class  SetWalkArmsParamsMessage */
01866 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_elbow_roll_amplitude00
01867 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_elbow_roll_amplitude00(lua_State* tolua_S)
01868 {
01869 #ifndef TOLUA_RELEASE
01870  tolua_Error tolua_err;
01871  if (
01872      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01873      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01874      !tolua_isnoobj(tolua_S,3,&tolua_err)
01875  )
01876   goto tolua_lerror;
01877  else
01878 #endif
01879  {
01880   fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01881   const float new_elbow_roll_amplitude = ((const float)  tolua_tonumber(tolua_S,2,0));
01882 #ifndef TOLUA_RELEASE
01883   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_elbow_roll_amplitude'", NULL);
01884 #endif
01885   {
01886    self->set_elbow_roll_amplitude(new_elbow_roll_amplitude);
01887   }
01888  }
01889  return 0;
01890 #ifndef TOLUA_RELEASE
01891  tolua_lerror:
01892  tolua_error(tolua_S,"#ferror in function 'set_elbow_roll_amplitude'.",&tolua_err);
01893  return 0;
01894 #endif
01895 }
01896 #endif //#ifndef TOLUA_DISABLE
01897 
01898 /* method: maxlenof_elbow_roll_amplitude of class  SetWalkArmsParamsMessage */
01899 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_elbow_roll_amplitude00
01900 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_elbow_roll_amplitude00(lua_State* tolua_S)
01901 {
01902 #ifndef TOLUA_RELEASE
01903  tolua_Error tolua_err;
01904  if (
01905      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage",0,&tolua_err) ||
01906      !tolua_isnoobj(tolua_S,2,&tolua_err)
01907  )
01908   goto tolua_lerror;
01909  else
01910 #endif
01911  {
01912   const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage*)  tolua_tousertype(tolua_S,1,0);
01913 #ifndef TOLUA_RELEASE
01914   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_elbow_roll_amplitude'", NULL);
01915 #endif
01916   {
01917    int tolua_ret = (int)  self->maxlenof_elbow_roll_amplitude();
01918    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01919   }
01920  }
01921  return 1;
01922 #ifndef TOLUA_RELEASE
01923  tolua_lerror:
01924  tolua_error(tolua_S,"#ferror in function 'maxlenof_elbow_roll_amplitude'.",&tolua_err);
01925  return 0;
01926 #endif
01927 }
01928 #endif //#ifndef TOLUA_DISABLE
01929 
01930 /* method: new of class  StopMessage */
01931 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_new00
01932 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_new00(lua_State* tolua_S)
01933 {
01934 #ifndef TOLUA_RELEASE
01935  tolua_Error tolua_err;
01936  if (
01937      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::StopMessage",0,&tolua_err) ||
01938      !tolua_isnoobj(tolua_S,2,&tolua_err)
01939  )
01940   goto tolua_lerror;
01941  else
01942 #endif
01943  {
01944   {
01945    fawkes::HumanoidMotionInterface::StopMessage* tolua_ret = (fawkes::HumanoidMotionInterface::StopMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::StopMessage)());
01946     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::StopMessage");
01947   }
01948  }
01949  return 1;
01950 #ifndef TOLUA_RELEASE
01951  tolua_lerror:
01952  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01953  return 0;
01954 #endif
01955 }
01956 #endif //#ifndef TOLUA_DISABLE
01957 
01958 /* method: new_local of class  StopMessage */
01959 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_new00_local
01960 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_new00_local(lua_State* tolua_S)
01961 {
01962 #ifndef TOLUA_RELEASE
01963  tolua_Error tolua_err;
01964  if (
01965      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::StopMessage",0,&tolua_err) ||
01966      !tolua_isnoobj(tolua_S,2,&tolua_err)
01967  )
01968   goto tolua_lerror;
01969  else
01970 #endif
01971  {
01972   {
01973    fawkes::HumanoidMotionInterface::StopMessage* tolua_ret = (fawkes::HumanoidMotionInterface::StopMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::StopMessage)());
01974     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::StopMessage");
01975     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01976   }
01977  }
01978  return 1;
01979 #ifndef TOLUA_RELEASE
01980  tolua_lerror:
01981  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01982  return 0;
01983 #endif
01984 }
01985 #endif //#ifndef TOLUA_DISABLE
01986 
01987 /* method: delete of class  StopMessage */
01988 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_delete00
01989 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_delete00(lua_State* tolua_S)
01990 {
01991 #ifndef TOLUA_RELEASE
01992  tolua_Error tolua_err;
01993  if (
01994      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::StopMessage",0,&tolua_err) ||
01995      !tolua_isnoobj(tolua_S,2,&tolua_err)
01996  )
01997   goto tolua_lerror;
01998  else
01999 #endif
02000  {
02001   fawkes::HumanoidMotionInterface::StopMessage* self = (fawkes::HumanoidMotionInterface::StopMessage*)  tolua_tousertype(tolua_S,1,0);
02002 #ifndef TOLUA_RELEASE
02003   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
02004 #endif
02005   Mtolua_delete(self);
02006  }
02007  return 0;
02008 #ifndef TOLUA_RELEASE
02009  tolua_lerror:
02010  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02011  return 0;
02012 #endif
02013 }
02014 #endif //#ifndef TOLUA_DISABLE
02015 
02016 /* method: new of class  WalkStraightMessage */
02017 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00
02018 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00(lua_State* tolua_S)
02019 {
02020 #ifndef TOLUA_RELEASE
02021  tolua_Error tolua_err;
02022  if (
02023      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
02024      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02025      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02026      !tolua_isnoobj(tolua_S,4,&tolua_err)
02027  )
02028   goto tolua_lerror;
02029  else
02030 #endif
02031  {
02032   float ini_distance = ((float)  tolua_tonumber(tolua_S,2,0));
02033   unsigned int ini_num_samples = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
02034   {
02035    fawkes::HumanoidMotionInterface::WalkStraightMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkStraightMessage)(ini_distance,ini_num_samples));
02036     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkStraightMessage");
02037   }
02038  }
02039  return 1;
02040 #ifndef TOLUA_RELEASE
02041  tolua_lerror:
02042  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02043  return 0;
02044 #endif
02045 }
02046 #endif //#ifndef TOLUA_DISABLE
02047 
02048 /* method: new_local of class  WalkStraightMessage */
02049 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00_local
02050 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00_local(lua_State* tolua_S)
02051 {
02052 #ifndef TOLUA_RELEASE
02053  tolua_Error tolua_err;
02054  if (
02055      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
02056      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02057      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02058      !tolua_isnoobj(tolua_S,4,&tolua_err)
02059  )
02060   goto tolua_lerror;
02061  else
02062 #endif
02063  {
02064   float ini_distance = ((float)  tolua_tonumber(tolua_S,2,0));
02065   unsigned int ini_num_samples = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
02066   {
02067    fawkes::HumanoidMotionInterface::WalkStraightMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkStraightMessage)(ini_distance,ini_num_samples));
02068     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkStraightMessage");
02069     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02070   }
02071  }
02072  return 1;
02073 #ifndef TOLUA_RELEASE
02074  tolua_lerror:
02075  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02076  return 0;
02077 #endif
02078 }
02079 #endif //#ifndef TOLUA_DISABLE
02080 
02081 /* method: new of class  WalkStraightMessage */
02082 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new01
02083 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new01(lua_State* tolua_S)
02084 {
02085  tolua_Error tolua_err;
02086  if (
02087      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
02088      !tolua_isnoobj(tolua_S,2,&tolua_err)
02089  )
02090   goto tolua_lerror;
02091  else
02092  {
02093   {
02094    fawkes::HumanoidMotionInterface::WalkStraightMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkStraightMessage)());
02095     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkStraightMessage");
02096   }
02097  }
02098  return 1;
02099 tolua_lerror:
02100  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00(tolua_S);
02101 }
02102 #endif //#ifndef TOLUA_DISABLE
02103 
02104 /* method: new_local of class  WalkStraightMessage */
02105 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new01_local
02106 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new01_local(lua_State* tolua_S)
02107 {
02108  tolua_Error tolua_err;
02109  if (
02110      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
02111      !tolua_isnoobj(tolua_S,2,&tolua_err)
02112  )
02113   goto tolua_lerror;
02114  else
02115  {
02116   {
02117    fawkes::HumanoidMotionInterface::WalkStraightMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkStraightMessage)());
02118     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkStraightMessage");
02119     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02120   }
02121  }
02122  return 1;
02123 tolua_lerror:
02124  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00_local(tolua_S);
02125 }
02126 #endif //#ifndef TOLUA_DISABLE
02127 
02128 /* method: delete of class  WalkStraightMessage */
02129 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_delete00
02130 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_delete00(lua_State* tolua_S)
02131 {
02132 #ifndef TOLUA_RELEASE
02133  tolua_Error tolua_err;
02134  if (
02135      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
02136      !tolua_isnoobj(tolua_S,2,&tolua_err)
02137  )
02138   goto tolua_lerror;
02139  else
02140 #endif
02141  {
02142   fawkes::HumanoidMotionInterface::WalkStraightMessage* self = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  tolua_tousertype(tolua_S,1,0);
02143 #ifndef TOLUA_RELEASE
02144   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
02145 #endif
02146   Mtolua_delete(self);
02147  }
02148  return 0;
02149 #ifndef TOLUA_RELEASE
02150  tolua_lerror:
02151  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02152  return 0;
02153 #endif
02154 }
02155 #endif //#ifndef TOLUA_DISABLE
02156 
02157 /* method: distance of class  WalkStraightMessage */
02158 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_distance00
02159 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_distance00(lua_State* tolua_S)
02160 {
02161 #ifndef TOLUA_RELEASE
02162  tolua_Error tolua_err;
02163  if (
02164      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
02165      !tolua_isnoobj(tolua_S,2,&tolua_err)
02166  )
02167   goto tolua_lerror;
02168  else
02169 #endif
02170  {
02171   fawkes::HumanoidMotionInterface::WalkStraightMessage* self = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  tolua_tousertype(tolua_S,1,0);
02172 #ifndef TOLUA_RELEASE
02173   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'distance'", NULL);
02174 #endif
02175   {
02176    float tolua_ret = (float)  self->distance();
02177    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02178   }
02179  }
02180  return 1;
02181 #ifndef TOLUA_RELEASE
02182  tolua_lerror:
02183  tolua_error(tolua_S,"#ferror in function 'distance'.",&tolua_err);
02184  return 0;
02185 #endif
02186 }
02187 #endif //#ifndef TOLUA_DISABLE
02188 
02189 /* method: set_distance of class  WalkStraightMessage */
02190 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_set_distance00
02191 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_set_distance00(lua_State* tolua_S)
02192 {
02193 #ifndef TOLUA_RELEASE
02194  tolua_Error tolua_err;
02195  if (
02196      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
02197      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02198      !tolua_isnoobj(tolua_S,3,&tolua_err)
02199  )
02200   goto tolua_lerror;
02201  else
02202 #endif
02203  {
02204   fawkes::HumanoidMotionInterface::WalkStraightMessage* self = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  tolua_tousertype(tolua_S,1,0);
02205   const float new_distance = ((const float)  tolua_tonumber(tolua_S,2,0));
02206 #ifndef TOLUA_RELEASE
02207   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_distance'", NULL);
02208 #endif
02209   {
02210    self->set_distance(new_distance);
02211   }
02212  }
02213  return 0;
02214 #ifndef TOLUA_RELEASE
02215  tolua_lerror:
02216  tolua_error(tolua_S,"#ferror in function 'set_distance'.",&tolua_err);
02217  return 0;
02218 #endif
02219 }
02220 #endif //#ifndef TOLUA_DISABLE
02221 
02222 /* method: maxlenof_distance of class  WalkStraightMessage */
02223 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_maxlenof_distance00
02224 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_maxlenof_distance00(lua_State* tolua_S)
02225 {
02226 #ifndef TOLUA_RELEASE
02227  tolua_Error tolua_err;
02228  if (
02229      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
02230      !tolua_isnoobj(tolua_S,2,&tolua_err)
02231  )
02232   goto tolua_lerror;
02233  else
02234 #endif
02235  {
02236   const fawkes::HumanoidMotionInterface::WalkStraightMessage* self = (const fawkes::HumanoidMotionInterface::WalkStraightMessage*)  tolua_tousertype(tolua_S,1,0);
02237 #ifndef TOLUA_RELEASE
02238   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_distance'", NULL);
02239 #endif
02240   {
02241    int tolua_ret = (int)  self->maxlenof_distance();
02242    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02243   }
02244  }
02245  return 1;
02246 #ifndef TOLUA_RELEASE
02247  tolua_lerror:
02248  tolua_error(tolua_S,"#ferror in function 'maxlenof_distance'.",&tolua_err);
02249  return 0;
02250 #endif
02251 }
02252 #endif //#ifndef TOLUA_DISABLE
02253 
02254 /* method: num_samples of class  WalkStraightMessage */
02255 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_num_samples00
02256 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_num_samples00(lua_State* tolua_S)
02257 {
02258 #ifndef TOLUA_RELEASE
02259  tolua_Error tolua_err;
02260  if (
02261      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
02262      !tolua_isnoobj(tolua_S,2,&tolua_err)
02263  )
02264   goto tolua_lerror;
02265  else
02266 #endif
02267  {
02268   fawkes::HumanoidMotionInterface::WalkStraightMessage* self = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  tolua_tousertype(tolua_S,1,0);
02269 #ifndef TOLUA_RELEASE
02270   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_samples'", NULL);
02271 #endif
02272   {
02273    unsigned int tolua_ret = (unsigned int)  self->num_samples();
02274    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02275   }
02276  }
02277  return 1;
02278 #ifndef TOLUA_RELEASE
02279  tolua_lerror:
02280  tolua_error(tolua_S,"#ferror in function 'num_samples'.",&tolua_err);
02281  return 0;
02282 #endif
02283 }
02284 #endif //#ifndef TOLUA_DISABLE
02285 
02286 /* method: set_num_samples of class  WalkStraightMessage */
02287 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_set_num_samples00
02288 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_set_num_samples00(lua_State* tolua_S)
02289 {
02290 #ifndef TOLUA_RELEASE
02291  tolua_Error tolua_err;
02292  if (
02293      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
02294      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02295      !tolua_isnoobj(tolua_S,3,&tolua_err)
02296  )
02297   goto tolua_lerror;
02298  else
02299 #endif
02300  {
02301   fawkes::HumanoidMotionInterface::WalkStraightMessage* self = (fawkes::HumanoidMotionInterface::WalkStraightMessage*)  tolua_tousertype(tolua_S,1,0);
02302   unsigned const int new_num_samples = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
02303 #ifndef TOLUA_RELEASE
02304   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_num_samples'", NULL);
02305 #endif
02306   {
02307    self->set_num_samples(new_num_samples);
02308   }
02309  }
02310  return 0;
02311 #ifndef TOLUA_RELEASE
02312  tolua_lerror:
02313  tolua_error(tolua_S,"#ferror in function 'set_num_samples'.",&tolua_err);
02314  return 0;
02315 #endif
02316 }
02317 #endif //#ifndef TOLUA_DISABLE
02318 
02319 /* method: maxlenof_num_samples of class  WalkStraightMessage */
02320 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_maxlenof_num_samples00
02321 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_maxlenof_num_samples00(lua_State* tolua_S)
02322 {
02323 #ifndef TOLUA_RELEASE
02324  tolua_Error tolua_err;
02325  if (
02326      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkStraightMessage",0,&tolua_err) ||
02327      !tolua_isnoobj(tolua_S,2,&tolua_err)
02328  )
02329   goto tolua_lerror;
02330  else
02331 #endif
02332  {
02333   const fawkes::HumanoidMotionInterface::WalkStraightMessage* self = (const fawkes::HumanoidMotionInterface::WalkStraightMessage*)  tolua_tousertype(tolua_S,1,0);
02334 #ifndef TOLUA_RELEASE
02335   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_num_samples'", NULL);
02336 #endif
02337   {
02338    int tolua_ret = (int)  self->maxlenof_num_samples();
02339    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02340   }
02341  }
02342  return 1;
02343 #ifndef TOLUA_RELEASE
02344  tolua_lerror:
02345  tolua_error(tolua_S,"#ferror in function 'maxlenof_num_samples'.",&tolua_err);
02346  return 0;
02347 #endif
02348 }
02349 #endif //#ifndef TOLUA_DISABLE
02350 
02351 /* method: new of class  WalkSidewaysMessage */
02352 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00
02353 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00(lua_State* tolua_S)
02354 {
02355 #ifndef TOLUA_RELEASE
02356  tolua_Error tolua_err;
02357  if (
02358      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
02359      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02360      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02361      !tolua_isnoobj(tolua_S,4,&tolua_err)
02362  )
02363   goto tolua_lerror;
02364  else
02365 #endif
02366  {
02367   float ini_distance = ((float)  tolua_tonumber(tolua_S,2,0));
02368   unsigned int ini_num_samples = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
02369   {
02370    fawkes::HumanoidMotionInterface::WalkSidewaysMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkSidewaysMessage)(ini_distance,ini_num_samples));
02371     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage");
02372   }
02373  }
02374  return 1;
02375 #ifndef TOLUA_RELEASE
02376  tolua_lerror:
02377  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02378  return 0;
02379 #endif
02380 }
02381 #endif //#ifndef TOLUA_DISABLE
02382 
02383 /* method: new_local of class  WalkSidewaysMessage */
02384 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00_local
02385 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00_local(lua_State* tolua_S)
02386 {
02387 #ifndef TOLUA_RELEASE
02388  tolua_Error tolua_err;
02389  if (
02390      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
02391      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02392      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02393      !tolua_isnoobj(tolua_S,4,&tolua_err)
02394  )
02395   goto tolua_lerror;
02396  else
02397 #endif
02398  {
02399   float ini_distance = ((float)  tolua_tonumber(tolua_S,2,0));
02400   unsigned int ini_num_samples = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
02401   {
02402    fawkes::HumanoidMotionInterface::WalkSidewaysMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkSidewaysMessage)(ini_distance,ini_num_samples));
02403     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage");
02404     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02405   }
02406  }
02407  return 1;
02408 #ifndef TOLUA_RELEASE
02409  tolua_lerror:
02410  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02411  return 0;
02412 #endif
02413 }
02414 #endif //#ifndef TOLUA_DISABLE
02415 
02416 /* method: new of class  WalkSidewaysMessage */
02417 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new01
02418 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new01(lua_State* tolua_S)
02419 {
02420  tolua_Error tolua_err;
02421  if (
02422      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
02423      !tolua_isnoobj(tolua_S,2,&tolua_err)
02424  )
02425   goto tolua_lerror;
02426  else
02427  {
02428   {
02429    fawkes::HumanoidMotionInterface::WalkSidewaysMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkSidewaysMessage)());
02430     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage");
02431   }
02432  }
02433  return 1;
02434 tolua_lerror:
02435  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00(tolua_S);
02436 }
02437 #endif //#ifndef TOLUA_DISABLE
02438 
02439 /* method: new_local of class  WalkSidewaysMessage */
02440 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new01_local
02441 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new01_local(lua_State* tolua_S)
02442 {
02443  tolua_Error tolua_err;
02444  if (
02445      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
02446      !tolua_isnoobj(tolua_S,2,&tolua_err)
02447  )
02448   goto tolua_lerror;
02449  else
02450  {
02451   {
02452    fawkes::HumanoidMotionInterface::WalkSidewaysMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkSidewaysMessage)());
02453     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage");
02454     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02455   }
02456  }
02457  return 1;
02458 tolua_lerror:
02459  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00_local(tolua_S);
02460 }
02461 #endif //#ifndef TOLUA_DISABLE
02462 
02463 /* method: delete of class  WalkSidewaysMessage */
02464 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_delete00
02465 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_delete00(lua_State* tolua_S)
02466 {
02467 #ifndef TOLUA_RELEASE
02468  tolua_Error tolua_err;
02469  if (
02470      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
02471      !tolua_isnoobj(tolua_S,2,&tolua_err)
02472  )
02473   goto tolua_lerror;
02474  else
02475 #endif
02476  {
02477   fawkes::HumanoidMotionInterface::WalkSidewaysMessage* self = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  tolua_tousertype(tolua_S,1,0);
02478 #ifndef TOLUA_RELEASE
02479   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
02480 #endif
02481   Mtolua_delete(self);
02482  }
02483  return 0;
02484 #ifndef TOLUA_RELEASE
02485  tolua_lerror:
02486  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02487  return 0;
02488 #endif
02489 }
02490 #endif //#ifndef TOLUA_DISABLE
02491 
02492 /* method: distance of class  WalkSidewaysMessage */
02493 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_distance00
02494 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_distance00(lua_State* tolua_S)
02495 {
02496 #ifndef TOLUA_RELEASE
02497  tolua_Error tolua_err;
02498  if (
02499      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
02500      !tolua_isnoobj(tolua_S,2,&tolua_err)
02501  )
02502   goto tolua_lerror;
02503  else
02504 #endif
02505  {
02506   fawkes::HumanoidMotionInterface::WalkSidewaysMessage* self = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  tolua_tousertype(tolua_S,1,0);
02507 #ifndef TOLUA_RELEASE
02508   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'distance'", NULL);
02509 #endif
02510   {
02511    float tolua_ret = (float)  self->distance();
02512    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02513   }
02514  }
02515  return 1;
02516 #ifndef TOLUA_RELEASE
02517  tolua_lerror:
02518  tolua_error(tolua_S,"#ferror in function 'distance'.",&tolua_err);
02519  return 0;
02520 #endif
02521 }
02522 #endif //#ifndef TOLUA_DISABLE
02523 
02524 /* method: set_distance of class  WalkSidewaysMessage */
02525 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_set_distance00
02526 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_set_distance00(lua_State* tolua_S)
02527 {
02528 #ifndef TOLUA_RELEASE
02529  tolua_Error tolua_err;
02530  if (
02531      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
02532      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02533      !tolua_isnoobj(tolua_S,3,&tolua_err)
02534  )
02535   goto tolua_lerror;
02536  else
02537 #endif
02538  {
02539   fawkes::HumanoidMotionInterface::WalkSidewaysMessage* self = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  tolua_tousertype(tolua_S,1,0);
02540   const float new_distance = ((const float)  tolua_tonumber(tolua_S,2,0));
02541 #ifndef TOLUA_RELEASE
02542   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_distance'", NULL);
02543 #endif
02544   {
02545    self->set_distance(new_distance);
02546   }
02547  }
02548  return 0;
02549 #ifndef TOLUA_RELEASE
02550  tolua_lerror:
02551  tolua_error(tolua_S,"#ferror in function 'set_distance'.",&tolua_err);
02552  return 0;
02553 #endif
02554 }
02555 #endif //#ifndef TOLUA_DISABLE
02556 
02557 /* method: maxlenof_distance of class  WalkSidewaysMessage */
02558 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_maxlenof_distance00
02559 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_maxlenof_distance00(lua_State* tolua_S)
02560 {
02561 #ifndef TOLUA_RELEASE
02562  tolua_Error tolua_err;
02563  if (
02564      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
02565      !tolua_isnoobj(tolua_S,2,&tolua_err)
02566  )
02567   goto tolua_lerror;
02568  else
02569 #endif
02570  {
02571   const fawkes::HumanoidMotionInterface::WalkSidewaysMessage* self = (const fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  tolua_tousertype(tolua_S,1,0);
02572 #ifndef TOLUA_RELEASE
02573   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_distance'", NULL);
02574 #endif
02575   {
02576    int tolua_ret = (int)  self->maxlenof_distance();
02577    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02578   }
02579  }
02580  return 1;
02581 #ifndef TOLUA_RELEASE
02582  tolua_lerror:
02583  tolua_error(tolua_S,"#ferror in function 'maxlenof_distance'.",&tolua_err);
02584  return 0;
02585 #endif
02586 }
02587 #endif //#ifndef TOLUA_DISABLE
02588 
02589 /* method: num_samples of class  WalkSidewaysMessage */
02590 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_num_samples00
02591 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_num_samples00(lua_State* tolua_S)
02592 {
02593 #ifndef TOLUA_RELEASE
02594  tolua_Error tolua_err;
02595  if (
02596      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
02597      !tolua_isnoobj(tolua_S,2,&tolua_err)
02598  )
02599   goto tolua_lerror;
02600  else
02601 #endif
02602  {
02603   fawkes::HumanoidMotionInterface::WalkSidewaysMessage* self = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  tolua_tousertype(tolua_S,1,0);
02604 #ifndef TOLUA_RELEASE
02605   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_samples'", NULL);
02606 #endif
02607   {
02608    unsigned int tolua_ret = (unsigned int)  self->num_samples();
02609    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02610   }
02611  }
02612  return 1;
02613 #ifndef TOLUA_RELEASE
02614  tolua_lerror:
02615  tolua_error(tolua_S,"#ferror in function 'num_samples'.",&tolua_err);
02616  return 0;
02617 #endif
02618 }
02619 #endif //#ifndef TOLUA_DISABLE
02620 
02621 /* method: set_num_samples of class  WalkSidewaysMessage */
02622 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_set_num_samples00
02623 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_set_num_samples00(lua_State* tolua_S)
02624 {
02625 #ifndef TOLUA_RELEASE
02626  tolua_Error tolua_err;
02627  if (
02628      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
02629      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02630      !tolua_isnoobj(tolua_S,3,&tolua_err)
02631  )
02632   goto tolua_lerror;
02633  else
02634 #endif
02635  {
02636   fawkes::HumanoidMotionInterface::WalkSidewaysMessage* self = (fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  tolua_tousertype(tolua_S,1,0);
02637   unsigned const int new_num_samples = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
02638 #ifndef TOLUA_RELEASE
02639   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_num_samples'", NULL);
02640 #endif
02641   {
02642    self->set_num_samples(new_num_samples);
02643   }
02644  }
02645  return 0;
02646 #ifndef TOLUA_RELEASE
02647  tolua_lerror:
02648  tolua_error(tolua_S,"#ferror in function 'set_num_samples'.",&tolua_err);
02649  return 0;
02650 #endif
02651 }
02652 #endif //#ifndef TOLUA_DISABLE
02653 
02654 /* method: maxlenof_num_samples of class  WalkSidewaysMessage */
02655 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_maxlenof_num_samples00
02656 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_maxlenof_num_samples00(lua_State* tolua_S)
02657 {
02658 #ifndef TOLUA_RELEASE
02659  tolua_Error tolua_err;
02660  if (
02661      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkSidewaysMessage",0,&tolua_err) ||
02662      !tolua_isnoobj(tolua_S,2,&tolua_err)
02663  )
02664   goto tolua_lerror;
02665  else
02666 #endif
02667  {
02668   const fawkes::HumanoidMotionInterface::WalkSidewaysMessage* self = (const fawkes::HumanoidMotionInterface::WalkSidewaysMessage*)  tolua_tousertype(tolua_S,1,0);
02669 #ifndef TOLUA_RELEASE
02670   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_num_samples'", NULL);
02671 #endif
02672   {
02673    int tolua_ret = (int)  self->maxlenof_num_samples();
02674    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02675   }
02676  }
02677  return 1;
02678 #ifndef TOLUA_RELEASE
02679  tolua_lerror:
02680  tolua_error(tolua_S,"#ferror in function 'maxlenof_num_samples'.",&tolua_err);
02681  return 0;
02682 #endif
02683 }
02684 #endif //#ifndef TOLUA_DISABLE
02685 
02686 /* method: new of class  WalkArcMessage */
02687 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00
02688 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00(lua_State* tolua_S)
02689 {
02690 #ifndef TOLUA_RELEASE
02691  tolua_Error tolua_err;
02692  if (
02693      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
02694      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02695      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02696      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02697      !tolua_isnoobj(tolua_S,5,&tolua_err)
02698  )
02699   goto tolua_lerror;
02700  else
02701 #endif
02702  {
02703   float ini_angle = ((float)  tolua_tonumber(tolua_S,2,0));
02704   float ini_radius = ((float)  tolua_tonumber(tolua_S,3,0));
02705   unsigned int ini_num_samples = ((unsigned int)  tolua_tonumber(tolua_S,4,0));
02706   {
02707    fawkes::HumanoidMotionInterface::WalkArcMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkArcMessage)(ini_angle,ini_radius,ini_num_samples));
02708     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkArcMessage");
02709   }
02710  }
02711  return 1;
02712 #ifndef TOLUA_RELEASE
02713  tolua_lerror:
02714  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02715  return 0;
02716 #endif
02717 }
02718 #endif //#ifndef TOLUA_DISABLE
02719 
02720 /* method: new_local of class  WalkArcMessage */
02721 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00_local
02722 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00_local(lua_State* tolua_S)
02723 {
02724 #ifndef TOLUA_RELEASE
02725  tolua_Error tolua_err;
02726  if (
02727      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
02728      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02729      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02730      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02731      !tolua_isnoobj(tolua_S,5,&tolua_err)
02732  )
02733   goto tolua_lerror;
02734  else
02735 #endif
02736  {
02737   float ini_angle = ((float)  tolua_tonumber(tolua_S,2,0));
02738   float ini_radius = ((float)  tolua_tonumber(tolua_S,3,0));
02739   unsigned int ini_num_samples = ((unsigned int)  tolua_tonumber(tolua_S,4,0));
02740   {
02741    fawkes::HumanoidMotionInterface::WalkArcMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkArcMessage)(ini_angle,ini_radius,ini_num_samples));
02742     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkArcMessage");
02743     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02744   }
02745  }
02746  return 1;
02747 #ifndef TOLUA_RELEASE
02748  tolua_lerror:
02749  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02750  return 0;
02751 #endif
02752 }
02753 #endif //#ifndef TOLUA_DISABLE
02754 
02755 /* method: new of class  WalkArcMessage */
02756 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new01
02757 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new01(lua_State* tolua_S)
02758 {
02759  tolua_Error tolua_err;
02760  if (
02761      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
02762      !tolua_isnoobj(tolua_S,2,&tolua_err)
02763  )
02764   goto tolua_lerror;
02765  else
02766  {
02767   {
02768    fawkes::HumanoidMotionInterface::WalkArcMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkArcMessage)());
02769     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkArcMessage");
02770   }
02771  }
02772  return 1;
02773 tolua_lerror:
02774  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00(tolua_S);
02775 }
02776 #endif //#ifndef TOLUA_DISABLE
02777 
02778 /* method: new_local of class  WalkArcMessage */
02779 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new01_local
02780 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new01_local(lua_State* tolua_S)
02781 {
02782  tolua_Error tolua_err;
02783  if (
02784      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
02785      !tolua_isnoobj(tolua_S,2,&tolua_err)
02786  )
02787   goto tolua_lerror;
02788  else
02789  {
02790   {
02791    fawkes::HumanoidMotionInterface::WalkArcMessage* tolua_ret = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::WalkArcMessage)());
02792     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::WalkArcMessage");
02793     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02794   }
02795  }
02796  return 1;
02797 tolua_lerror:
02798  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00_local(tolua_S);
02799 }
02800 #endif //#ifndef TOLUA_DISABLE
02801 
02802 /* method: delete of class  WalkArcMessage */
02803 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_delete00
02804 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_delete00(lua_State* tolua_S)
02805 {
02806 #ifndef TOLUA_RELEASE
02807  tolua_Error tolua_err;
02808  if (
02809      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
02810      !tolua_isnoobj(tolua_S,2,&tolua_err)
02811  )
02812   goto tolua_lerror;
02813  else
02814 #endif
02815  {
02816   fawkes::HumanoidMotionInterface::WalkArcMessage* self = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
02817 #ifndef TOLUA_RELEASE
02818   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
02819 #endif
02820   Mtolua_delete(self);
02821  }
02822  return 0;
02823 #ifndef TOLUA_RELEASE
02824  tolua_lerror:
02825  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02826  return 0;
02827 #endif
02828 }
02829 #endif //#ifndef TOLUA_DISABLE
02830 
02831 /* method: angle of class  WalkArcMessage */
02832 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_angle00
02833 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_angle00(lua_State* tolua_S)
02834 {
02835 #ifndef TOLUA_RELEASE
02836  tolua_Error tolua_err;
02837  if (
02838      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
02839      !tolua_isnoobj(tolua_S,2,&tolua_err)
02840  )
02841   goto tolua_lerror;
02842  else
02843 #endif
02844  {
02845   fawkes::HumanoidMotionInterface::WalkArcMessage* self = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
02846 #ifndef TOLUA_RELEASE
02847   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'angle'", NULL);
02848 #endif
02849   {
02850    float tolua_ret = (float)  self->angle();
02851    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02852   }
02853  }
02854  return 1;
02855 #ifndef TOLUA_RELEASE
02856  tolua_lerror:
02857  tolua_error(tolua_S,"#ferror in function 'angle'.",&tolua_err);
02858  return 0;
02859 #endif
02860 }
02861 #endif //#ifndef TOLUA_DISABLE
02862 
02863 /* method: set_angle of class  WalkArcMessage */
02864 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_angle00
02865 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_angle00(lua_State* tolua_S)
02866 {
02867 #ifndef TOLUA_RELEASE
02868  tolua_Error tolua_err;
02869  if (
02870      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
02871      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02872      !tolua_isnoobj(tolua_S,3,&tolua_err)
02873  )
02874   goto tolua_lerror;
02875  else
02876 #endif
02877  {
02878   fawkes::HumanoidMotionInterface::WalkArcMessage* self = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
02879   const float new_angle = ((const float)  tolua_tonumber(tolua_S,2,0));
02880 #ifndef TOLUA_RELEASE
02881   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_angle'", NULL);
02882 #endif
02883   {
02884    self->set_angle(new_angle);
02885   }
02886  }
02887  return 0;
02888 #ifndef TOLUA_RELEASE
02889  tolua_lerror:
02890  tolua_error(tolua_S,"#ferror in function 'set_angle'.",&tolua_err);
02891  return 0;
02892 #endif
02893 }
02894 #endif //#ifndef TOLUA_DISABLE
02895 
02896 /* method: maxlenof_angle of class  WalkArcMessage */
02897 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_angle00
02898 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_angle00(lua_State* tolua_S)
02899 {
02900 #ifndef TOLUA_RELEASE
02901  tolua_Error tolua_err;
02902  if (
02903      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
02904      !tolua_isnoobj(tolua_S,2,&tolua_err)
02905  )
02906   goto tolua_lerror;
02907  else
02908 #endif
02909  {
02910   const fawkes::HumanoidMotionInterface::WalkArcMessage* self = (const fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
02911 #ifndef TOLUA_RELEASE
02912   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_angle'", NULL);
02913 #endif
02914   {
02915    int tolua_ret = (int)  self->maxlenof_angle();
02916    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02917   }
02918  }
02919  return 1;
02920 #ifndef TOLUA_RELEASE
02921  tolua_lerror:
02922  tolua_error(tolua_S,"#ferror in function 'maxlenof_angle'.",&tolua_err);
02923  return 0;
02924 #endif
02925 }
02926 #endif //#ifndef TOLUA_DISABLE
02927 
02928 /* method: radius of class  WalkArcMessage */
02929 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_radius00
02930 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_radius00(lua_State* tolua_S)
02931 {
02932 #ifndef TOLUA_RELEASE
02933  tolua_Error tolua_err;
02934  if (
02935      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
02936      !tolua_isnoobj(tolua_S,2,&tolua_err)
02937  )
02938   goto tolua_lerror;
02939  else
02940 #endif
02941  {
02942   fawkes::HumanoidMotionInterface::WalkArcMessage* self = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
02943 #ifndef TOLUA_RELEASE
02944   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'radius'", NULL);
02945 #endif
02946   {
02947    float tolua_ret = (float)  self->radius();
02948    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02949   }
02950  }
02951  return 1;
02952 #ifndef TOLUA_RELEASE
02953  tolua_lerror:
02954  tolua_error(tolua_S,"#ferror in function 'radius'.",&tolua_err);
02955  return 0;
02956 #endif
02957 }
02958 #endif //#ifndef TOLUA_DISABLE
02959 
02960 /* method: set_radius of class  WalkArcMessage */
02961 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_radius00
02962 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_radius00(lua_State* tolua_S)
02963 {
02964 #ifndef TOLUA_RELEASE
02965  tolua_Error tolua_err;
02966  if (
02967      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
02968      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02969      !tolua_isnoobj(tolua_S,3,&tolua_err)
02970  )
02971   goto tolua_lerror;
02972  else
02973 #endif
02974  {
02975   fawkes::HumanoidMotionInterface::WalkArcMessage* self = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
02976   const float new_radius = ((const float)  tolua_tonumber(tolua_S,2,0));
02977 #ifndef TOLUA_RELEASE
02978   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_radius'", NULL);
02979 #endif
02980   {
02981    self->set_radius(new_radius);
02982   }
02983  }
02984  return 0;
02985 #ifndef TOLUA_RELEASE
02986  tolua_lerror:
02987  tolua_error(tolua_S,"#ferror in function 'set_radius'.",&tolua_err);
02988  return 0;
02989 #endif
02990 }
02991 #endif //#ifndef TOLUA_DISABLE
02992 
02993 /* method: maxlenof_radius of class  WalkArcMessage */
02994 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_radius00
02995 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_radius00(lua_State* tolua_S)
02996 {
02997 #ifndef TOLUA_RELEASE
02998  tolua_Error tolua_err;
02999  if (
03000      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
03001      !tolua_isnoobj(tolua_S,2,&tolua_err)
03002  )
03003   goto tolua_lerror;
03004  else
03005 #endif
03006  {
03007   const fawkes::HumanoidMotionInterface::WalkArcMessage* self = (const fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
03008 #ifndef TOLUA_RELEASE
03009   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_radius'", NULL);
03010 #endif
03011   {
03012    int tolua_ret = (int)  self->maxlenof_radius();
03013    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03014   }
03015  }
03016  return 1;
03017 #ifndef TOLUA_RELEASE
03018  tolua_lerror:
03019  tolua_error(tolua_S,"#ferror in function 'maxlenof_radius'.",&tolua_err);
03020  return 0;
03021 #endif
03022 }
03023 #endif //#ifndef TOLUA_DISABLE
03024 
03025 /* method: num_samples of class  WalkArcMessage */
03026 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_num_samples00
03027 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_num_samples00(lua_State* tolua_S)
03028 {
03029 #ifndef TOLUA_RELEASE
03030  tolua_Error tolua_err;
03031  if (
03032      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
03033      !tolua_isnoobj(tolua_S,2,&tolua_err)
03034  )
03035   goto tolua_lerror;
03036  else
03037 #endif
03038  {
03039   fawkes::HumanoidMotionInterface::WalkArcMessage* self = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
03040 #ifndef TOLUA_RELEASE
03041   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_samples'", NULL);
03042 #endif
03043   {
03044    unsigned int tolua_ret = (unsigned int)  self->num_samples();
03045    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03046   }
03047  }
03048  return 1;
03049 #ifndef TOLUA_RELEASE
03050  tolua_lerror:
03051  tolua_error(tolua_S,"#ferror in function 'num_samples'.",&tolua_err);
03052  return 0;
03053 #endif
03054 }
03055 #endif //#ifndef TOLUA_DISABLE
03056 
03057 /* method: set_num_samples of class  WalkArcMessage */
03058 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_num_samples00
03059 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_num_samples00(lua_State* tolua_S)
03060 {
03061 #ifndef TOLUA_RELEASE
03062  tolua_Error tolua_err;
03063  if (
03064      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
03065      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03066      !tolua_isnoobj(tolua_S,3,&tolua_err)
03067  )
03068   goto tolua_lerror;
03069  else
03070 #endif
03071  {
03072   fawkes::HumanoidMotionInterface::WalkArcMessage* self = (fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
03073   unsigned const int new_num_samples = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
03074 #ifndef TOLUA_RELEASE
03075   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_num_samples'", NULL);
03076 #endif
03077   {
03078    self->set_num_samples(new_num_samples);
03079   }
03080  }
03081  return 0;
03082 #ifndef TOLUA_RELEASE
03083  tolua_lerror:
03084  tolua_error(tolua_S,"#ferror in function 'set_num_samples'.",&tolua_err);
03085  return 0;
03086 #endif
03087 }
03088 #endif //#ifndef TOLUA_DISABLE
03089 
03090 /* method: maxlenof_num_samples of class  WalkArcMessage */
03091 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_num_samples00
03092 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_num_samples00(lua_State* tolua_S)
03093 {
03094 #ifndef TOLUA_RELEASE
03095  tolua_Error tolua_err;
03096  if (
03097      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::WalkArcMessage",0,&tolua_err) ||
03098      !tolua_isnoobj(tolua_S,2,&tolua_err)
03099  )
03100   goto tolua_lerror;
03101  else
03102 #endif
03103  {
03104   const fawkes::HumanoidMotionInterface::WalkArcMessage* self = (const fawkes::HumanoidMotionInterface::WalkArcMessage*)  tolua_tousertype(tolua_S,1,0);
03105 #ifndef TOLUA_RELEASE
03106   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_num_samples'", NULL);
03107 #endif
03108   {
03109    int tolua_ret = (int)  self->maxlenof_num_samples();
03110    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03111   }
03112  }
03113  return 1;
03114 #ifndef TOLUA_RELEASE
03115  tolua_lerror:
03116  tolua_error(tolua_S,"#ferror in function 'maxlenof_num_samples'.",&tolua_err);
03117  return 0;
03118 #endif
03119 }
03120 #endif //#ifndef TOLUA_DISABLE
03121 
03122 /* method: new of class  TurnMessage */
03123 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00
03124 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00(lua_State* tolua_S)
03125 {
03126 #ifndef TOLUA_RELEASE
03127  tolua_Error tolua_err;
03128  if (
03129      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
03130      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03131      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
03132      !tolua_isnoobj(tolua_S,4,&tolua_err)
03133  )
03134   goto tolua_lerror;
03135  else
03136 #endif
03137  {
03138   float ini_angle = ((float)  tolua_tonumber(tolua_S,2,0));
03139   unsigned int ini_num_samples = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
03140   {
03141    fawkes::HumanoidMotionInterface::TurnMessage* tolua_ret = (fawkes::HumanoidMotionInterface::TurnMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::TurnMessage)(ini_angle,ini_num_samples));
03142     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::TurnMessage");
03143   }
03144  }
03145  return 1;
03146 #ifndef TOLUA_RELEASE
03147  tolua_lerror:
03148  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03149  return 0;
03150 #endif
03151 }
03152 #endif //#ifndef TOLUA_DISABLE
03153 
03154 /* method: new_local of class  TurnMessage */
03155 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00_local
03156 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00_local(lua_State* tolua_S)
03157 {
03158 #ifndef TOLUA_RELEASE
03159  tolua_Error tolua_err;
03160  if (
03161      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
03162      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03163      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
03164      !tolua_isnoobj(tolua_S,4,&tolua_err)
03165  )
03166   goto tolua_lerror;
03167  else
03168 #endif
03169  {
03170   float ini_angle = ((float)  tolua_tonumber(tolua_S,2,0));
03171   unsigned int ini_num_samples = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
03172   {
03173    fawkes::HumanoidMotionInterface::TurnMessage* tolua_ret = (fawkes::HumanoidMotionInterface::TurnMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::TurnMessage)(ini_angle,ini_num_samples));
03174     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::TurnMessage");
03175     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03176   }
03177  }
03178  return 1;
03179 #ifndef TOLUA_RELEASE
03180  tolua_lerror:
03181  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03182  return 0;
03183 #endif
03184 }
03185 #endif //#ifndef TOLUA_DISABLE
03186 
03187 /* method: new of class  TurnMessage */
03188 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new01
03189 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new01(lua_State* tolua_S)
03190 {
03191  tolua_Error tolua_err;
03192  if (
03193      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
03194      !tolua_isnoobj(tolua_S,2,&tolua_err)
03195  )
03196   goto tolua_lerror;
03197  else
03198  {
03199   {
03200    fawkes::HumanoidMotionInterface::TurnMessage* tolua_ret = (fawkes::HumanoidMotionInterface::TurnMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::TurnMessage)());
03201     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::TurnMessage");
03202   }
03203  }
03204  return 1;
03205 tolua_lerror:
03206  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00(tolua_S);
03207 }
03208 #endif //#ifndef TOLUA_DISABLE
03209 
03210 /* method: new_local of class  TurnMessage */
03211 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new01_local
03212 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new01_local(lua_State* tolua_S)
03213 {
03214  tolua_Error tolua_err;
03215  if (
03216      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
03217      !tolua_isnoobj(tolua_S,2,&tolua_err)
03218  )
03219   goto tolua_lerror;
03220  else
03221  {
03222   {
03223    fawkes::HumanoidMotionInterface::TurnMessage* tolua_ret = (fawkes::HumanoidMotionInterface::TurnMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::TurnMessage)());
03224     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::TurnMessage");
03225     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03226   }
03227  }
03228  return 1;
03229 tolua_lerror:
03230  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00_local(tolua_S);
03231 }
03232 #endif //#ifndef TOLUA_DISABLE
03233 
03234 /* method: delete of class  TurnMessage */
03235 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_delete00
03236 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_delete00(lua_State* tolua_S)
03237 {
03238 #ifndef TOLUA_RELEASE
03239  tolua_Error tolua_err;
03240  if (
03241      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
03242      !tolua_isnoobj(tolua_S,2,&tolua_err)
03243  )
03244   goto tolua_lerror;
03245  else
03246 #endif
03247  {
03248   fawkes::HumanoidMotionInterface::TurnMessage* self = (fawkes::HumanoidMotionInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
03249 #ifndef TOLUA_RELEASE
03250   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
03251 #endif
03252   Mtolua_delete(self);
03253  }
03254  return 0;
03255 #ifndef TOLUA_RELEASE
03256  tolua_lerror:
03257  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
03258  return 0;
03259 #endif
03260 }
03261 #endif //#ifndef TOLUA_DISABLE
03262 
03263 /* method: angle of class  TurnMessage */
03264 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_angle00
03265 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_angle00(lua_State* tolua_S)
03266 {
03267 #ifndef TOLUA_RELEASE
03268  tolua_Error tolua_err;
03269  if (
03270      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
03271      !tolua_isnoobj(tolua_S,2,&tolua_err)
03272  )
03273   goto tolua_lerror;
03274  else
03275 #endif
03276  {
03277   fawkes::HumanoidMotionInterface::TurnMessage* self = (fawkes::HumanoidMotionInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
03278 #ifndef TOLUA_RELEASE
03279   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'angle'", NULL);
03280 #endif
03281   {
03282    float tolua_ret = (float)  self->angle();
03283    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03284   }
03285  }
03286  return 1;
03287 #ifndef TOLUA_RELEASE
03288  tolua_lerror:
03289  tolua_error(tolua_S,"#ferror in function 'angle'.",&tolua_err);
03290  return 0;
03291 #endif
03292 }
03293 #endif //#ifndef TOLUA_DISABLE
03294 
03295 /* method: set_angle of class  TurnMessage */
03296 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_set_angle00
03297 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_set_angle00(lua_State* tolua_S)
03298 {
03299 #ifndef TOLUA_RELEASE
03300  tolua_Error tolua_err;
03301  if (
03302      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
03303      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03304      !tolua_isnoobj(tolua_S,3,&tolua_err)
03305  )
03306   goto tolua_lerror;
03307  else
03308 #endif
03309  {
03310   fawkes::HumanoidMotionInterface::TurnMessage* self = (fawkes::HumanoidMotionInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
03311   const float new_angle = ((const float)  tolua_tonumber(tolua_S,2,0));
03312 #ifndef TOLUA_RELEASE
03313   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_angle'", NULL);
03314 #endif
03315   {
03316    self->set_angle(new_angle);
03317   }
03318  }
03319  return 0;
03320 #ifndef TOLUA_RELEASE
03321  tolua_lerror:
03322  tolua_error(tolua_S,"#ferror in function 'set_angle'.",&tolua_err);
03323  return 0;
03324 #endif
03325 }
03326 #endif //#ifndef TOLUA_DISABLE
03327 
03328 /* method: maxlenof_angle of class  TurnMessage */
03329 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_maxlenof_angle00
03330 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_maxlenof_angle00(lua_State* tolua_S)
03331 {
03332 #ifndef TOLUA_RELEASE
03333  tolua_Error tolua_err;
03334  if (
03335      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
03336      !tolua_isnoobj(tolua_S,2,&tolua_err)
03337  )
03338   goto tolua_lerror;
03339  else
03340 #endif
03341  {
03342   const fawkes::HumanoidMotionInterface::TurnMessage* self = (const fawkes::HumanoidMotionInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
03343 #ifndef TOLUA_RELEASE
03344   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_angle'", NULL);
03345 #endif
03346   {
03347    int tolua_ret = (int)  self->maxlenof_angle();
03348    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03349   }
03350  }
03351  return 1;
03352 #ifndef TOLUA_RELEASE
03353  tolua_lerror:
03354  tolua_error(tolua_S,"#ferror in function 'maxlenof_angle'.",&tolua_err);
03355  return 0;
03356 #endif
03357 }
03358 #endif //#ifndef TOLUA_DISABLE
03359 
03360 /* method: num_samples of class  TurnMessage */
03361 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_num_samples00
03362 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_num_samples00(lua_State* tolua_S)
03363 {
03364 #ifndef TOLUA_RELEASE
03365  tolua_Error tolua_err;
03366  if (
03367      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
03368      !tolua_isnoobj(tolua_S,2,&tolua_err)
03369  )
03370   goto tolua_lerror;
03371  else
03372 #endif
03373  {
03374   fawkes::HumanoidMotionInterface::TurnMessage* self = (fawkes::HumanoidMotionInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
03375 #ifndef TOLUA_RELEASE
03376   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_samples'", NULL);
03377 #endif
03378   {
03379    unsigned int tolua_ret = (unsigned int)  self->num_samples();
03380    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03381   }
03382  }
03383  return 1;
03384 #ifndef TOLUA_RELEASE
03385  tolua_lerror:
03386  tolua_error(tolua_S,"#ferror in function 'num_samples'.",&tolua_err);
03387  return 0;
03388 #endif
03389 }
03390 #endif //#ifndef TOLUA_DISABLE
03391 
03392 /* method: set_num_samples of class  TurnMessage */
03393 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_set_num_samples00
03394 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_set_num_samples00(lua_State* tolua_S)
03395 {
03396 #ifndef TOLUA_RELEASE
03397  tolua_Error tolua_err;
03398  if (
03399      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
03400      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03401      !tolua_isnoobj(tolua_S,3,&tolua_err)
03402  )
03403   goto tolua_lerror;
03404  else
03405 #endif
03406  {
03407   fawkes::HumanoidMotionInterface::TurnMessage* self = (fawkes::HumanoidMotionInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
03408   unsigned const int new_num_samples = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
03409 #ifndef TOLUA_RELEASE
03410   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_num_samples'", NULL);
03411 #endif
03412   {
03413    self->set_num_samples(new_num_samples);
03414   }
03415  }
03416  return 0;
03417 #ifndef TOLUA_RELEASE
03418  tolua_lerror:
03419  tolua_error(tolua_S,"#ferror in function 'set_num_samples'.",&tolua_err);
03420  return 0;
03421 #endif
03422 }
03423 #endif //#ifndef TOLUA_DISABLE
03424 
03425 /* method: maxlenof_num_samples of class  TurnMessage */
03426 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_maxlenof_num_samples00
03427 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_maxlenof_num_samples00(lua_State* tolua_S)
03428 {
03429 #ifndef TOLUA_RELEASE
03430  tolua_Error tolua_err;
03431  if (
03432      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::TurnMessage",0,&tolua_err) ||
03433      !tolua_isnoobj(tolua_S,2,&tolua_err)
03434  )
03435   goto tolua_lerror;
03436  else
03437 #endif
03438  {
03439   const fawkes::HumanoidMotionInterface::TurnMessage* self = (const fawkes::HumanoidMotionInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
03440 #ifndef TOLUA_RELEASE
03441   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_num_samples'", NULL);
03442 #endif
03443   {
03444    int tolua_ret = (int)  self->maxlenof_num_samples();
03445    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03446   }
03447  }
03448  return 1;
03449 #ifndef TOLUA_RELEASE
03450  tolua_lerror:
03451  tolua_error(tolua_S,"#ferror in function 'maxlenof_num_samples'.",&tolua_err);
03452  return 0;
03453 #endif
03454 }
03455 #endif //#ifndef TOLUA_DISABLE
03456 
03457 /* method: new of class  KickMessage */
03458 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00
03459 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00(lua_State* tolua_S)
03460 {
03461 #ifndef TOLUA_RELEASE
03462  tolua_Error tolua_err;
03463  if (
03464      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
03465      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03466      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
03467      !tolua_isnoobj(tolua_S,4,&tolua_err)
03468  )
03469   goto tolua_lerror;
03470  else
03471 #endif
03472  {
03473   fawkes::HumanoidMotionInterface::LegEnum ini_leg = ((fawkes::HumanoidMotionInterface::LegEnum) (int)  tolua_tonumber(tolua_S,2,0));
03474   float ini_strength = ((float)  tolua_tonumber(tolua_S,3,0));
03475   {
03476    fawkes::HumanoidMotionInterface::KickMessage* tolua_ret = (fawkes::HumanoidMotionInterface::KickMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::KickMessage)(ini_leg,ini_strength));
03477     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::KickMessage");
03478   }
03479  }
03480  return 1;
03481 #ifndef TOLUA_RELEASE
03482  tolua_lerror:
03483  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03484  return 0;
03485 #endif
03486 }
03487 #endif //#ifndef TOLUA_DISABLE
03488 
03489 /* method: new_local of class  KickMessage */
03490 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00_local
03491 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00_local(lua_State* tolua_S)
03492 {
03493 #ifndef TOLUA_RELEASE
03494  tolua_Error tolua_err;
03495  if (
03496      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
03497      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03498      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
03499      !tolua_isnoobj(tolua_S,4,&tolua_err)
03500  )
03501   goto tolua_lerror;
03502  else
03503 #endif
03504  {
03505   fawkes::HumanoidMotionInterface::LegEnum ini_leg = ((fawkes::HumanoidMotionInterface::LegEnum) (int)  tolua_tonumber(tolua_S,2,0));
03506   float ini_strength = ((float)  tolua_tonumber(tolua_S,3,0));
03507   {
03508    fawkes::HumanoidMotionInterface::KickMessage* tolua_ret = (fawkes::HumanoidMotionInterface::KickMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::KickMessage)(ini_leg,ini_strength));
03509     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::KickMessage");
03510     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03511   }
03512  }
03513  return 1;
03514 #ifndef TOLUA_RELEASE
03515  tolua_lerror:
03516  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03517  return 0;
03518 #endif
03519 }
03520 #endif //#ifndef TOLUA_DISABLE
03521 
03522 /* method: new of class  KickMessage */
03523 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new01
03524 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new01(lua_State* tolua_S)
03525 {
03526  tolua_Error tolua_err;
03527  if (
03528      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
03529      !tolua_isnoobj(tolua_S,2,&tolua_err)
03530  )
03531   goto tolua_lerror;
03532  else
03533  {
03534   {
03535    fawkes::HumanoidMotionInterface::KickMessage* tolua_ret = (fawkes::HumanoidMotionInterface::KickMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::KickMessage)());
03536     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::KickMessage");
03537   }
03538  }
03539  return 1;
03540 tolua_lerror:
03541  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00(tolua_S);
03542 }
03543 #endif //#ifndef TOLUA_DISABLE
03544 
03545 /* method: new_local of class  KickMessage */
03546 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new01_local
03547 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new01_local(lua_State* tolua_S)
03548 {
03549  tolua_Error tolua_err;
03550  if (
03551      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
03552      !tolua_isnoobj(tolua_S,2,&tolua_err)
03553  )
03554   goto tolua_lerror;
03555  else
03556  {
03557   {
03558    fawkes::HumanoidMotionInterface::KickMessage* tolua_ret = (fawkes::HumanoidMotionInterface::KickMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::KickMessage)());
03559     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::KickMessage");
03560     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03561   }
03562  }
03563  return 1;
03564 tolua_lerror:
03565  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00_local(tolua_S);
03566 }
03567 #endif //#ifndef TOLUA_DISABLE
03568 
03569 /* method: delete of class  KickMessage */
03570 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_delete00
03571 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_delete00(lua_State* tolua_S)
03572 {
03573 #ifndef TOLUA_RELEASE
03574  tolua_Error tolua_err;
03575  if (
03576      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
03577      !tolua_isnoobj(tolua_S,2,&tolua_err)
03578  )
03579   goto tolua_lerror;
03580  else
03581 #endif
03582  {
03583   fawkes::HumanoidMotionInterface::KickMessage* self = (fawkes::HumanoidMotionInterface::KickMessage*)  tolua_tousertype(tolua_S,1,0);
03584 #ifndef TOLUA_RELEASE
03585   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
03586 #endif
03587   Mtolua_delete(self);
03588  }
03589  return 0;
03590 #ifndef TOLUA_RELEASE
03591  tolua_lerror:
03592  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
03593  return 0;
03594 #endif
03595 }
03596 #endif //#ifndef TOLUA_DISABLE
03597 
03598 /* method: leg of class  KickMessage */
03599 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_leg00
03600 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_leg00(lua_State* tolua_S)
03601 {
03602 #ifndef TOLUA_RELEASE
03603  tolua_Error tolua_err;
03604  if (
03605      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
03606      !tolua_isnoobj(tolua_S,2,&tolua_err)
03607  )
03608   goto tolua_lerror;
03609  else
03610 #endif
03611  {
03612   fawkes::HumanoidMotionInterface::KickMessage* self = (fawkes::HumanoidMotionInterface::KickMessage*)  tolua_tousertype(tolua_S,1,0);
03613 #ifndef TOLUA_RELEASE
03614   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'leg'", NULL);
03615 #endif
03616   {
03617    fawkes::HumanoidMotionInterface::LegEnum tolua_ret = (fawkes::HumanoidMotionInterface::LegEnum)  self->leg();
03618    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03619   }
03620  }
03621  return 1;
03622 #ifndef TOLUA_RELEASE
03623  tolua_lerror:
03624  tolua_error(tolua_S,"#ferror in function 'leg'.",&tolua_err);
03625  return 0;
03626 #endif
03627 }
03628 #endif //#ifndef TOLUA_DISABLE
03629 
03630 /* method: set_leg of class  KickMessage */
03631 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_set_leg00
03632 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_set_leg00(lua_State* tolua_S)
03633 {
03634 #ifndef TOLUA_RELEASE
03635  tolua_Error tolua_err;
03636  if (
03637      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
03638      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03639      !tolua_isnoobj(tolua_S,3,&tolua_err)
03640  )
03641   goto tolua_lerror;
03642  else
03643 #endif
03644  {
03645   fawkes::HumanoidMotionInterface::KickMessage* self = (fawkes::HumanoidMotionInterface::KickMessage*)  tolua_tousertype(tolua_S,1,0);
03646   const fawkes::HumanoidMotionInterface::LegEnum new_leg = ((const fawkes::HumanoidMotionInterface::LegEnum) (int)  tolua_tonumber(tolua_S,2,0));
03647 #ifndef TOLUA_RELEASE
03648   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_leg'", NULL);
03649 #endif
03650   {
03651    self->set_leg(new_leg);
03652   }
03653  }
03654  return 0;
03655 #ifndef TOLUA_RELEASE
03656  tolua_lerror:
03657  tolua_error(tolua_S,"#ferror in function 'set_leg'.",&tolua_err);
03658  return 0;
03659 #endif
03660 }
03661 #endif //#ifndef TOLUA_DISABLE
03662 
03663 /* method: maxlenof_leg of class  KickMessage */
03664 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_maxlenof_leg00
03665 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_maxlenof_leg00(lua_State* tolua_S)
03666 {
03667 #ifndef TOLUA_RELEASE
03668  tolua_Error tolua_err;
03669  if (
03670      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
03671      !tolua_isnoobj(tolua_S,2,&tolua_err)
03672  )
03673   goto tolua_lerror;
03674  else
03675 #endif
03676  {
03677   const fawkes::HumanoidMotionInterface::KickMessage* self = (const fawkes::HumanoidMotionInterface::KickMessage*)  tolua_tousertype(tolua_S,1,0);
03678 #ifndef TOLUA_RELEASE
03679   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_leg'", NULL);
03680 #endif
03681   {
03682    int tolua_ret = (int)  self->maxlenof_leg();
03683    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03684   }
03685  }
03686  return 1;
03687 #ifndef TOLUA_RELEASE
03688  tolua_lerror:
03689  tolua_error(tolua_S,"#ferror in function 'maxlenof_leg'.",&tolua_err);
03690  return 0;
03691 #endif
03692 }
03693 #endif //#ifndef TOLUA_DISABLE
03694 
03695 /* method: strength of class  KickMessage */
03696 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_strength00
03697 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_strength00(lua_State* tolua_S)
03698 {
03699 #ifndef TOLUA_RELEASE
03700  tolua_Error tolua_err;
03701  if (
03702      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
03703      !tolua_isnoobj(tolua_S,2,&tolua_err)
03704  )
03705   goto tolua_lerror;
03706  else
03707 #endif
03708  {
03709   fawkes::HumanoidMotionInterface::KickMessage* self = (fawkes::HumanoidMotionInterface::KickMessage*)  tolua_tousertype(tolua_S,1,0);
03710 #ifndef TOLUA_RELEASE
03711   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'strength'", NULL);
03712 #endif
03713   {
03714    float tolua_ret = (float)  self->strength();
03715    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03716   }
03717  }
03718  return 1;
03719 #ifndef TOLUA_RELEASE
03720  tolua_lerror:
03721  tolua_error(tolua_S,"#ferror in function 'strength'.",&tolua_err);
03722  return 0;
03723 #endif
03724 }
03725 #endif //#ifndef TOLUA_DISABLE
03726 
03727 /* method: set_strength of class  KickMessage */
03728 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_set_strength00
03729 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_set_strength00(lua_State* tolua_S)
03730 {
03731 #ifndef TOLUA_RELEASE
03732  tolua_Error tolua_err;
03733  if (
03734      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
03735      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03736      !tolua_isnoobj(tolua_S,3,&tolua_err)
03737  )
03738   goto tolua_lerror;
03739  else
03740 #endif
03741  {
03742   fawkes::HumanoidMotionInterface::KickMessage* self = (fawkes::HumanoidMotionInterface::KickMessage*)  tolua_tousertype(tolua_S,1,0);
03743   const float new_strength = ((const float)  tolua_tonumber(tolua_S,2,0));
03744 #ifndef TOLUA_RELEASE
03745   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_strength'", NULL);
03746 #endif
03747   {
03748    self->set_strength(new_strength);
03749   }
03750  }
03751  return 0;
03752 #ifndef TOLUA_RELEASE
03753  tolua_lerror:
03754  tolua_error(tolua_S,"#ferror in function 'set_strength'.",&tolua_err);
03755  return 0;
03756 #endif
03757 }
03758 #endif //#ifndef TOLUA_DISABLE
03759 
03760 /* method: maxlenof_strength of class  KickMessage */
03761 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_maxlenof_strength00
03762 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_maxlenof_strength00(lua_State* tolua_S)
03763 {
03764 #ifndef TOLUA_RELEASE
03765  tolua_Error tolua_err;
03766  if (
03767      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::KickMessage",0,&tolua_err) ||
03768      !tolua_isnoobj(tolua_S,2,&tolua_err)
03769  )
03770   goto tolua_lerror;
03771  else
03772 #endif
03773  {
03774   const fawkes::HumanoidMotionInterface::KickMessage* self = (const fawkes::HumanoidMotionInterface::KickMessage*)  tolua_tousertype(tolua_S,1,0);
03775 #ifndef TOLUA_RELEASE
03776   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_strength'", NULL);
03777 #endif
03778   {
03779    int tolua_ret = (int)  self->maxlenof_strength();
03780    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03781   }
03782  }
03783  return 1;
03784 #ifndef TOLUA_RELEASE
03785  tolua_lerror:
03786  tolua_error(tolua_S,"#ferror in function 'maxlenof_strength'.",&tolua_err);
03787  return 0;
03788 #endif
03789 }
03790 #endif //#ifndef TOLUA_DISABLE
03791 
03792 /* method: new of class  ParkMessage */
03793 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00
03794 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00(lua_State* tolua_S)
03795 {
03796 #ifndef TOLUA_RELEASE
03797  tolua_Error tolua_err;
03798  if (
03799      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::ParkMessage",0,&tolua_err) ||
03800      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03801      !tolua_isnoobj(tolua_S,3,&tolua_err)
03802  )
03803   goto tolua_lerror;
03804  else
03805 #endif
03806  {
03807   float ini_time_sec = ((float)  tolua_tonumber(tolua_S,2,0));
03808   {
03809    fawkes::HumanoidMotionInterface::ParkMessage* tolua_ret = (fawkes::HumanoidMotionInterface::ParkMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::ParkMessage)(ini_time_sec));
03810     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::ParkMessage");
03811   }
03812  }
03813  return 1;
03814 #ifndef TOLUA_RELEASE
03815  tolua_lerror:
03816  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03817  return 0;
03818 #endif
03819 }
03820 #endif //#ifndef TOLUA_DISABLE
03821 
03822 /* method: new_local of class  ParkMessage */
03823 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00_local
03824 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00_local(lua_State* tolua_S)
03825 {
03826 #ifndef TOLUA_RELEASE
03827  tolua_Error tolua_err;
03828  if (
03829      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::ParkMessage",0,&tolua_err) ||
03830      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03831      !tolua_isnoobj(tolua_S,3,&tolua_err)
03832  )
03833   goto tolua_lerror;
03834  else
03835 #endif
03836  {
03837   float ini_time_sec = ((float)  tolua_tonumber(tolua_S,2,0));
03838   {
03839    fawkes::HumanoidMotionInterface::ParkMessage* tolua_ret = (fawkes::HumanoidMotionInterface::ParkMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::ParkMessage)(ini_time_sec));
03840     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::ParkMessage");
03841     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03842   }
03843  }
03844  return 1;
03845 #ifndef TOLUA_RELEASE
03846  tolua_lerror:
03847  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03848  return 0;
03849 #endif
03850 }
03851 #endif //#ifndef TOLUA_DISABLE
03852 
03853 /* method: new of class  ParkMessage */
03854 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new01
03855 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new01(lua_State* tolua_S)
03856 {
03857  tolua_Error tolua_err;
03858  if (
03859      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::ParkMessage",0,&tolua_err) ||
03860      !tolua_isnoobj(tolua_S,2,&tolua_err)
03861  )
03862   goto tolua_lerror;
03863  else
03864  {
03865   {
03866    fawkes::HumanoidMotionInterface::ParkMessage* tolua_ret = (fawkes::HumanoidMotionInterface::ParkMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::ParkMessage)());
03867     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::ParkMessage");
03868   }
03869  }
03870  return 1;
03871 tolua_lerror:
03872  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00(tolua_S);
03873 }
03874 #endif //#ifndef TOLUA_DISABLE
03875 
03876 /* method: new_local of class  ParkMessage */
03877 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new01_local
03878 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new01_local(lua_State* tolua_S)
03879 {
03880  tolua_Error tolua_err;
03881  if (
03882      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::ParkMessage",0,&tolua_err) ||
03883      !tolua_isnoobj(tolua_S,2,&tolua_err)
03884  )
03885   goto tolua_lerror;
03886  else
03887  {
03888   {
03889    fawkes::HumanoidMotionInterface::ParkMessage* tolua_ret = (fawkes::HumanoidMotionInterface::ParkMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::ParkMessage)());
03890     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::ParkMessage");
03891     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03892   }
03893  }
03894  return 1;
03895 tolua_lerror:
03896  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00_local(tolua_S);
03897 }
03898 #endif //#ifndef TOLUA_DISABLE
03899 
03900 /* method: delete of class  ParkMessage */
03901 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_delete00
03902 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_delete00(lua_State* tolua_S)
03903 {
03904 #ifndef TOLUA_RELEASE
03905  tolua_Error tolua_err;
03906  if (
03907      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::ParkMessage",0,&tolua_err) ||
03908      !tolua_isnoobj(tolua_S,2,&tolua_err)
03909  )
03910   goto tolua_lerror;
03911  else
03912 #endif
03913  {
03914   fawkes::HumanoidMotionInterface::ParkMessage* self = (fawkes::HumanoidMotionInterface::ParkMessage*)  tolua_tousertype(tolua_S,1,0);
03915 #ifndef TOLUA_RELEASE
03916   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
03917 #endif
03918   Mtolua_delete(self);
03919  }
03920  return 0;
03921 #ifndef TOLUA_RELEASE
03922  tolua_lerror:
03923  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
03924  return 0;
03925 #endif
03926 }
03927 #endif //#ifndef TOLUA_DISABLE
03928 
03929 /* method: time_sec of class  ParkMessage */
03930 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_time_sec00
03931 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_time_sec00(lua_State* tolua_S)
03932 {
03933 #ifndef TOLUA_RELEASE
03934  tolua_Error tolua_err;
03935  if (
03936      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::ParkMessage",0,&tolua_err) ||
03937      !tolua_isnoobj(tolua_S,2,&tolua_err)
03938  )
03939   goto tolua_lerror;
03940  else
03941 #endif
03942  {
03943   fawkes::HumanoidMotionInterface::ParkMessage* self = (fawkes::HumanoidMotionInterface::ParkMessage*)  tolua_tousertype(tolua_S,1,0);
03944 #ifndef TOLUA_RELEASE
03945   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'time_sec'", NULL);
03946 #endif
03947   {
03948    float tolua_ret = (float)  self->time_sec();
03949    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03950   }
03951  }
03952  return 1;
03953 #ifndef TOLUA_RELEASE
03954  tolua_lerror:
03955  tolua_error(tolua_S,"#ferror in function 'time_sec'.",&tolua_err);
03956  return 0;
03957 #endif
03958 }
03959 #endif //#ifndef TOLUA_DISABLE
03960 
03961 /* method: set_time_sec of class  ParkMessage */
03962 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_set_time_sec00
03963 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_set_time_sec00(lua_State* tolua_S)
03964 {
03965 #ifndef TOLUA_RELEASE
03966  tolua_Error tolua_err;
03967  if (
03968      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::ParkMessage",0,&tolua_err) ||
03969      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03970      !tolua_isnoobj(tolua_S,3,&tolua_err)
03971  )
03972   goto tolua_lerror;
03973  else
03974 #endif
03975  {
03976   fawkes::HumanoidMotionInterface::ParkMessage* self = (fawkes::HumanoidMotionInterface::ParkMessage*)  tolua_tousertype(tolua_S,1,0);
03977   const float new_time_sec = ((const float)  tolua_tonumber(tolua_S,2,0));
03978 #ifndef TOLUA_RELEASE
03979   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time_sec'", NULL);
03980 #endif
03981   {
03982    self->set_time_sec(new_time_sec);
03983   }
03984  }
03985  return 0;
03986 #ifndef TOLUA_RELEASE
03987  tolua_lerror:
03988  tolua_error(tolua_S,"#ferror in function 'set_time_sec'.",&tolua_err);
03989  return 0;
03990 #endif
03991 }
03992 #endif //#ifndef TOLUA_DISABLE
03993 
03994 /* method: maxlenof_time_sec of class  ParkMessage */
03995 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_maxlenof_time_sec00
03996 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_maxlenof_time_sec00(lua_State* tolua_S)
03997 {
03998 #ifndef TOLUA_RELEASE
03999  tolua_Error tolua_err;
04000  if (
04001      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::ParkMessage",0,&tolua_err) ||
04002      !tolua_isnoobj(tolua_S,2,&tolua_err)
04003  )
04004   goto tolua_lerror;
04005  else
04006 #endif
04007  {
04008   const fawkes::HumanoidMotionInterface::ParkMessage* self = (const fawkes::HumanoidMotionInterface::ParkMessage*)  tolua_tousertype(tolua_S,1,0);
04009 #ifndef TOLUA_RELEASE
04010   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_time_sec'", NULL);
04011 #endif
04012   {
04013    int tolua_ret = (int)  self->maxlenof_time_sec();
04014    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04015   }
04016  }
04017  return 1;
04018 #ifndef TOLUA_RELEASE
04019  tolua_lerror:
04020  tolua_error(tolua_S,"#ferror in function 'maxlenof_time_sec'.",&tolua_err);
04021  return 0;
04022 #endif
04023 }
04024 #endif //#ifndef TOLUA_DISABLE
04025 
04026 /* method: new of class  GetUpMessage */
04027 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00
04028 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00(lua_State* tolua_S)
04029 {
04030 #ifndef TOLUA_RELEASE
04031  tolua_Error tolua_err;
04032  if (
04033      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::GetUpMessage",0,&tolua_err) ||
04034      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04035      !tolua_isnoobj(tolua_S,3,&tolua_err)
04036  )
04037   goto tolua_lerror;
04038  else
04039 #endif
04040  {
04041   float ini_time_sec = ((float)  tolua_tonumber(tolua_S,2,0));
04042   {
04043    fawkes::HumanoidMotionInterface::GetUpMessage* tolua_ret = (fawkes::HumanoidMotionInterface::GetUpMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::GetUpMessage)(ini_time_sec));
04044     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::GetUpMessage");
04045   }
04046  }
04047  return 1;
04048 #ifndef TOLUA_RELEASE
04049  tolua_lerror:
04050  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04051  return 0;
04052 #endif
04053 }
04054 #endif //#ifndef TOLUA_DISABLE
04055 
04056 /* method: new_local of class  GetUpMessage */
04057 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00_local
04058 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00_local(lua_State* tolua_S)
04059 {
04060 #ifndef TOLUA_RELEASE
04061  tolua_Error tolua_err;
04062  if (
04063      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::GetUpMessage",0,&tolua_err) ||
04064      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04065      !tolua_isnoobj(tolua_S,3,&tolua_err)
04066  )
04067   goto tolua_lerror;
04068  else
04069 #endif
04070  {
04071   float ini_time_sec = ((float)  tolua_tonumber(tolua_S,2,0));
04072   {
04073    fawkes::HumanoidMotionInterface::GetUpMessage* tolua_ret = (fawkes::HumanoidMotionInterface::GetUpMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::GetUpMessage)(ini_time_sec));
04074     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::GetUpMessage");
04075     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04076   }
04077  }
04078  return 1;
04079 #ifndef TOLUA_RELEASE
04080  tolua_lerror:
04081  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04082  return 0;
04083 #endif
04084 }
04085 #endif //#ifndef TOLUA_DISABLE
04086 
04087 /* method: new of class  GetUpMessage */
04088 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new01
04089 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new01(lua_State* tolua_S)
04090 {
04091  tolua_Error tolua_err;
04092  if (
04093      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::GetUpMessage",0,&tolua_err) ||
04094      !tolua_isnoobj(tolua_S,2,&tolua_err)
04095  )
04096   goto tolua_lerror;
04097  else
04098  {
04099   {
04100    fawkes::HumanoidMotionInterface::GetUpMessage* tolua_ret = (fawkes::HumanoidMotionInterface::GetUpMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::GetUpMessage)());
04101     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::GetUpMessage");
04102   }
04103  }
04104  return 1;
04105 tolua_lerror:
04106  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00(tolua_S);
04107 }
04108 #endif //#ifndef TOLUA_DISABLE
04109 
04110 /* method: new_local of class  GetUpMessage */
04111 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new01_local
04112 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new01_local(lua_State* tolua_S)
04113 {
04114  tolua_Error tolua_err;
04115  if (
04116      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::GetUpMessage",0,&tolua_err) ||
04117      !tolua_isnoobj(tolua_S,2,&tolua_err)
04118  )
04119   goto tolua_lerror;
04120  else
04121  {
04122   {
04123    fawkes::HumanoidMotionInterface::GetUpMessage* tolua_ret = (fawkes::HumanoidMotionInterface::GetUpMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::GetUpMessage)());
04124     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::GetUpMessage");
04125     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04126   }
04127  }
04128  return 1;
04129 tolua_lerror:
04130  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00_local(tolua_S);
04131 }
04132 #endif //#ifndef TOLUA_DISABLE
04133 
04134 /* method: delete of class  GetUpMessage */
04135 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_delete00
04136 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_delete00(lua_State* tolua_S)
04137 {
04138 #ifndef TOLUA_RELEASE
04139  tolua_Error tolua_err;
04140  if (
04141      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::GetUpMessage",0,&tolua_err) ||
04142      !tolua_isnoobj(tolua_S,2,&tolua_err)
04143  )
04144   goto tolua_lerror;
04145  else
04146 #endif
04147  {
04148   fawkes::HumanoidMotionInterface::GetUpMessage* self = (fawkes::HumanoidMotionInterface::GetUpMessage*)  tolua_tousertype(tolua_S,1,0);
04149 #ifndef TOLUA_RELEASE
04150   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
04151 #endif
04152   Mtolua_delete(self);
04153  }
04154  return 0;
04155 #ifndef TOLUA_RELEASE
04156  tolua_lerror:
04157  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
04158  return 0;
04159 #endif
04160 }
04161 #endif //#ifndef TOLUA_DISABLE
04162 
04163 /* method: time_sec of class  GetUpMessage */
04164 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_time_sec00
04165 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_time_sec00(lua_State* tolua_S)
04166 {
04167 #ifndef TOLUA_RELEASE
04168  tolua_Error tolua_err;
04169  if (
04170      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::GetUpMessage",0,&tolua_err) ||
04171      !tolua_isnoobj(tolua_S,2,&tolua_err)
04172  )
04173   goto tolua_lerror;
04174  else
04175 #endif
04176  {
04177   fawkes::HumanoidMotionInterface::GetUpMessage* self = (fawkes::HumanoidMotionInterface::GetUpMessage*)  tolua_tousertype(tolua_S,1,0);
04178 #ifndef TOLUA_RELEASE
04179   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'time_sec'", NULL);
04180 #endif
04181   {
04182    float tolua_ret = (float)  self->time_sec();
04183    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04184   }
04185  }
04186  return 1;
04187 #ifndef TOLUA_RELEASE
04188  tolua_lerror:
04189  tolua_error(tolua_S,"#ferror in function 'time_sec'.",&tolua_err);
04190  return 0;
04191 #endif
04192 }
04193 #endif //#ifndef TOLUA_DISABLE
04194 
04195 /* method: set_time_sec of class  GetUpMessage */
04196 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_set_time_sec00
04197 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_set_time_sec00(lua_State* tolua_S)
04198 {
04199 #ifndef TOLUA_RELEASE
04200  tolua_Error tolua_err;
04201  if (
04202      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::GetUpMessage",0,&tolua_err) ||
04203      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04204      !tolua_isnoobj(tolua_S,3,&tolua_err)
04205  )
04206   goto tolua_lerror;
04207  else
04208 #endif
04209  {
04210   fawkes::HumanoidMotionInterface::GetUpMessage* self = (fawkes::HumanoidMotionInterface::GetUpMessage*)  tolua_tousertype(tolua_S,1,0);
04211   const float new_time_sec = ((const float)  tolua_tonumber(tolua_S,2,0));
04212 #ifndef TOLUA_RELEASE
04213   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time_sec'", NULL);
04214 #endif
04215   {
04216    self->set_time_sec(new_time_sec);
04217   }
04218  }
04219  return 0;
04220 #ifndef TOLUA_RELEASE
04221  tolua_lerror:
04222  tolua_error(tolua_S,"#ferror in function 'set_time_sec'.",&tolua_err);
04223  return 0;
04224 #endif
04225 }
04226 #endif //#ifndef TOLUA_DISABLE
04227 
04228 /* method: maxlenof_time_sec of class  GetUpMessage */
04229 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_maxlenof_time_sec00
04230 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_maxlenof_time_sec00(lua_State* tolua_S)
04231 {
04232 #ifndef TOLUA_RELEASE
04233  tolua_Error tolua_err;
04234  if (
04235      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::GetUpMessage",0,&tolua_err) ||
04236      !tolua_isnoobj(tolua_S,2,&tolua_err)
04237  )
04238   goto tolua_lerror;
04239  else
04240 #endif
04241  {
04242   const fawkes::HumanoidMotionInterface::GetUpMessage* self = (const fawkes::HumanoidMotionInterface::GetUpMessage*)  tolua_tousertype(tolua_S,1,0);
04243 #ifndef TOLUA_RELEASE
04244   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_time_sec'", NULL);
04245 #endif
04246   {
04247    int tolua_ret = (int)  self->maxlenof_time_sec();
04248    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04249   }
04250  }
04251  return 1;
04252 #ifndef TOLUA_RELEASE
04253  tolua_lerror:
04254  tolua_error(tolua_S,"#ferror in function 'maxlenof_time_sec'.",&tolua_err);
04255  return 0;
04256 #endif
04257 }
04258 #endif //#ifndef TOLUA_DISABLE
04259 
04260 /* method: new of class  StandupMessage */
04261 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00
04262 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00(lua_State* tolua_S)
04263 {
04264 #ifndef TOLUA_RELEASE
04265  tolua_Error tolua_err;
04266  if (
04267      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
04268      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04269      !tolua_isnoobj(tolua_S,3,&tolua_err)
04270  )
04271   goto tolua_lerror;
04272  else
04273 #endif
04274  {
04275   fawkes::HumanoidMotionInterface::StandupEnum ini_from_pos = ((fawkes::HumanoidMotionInterface::StandupEnum) (int)  tolua_tonumber(tolua_S,2,0));
04276   {
04277    fawkes::HumanoidMotionInterface::StandupMessage* tolua_ret = (fawkes::HumanoidMotionInterface::StandupMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::StandupMessage)(ini_from_pos));
04278     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::StandupMessage");
04279   }
04280  }
04281  return 1;
04282 #ifndef TOLUA_RELEASE
04283  tolua_lerror:
04284  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04285  return 0;
04286 #endif
04287 }
04288 #endif //#ifndef TOLUA_DISABLE
04289 
04290 /* method: new_local of class  StandupMessage */
04291 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00_local
04292 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00_local(lua_State* tolua_S)
04293 {
04294 #ifndef TOLUA_RELEASE
04295  tolua_Error tolua_err;
04296  if (
04297      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
04298      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04299      !tolua_isnoobj(tolua_S,3,&tolua_err)
04300  )
04301   goto tolua_lerror;
04302  else
04303 #endif
04304  {
04305   fawkes::HumanoidMotionInterface::StandupEnum ini_from_pos = ((fawkes::HumanoidMotionInterface::StandupEnum) (int)  tolua_tonumber(tolua_S,2,0));
04306   {
04307    fawkes::HumanoidMotionInterface::StandupMessage* tolua_ret = (fawkes::HumanoidMotionInterface::StandupMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::StandupMessage)(ini_from_pos));
04308     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::StandupMessage");
04309     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04310   }
04311  }
04312  return 1;
04313 #ifndef TOLUA_RELEASE
04314  tolua_lerror:
04315  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04316  return 0;
04317 #endif
04318 }
04319 #endif //#ifndef TOLUA_DISABLE
04320 
04321 /* method: new of class  StandupMessage */
04322 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new01
04323 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new01(lua_State* tolua_S)
04324 {
04325  tolua_Error tolua_err;
04326  if (
04327      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
04328      !tolua_isnoobj(tolua_S,2,&tolua_err)
04329  )
04330   goto tolua_lerror;
04331  else
04332  {
04333   {
04334    fawkes::HumanoidMotionInterface::StandupMessage* tolua_ret = (fawkes::HumanoidMotionInterface::StandupMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::StandupMessage)());
04335     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::StandupMessage");
04336   }
04337  }
04338  return 1;
04339 tolua_lerror:
04340  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00(tolua_S);
04341 }
04342 #endif //#ifndef TOLUA_DISABLE
04343 
04344 /* method: new_local of class  StandupMessage */
04345 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new01_local
04346 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new01_local(lua_State* tolua_S)
04347 {
04348  tolua_Error tolua_err;
04349  if (
04350      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
04351      !tolua_isnoobj(tolua_S,2,&tolua_err)
04352  )
04353   goto tolua_lerror;
04354  else
04355  {
04356   {
04357    fawkes::HumanoidMotionInterface::StandupMessage* tolua_ret = (fawkes::HumanoidMotionInterface::StandupMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::StandupMessage)());
04358     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::StandupMessage");
04359     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04360   }
04361  }
04362  return 1;
04363 tolua_lerror:
04364  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00_local(tolua_S);
04365 }
04366 #endif //#ifndef TOLUA_DISABLE
04367 
04368 /* method: delete of class  StandupMessage */
04369 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_delete00
04370 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_delete00(lua_State* tolua_S)
04371 {
04372 #ifndef TOLUA_RELEASE
04373  tolua_Error tolua_err;
04374  if (
04375      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
04376      !tolua_isnoobj(tolua_S,2,&tolua_err)
04377  )
04378   goto tolua_lerror;
04379  else
04380 #endif
04381  {
04382   fawkes::HumanoidMotionInterface::StandupMessage* self = (fawkes::HumanoidMotionInterface::StandupMessage*)  tolua_tousertype(tolua_S,1,0);
04383 #ifndef TOLUA_RELEASE
04384   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
04385 #endif
04386   Mtolua_delete(self);
04387  }
04388  return 0;
04389 #ifndef TOLUA_RELEASE
04390  tolua_lerror:
04391  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
04392  return 0;
04393 #endif
04394 }
04395 #endif //#ifndef TOLUA_DISABLE
04396 
04397 /* method: from_pos of class  StandupMessage */
04398 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_from_pos00
04399 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_from_pos00(lua_State* tolua_S)
04400 {
04401 #ifndef TOLUA_RELEASE
04402  tolua_Error tolua_err;
04403  if (
04404      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
04405      !tolua_isnoobj(tolua_S,2,&tolua_err)
04406  )
04407   goto tolua_lerror;
04408  else
04409 #endif
04410  {
04411   fawkes::HumanoidMotionInterface::StandupMessage* self = (fawkes::HumanoidMotionInterface::StandupMessage*)  tolua_tousertype(tolua_S,1,0);
04412 #ifndef TOLUA_RELEASE
04413   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'from_pos'", NULL);
04414 #endif
04415   {
04416    fawkes::HumanoidMotionInterface::StandupEnum tolua_ret = (fawkes::HumanoidMotionInterface::StandupEnum)  self->from_pos();
04417    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04418   }
04419  }
04420  return 1;
04421 #ifndef TOLUA_RELEASE
04422  tolua_lerror:
04423  tolua_error(tolua_S,"#ferror in function 'from_pos'.",&tolua_err);
04424  return 0;
04425 #endif
04426 }
04427 #endif //#ifndef TOLUA_DISABLE
04428 
04429 /* method: set_from_pos of class  StandupMessage */
04430 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_set_from_pos00
04431 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_set_from_pos00(lua_State* tolua_S)
04432 {
04433 #ifndef TOLUA_RELEASE
04434  tolua_Error tolua_err;
04435  if (
04436      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
04437      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04438      !tolua_isnoobj(tolua_S,3,&tolua_err)
04439  )
04440   goto tolua_lerror;
04441  else
04442 #endif
04443  {
04444   fawkes::HumanoidMotionInterface::StandupMessage* self = (fawkes::HumanoidMotionInterface::StandupMessage*)  tolua_tousertype(tolua_S,1,0);
04445   const fawkes::HumanoidMotionInterface::StandupEnum new_from_pos = ((const fawkes::HumanoidMotionInterface::StandupEnum) (int)  tolua_tonumber(tolua_S,2,0));
04446 #ifndef TOLUA_RELEASE
04447   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_pos'", NULL);
04448 #endif
04449   {
04450    self->set_from_pos(new_from_pos);
04451   }
04452  }
04453  return 0;
04454 #ifndef TOLUA_RELEASE
04455  tolua_lerror:
04456  tolua_error(tolua_S,"#ferror in function 'set_from_pos'.",&tolua_err);
04457  return 0;
04458 #endif
04459 }
04460 #endif //#ifndef TOLUA_DISABLE
04461 
04462 /* method: maxlenof_from_pos of class  StandupMessage */
04463 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_maxlenof_from_pos00
04464 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_maxlenof_from_pos00(lua_State* tolua_S)
04465 {
04466 #ifndef TOLUA_RELEASE
04467  tolua_Error tolua_err;
04468  if (
04469      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::StandupMessage",0,&tolua_err) ||
04470      !tolua_isnoobj(tolua_S,2,&tolua_err)
04471  )
04472   goto tolua_lerror;
04473  else
04474 #endif
04475  {
04476   const fawkes::HumanoidMotionInterface::StandupMessage* self = (const fawkes::HumanoidMotionInterface::StandupMessage*)  tolua_tousertype(tolua_S,1,0);
04477 #ifndef TOLUA_RELEASE
04478   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_from_pos'", NULL);
04479 #endif
04480   {
04481    int tolua_ret = (int)  self->maxlenof_from_pos();
04482    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04483   }
04484  }
04485  return 1;
04486 #ifndef TOLUA_RELEASE
04487  tolua_lerror:
04488  tolua_error(tolua_S,"#ferror in function 'maxlenof_from_pos'.",&tolua_err);
04489  return 0;
04490 #endif
04491 }
04492 #endif //#ifndef TOLUA_DISABLE
04493 
04494 /* method: new of class  YawPitchHeadMessage */
04495 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new00
04496 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new00(lua_State* tolua_S)
04497 {
04498 #ifndef TOLUA_RELEASE
04499  tolua_Error tolua_err;
04500  if (
04501      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage",0,&tolua_err) ||
04502      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04503      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
04504      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
04505      !tolua_isnoobj(tolua_S,5,&tolua_err)
04506  )
04507   goto tolua_lerror;
04508  else
04509 #endif
04510  {
04511   float ini_yaw = ((float)  tolua_tonumber(tolua_S,2,0));
04512   float ini_pitch = ((float)  tolua_tonumber(tolua_S,3,0));
04513   float ini_time_sec = ((float)  tolua_tonumber(tolua_S,4,0));
04514   {
04515    fawkes::HumanoidMotionInterface::YawPitchHeadMessage* tolua_ret = (fawkes::HumanoidMotionInterface::YawPitchHeadMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::YawPitchHeadMessage)(ini_yaw,ini_pitch,ini_time_sec));
04516     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage");
04517   }
04518  }
04519  return 1;
04520 #ifndef TOLUA_RELEASE
04521  tolua_lerror:
04522  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04523  return 0;
04524 #endif
04525 }
04526 #endif //#ifndef TOLUA_DISABLE
04527 
04528 /* method: new_local of class  YawPitchHeadMessage */
04529 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new00_local
04530 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new00_local(lua_State* tolua_S)
04531 {
04532 #ifndef TOLUA_RELEASE
04533  tolua_Error tolua_err;
04534  if (
04535      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage",0,&tolua_err) ||
04536      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04537      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
04538      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
04539      !tolua_isnoobj(tolua_S,5,&tolua_err)
04540  )
04541   goto tolua_lerror;
04542  else
04543 #endif
04544  {
04545   float ini_yaw = ((float)  tolua_tonumber(tolua_S,2,0));
04546   float ini_pitch = ((float)  tolua_tonumber(tolua_S,3,0));
04547   float ini_time_sec = ((float)  tolua_tonumber(tolua_S,4,0));
04548   {
04549    fawkes::HumanoidMotionInterface::YawPitchHeadMessage* tolua_ret = (fawkes::HumanoidMotionInterface::YawPitchHeadMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::YawPitchHeadMessage)(ini_yaw,ini_pitch,ini_time_sec));
04550     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage");
04551     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04552   }
04553  }
04554  return 1;
04555 #ifndef TOLUA_RELEASE
04556  tolua_lerror:
04557  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04558  return 0;
04559 #endif
04560 }
04561 #endif //#ifndef TOLUA_DISABLE
04562 
04563 /* method: new of class  YawPitchHeadMessage */
04564 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new01
04565 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new01(lua_State* tolua_S)
04566 {
04567  tolua_Error tolua_err;
04568  if (
04569      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage",0,&tolua_err) ||
04570      !tolua_isnoobj(tolua_S,2,&tolua_err)
04571  )
04572   goto tolua_lerror;
04573  else
04574  {
04575   {
04576    fawkes::HumanoidMotionInterface::YawPitchHeadMessage* tolua_ret = (fawkes::HumanoidMotionInterface::YawPitchHeadMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::YawPitchHeadMessage)());
04577     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage");
04578   }
04579  }
04580  return 1;
04581 tolua_lerror:
04582  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new00(tolua_S);
04583 }
04584 #endif //#ifndef TOLUA_DISABLE
04585 
04586 /* method: new_local of class  YawPitchHeadMessage */
04587 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new01_local
04588 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new01_local(lua_State* tolua_S)
04589 {
04590  tolua_Error tolua_err;
04591  if (
04592      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage",0,&tolua_err) ||
04593      !tolua_isnoobj(tolua_S,2,&tolua_err)
04594  )
04595   goto tolua_lerror;
04596  else
04597  {
04598   {
04599    fawkes::HumanoidMotionInterface::YawPitchHeadMessage* tolua_ret = (fawkes::HumanoidMotionInterface::YawPitchHeadMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::YawPitchHeadMessage)());
04600     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage");
04601     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04602   }
04603  }
04604  return 1;
04605 tolua_lerror:
04606  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new00_local(tolua_S);
04607 }
04608 #endif //#ifndef TOLUA_DISABLE
04609 
04610 /* method: delete of class  YawPitchHeadMessage */
04611 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_delete00
04612 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_delete00(lua_State* tolua_S)
04613 {
04614 #ifndef TOLUA_RELEASE
04615  tolua_Error tolua_err;
04616  if (
04617      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage",0,&tolua_err) ||
04618      !tolua_isnoobj(tolua_S,2,&tolua_err)
04619  )
04620   goto tolua_lerror;
04621  else
04622 #endif
04623  {
04624   fawkes::HumanoidMotionInterface::YawPitchHeadMessage* self = (fawkes::HumanoidMotionInterface::YawPitchHeadMessage*)  tolua_tousertype(tolua_S,1,0);
04625 #ifndef TOLUA_RELEASE
04626   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
04627 #endif
04628   Mtolua_delete(self);
04629  }
04630  return 0;
04631 #ifndef TOLUA_RELEASE
04632  tolua_lerror:
04633  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
04634  return 0;
04635 #endif
04636 }
04637 #endif //#ifndef TOLUA_DISABLE
04638 
04639 /* method: yaw of class  YawPitchHeadMessage */
04640 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_yaw00
04641 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_yaw00(lua_State* tolua_S)
04642 {
04643 #ifndef TOLUA_RELEASE
04644  tolua_Error tolua_err;
04645  if (
04646      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage",0,&tolua_err) ||
04647      !tolua_isnoobj(tolua_S,2,&tolua_err)
04648  )
04649   goto tolua_lerror;
04650  else
04651 #endif
04652  {
04653   fawkes::HumanoidMotionInterface::YawPitchHeadMessage* self = (fawkes::HumanoidMotionInterface::YawPitchHeadMessage*)  tolua_tousertype(tolua_S,1,0);
04654 #ifndef TOLUA_RELEASE
04655   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'yaw'", NULL);
04656 #endif
04657   {
04658    float tolua_ret = (float)  self->yaw();
04659    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04660   }
04661  }
04662  return 1;
04663 #ifndef TOLUA_RELEASE
04664  tolua_lerror:
04665  tolua_error(tolua_S,"#ferror in function 'yaw'.",&tolua_err);
04666  return 0;
04667 #endif
04668 }
04669 #endif //#ifndef TOLUA_DISABLE
04670 
04671 /* method: set_yaw of class  YawPitchHeadMessage */
04672 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_set_yaw00
04673 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_set_yaw00(lua_State* tolua_S)
04674 {
04675 #ifndef TOLUA_RELEASE
04676  tolua_Error tolua_err;
04677  if (
04678      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage",0,&tolua_err) ||
04679      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04680      !tolua_isnoobj(tolua_S,3,&tolua_err)
04681  )
04682   goto tolua_lerror;
04683  else
04684 #endif
04685  {
04686   fawkes::HumanoidMotionInterface::YawPitchHeadMessage* self = (fawkes::HumanoidMotionInterface::YawPitchHeadMessage*)  tolua_tousertype(tolua_S,1,0);
04687   const float new_yaw = ((const float)  tolua_tonumber(tolua_S,2,0));
04688 #ifndef TOLUA_RELEASE
04689   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_yaw'", NULL);
04690 #endif
04691   {
04692    self->set_yaw(new_yaw);
04693   }
04694  }
04695  return 0;
04696 #ifndef TOLUA_RELEASE
04697  tolua_lerror:
04698  tolua_error(tolua_S,"#ferror in function 'set_yaw'.",&tolua_err);
04699  return 0;
04700 #endif
04701 }
04702 #endif //#ifndef TOLUA_DISABLE
04703 
04704 /* method: maxlenof_yaw of class  YawPitchHeadMessage */
04705 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_maxlenof_yaw00
04706 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_maxlenof_yaw00(lua_State* tolua_S)
04707 {
04708 #ifndef TOLUA_RELEASE
04709  tolua_Error tolua_err;
04710  if (
04711      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::YawPitchHeadMessage",0,&tolua_err) ||
04712      !tolua_isnoobj(tolua_S,2,&tolua_err)
04713  )
04714   goto tolua_lerror;
04715  else
04716 #endif
04717  {
04718   const fawkes::HumanoidMotionInterface::YawPitchHeadMessage* self = (const fawkes::HumanoidMotionInterface::YawPitchHeadMessage*)  tolua_tousertype(tolua_S,1,0);
04719 #ifndef TOLUA_RELEASE
04720   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_yaw'", NULL);
04721 #endif
04722   {
04723    int tolua_ret = (int)  self->maxlenof_yaw();
04724    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04725   }
04726  }
04727  return 1;
04728 #ifndef TOLUA_RELEASE
04729  tolua_lerror:
04730  tolua_error(tolua_S,"#ferror in function 'maxlenof_yaw'.",&tolua_err);
04731  return 0;
04732 #endif
04733 }
04734 #endif //#ifndef TOLUA_DISABLE
04735 
04736 /* method: pitch of class  YawPitchHeadMessage */
04737 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_pitch00
04738 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_pitch00(lua_State* tolua_S)
04739 {
04740 #ifndef TOLUA_RELEASE
04741  tolua_Error tolua_err;
04742  if (
04743      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage",0,&tolua_err) ||
04744      !tolua_isnoobj(tolua_S,2,&tolua_err)
04745  )
04746   goto tolua_lerror;
04747  else
04748 #endif
04749  {
04750   fawkes::HumanoidMotionInterface::YawPitchHeadMessage* self = (fawkes::HumanoidMotionInterface::YawPitchHeadMessage*)  tolua_tousertype(tolua_S,1,0);
04751 #ifndef TOLUA_RELEASE
04752   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pitch'", NULL);
04753 #endif
04754   {
04755    float tolua_ret = (float)  self->pitch();
04756    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04757   }
04758  }
04759  return 1;
04760 #ifndef TOLUA_RELEASE
04761  tolua_lerror:
04762  tolua_error(tolua_S,"#ferror in function 'pitch'.",&tolua_err);
04763  return 0;
04764 #endif
04765 }
04766 #endif //#ifndef TOLUA_DISABLE
04767 
04768 /* method: set_pitch of class  YawPitchHeadMessage */
04769 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_set_pitch00
04770 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_set_pitch00(lua_State* tolua_S)
04771 {
04772 #ifndef TOLUA_RELEASE
04773  tolua_Error tolua_err;
04774  if (
04775      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage",0,&tolua_err) ||
04776      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04777      !tolua_isnoobj(tolua_S,3,&tolua_err)
04778  )
04779   goto tolua_lerror;
04780  else
04781 #endif
04782  {
04783   fawkes::HumanoidMotionInterface::YawPitchHeadMessage* self = (fawkes::HumanoidMotionInterface::YawPitchHeadMessage*)  tolua_tousertype(tolua_S,1,0);
04784   const float new_pitch = ((const float)  tolua_tonumber(tolua_S,2,0));
04785 #ifndef TOLUA_RELEASE
04786   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_pitch'", NULL);
04787 #endif
04788   {
04789    self->set_pitch(new_pitch);
04790   }
04791  }
04792  return 0;
04793 #ifndef TOLUA_RELEASE
04794  tolua_lerror:
04795  tolua_error(tolua_S,"#ferror in function 'set_pitch'.",&tolua_err);
04796  return 0;
04797 #endif
04798 }
04799 #endif //#ifndef TOLUA_DISABLE
04800 
04801 /* method: maxlenof_pitch of class  YawPitchHeadMessage */
04802 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_maxlenof_pitch00
04803 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_maxlenof_pitch00(lua_State* tolua_S)
04804 {
04805 #ifndef TOLUA_RELEASE
04806  tolua_Error tolua_err;
04807  if (
04808      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::YawPitchHeadMessage",0,&tolua_err) ||
04809      !tolua_isnoobj(tolua_S,2,&tolua_err)
04810  )
04811   goto tolua_lerror;
04812  else
04813 #endif
04814  {
04815   const fawkes::HumanoidMotionInterface::YawPitchHeadMessage* self = (const fawkes::HumanoidMotionInterface::YawPitchHeadMessage*)  tolua_tousertype(tolua_S,1,0);
04816 #ifndef TOLUA_RELEASE
04817   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_pitch'", NULL);
04818 #endif
04819   {
04820    int tolua_ret = (int)  self->maxlenof_pitch();
04821    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04822   }
04823  }
04824  return 1;
04825 #ifndef TOLUA_RELEASE
04826  tolua_lerror:
04827  tolua_error(tolua_S,"#ferror in function 'maxlenof_pitch'.",&tolua_err);
04828  return 0;
04829 #endif
04830 }
04831 #endif //#ifndef TOLUA_DISABLE
04832 
04833 /* method: time_sec of class  YawPitchHeadMessage */
04834 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_time_sec00
04835 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_time_sec00(lua_State* tolua_S)
04836 {
04837 #ifndef TOLUA_RELEASE
04838  tolua_Error tolua_err;
04839  if (
04840      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage",0,&tolua_err) ||
04841      !tolua_isnoobj(tolua_S,2,&tolua_err)
04842  )
04843   goto tolua_lerror;
04844  else
04845 #endif
04846  {
04847   fawkes::HumanoidMotionInterface::YawPitchHeadMessage* self = (fawkes::HumanoidMotionInterface::YawPitchHeadMessage*)  tolua_tousertype(tolua_S,1,0);
04848 #ifndef TOLUA_RELEASE
04849   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'time_sec'", NULL);
04850 #endif
04851   {
04852    float tolua_ret = (float)  self->time_sec();
04853    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04854   }
04855  }
04856  return 1;
04857 #ifndef TOLUA_RELEASE
04858  tolua_lerror:
04859  tolua_error(tolua_S,"#ferror in function 'time_sec'.",&tolua_err);
04860  return 0;
04861 #endif
04862 }
04863 #endif //#ifndef TOLUA_DISABLE
04864 
04865 /* method: set_time_sec of class  YawPitchHeadMessage */
04866 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_set_time_sec00
04867 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_set_time_sec00(lua_State* tolua_S)
04868 {
04869 #ifndef TOLUA_RELEASE
04870  tolua_Error tolua_err;
04871  if (
04872      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::YawPitchHeadMessage",0,&tolua_err) ||
04873      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04874      !tolua_isnoobj(tolua_S,3,&tolua_err)
04875  )
04876   goto tolua_lerror;
04877  else
04878 #endif
04879  {
04880   fawkes::HumanoidMotionInterface::YawPitchHeadMessage* self = (fawkes::HumanoidMotionInterface::YawPitchHeadMessage*)  tolua_tousertype(tolua_S,1,0);
04881   const float new_time_sec = ((const float)  tolua_tonumber(tolua_S,2,0));
04882 #ifndef TOLUA_RELEASE
04883   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time_sec'", NULL);
04884 #endif
04885   {
04886    self->set_time_sec(new_time_sec);
04887   }
04888  }
04889  return 0;
04890 #ifndef TOLUA_RELEASE
04891  tolua_lerror:
04892  tolua_error(tolua_S,"#ferror in function 'set_time_sec'.",&tolua_err);
04893  return 0;
04894 #endif
04895 }
04896 #endif //#ifndef TOLUA_DISABLE
04897 
04898 /* method: maxlenof_time_sec of class  YawPitchHeadMessage */
04899 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_maxlenof_time_sec00
04900 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_maxlenof_time_sec00(lua_State* tolua_S)
04901 {
04902 #ifndef TOLUA_RELEASE
04903  tolua_Error tolua_err;
04904  if (
04905      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::YawPitchHeadMessage",0,&tolua_err) ||
04906      !tolua_isnoobj(tolua_S,2,&tolua_err)
04907  )
04908   goto tolua_lerror;
04909  else
04910 #endif
04911  {
04912   const fawkes::HumanoidMotionInterface::YawPitchHeadMessage* self = (const fawkes::HumanoidMotionInterface::YawPitchHeadMessage*)  tolua_tousertype(tolua_S,1,0);
04913 #ifndef TOLUA_RELEASE
04914   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_time_sec'", NULL);
04915 #endif
04916   {
04917    int tolua_ret = (int)  self->maxlenof_time_sec();
04918    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04919   }
04920  }
04921  return 1;
04922 #ifndef TOLUA_RELEASE
04923  tolua_lerror:
04924  tolua_error(tolua_S,"#ferror in function 'maxlenof_time_sec'.",&tolua_err);
04925  return 0;
04926 #endif
04927 }
04928 #endif //#ifndef TOLUA_DISABLE
04929 
04930 /* method: new of class  SetStiffnessParamsMessage */
04931 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new00
04932 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new00(lua_State* tolua_S)
04933 {
04934 #ifndef TOLUA_RELEASE
04935  tolua_Error tolua_err;
04936  if (
04937      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
04938      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04939      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
04940      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
04941      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
04942      !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
04943      !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
04944      !tolua_isnumber(tolua_S,8,0,&tolua_err) ||
04945      !tolua_isnumber(tolua_S,9,0,&tolua_err) ||
04946      !tolua_isnumber(tolua_S,10,0,&tolua_err) ||
04947      !tolua_isnumber(tolua_S,11,0,&tolua_err) ||
04948      !tolua_isnumber(tolua_S,12,0,&tolua_err) ||
04949      !tolua_isnumber(tolua_S,13,0,&tolua_err) ||
04950      !tolua_isnumber(tolua_S,14,0,&tolua_err) ||
04951      !tolua_isnumber(tolua_S,15,0,&tolua_err) ||
04952      !tolua_isnumber(tolua_S,16,0,&tolua_err) ||
04953      !tolua_isnumber(tolua_S,17,0,&tolua_err) ||
04954      !tolua_isnumber(tolua_S,18,0,&tolua_err) ||
04955      !tolua_isnumber(tolua_S,19,0,&tolua_err) ||
04956      !tolua_isnumber(tolua_S,20,0,&tolua_err) ||
04957      !tolua_isnumber(tolua_S,21,0,&tolua_err) ||
04958      !tolua_isnumber(tolua_S,22,0,&tolua_err) ||
04959      !tolua_isnumber(tolua_S,23,0,&tolua_err) ||
04960      !tolua_isnumber(tolua_S,24,0,&tolua_err) ||
04961      !tolua_isnoobj(tolua_S,25,&tolua_err)
04962  )
04963   goto tolua_lerror;
04964  else
04965 #endif
04966  {
04967   fawkes::HumanoidMotionInterface::StiffnessMotionPatternEnum ini_motion_pattern = ((fawkes::HumanoidMotionInterface::StiffnessMotionPatternEnum) (int)  tolua_tonumber(tolua_S,2,0));
04968   float ini_head_yaw = ((float)  tolua_tonumber(tolua_S,3,0));
04969   float ini_head_pitch = ((float)  tolua_tonumber(tolua_S,4,0));
04970   float ini_l_shoulder_pitch = ((float)  tolua_tonumber(tolua_S,5,0));
04971   float ini_l_shoulder_roll = ((float)  tolua_tonumber(tolua_S,6,0));
04972   float ini_l_elbow_yaw = ((float)  tolua_tonumber(tolua_S,7,0));
04973   float ini_l_elbow_roll = ((float)  tolua_tonumber(tolua_S,8,0));
04974   float ini_l_hip_yaw_pitch = ((float)  tolua_tonumber(tolua_S,9,0));
04975   float ini_l_hip_roll = ((float)  tolua_tonumber(tolua_S,10,0));
04976   float ini_l_hip_pitch = ((float)  tolua_tonumber(tolua_S,11,0));
04977   float ini_l_knee_pitch = ((float)  tolua_tonumber(tolua_S,12,0));
04978   float ini_l_ankle_pitch = ((float)  tolua_tonumber(tolua_S,13,0));
04979   float ini_l_ankle_roll = ((float)  tolua_tonumber(tolua_S,14,0));
04980   float ini_r_hip_yaw_pitch = ((float)  tolua_tonumber(tolua_S,15,0));
04981   float ini_r_hip_roll = ((float)  tolua_tonumber(tolua_S,16,0));
04982   float ini_r_hip_pitch = ((float)  tolua_tonumber(tolua_S,17,0));
04983   float ini_r_knee_pitch = ((float)  tolua_tonumber(tolua_S,18,0));
04984   float ini_r_ankle_pitch = ((float)  tolua_tonumber(tolua_S,19,0));
04985   float ini_r_ankle_roll = ((float)  tolua_tonumber(tolua_S,20,0));
04986   float ini_r_shoulder_pitch = ((float)  tolua_tonumber(tolua_S,21,0));
04987   float ini_r_shoulder_roll = ((float)  tolua_tonumber(tolua_S,22,0));
04988   float ini_r_elbow_yaw = ((float)  tolua_tonumber(tolua_S,23,0));
04989   float ini_r_elbow_roll = ((float)  tolua_tonumber(tolua_S,24,0));
04990   {
04991    fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* tolua_ret = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage)(ini_motion_pattern,ini_head_yaw,ini_head_pitch,ini_l_shoulder_pitch,ini_l_shoulder_roll,ini_l_elbow_yaw,ini_l_elbow_roll,ini_l_hip_yaw_pitch,ini_l_hip_roll,ini_l_hip_pitch,ini_l_knee_pitch,ini_l_ankle_pitch,ini_l_ankle_roll,ini_r_hip_yaw_pitch,ini_r_hip_roll,ini_r_hip_pitch,ini_r_knee_pitch,ini_r_ankle_pitch,ini_r_ankle_roll,ini_r_shoulder_pitch,ini_r_shoulder_roll,ini_r_elbow_yaw,ini_r_elbow_roll));
04992     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage");
04993   }
04994  }
04995  return 1;
04996 #ifndef TOLUA_RELEASE
04997  tolua_lerror:
04998  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04999  return 0;
05000 #endif
05001 }
05002 #endif //#ifndef TOLUA_DISABLE
05003 
05004 /* method: new_local of class  SetStiffnessParamsMessage */
05005 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new00_local
05006 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new00_local(lua_State* tolua_S)
05007 {
05008 #ifndef TOLUA_RELEASE
05009  tolua_Error tolua_err;
05010  if (
05011      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05012      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05013      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
05014      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
05015      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
05016      !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
05017      !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
05018      !tolua_isnumber(tolua_S,8,0,&tolua_err) ||
05019      !tolua_isnumber(tolua_S,9,0,&tolua_err) ||
05020      !tolua_isnumber(tolua_S,10,0,&tolua_err) ||
05021      !tolua_isnumber(tolua_S,11,0,&tolua_err) ||
05022      !tolua_isnumber(tolua_S,12,0,&tolua_err) ||
05023      !tolua_isnumber(tolua_S,13,0,&tolua_err) ||
05024      !tolua_isnumber(tolua_S,14,0,&tolua_err) ||
05025      !tolua_isnumber(tolua_S,15,0,&tolua_err) ||
05026      !tolua_isnumber(tolua_S,16,0,&tolua_err) ||
05027      !tolua_isnumber(tolua_S,17,0,&tolua_err) ||
05028      !tolua_isnumber(tolua_S,18,0,&tolua_err) ||
05029      !tolua_isnumber(tolua_S,19,0,&tolua_err) ||
05030      !tolua_isnumber(tolua_S,20,0,&tolua_err) ||
05031      !tolua_isnumber(tolua_S,21,0,&tolua_err) ||
05032      !tolua_isnumber(tolua_S,22,0,&tolua_err) ||
05033      !tolua_isnumber(tolua_S,23,0,&tolua_err) ||
05034      !tolua_isnumber(tolua_S,24,0,&tolua_err) ||
05035      !tolua_isnoobj(tolua_S,25,&tolua_err)
05036  )
05037   goto tolua_lerror;
05038  else
05039 #endif
05040  {
05041   fawkes::HumanoidMotionInterface::StiffnessMotionPatternEnum ini_motion_pattern = ((fawkes::HumanoidMotionInterface::StiffnessMotionPatternEnum) (int)  tolua_tonumber(tolua_S,2,0));
05042   float ini_head_yaw = ((float)  tolua_tonumber(tolua_S,3,0));
05043   float ini_head_pitch = ((float)  tolua_tonumber(tolua_S,4,0));
05044   float ini_l_shoulder_pitch = ((float)  tolua_tonumber(tolua_S,5,0));
05045   float ini_l_shoulder_roll = ((float)  tolua_tonumber(tolua_S,6,0));
05046   float ini_l_elbow_yaw = ((float)  tolua_tonumber(tolua_S,7,0));
05047   float ini_l_elbow_roll = ((float)  tolua_tonumber(tolua_S,8,0));
05048   float ini_l_hip_yaw_pitch = ((float)  tolua_tonumber(tolua_S,9,0));
05049   float ini_l_hip_roll = ((float)  tolua_tonumber(tolua_S,10,0));
05050   float ini_l_hip_pitch = ((float)  tolua_tonumber(tolua_S,11,0));
05051   float ini_l_knee_pitch = ((float)  tolua_tonumber(tolua_S,12,0));
05052   float ini_l_ankle_pitch = ((float)  tolua_tonumber(tolua_S,13,0));
05053   float ini_l_ankle_roll = ((float)  tolua_tonumber(tolua_S,14,0));
05054   float ini_r_hip_yaw_pitch = ((float)  tolua_tonumber(tolua_S,15,0));
05055   float ini_r_hip_roll = ((float)  tolua_tonumber(tolua_S,16,0));
05056   float ini_r_hip_pitch = ((float)  tolua_tonumber(tolua_S,17,0));
05057   float ini_r_knee_pitch = ((float)  tolua_tonumber(tolua_S,18,0));
05058   float ini_r_ankle_pitch = ((float)  tolua_tonumber(tolua_S,19,0));
05059   float ini_r_ankle_roll = ((float)  tolua_tonumber(tolua_S,20,0));
05060   float ini_r_shoulder_pitch = ((float)  tolua_tonumber(tolua_S,21,0));
05061   float ini_r_shoulder_roll = ((float)  tolua_tonumber(tolua_S,22,0));
05062   float ini_r_elbow_yaw = ((float)  tolua_tonumber(tolua_S,23,0));
05063   float ini_r_elbow_roll = ((float)  tolua_tonumber(tolua_S,24,0));
05064   {
05065    fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* tolua_ret = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage)(ini_motion_pattern,ini_head_yaw,ini_head_pitch,ini_l_shoulder_pitch,ini_l_shoulder_roll,ini_l_elbow_yaw,ini_l_elbow_roll,ini_l_hip_yaw_pitch,ini_l_hip_roll,ini_l_hip_pitch,ini_l_knee_pitch,ini_l_ankle_pitch,ini_l_ankle_roll,ini_r_hip_yaw_pitch,ini_r_hip_roll,ini_r_hip_pitch,ini_r_knee_pitch,ini_r_ankle_pitch,ini_r_ankle_roll,ini_r_shoulder_pitch,ini_r_shoulder_roll,ini_r_elbow_yaw,ini_r_elbow_roll));
05066     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage");
05067     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
05068   }
05069  }
05070  return 1;
05071 #ifndef TOLUA_RELEASE
05072  tolua_lerror:
05073  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
05074  return 0;
05075 #endif
05076 }
05077 #endif //#ifndef TOLUA_DISABLE
05078 
05079 /* method: new of class  SetStiffnessParamsMessage */
05080 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new01
05081 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new01(lua_State* tolua_S)
05082 {
05083  tolua_Error tolua_err;
05084  if (
05085      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05086      !tolua_isnoobj(tolua_S,2,&tolua_err)
05087  )
05088   goto tolua_lerror;
05089  else
05090  {
05091   {
05092    fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* tolua_ret = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage)());
05093     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage");
05094   }
05095  }
05096  return 1;
05097 tolua_lerror:
05098  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new00(tolua_S);
05099 }
05100 #endif //#ifndef TOLUA_DISABLE
05101 
05102 /* method: new_local of class  SetStiffnessParamsMessage */
05103 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new01_local
05104 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new01_local(lua_State* tolua_S)
05105 {
05106  tolua_Error tolua_err;
05107  if (
05108      !tolua_isusertable(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05109      !tolua_isnoobj(tolua_S,2,&tolua_err)
05110  )
05111   goto tolua_lerror;
05112  else
05113  {
05114   {
05115    fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* tolua_ret = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  Mtolua_new((fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage)());
05116     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage");
05117     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
05118   }
05119  }
05120  return 1;
05121 tolua_lerror:
05122  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new00_local(tolua_S);
05123 }
05124 #endif //#ifndef TOLUA_DISABLE
05125 
05126 /* method: delete of class  SetStiffnessParamsMessage */
05127 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_delete00
05128 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_delete00(lua_State* tolua_S)
05129 {
05130 #ifndef TOLUA_RELEASE
05131  tolua_Error tolua_err;
05132  if (
05133      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05134      !tolua_isnoobj(tolua_S,2,&tolua_err)
05135  )
05136   goto tolua_lerror;
05137  else
05138 #endif
05139  {
05140   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05141 #ifndef TOLUA_RELEASE
05142   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
05143 #endif
05144   Mtolua_delete(self);
05145  }
05146  return 0;
05147 #ifndef TOLUA_RELEASE
05148  tolua_lerror:
05149  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
05150  return 0;
05151 #endif
05152 }
05153 #endif //#ifndef TOLUA_DISABLE
05154 
05155 /* method: motion_pattern of class  SetStiffnessParamsMessage */
05156 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_motion_pattern00
05157 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_motion_pattern00(lua_State* tolua_S)
05158 {
05159 #ifndef TOLUA_RELEASE
05160  tolua_Error tolua_err;
05161  if (
05162      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05163      !tolua_isnoobj(tolua_S,2,&tolua_err)
05164  )
05165   goto tolua_lerror;
05166  else
05167 #endif
05168  {
05169   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05170 #ifndef TOLUA_RELEASE
05171   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'motion_pattern'", NULL);
05172 #endif
05173   {
05174    fawkes::HumanoidMotionInterface::StiffnessMotionPatternEnum tolua_ret = (fawkes::HumanoidMotionInterface::StiffnessMotionPatternEnum)  self->motion_pattern();
05175    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05176   }
05177  }
05178  return 1;
05179 #ifndef TOLUA_RELEASE
05180  tolua_lerror:
05181  tolua_error(tolua_S,"#ferror in function 'motion_pattern'.",&tolua_err);
05182  return 0;
05183 #endif
05184 }
05185 #endif //#ifndef TOLUA_DISABLE
05186 
05187 /* method: set_motion_pattern of class  SetStiffnessParamsMessage */
05188 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_motion_pattern00
05189 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_motion_pattern00(lua_State* tolua_S)
05190 {
05191 #ifndef TOLUA_RELEASE
05192  tolua_Error tolua_err;
05193  if (
05194      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05195      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05196      !tolua_isnoobj(tolua_S,3,&tolua_err)
05197  )
05198   goto tolua_lerror;
05199  else
05200 #endif
05201  {
05202   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05203   const fawkes::HumanoidMotionInterface::StiffnessMotionPatternEnum new_motion_pattern = ((const fawkes::HumanoidMotionInterface::StiffnessMotionPatternEnum) (int)  tolua_tonumber(tolua_S,2,0));
05204 #ifndef TOLUA_RELEASE
05205   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_motion_pattern'", NULL);
05206 #endif
05207   {
05208    self->set_motion_pattern(new_motion_pattern);
05209   }
05210  }
05211  return 0;
05212 #ifndef TOLUA_RELEASE
05213  tolua_lerror:
05214  tolua_error(tolua_S,"#ferror in function 'set_motion_pattern'.",&tolua_err);
05215  return 0;
05216 #endif
05217 }
05218 #endif //#ifndef TOLUA_DISABLE
05219 
05220 /* method: maxlenof_motion_pattern of class  SetStiffnessParamsMessage */
05221 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_motion_pattern00
05222 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_motion_pattern00(lua_State* tolua_S)
05223 {
05224 #ifndef TOLUA_RELEASE
05225  tolua_Error tolua_err;
05226  if (
05227      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05228      !tolua_isnoobj(tolua_S,2,&tolua_err)
05229  )
05230   goto tolua_lerror;
05231  else
05232 #endif
05233  {
05234   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05235 #ifndef TOLUA_RELEASE
05236   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_motion_pattern'", NULL);
05237 #endif
05238   {
05239    int tolua_ret = (int)  self->maxlenof_motion_pattern();
05240    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05241   }
05242  }
05243  return 1;
05244 #ifndef TOLUA_RELEASE
05245  tolua_lerror:
05246  tolua_error(tolua_S,"#ferror in function 'maxlenof_motion_pattern'.",&tolua_err);
05247  return 0;
05248 #endif
05249 }
05250 #endif //#ifndef TOLUA_DISABLE
05251 
05252 /* method: head_yaw of class  SetStiffnessParamsMessage */
05253 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_head_yaw00
05254 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_head_yaw00(lua_State* tolua_S)
05255 {
05256 #ifndef TOLUA_RELEASE
05257  tolua_Error tolua_err;
05258  if (
05259      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05260      !tolua_isnoobj(tolua_S,2,&tolua_err)
05261  )
05262   goto tolua_lerror;
05263  else
05264 #endif
05265  {
05266   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05267 #ifndef TOLUA_RELEASE
05268   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'head_yaw'", NULL);
05269 #endif
05270   {
05271    float tolua_ret = (float)  self->head_yaw();
05272    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05273   }
05274  }
05275  return 1;
05276 #ifndef TOLUA_RELEASE
05277  tolua_lerror:
05278  tolua_error(tolua_S,"#ferror in function 'head_yaw'.",&tolua_err);
05279  return 0;
05280 #endif
05281 }
05282 #endif //#ifndef TOLUA_DISABLE
05283 
05284 /* method: set_head_yaw of class  SetStiffnessParamsMessage */
05285 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_head_yaw00
05286 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_head_yaw00(lua_State* tolua_S)
05287 {
05288 #ifndef TOLUA_RELEASE
05289  tolua_Error tolua_err;
05290  if (
05291      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05292      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05293      !tolua_isnoobj(tolua_S,3,&tolua_err)
05294  )
05295   goto tolua_lerror;
05296  else
05297 #endif
05298  {
05299   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05300   const float new_head_yaw = ((const float)  tolua_tonumber(tolua_S,2,0));
05301 #ifndef TOLUA_RELEASE
05302   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_head_yaw'", NULL);
05303 #endif
05304   {
05305    self->set_head_yaw(new_head_yaw);
05306   }
05307  }
05308  return 0;
05309 #ifndef TOLUA_RELEASE
05310  tolua_lerror:
05311  tolua_error(tolua_S,"#ferror in function 'set_head_yaw'.",&tolua_err);
05312  return 0;
05313 #endif
05314 }
05315 #endif //#ifndef TOLUA_DISABLE
05316 
05317 /* method: maxlenof_head_yaw of class  SetStiffnessParamsMessage */
05318 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_head_yaw00
05319 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_head_yaw00(lua_State* tolua_S)
05320 {
05321 #ifndef TOLUA_RELEASE
05322  tolua_Error tolua_err;
05323  if (
05324      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05325      !tolua_isnoobj(tolua_S,2,&tolua_err)
05326  )
05327   goto tolua_lerror;
05328  else
05329 #endif
05330  {
05331   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05332 #ifndef TOLUA_RELEASE
05333   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_head_yaw'", NULL);
05334 #endif
05335   {
05336    int tolua_ret = (int)  self->maxlenof_head_yaw();
05337    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05338   }
05339  }
05340  return 1;
05341 #ifndef TOLUA_RELEASE
05342  tolua_lerror:
05343  tolua_error(tolua_S,"#ferror in function 'maxlenof_head_yaw'.",&tolua_err);
05344  return 0;
05345 #endif
05346 }
05347 #endif //#ifndef TOLUA_DISABLE
05348 
05349 /* method: head_pitch of class  SetStiffnessParamsMessage */
05350 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_head_pitch00
05351 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_head_pitch00(lua_State* tolua_S)
05352 {
05353 #ifndef TOLUA_RELEASE
05354  tolua_Error tolua_err;
05355  if (
05356      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05357      !tolua_isnoobj(tolua_S,2,&tolua_err)
05358  )
05359   goto tolua_lerror;
05360  else
05361 #endif
05362  {
05363   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05364 #ifndef TOLUA_RELEASE
05365   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'head_pitch'", NULL);
05366 #endif
05367   {
05368    float tolua_ret = (float)  self->head_pitch();
05369    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05370   }
05371  }
05372  return 1;
05373 #ifndef TOLUA_RELEASE
05374  tolua_lerror:
05375  tolua_error(tolua_S,"#ferror in function 'head_pitch'.",&tolua_err);
05376  return 0;
05377 #endif
05378 }
05379 #endif //#ifndef TOLUA_DISABLE
05380 
05381 /* method: set_head_pitch of class  SetStiffnessParamsMessage */
05382 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_head_pitch00
05383 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_head_pitch00(lua_State* tolua_S)
05384 {
05385 #ifndef TOLUA_RELEASE
05386  tolua_Error tolua_err;
05387  if (
05388      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05389      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05390      !tolua_isnoobj(tolua_S,3,&tolua_err)
05391  )
05392   goto tolua_lerror;
05393  else
05394 #endif
05395  {
05396   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05397   const float new_head_pitch = ((const float)  tolua_tonumber(tolua_S,2,0));
05398 #ifndef TOLUA_RELEASE
05399   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_head_pitch'", NULL);
05400 #endif
05401   {
05402    self->set_head_pitch(new_head_pitch);
05403   }
05404  }
05405  return 0;
05406 #ifndef TOLUA_RELEASE
05407  tolua_lerror:
05408  tolua_error(tolua_S,"#ferror in function 'set_head_pitch'.",&tolua_err);
05409  return 0;
05410 #endif
05411 }
05412 #endif //#ifndef TOLUA_DISABLE
05413 
05414 /* method: maxlenof_head_pitch of class  SetStiffnessParamsMessage */
05415 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_head_pitch00
05416 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_head_pitch00(lua_State* tolua_S)
05417 {
05418 #ifndef TOLUA_RELEASE
05419  tolua_Error tolua_err;
05420  if (
05421      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05422      !tolua_isnoobj(tolua_S,2,&tolua_err)
05423  )
05424   goto tolua_lerror;
05425  else
05426 #endif
05427  {
05428   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05429 #ifndef TOLUA_RELEASE
05430   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_head_pitch'", NULL);
05431 #endif
05432   {
05433    int tolua_ret = (int)  self->maxlenof_head_pitch();
05434    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05435   }
05436  }
05437  return 1;
05438 #ifndef TOLUA_RELEASE
05439  tolua_lerror:
05440  tolua_error(tolua_S,"#ferror in function 'maxlenof_head_pitch'.",&tolua_err);
05441  return 0;
05442 #endif
05443 }
05444 #endif //#ifndef TOLUA_DISABLE
05445 
05446 /* method: l_shoulder_pitch of class  SetStiffnessParamsMessage */
05447 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_shoulder_pitch00
05448 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_shoulder_pitch00(lua_State* tolua_S)
05449 {
05450 #ifndef TOLUA_RELEASE
05451  tolua_Error tolua_err;
05452  if (
05453      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05454      !tolua_isnoobj(tolua_S,2,&tolua_err)
05455  )
05456   goto tolua_lerror;
05457  else
05458 #endif
05459  {
05460   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05461 #ifndef TOLUA_RELEASE
05462   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'l_shoulder_pitch'", NULL);
05463 #endif
05464   {
05465    float tolua_ret = (float)  self->l_shoulder_pitch();
05466    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05467   }
05468  }
05469  return 1;
05470 #ifndef TOLUA_RELEASE
05471  tolua_lerror:
05472  tolua_error(tolua_S,"#ferror in function 'l_shoulder_pitch'.",&tolua_err);
05473  return 0;
05474 #endif
05475 }
05476 #endif //#ifndef TOLUA_DISABLE
05477 
05478 /* method: set_l_shoulder_pitch of class  SetStiffnessParamsMessage */
05479 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_shoulder_pitch00
05480 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_shoulder_pitch00(lua_State* tolua_S)
05481 {
05482 #ifndef TOLUA_RELEASE
05483  tolua_Error tolua_err;
05484  if (
05485      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05486      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05487      !tolua_isnoobj(tolua_S,3,&tolua_err)
05488  )
05489   goto tolua_lerror;
05490  else
05491 #endif
05492  {
05493   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05494   const float new_l_shoulder_pitch = ((const float)  tolua_tonumber(tolua_S,2,0));
05495 #ifndef TOLUA_RELEASE
05496   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_l_shoulder_pitch'", NULL);
05497 #endif
05498   {
05499    self->set_l_shoulder_pitch(new_l_shoulder_pitch);
05500   }
05501  }
05502  return 0;
05503 #ifndef TOLUA_RELEASE
05504  tolua_lerror:
05505  tolua_error(tolua_S,"#ferror in function 'set_l_shoulder_pitch'.",&tolua_err);
05506  return 0;
05507 #endif
05508 }
05509 #endif //#ifndef TOLUA_DISABLE
05510 
05511 /* method: maxlenof_l_shoulder_pitch of class  SetStiffnessParamsMessage */
05512 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_shoulder_pitch00
05513 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_shoulder_pitch00(lua_State* tolua_S)
05514 {
05515 #ifndef TOLUA_RELEASE
05516  tolua_Error tolua_err;
05517  if (
05518      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05519      !tolua_isnoobj(tolua_S,2,&tolua_err)
05520  )
05521   goto tolua_lerror;
05522  else
05523 #endif
05524  {
05525   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05526 #ifndef TOLUA_RELEASE
05527   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_l_shoulder_pitch'", NULL);
05528 #endif
05529   {
05530    int tolua_ret = (int)  self->maxlenof_l_shoulder_pitch();
05531    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05532   }
05533  }
05534  return 1;
05535 #ifndef TOLUA_RELEASE
05536  tolua_lerror:
05537  tolua_error(tolua_S,"#ferror in function 'maxlenof_l_shoulder_pitch'.",&tolua_err);
05538  return 0;
05539 #endif
05540 }
05541 #endif //#ifndef TOLUA_DISABLE
05542 
05543 /* method: l_shoulder_roll of class  SetStiffnessParamsMessage */
05544 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_shoulder_roll00
05545 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_shoulder_roll00(lua_State* tolua_S)
05546 {
05547 #ifndef TOLUA_RELEASE
05548  tolua_Error tolua_err;
05549  if (
05550      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05551      !tolua_isnoobj(tolua_S,2,&tolua_err)
05552  )
05553   goto tolua_lerror;
05554  else
05555 #endif
05556  {
05557   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05558 #ifndef TOLUA_RELEASE
05559   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'l_shoulder_roll'", NULL);
05560 #endif
05561   {
05562    float tolua_ret = (float)  self->l_shoulder_roll();
05563    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05564   }
05565  }
05566  return 1;
05567 #ifndef TOLUA_RELEASE
05568  tolua_lerror:
05569  tolua_error(tolua_S,"#ferror in function 'l_shoulder_roll'.",&tolua_err);
05570  return 0;
05571 #endif
05572 }
05573 #endif //#ifndef TOLUA_DISABLE
05574 
05575 /* method: set_l_shoulder_roll of class  SetStiffnessParamsMessage */
05576 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_shoulder_roll00
05577 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_shoulder_roll00(lua_State* tolua_S)
05578 {
05579 #ifndef TOLUA_RELEASE
05580  tolua_Error tolua_err;
05581  if (
05582      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05583      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05584      !tolua_isnoobj(tolua_S,3,&tolua_err)
05585  )
05586   goto tolua_lerror;
05587  else
05588 #endif
05589  {
05590   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05591   const float new_l_shoulder_roll = ((const float)  tolua_tonumber(tolua_S,2,0));
05592 #ifndef TOLUA_RELEASE
05593   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_l_shoulder_roll'", NULL);
05594 #endif
05595   {
05596    self->set_l_shoulder_roll(new_l_shoulder_roll);
05597   }
05598  }
05599  return 0;
05600 #ifndef TOLUA_RELEASE
05601  tolua_lerror:
05602  tolua_error(tolua_S,"#ferror in function 'set_l_shoulder_roll'.",&tolua_err);
05603  return 0;
05604 #endif
05605 }
05606 #endif //#ifndef TOLUA_DISABLE
05607 
05608 /* method: maxlenof_l_shoulder_roll of class  SetStiffnessParamsMessage */
05609 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_shoulder_roll00
05610 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_shoulder_roll00(lua_State* tolua_S)
05611 {
05612 #ifndef TOLUA_RELEASE
05613  tolua_Error tolua_err;
05614  if (
05615      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05616      !tolua_isnoobj(tolua_S,2,&tolua_err)
05617  )
05618   goto tolua_lerror;
05619  else
05620 #endif
05621  {
05622   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05623 #ifndef TOLUA_RELEASE
05624   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_l_shoulder_roll'", NULL);
05625 #endif
05626   {
05627    int tolua_ret = (int)  self->maxlenof_l_shoulder_roll();
05628    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05629   }
05630  }
05631  return 1;
05632 #ifndef TOLUA_RELEASE
05633  tolua_lerror:
05634  tolua_error(tolua_S,"#ferror in function 'maxlenof_l_shoulder_roll'.",&tolua_err);
05635  return 0;
05636 #endif
05637 }
05638 #endif //#ifndef TOLUA_DISABLE
05639 
05640 /* method: l_elbow_yaw of class  SetStiffnessParamsMessage */
05641 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_elbow_yaw00
05642 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_elbow_yaw00(lua_State* tolua_S)
05643 {
05644 #ifndef TOLUA_RELEASE
05645  tolua_Error tolua_err;
05646  if (
05647      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05648      !tolua_isnoobj(tolua_S,2,&tolua_err)
05649  )
05650   goto tolua_lerror;
05651  else
05652 #endif
05653  {
05654   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05655 #ifndef TOLUA_RELEASE
05656   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'l_elbow_yaw'", NULL);
05657 #endif
05658   {
05659    float tolua_ret = (float)  self->l_elbow_yaw();
05660    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05661   }
05662  }
05663  return 1;
05664 #ifndef TOLUA_RELEASE
05665  tolua_lerror:
05666  tolua_error(tolua_S,"#ferror in function 'l_elbow_yaw'.",&tolua_err);
05667  return 0;
05668 #endif
05669 }
05670 #endif //#ifndef TOLUA_DISABLE
05671 
05672 /* method: set_l_elbow_yaw of class  SetStiffnessParamsMessage */
05673 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_elbow_yaw00
05674 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_elbow_yaw00(lua_State* tolua_S)
05675 {
05676 #ifndef TOLUA_RELEASE
05677  tolua_Error tolua_err;
05678  if (
05679      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05680      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05681      !tolua_isnoobj(tolua_S,3,&tolua_err)
05682  )
05683   goto tolua_lerror;
05684  else
05685 #endif
05686  {
05687   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05688   const float new_l_elbow_yaw = ((const float)  tolua_tonumber(tolua_S,2,0));
05689 #ifndef TOLUA_RELEASE
05690   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_l_elbow_yaw'", NULL);
05691 #endif
05692   {
05693    self->set_l_elbow_yaw(new_l_elbow_yaw);
05694   }
05695  }
05696  return 0;
05697 #ifndef TOLUA_RELEASE
05698  tolua_lerror:
05699  tolua_error(tolua_S,"#ferror in function 'set_l_elbow_yaw'.",&tolua_err);
05700  return 0;
05701 #endif
05702 }
05703 #endif //#ifndef TOLUA_DISABLE
05704 
05705 /* method: maxlenof_l_elbow_yaw of class  SetStiffnessParamsMessage */
05706 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_elbow_yaw00
05707 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_elbow_yaw00(lua_State* tolua_S)
05708 {
05709 #ifndef TOLUA_RELEASE
05710  tolua_Error tolua_err;
05711  if (
05712      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05713      !tolua_isnoobj(tolua_S,2,&tolua_err)
05714  )
05715   goto tolua_lerror;
05716  else
05717 #endif
05718  {
05719   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05720 #ifndef TOLUA_RELEASE
05721   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_l_elbow_yaw'", NULL);
05722 #endif
05723   {
05724    int tolua_ret = (int)  self->maxlenof_l_elbow_yaw();
05725    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05726   }
05727  }
05728  return 1;
05729 #ifndef TOLUA_RELEASE
05730  tolua_lerror:
05731  tolua_error(tolua_S,"#ferror in function 'maxlenof_l_elbow_yaw'.",&tolua_err);
05732  return 0;
05733 #endif
05734 }
05735 #endif //#ifndef TOLUA_DISABLE
05736 
05737 /* method: l_elbow_roll of class  SetStiffnessParamsMessage */
05738 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_elbow_roll00
05739 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_elbow_roll00(lua_State* tolua_S)
05740 {
05741 #ifndef TOLUA_RELEASE
05742  tolua_Error tolua_err;
05743  if (
05744      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05745      !tolua_isnoobj(tolua_S,2,&tolua_err)
05746  )
05747   goto tolua_lerror;
05748  else
05749 #endif
05750  {
05751   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05752 #ifndef TOLUA_RELEASE
05753   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'l_elbow_roll'", NULL);
05754 #endif
05755   {
05756    float tolua_ret = (float)  self->l_elbow_roll();
05757    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05758   }
05759  }
05760  return 1;
05761 #ifndef TOLUA_RELEASE
05762  tolua_lerror:
05763  tolua_error(tolua_S,"#ferror in function 'l_elbow_roll'.",&tolua_err);
05764  return 0;
05765 #endif
05766 }
05767 #endif //#ifndef TOLUA_DISABLE
05768 
05769 /* method: set_l_elbow_roll of class  SetStiffnessParamsMessage */
05770 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_elbow_roll00
05771 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_elbow_roll00(lua_State* tolua_S)
05772 {
05773 #ifndef TOLUA_RELEASE
05774  tolua_Error tolua_err;
05775  if (
05776      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05777      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05778      !tolua_isnoobj(tolua_S,3,&tolua_err)
05779  )
05780   goto tolua_lerror;
05781  else
05782 #endif
05783  {
05784   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05785   const float new_l_elbow_roll = ((const float)  tolua_tonumber(tolua_S,2,0));
05786 #ifndef TOLUA_RELEASE
05787   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_l_elbow_roll'", NULL);
05788 #endif
05789   {
05790    self->set_l_elbow_roll(new_l_elbow_roll);
05791   }
05792  }
05793  return 0;
05794 #ifndef TOLUA_RELEASE
05795  tolua_lerror:
05796  tolua_error(tolua_S,"#ferror in function 'set_l_elbow_roll'.",&tolua_err);
05797  return 0;
05798 #endif
05799 }
05800 #endif //#ifndef TOLUA_DISABLE
05801 
05802 /* method: maxlenof_l_elbow_roll of class  SetStiffnessParamsMessage */
05803 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_elbow_roll00
05804 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_elbow_roll00(lua_State* tolua_S)
05805 {
05806 #ifndef TOLUA_RELEASE
05807  tolua_Error tolua_err;
05808  if (
05809      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05810      !tolua_isnoobj(tolua_S,2,&tolua_err)
05811  )
05812   goto tolua_lerror;
05813  else
05814 #endif
05815  {
05816   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05817 #ifndef TOLUA_RELEASE
05818   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_l_elbow_roll'", NULL);
05819 #endif
05820   {
05821    int tolua_ret = (int)  self->maxlenof_l_elbow_roll();
05822    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05823   }
05824  }
05825  return 1;
05826 #ifndef TOLUA_RELEASE
05827  tolua_lerror:
05828  tolua_error(tolua_S,"#ferror in function 'maxlenof_l_elbow_roll'.",&tolua_err);
05829  return 0;
05830 #endif
05831 }
05832 #endif //#ifndef TOLUA_DISABLE
05833 
05834 /* method: l_hip_yaw_pitch of class  SetStiffnessParamsMessage */
05835 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_hip_yaw_pitch00
05836 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_hip_yaw_pitch00(lua_State* tolua_S)
05837 {
05838 #ifndef TOLUA_RELEASE
05839  tolua_Error tolua_err;
05840  if (
05841      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05842      !tolua_isnoobj(tolua_S,2,&tolua_err)
05843  )
05844   goto tolua_lerror;
05845  else
05846 #endif
05847  {
05848   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05849 #ifndef TOLUA_RELEASE
05850   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'l_hip_yaw_pitch'", NULL);
05851 #endif
05852   {
05853    float tolua_ret = (float)  self->l_hip_yaw_pitch();
05854    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05855   }
05856  }
05857  return 1;
05858 #ifndef TOLUA_RELEASE
05859  tolua_lerror:
05860  tolua_error(tolua_S,"#ferror in function 'l_hip_yaw_pitch'.",&tolua_err);
05861  return 0;
05862 #endif
05863 }
05864 #endif //#ifndef TOLUA_DISABLE
05865 
05866 /* method: set_l_hip_yaw_pitch of class  SetStiffnessParamsMessage */
05867 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_hip_yaw_pitch00
05868 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_hip_yaw_pitch00(lua_State* tolua_S)
05869 {
05870 #ifndef TOLUA_RELEASE
05871  tolua_Error tolua_err;
05872  if (
05873      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05874      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05875      !tolua_isnoobj(tolua_S,3,&tolua_err)
05876  )
05877   goto tolua_lerror;
05878  else
05879 #endif
05880  {
05881   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05882   const float new_l_hip_yaw_pitch = ((const float)  tolua_tonumber(tolua_S,2,0));
05883 #ifndef TOLUA_RELEASE
05884   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_l_hip_yaw_pitch'", NULL);
05885 #endif
05886   {
05887    self->set_l_hip_yaw_pitch(new_l_hip_yaw_pitch);
05888   }
05889  }
05890  return 0;
05891 #ifndef TOLUA_RELEASE
05892  tolua_lerror:
05893  tolua_error(tolua_S,"#ferror in function 'set_l_hip_yaw_pitch'.",&tolua_err);
05894  return 0;
05895 #endif
05896 }
05897 #endif //#ifndef TOLUA_DISABLE
05898 
05899 /* method: maxlenof_l_hip_yaw_pitch of class  SetStiffnessParamsMessage */
05900 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_hip_yaw_pitch00
05901 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_hip_yaw_pitch00(lua_State* tolua_S)
05902 {
05903 #ifndef TOLUA_RELEASE
05904  tolua_Error tolua_err;
05905  if (
05906      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05907      !tolua_isnoobj(tolua_S,2,&tolua_err)
05908  )
05909   goto tolua_lerror;
05910  else
05911 #endif
05912  {
05913   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05914 #ifndef TOLUA_RELEASE
05915   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_l_hip_yaw_pitch'", NULL);
05916 #endif
05917   {
05918    int tolua_ret = (int)  self->maxlenof_l_hip_yaw_pitch();
05919    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05920   }
05921  }
05922  return 1;
05923 #ifndef TOLUA_RELEASE
05924  tolua_lerror:
05925  tolua_error(tolua_S,"#ferror in function 'maxlenof_l_hip_yaw_pitch'.",&tolua_err);
05926  return 0;
05927 #endif
05928 }
05929 #endif //#ifndef TOLUA_DISABLE
05930 
05931 /* method: l_hip_roll of class  SetStiffnessParamsMessage */
05932 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_hip_roll00
05933 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_hip_roll00(lua_State* tolua_S)
05934 {
05935 #ifndef TOLUA_RELEASE
05936  tolua_Error tolua_err;
05937  if (
05938      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05939      !tolua_isnoobj(tolua_S,2,&tolua_err)
05940  )
05941   goto tolua_lerror;
05942  else
05943 #endif
05944  {
05945   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05946 #ifndef TOLUA_RELEASE
05947   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'l_hip_roll'", NULL);
05948 #endif
05949   {
05950    float tolua_ret = (float)  self->l_hip_roll();
05951    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05952   }
05953  }
05954  return 1;
05955 #ifndef TOLUA_RELEASE
05956  tolua_lerror:
05957  tolua_error(tolua_S,"#ferror in function 'l_hip_roll'.",&tolua_err);
05958  return 0;
05959 #endif
05960 }
05961 #endif //#ifndef TOLUA_DISABLE
05962 
05963 /* method: set_l_hip_roll of class  SetStiffnessParamsMessage */
05964 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_hip_roll00
05965 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_hip_roll00(lua_State* tolua_S)
05966 {
05967 #ifndef TOLUA_RELEASE
05968  tolua_Error tolua_err;
05969  if (
05970      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
05971      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05972      !tolua_isnoobj(tolua_S,3,&tolua_err)
05973  )
05974   goto tolua_lerror;
05975  else
05976 #endif
05977  {
05978   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
05979   const float new_l_hip_roll = ((const float)  tolua_tonumber(tolua_S,2,0));
05980 #ifndef TOLUA_RELEASE
05981   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_l_hip_roll'", NULL);
05982 #endif
05983   {
05984    self->set_l_hip_roll(new_l_hip_roll);
05985   }
05986  }
05987  return 0;
05988 #ifndef TOLUA_RELEASE
05989  tolua_lerror:
05990  tolua_error(tolua_S,"#ferror in function 'set_l_hip_roll'.",&tolua_err);
05991  return 0;
05992 #endif
05993 }
05994 #endif //#ifndef TOLUA_DISABLE
05995 
05996 /* method: maxlenof_l_hip_roll of class  SetStiffnessParamsMessage */
05997 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_hip_roll00
05998 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_hip_roll00(lua_State* tolua_S)
05999 {
06000 #ifndef TOLUA_RELEASE
06001  tolua_Error tolua_err;
06002  if (
06003      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06004      !tolua_isnoobj(tolua_S,2,&tolua_err)
06005  )
06006   goto tolua_lerror;
06007  else
06008 #endif
06009  {
06010   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06011 #ifndef TOLUA_RELEASE
06012   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_l_hip_roll'", NULL);
06013 #endif
06014   {
06015    int tolua_ret = (int)  self->maxlenof_l_hip_roll();
06016    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06017   }
06018  }
06019  return 1;
06020 #ifndef TOLUA_RELEASE
06021  tolua_lerror:
06022  tolua_error(tolua_S,"#ferror in function 'maxlenof_l_hip_roll'.",&tolua_err);
06023  return 0;
06024 #endif
06025 }
06026 #endif //#ifndef TOLUA_DISABLE
06027 
06028 /* method: l_hip_pitch of class  SetStiffnessParamsMessage */
06029 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_hip_pitch00
06030 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_hip_pitch00(lua_State* tolua_S)
06031 {
06032 #ifndef TOLUA_RELEASE
06033  tolua_Error tolua_err;
06034  if (
06035      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06036      !tolua_isnoobj(tolua_S,2,&tolua_err)
06037  )
06038   goto tolua_lerror;
06039  else
06040 #endif
06041  {
06042   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06043 #ifndef TOLUA_RELEASE
06044   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'l_hip_pitch'", NULL);
06045 #endif
06046   {
06047    float tolua_ret = (float)  self->l_hip_pitch();
06048    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06049   }
06050  }
06051  return 1;
06052 #ifndef TOLUA_RELEASE
06053  tolua_lerror:
06054  tolua_error(tolua_S,"#ferror in function 'l_hip_pitch'.",&tolua_err);
06055  return 0;
06056 #endif
06057 }
06058 #endif //#ifndef TOLUA_DISABLE
06059 
06060 /* method: set_l_hip_pitch of class  SetStiffnessParamsMessage */
06061 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_hip_pitch00
06062 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_hip_pitch00(lua_State* tolua_S)
06063 {
06064 #ifndef TOLUA_RELEASE
06065  tolua_Error tolua_err;
06066  if (
06067      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06068      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06069      !tolua_isnoobj(tolua_S,3,&tolua_err)
06070  )
06071   goto tolua_lerror;
06072  else
06073 #endif
06074  {
06075   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06076   const float new_l_hip_pitch = ((const float)  tolua_tonumber(tolua_S,2,0));
06077 #ifndef TOLUA_RELEASE
06078   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_l_hip_pitch'", NULL);
06079 #endif
06080   {
06081    self->set_l_hip_pitch(new_l_hip_pitch);
06082   }
06083  }
06084  return 0;
06085 #ifndef TOLUA_RELEASE
06086  tolua_lerror:
06087  tolua_error(tolua_S,"#ferror in function 'set_l_hip_pitch'.",&tolua_err);
06088  return 0;
06089 #endif
06090 }
06091 #endif //#ifndef TOLUA_DISABLE
06092 
06093 /* method: maxlenof_l_hip_pitch of class  SetStiffnessParamsMessage */
06094 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_hip_pitch00
06095 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_hip_pitch00(lua_State* tolua_S)
06096 {
06097 #ifndef TOLUA_RELEASE
06098  tolua_Error tolua_err;
06099  if (
06100      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06101      !tolua_isnoobj(tolua_S,2,&tolua_err)
06102  )
06103   goto tolua_lerror;
06104  else
06105 #endif
06106  {
06107   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06108 #ifndef TOLUA_RELEASE
06109   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_l_hip_pitch'", NULL);
06110 #endif
06111   {
06112    int tolua_ret = (int)  self->maxlenof_l_hip_pitch();
06113    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06114   }
06115  }
06116  return 1;
06117 #ifndef TOLUA_RELEASE
06118  tolua_lerror:
06119  tolua_error(tolua_S,"#ferror in function 'maxlenof_l_hip_pitch'.",&tolua_err);
06120  return 0;
06121 #endif
06122 }
06123 #endif //#ifndef TOLUA_DISABLE
06124 
06125 /* method: l_knee_pitch of class  SetStiffnessParamsMessage */
06126 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_knee_pitch00
06127 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_knee_pitch00(lua_State* tolua_S)
06128 {
06129 #ifndef TOLUA_RELEASE
06130  tolua_Error tolua_err;
06131  if (
06132      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06133      !tolua_isnoobj(tolua_S,2,&tolua_err)
06134  )
06135   goto tolua_lerror;
06136  else
06137 #endif
06138  {
06139   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06140 #ifndef TOLUA_RELEASE
06141   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'l_knee_pitch'", NULL);
06142 #endif
06143   {
06144    float tolua_ret = (float)  self->l_knee_pitch();
06145    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06146   }
06147  }
06148  return 1;
06149 #ifndef TOLUA_RELEASE
06150  tolua_lerror:
06151  tolua_error(tolua_S,"#ferror in function 'l_knee_pitch'.",&tolua_err);
06152  return 0;
06153 #endif
06154 }
06155 #endif //#ifndef TOLUA_DISABLE
06156 
06157 /* method: set_l_knee_pitch of class  SetStiffnessParamsMessage */
06158 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_knee_pitch00
06159 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_knee_pitch00(lua_State* tolua_S)
06160 {
06161 #ifndef TOLUA_RELEASE
06162  tolua_Error tolua_err;
06163  if (
06164      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06165      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06166      !tolua_isnoobj(tolua_S,3,&tolua_err)
06167  )
06168   goto tolua_lerror;
06169  else
06170 #endif
06171  {
06172   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06173   const float new_l_knee_pitch = ((const float)  tolua_tonumber(tolua_S,2,0));
06174 #ifndef TOLUA_RELEASE
06175   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_l_knee_pitch'", NULL);
06176 #endif
06177   {
06178    self->set_l_knee_pitch(new_l_knee_pitch);
06179   }
06180  }
06181  return 0;
06182 #ifndef TOLUA_RELEASE
06183  tolua_lerror:
06184  tolua_error(tolua_S,"#ferror in function 'set_l_knee_pitch'.",&tolua_err);
06185  return 0;
06186 #endif
06187 }
06188 #endif //#ifndef TOLUA_DISABLE
06189 
06190 /* method: maxlenof_l_knee_pitch of class  SetStiffnessParamsMessage */
06191 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_knee_pitch00
06192 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_knee_pitch00(lua_State* tolua_S)
06193 {
06194 #ifndef TOLUA_RELEASE
06195  tolua_Error tolua_err;
06196  if (
06197      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06198      !tolua_isnoobj(tolua_S,2,&tolua_err)
06199  )
06200   goto tolua_lerror;
06201  else
06202 #endif
06203  {
06204   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06205 #ifndef TOLUA_RELEASE
06206   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_l_knee_pitch'", NULL);
06207 #endif
06208   {
06209    int tolua_ret = (int)  self->maxlenof_l_knee_pitch();
06210    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06211   }
06212  }
06213  return 1;
06214 #ifndef TOLUA_RELEASE
06215  tolua_lerror:
06216  tolua_error(tolua_S,"#ferror in function 'maxlenof_l_knee_pitch'.",&tolua_err);
06217  return 0;
06218 #endif
06219 }
06220 #endif //#ifndef TOLUA_DISABLE
06221 
06222 /* method: l_ankle_pitch of class  SetStiffnessParamsMessage */
06223 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_ankle_pitch00
06224 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_ankle_pitch00(lua_State* tolua_S)
06225 {
06226 #ifndef TOLUA_RELEASE
06227  tolua_Error tolua_err;
06228  if (
06229      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06230      !tolua_isnoobj(tolua_S,2,&tolua_err)
06231  )
06232   goto tolua_lerror;
06233  else
06234 #endif
06235  {
06236   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06237 #ifndef TOLUA_RELEASE
06238   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'l_ankle_pitch'", NULL);
06239 #endif
06240   {
06241    float tolua_ret = (float)  self->l_ankle_pitch();
06242    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06243   }
06244  }
06245  return 1;
06246 #ifndef TOLUA_RELEASE
06247  tolua_lerror:
06248  tolua_error(tolua_S,"#ferror in function 'l_ankle_pitch'.",&tolua_err);
06249  return 0;
06250 #endif
06251 }
06252 #endif //#ifndef TOLUA_DISABLE
06253 
06254 /* method: set_l_ankle_pitch of class  SetStiffnessParamsMessage */
06255 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_ankle_pitch00
06256 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_ankle_pitch00(lua_State* tolua_S)
06257 {
06258 #ifndef TOLUA_RELEASE
06259  tolua_Error tolua_err;
06260  if (
06261      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06262      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06263      !tolua_isnoobj(tolua_S,3,&tolua_err)
06264  )
06265   goto tolua_lerror;
06266  else
06267 #endif
06268  {
06269   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06270   const float new_l_ankle_pitch = ((const float)  tolua_tonumber(tolua_S,2,0));
06271 #ifndef TOLUA_RELEASE
06272   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_l_ankle_pitch'", NULL);
06273 #endif
06274   {
06275    self->set_l_ankle_pitch(new_l_ankle_pitch);
06276   }
06277  }
06278  return 0;
06279 #ifndef TOLUA_RELEASE
06280  tolua_lerror:
06281  tolua_error(tolua_S,"#ferror in function 'set_l_ankle_pitch'.",&tolua_err);
06282  return 0;
06283 #endif
06284 }
06285 #endif //#ifndef TOLUA_DISABLE
06286 
06287 /* method: maxlenof_l_ankle_pitch of class  SetStiffnessParamsMessage */
06288 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_ankle_pitch00
06289 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_ankle_pitch00(lua_State* tolua_S)
06290 {
06291 #ifndef TOLUA_RELEASE
06292  tolua_Error tolua_err;
06293  if (
06294      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06295      !tolua_isnoobj(tolua_S,2,&tolua_err)
06296  )
06297   goto tolua_lerror;
06298  else
06299 #endif
06300  {
06301   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06302 #ifndef TOLUA_RELEASE
06303   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_l_ankle_pitch'", NULL);
06304 #endif
06305   {
06306    int tolua_ret = (int)  self->maxlenof_l_ankle_pitch();
06307    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06308   }
06309  }
06310  return 1;
06311 #ifndef TOLUA_RELEASE
06312  tolua_lerror:
06313  tolua_error(tolua_S,"#ferror in function 'maxlenof_l_ankle_pitch'.",&tolua_err);
06314  return 0;
06315 #endif
06316 }
06317 #endif //#ifndef TOLUA_DISABLE
06318 
06319 /* method: l_ankle_roll of class  SetStiffnessParamsMessage */
06320 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_ankle_roll00
06321 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_ankle_roll00(lua_State* tolua_S)
06322 {
06323 #ifndef TOLUA_RELEASE
06324  tolua_Error tolua_err;
06325  if (
06326      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06327      !tolua_isnoobj(tolua_S,2,&tolua_err)
06328  )
06329   goto tolua_lerror;
06330  else
06331 #endif
06332  {
06333   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06334 #ifndef TOLUA_RELEASE
06335   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'l_ankle_roll'", NULL);
06336 #endif
06337   {
06338    float tolua_ret = (float)  self->l_ankle_roll();
06339    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06340   }
06341  }
06342  return 1;
06343 #ifndef TOLUA_RELEASE
06344  tolua_lerror:
06345  tolua_error(tolua_S,"#ferror in function 'l_ankle_roll'.",&tolua_err);
06346  return 0;
06347 #endif
06348 }
06349 #endif //#ifndef TOLUA_DISABLE
06350 
06351 /* method: set_l_ankle_roll of class  SetStiffnessParamsMessage */
06352 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_ankle_roll00
06353 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_ankle_roll00(lua_State* tolua_S)
06354 {
06355 #ifndef TOLUA_RELEASE
06356  tolua_Error tolua_err;
06357  if (
06358      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06359      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06360      !tolua_isnoobj(tolua_S,3,&tolua_err)
06361  )
06362   goto tolua_lerror;
06363  else
06364 #endif
06365  {
06366   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06367   const float new_l_ankle_roll = ((const float)  tolua_tonumber(tolua_S,2,0));
06368 #ifndef TOLUA_RELEASE
06369   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_l_ankle_roll'", NULL);
06370 #endif
06371   {
06372    self->set_l_ankle_roll(new_l_ankle_roll);
06373   }
06374  }
06375  return 0;
06376 #ifndef TOLUA_RELEASE
06377  tolua_lerror:
06378  tolua_error(tolua_S,"#ferror in function 'set_l_ankle_roll'.",&tolua_err);
06379  return 0;
06380 #endif
06381 }
06382 #endif //#ifndef TOLUA_DISABLE
06383 
06384 /* method: maxlenof_l_ankle_roll of class  SetStiffnessParamsMessage */
06385 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_ankle_roll00
06386 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_ankle_roll00(lua_State* tolua_S)
06387 {
06388 #ifndef TOLUA_RELEASE
06389  tolua_Error tolua_err;
06390  if (
06391      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06392      !tolua_isnoobj(tolua_S,2,&tolua_err)
06393  )
06394   goto tolua_lerror;
06395  else
06396 #endif
06397  {
06398   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06399 #ifndef TOLUA_RELEASE
06400   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_l_ankle_roll'", NULL);
06401 #endif
06402   {
06403    int tolua_ret = (int)  self->maxlenof_l_ankle_roll();
06404    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06405   }
06406  }
06407  return 1;
06408 #ifndef TOLUA_RELEASE
06409  tolua_lerror:
06410  tolua_error(tolua_S,"#ferror in function 'maxlenof_l_ankle_roll'.",&tolua_err);
06411  return 0;
06412 #endif
06413 }
06414 #endif //#ifndef TOLUA_DISABLE
06415 
06416 /* method: r_hip_yaw_pitch of class  SetStiffnessParamsMessage */
06417 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_hip_yaw_pitch00
06418 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_hip_yaw_pitch00(lua_State* tolua_S)
06419 {
06420 #ifndef TOLUA_RELEASE
06421  tolua_Error tolua_err;
06422  if (
06423      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06424      !tolua_isnoobj(tolua_S,2,&tolua_err)
06425  )
06426   goto tolua_lerror;
06427  else
06428 #endif
06429  {
06430   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06431 #ifndef TOLUA_RELEASE
06432   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'r_hip_yaw_pitch'", NULL);
06433 #endif
06434   {
06435    float tolua_ret = (float)  self->r_hip_yaw_pitch();
06436    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06437   }
06438  }
06439  return 1;
06440 #ifndef TOLUA_RELEASE
06441  tolua_lerror:
06442  tolua_error(tolua_S,"#ferror in function 'r_hip_yaw_pitch'.",&tolua_err);
06443  return 0;
06444 #endif
06445 }
06446 #endif //#ifndef TOLUA_DISABLE
06447 
06448 /* method: set_r_hip_yaw_pitch of class  SetStiffnessParamsMessage */
06449 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_hip_yaw_pitch00
06450 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_hip_yaw_pitch00(lua_State* tolua_S)
06451 {
06452 #ifndef TOLUA_RELEASE
06453  tolua_Error tolua_err;
06454  if (
06455      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06456      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06457      !tolua_isnoobj(tolua_S,3,&tolua_err)
06458  )
06459   goto tolua_lerror;
06460  else
06461 #endif
06462  {
06463   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06464   const float new_r_hip_yaw_pitch = ((const float)  tolua_tonumber(tolua_S,2,0));
06465 #ifndef TOLUA_RELEASE
06466   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_r_hip_yaw_pitch'", NULL);
06467 #endif
06468   {
06469    self->set_r_hip_yaw_pitch(new_r_hip_yaw_pitch);
06470   }
06471  }
06472  return 0;
06473 #ifndef TOLUA_RELEASE
06474  tolua_lerror:
06475  tolua_error(tolua_S,"#ferror in function 'set_r_hip_yaw_pitch'.",&tolua_err);
06476  return 0;
06477 #endif
06478 }
06479 #endif //#ifndef TOLUA_DISABLE
06480 
06481 /* method: maxlenof_r_hip_yaw_pitch of class  SetStiffnessParamsMessage */
06482 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_hip_yaw_pitch00
06483 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_hip_yaw_pitch00(lua_State* tolua_S)
06484 {
06485 #ifndef TOLUA_RELEASE
06486  tolua_Error tolua_err;
06487  if (
06488      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06489      !tolua_isnoobj(tolua_S,2,&tolua_err)
06490  )
06491   goto tolua_lerror;
06492  else
06493 #endif
06494  {
06495   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06496 #ifndef TOLUA_RELEASE
06497   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_r_hip_yaw_pitch'", NULL);
06498 #endif
06499   {
06500    int tolua_ret = (int)  self->maxlenof_r_hip_yaw_pitch();
06501    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06502   }
06503  }
06504  return 1;
06505 #ifndef TOLUA_RELEASE
06506  tolua_lerror:
06507  tolua_error(tolua_S,"#ferror in function 'maxlenof_r_hip_yaw_pitch'.",&tolua_err);
06508  return 0;
06509 #endif
06510 }
06511 #endif //#ifndef TOLUA_DISABLE
06512 
06513 /* method: r_hip_roll of class  SetStiffnessParamsMessage */
06514 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_hip_roll00
06515 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_hip_roll00(lua_State* tolua_S)
06516 {
06517 #ifndef TOLUA_RELEASE
06518  tolua_Error tolua_err;
06519  if (
06520      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06521      !tolua_isnoobj(tolua_S,2,&tolua_err)
06522  )
06523   goto tolua_lerror;
06524  else
06525 #endif
06526  {
06527   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06528 #ifndef TOLUA_RELEASE
06529   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'r_hip_roll'", NULL);
06530 #endif
06531   {
06532    float tolua_ret = (float)  self->r_hip_roll();
06533    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06534   }
06535  }
06536  return 1;
06537 #ifndef TOLUA_RELEASE
06538  tolua_lerror:
06539  tolua_error(tolua_S,"#ferror in function 'r_hip_roll'.",&tolua_err);
06540  return 0;
06541 #endif
06542 }
06543 #endif //#ifndef TOLUA_DISABLE
06544 
06545 /* method: set_r_hip_roll of class  SetStiffnessParamsMessage */
06546 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_hip_roll00
06547 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_hip_roll00(lua_State* tolua_S)
06548 {
06549 #ifndef TOLUA_RELEASE
06550  tolua_Error tolua_err;
06551  if (
06552      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06553      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06554      !tolua_isnoobj(tolua_S,3,&tolua_err)
06555  )
06556   goto tolua_lerror;
06557  else
06558 #endif
06559  {
06560   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06561   const float new_r_hip_roll = ((const float)  tolua_tonumber(tolua_S,2,0));
06562 #ifndef TOLUA_RELEASE
06563   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_r_hip_roll'", NULL);
06564 #endif
06565   {
06566    self->set_r_hip_roll(new_r_hip_roll);
06567   }
06568  }
06569  return 0;
06570 #ifndef TOLUA_RELEASE
06571  tolua_lerror:
06572  tolua_error(tolua_S,"#ferror in function 'set_r_hip_roll'.",&tolua_err);
06573  return 0;
06574 #endif
06575 }
06576 #endif //#ifndef TOLUA_DISABLE
06577 
06578 /* method: maxlenof_r_hip_roll of class  SetStiffnessParamsMessage */
06579 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_hip_roll00
06580 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_hip_roll00(lua_State* tolua_S)
06581 {
06582 #ifndef TOLUA_RELEASE
06583  tolua_Error tolua_err;
06584  if (
06585      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06586      !tolua_isnoobj(tolua_S,2,&tolua_err)
06587  )
06588   goto tolua_lerror;
06589  else
06590 #endif
06591  {
06592   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06593 #ifndef TOLUA_RELEASE
06594   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_r_hip_roll'", NULL);
06595 #endif
06596   {
06597    int tolua_ret = (int)  self->maxlenof_r_hip_roll();
06598    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06599   }
06600  }
06601  return 1;
06602 #ifndef TOLUA_RELEASE
06603  tolua_lerror:
06604  tolua_error(tolua_S,"#ferror in function 'maxlenof_r_hip_roll'.",&tolua_err);
06605  return 0;
06606 #endif
06607 }
06608 #endif //#ifndef TOLUA_DISABLE
06609 
06610 /* method: r_hip_pitch of class  SetStiffnessParamsMessage */
06611 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_hip_pitch00
06612 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_hip_pitch00(lua_State* tolua_S)
06613 {
06614 #ifndef TOLUA_RELEASE
06615  tolua_Error tolua_err;
06616  if (
06617      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06618      !tolua_isnoobj(tolua_S,2,&tolua_err)
06619  )
06620   goto tolua_lerror;
06621  else
06622 #endif
06623  {
06624   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06625 #ifndef TOLUA_RELEASE
06626   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'r_hip_pitch'", NULL);
06627 #endif
06628   {
06629    float tolua_ret = (float)  self->r_hip_pitch();
06630    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06631   }
06632  }
06633  return 1;
06634 #ifndef TOLUA_RELEASE
06635  tolua_lerror:
06636  tolua_error(tolua_S,"#ferror in function 'r_hip_pitch'.",&tolua_err);
06637  return 0;
06638 #endif
06639 }
06640 #endif //#ifndef TOLUA_DISABLE
06641 
06642 /* method: set_r_hip_pitch of class  SetStiffnessParamsMessage */
06643 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_hip_pitch00
06644 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_hip_pitch00(lua_State* tolua_S)
06645 {
06646 #ifndef TOLUA_RELEASE
06647  tolua_Error tolua_err;
06648  if (
06649      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06650      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06651      !tolua_isnoobj(tolua_S,3,&tolua_err)
06652  )
06653   goto tolua_lerror;
06654  else
06655 #endif
06656  {
06657   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06658   const float new_r_hip_pitch = ((const float)  tolua_tonumber(tolua_S,2,0));
06659 #ifndef TOLUA_RELEASE
06660   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_r_hip_pitch'", NULL);
06661 #endif
06662   {
06663    self->set_r_hip_pitch(new_r_hip_pitch);
06664   }
06665  }
06666  return 0;
06667 #ifndef TOLUA_RELEASE
06668  tolua_lerror:
06669  tolua_error(tolua_S,"#ferror in function 'set_r_hip_pitch'.",&tolua_err);
06670  return 0;
06671 #endif
06672 }
06673 #endif //#ifndef TOLUA_DISABLE
06674 
06675 /* method: maxlenof_r_hip_pitch of class  SetStiffnessParamsMessage */
06676 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_hip_pitch00
06677 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_hip_pitch00(lua_State* tolua_S)
06678 {
06679 #ifndef TOLUA_RELEASE
06680  tolua_Error tolua_err;
06681  if (
06682      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06683      !tolua_isnoobj(tolua_S,2,&tolua_err)
06684  )
06685   goto tolua_lerror;
06686  else
06687 #endif
06688  {
06689   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06690 #ifndef TOLUA_RELEASE
06691   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_r_hip_pitch'", NULL);
06692 #endif
06693   {
06694    int tolua_ret = (int)  self->maxlenof_r_hip_pitch();
06695    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06696   }
06697  }
06698  return 1;
06699 #ifndef TOLUA_RELEASE
06700  tolua_lerror:
06701  tolua_error(tolua_S,"#ferror in function 'maxlenof_r_hip_pitch'.",&tolua_err);
06702  return 0;
06703 #endif
06704 }
06705 #endif //#ifndef TOLUA_DISABLE
06706 
06707 /* method: r_knee_pitch of class  SetStiffnessParamsMessage */
06708 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_knee_pitch00
06709 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_knee_pitch00(lua_State* tolua_S)
06710 {
06711 #ifndef TOLUA_RELEASE
06712  tolua_Error tolua_err;
06713  if (
06714      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06715      !tolua_isnoobj(tolua_S,2,&tolua_err)
06716  )
06717   goto tolua_lerror;
06718  else
06719 #endif
06720  {
06721   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06722 #ifndef TOLUA_RELEASE
06723   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'r_knee_pitch'", NULL);
06724 #endif
06725   {
06726    float tolua_ret = (float)  self->r_knee_pitch();
06727    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06728   }
06729  }
06730  return 1;
06731 #ifndef TOLUA_RELEASE
06732  tolua_lerror:
06733  tolua_error(tolua_S,"#ferror in function 'r_knee_pitch'.",&tolua_err);
06734  return 0;
06735 #endif
06736 }
06737 #endif //#ifndef TOLUA_DISABLE
06738 
06739 /* method: set_r_knee_pitch of class  SetStiffnessParamsMessage */
06740 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_knee_pitch00
06741 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_knee_pitch00(lua_State* tolua_S)
06742 {
06743 #ifndef TOLUA_RELEASE
06744  tolua_Error tolua_err;
06745  if (
06746      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06747      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06748      !tolua_isnoobj(tolua_S,3,&tolua_err)
06749  )
06750   goto tolua_lerror;
06751  else
06752 #endif
06753  {
06754   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06755   const float new_r_knee_pitch = ((const float)  tolua_tonumber(tolua_S,2,0));
06756 #ifndef TOLUA_RELEASE
06757   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_r_knee_pitch'", NULL);
06758 #endif
06759   {
06760    self->set_r_knee_pitch(new_r_knee_pitch);
06761   }
06762  }
06763  return 0;
06764 #ifndef TOLUA_RELEASE
06765  tolua_lerror:
06766  tolua_error(tolua_S,"#ferror in function 'set_r_knee_pitch'.",&tolua_err);
06767  return 0;
06768 #endif
06769 }
06770 #endif //#ifndef TOLUA_DISABLE
06771 
06772 /* method: maxlenof_r_knee_pitch of class  SetStiffnessParamsMessage */
06773 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_knee_pitch00
06774 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_knee_pitch00(lua_State* tolua_S)
06775 {
06776 #ifndef TOLUA_RELEASE
06777  tolua_Error tolua_err;
06778  if (
06779      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06780      !tolua_isnoobj(tolua_S,2,&tolua_err)
06781  )
06782   goto tolua_lerror;
06783  else
06784 #endif
06785  {
06786   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06787 #ifndef TOLUA_RELEASE
06788   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_r_knee_pitch'", NULL);
06789 #endif
06790   {
06791    int tolua_ret = (int)  self->maxlenof_r_knee_pitch();
06792    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06793   }
06794  }
06795  return 1;
06796 #ifndef TOLUA_RELEASE
06797  tolua_lerror:
06798  tolua_error(tolua_S,"#ferror in function 'maxlenof_r_knee_pitch'.",&tolua_err);
06799  return 0;
06800 #endif
06801 }
06802 #endif //#ifndef TOLUA_DISABLE
06803 
06804 /* method: r_ankle_pitch of class  SetStiffnessParamsMessage */
06805 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_ankle_pitch00
06806 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_ankle_pitch00(lua_State* tolua_S)
06807 {
06808 #ifndef TOLUA_RELEASE
06809  tolua_Error tolua_err;
06810  if (
06811      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06812      !tolua_isnoobj(tolua_S,2,&tolua_err)
06813  )
06814   goto tolua_lerror;
06815  else
06816 #endif
06817  {
06818   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06819 #ifndef TOLUA_RELEASE
06820   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'r_ankle_pitch'", NULL);
06821 #endif
06822   {
06823    float tolua_ret = (float)  self->r_ankle_pitch();
06824    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06825   }
06826  }
06827  return 1;
06828 #ifndef TOLUA_RELEASE
06829  tolua_lerror:
06830  tolua_error(tolua_S,"#ferror in function 'r_ankle_pitch'.",&tolua_err);
06831  return 0;
06832 #endif
06833 }
06834 #endif //#ifndef TOLUA_DISABLE
06835 
06836 /* method: set_r_ankle_pitch of class  SetStiffnessParamsMessage */
06837 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_ankle_pitch00
06838 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_ankle_pitch00(lua_State* tolua_S)
06839 {
06840 #ifndef TOLUA_RELEASE
06841  tolua_Error tolua_err;
06842  if (
06843      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06844      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06845      !tolua_isnoobj(tolua_S,3,&tolua_err)
06846  )
06847   goto tolua_lerror;
06848  else
06849 #endif
06850  {
06851   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06852   const float new_r_ankle_pitch = ((const float)  tolua_tonumber(tolua_S,2,0));
06853 #ifndef TOLUA_RELEASE
06854   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_r_ankle_pitch'", NULL);
06855 #endif
06856   {
06857    self->set_r_ankle_pitch(new_r_ankle_pitch);
06858   }
06859  }
06860  return 0;
06861 #ifndef TOLUA_RELEASE
06862  tolua_lerror:
06863  tolua_error(tolua_S,"#ferror in function 'set_r_ankle_pitch'.",&tolua_err);
06864  return 0;
06865 #endif
06866 }
06867 #endif //#ifndef TOLUA_DISABLE
06868 
06869 /* method: maxlenof_r_ankle_pitch of class  SetStiffnessParamsMessage */
06870 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_ankle_pitch00
06871 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_ankle_pitch00(lua_State* tolua_S)
06872 {
06873 #ifndef TOLUA_RELEASE
06874  tolua_Error tolua_err;
06875  if (
06876      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06877      !tolua_isnoobj(tolua_S,2,&tolua_err)
06878  )
06879   goto tolua_lerror;
06880  else
06881 #endif
06882  {
06883   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06884 #ifndef TOLUA_RELEASE
06885   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_r_ankle_pitch'", NULL);
06886 #endif
06887   {
06888    int tolua_ret = (int)  self->maxlenof_r_ankle_pitch();
06889    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06890   }
06891  }
06892  return 1;
06893 #ifndef TOLUA_RELEASE
06894  tolua_lerror:
06895  tolua_error(tolua_S,"#ferror in function 'maxlenof_r_ankle_pitch'.",&tolua_err);
06896  return 0;
06897 #endif
06898 }
06899 #endif //#ifndef TOLUA_DISABLE
06900 
06901 /* method: r_ankle_roll of class  SetStiffnessParamsMessage */
06902 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_ankle_roll00
06903 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_ankle_roll00(lua_State* tolua_S)
06904 {
06905 #ifndef TOLUA_RELEASE
06906  tolua_Error tolua_err;
06907  if (
06908      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06909      !tolua_isnoobj(tolua_S,2,&tolua_err)
06910  )
06911   goto tolua_lerror;
06912  else
06913 #endif
06914  {
06915   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06916 #ifndef TOLUA_RELEASE
06917   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'r_ankle_roll'", NULL);
06918 #endif
06919   {
06920    float tolua_ret = (float)  self->r_ankle_roll();
06921    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06922   }
06923  }
06924  return 1;
06925 #ifndef TOLUA_RELEASE
06926  tolua_lerror:
06927  tolua_error(tolua_S,"#ferror in function 'r_ankle_roll'.",&tolua_err);
06928  return 0;
06929 #endif
06930 }
06931 #endif //#ifndef TOLUA_DISABLE
06932 
06933 /* method: set_r_ankle_roll of class  SetStiffnessParamsMessage */
06934 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_ankle_roll00
06935 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_ankle_roll00(lua_State* tolua_S)
06936 {
06937 #ifndef TOLUA_RELEASE
06938  tolua_Error tolua_err;
06939  if (
06940      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06941      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06942      !tolua_isnoobj(tolua_S,3,&tolua_err)
06943  )
06944   goto tolua_lerror;
06945  else
06946 #endif
06947  {
06948   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06949   const float new_r_ankle_roll = ((const float)  tolua_tonumber(tolua_S,2,0));
06950 #ifndef TOLUA_RELEASE
06951   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_r_ankle_roll'", NULL);
06952 #endif
06953   {
06954    self->set_r_ankle_roll(new_r_ankle_roll);
06955   }
06956  }
06957  return 0;
06958 #ifndef TOLUA_RELEASE
06959  tolua_lerror:
06960  tolua_error(tolua_S,"#ferror in function 'set_r_ankle_roll'.",&tolua_err);
06961  return 0;
06962 #endif
06963 }
06964 #endif //#ifndef TOLUA_DISABLE
06965 
06966 /* method: maxlenof_r_ankle_roll of class  SetStiffnessParamsMessage */
06967 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_ankle_roll00
06968 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_ankle_roll00(lua_State* tolua_S)
06969 {
06970 #ifndef TOLUA_RELEASE
06971  tolua_Error tolua_err;
06972  if (
06973      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
06974      !tolua_isnoobj(tolua_S,2,&tolua_err)
06975  )
06976   goto tolua_lerror;
06977  else
06978 #endif
06979  {
06980   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
06981 #ifndef TOLUA_RELEASE
06982   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_r_ankle_roll'", NULL);
06983 #endif
06984   {
06985    int tolua_ret = (int)  self->maxlenof_r_ankle_roll();
06986    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06987   }
06988  }
06989  return 1;
06990 #ifndef TOLUA_RELEASE
06991  tolua_lerror:
06992  tolua_error(tolua_S,"#ferror in function 'maxlenof_r_ankle_roll'.",&tolua_err);
06993  return 0;
06994 #endif
06995 }
06996 #endif //#ifndef TOLUA_DISABLE
06997 
06998 /* method: r_shoulder_pitch of class  SetStiffnessParamsMessage */
06999 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_shoulder_pitch00
07000 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_shoulder_pitch00(lua_State* tolua_S)
07001 {
07002 #ifndef TOLUA_RELEASE
07003  tolua_Error tolua_err;
07004  if (
07005      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
07006      !tolua_isnoobj(tolua_S,2,&tolua_err)
07007  )
07008   goto tolua_lerror;
07009  else
07010 #endif
07011  {
07012   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
07013 #ifndef TOLUA_RELEASE
07014   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'r_shoulder_pitch'", NULL);
07015 #endif
07016   {
07017    float tolua_ret = (float)  self->r_shoulder_pitch();
07018    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07019   }
07020  }
07021  return 1;
07022 #ifndef TOLUA_RELEASE
07023  tolua_lerror:
07024  tolua_error(tolua_S,"#ferror in function 'r_shoulder_pitch'.",&tolua_err);
07025  return 0;
07026 #endif
07027 }
07028 #endif //#ifndef TOLUA_DISABLE
07029 
07030 /* method: set_r_shoulder_pitch of class  SetStiffnessParamsMessage */
07031 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_shoulder_pitch00
07032 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_shoulder_pitch00(lua_State* tolua_S)
07033 {
07034 #ifndef TOLUA_RELEASE
07035  tolua_Error tolua_err;
07036  if (
07037      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
07038      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07039      !tolua_isnoobj(tolua_S,3,&tolua_err)
07040  )
07041   goto tolua_lerror;
07042  else
07043 #endif
07044  {
07045   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
07046   const float new_r_shoulder_pitch = ((const float)  tolua_tonumber(tolua_S,2,0));
07047 #ifndef TOLUA_RELEASE
07048   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_r_shoulder_pitch'", NULL);
07049 #endif
07050   {
07051    self->set_r_shoulder_pitch(new_r_shoulder_pitch);
07052   }
07053  }
07054  return 0;
07055 #ifndef TOLUA_RELEASE
07056  tolua_lerror:
07057  tolua_error(tolua_S,"#ferror in function 'set_r_shoulder_pitch'.",&tolua_err);
07058  return 0;
07059 #endif
07060 }
07061 #endif //#ifndef TOLUA_DISABLE
07062 
07063 /* method: maxlenof_r_shoulder_pitch of class  SetStiffnessParamsMessage */
07064 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_shoulder_pitch00
07065 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_shoulder_pitch00(lua_State* tolua_S)
07066 {
07067 #ifndef TOLUA_RELEASE
07068  tolua_Error tolua_err;
07069  if (
07070      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
07071      !tolua_isnoobj(tolua_S,2,&tolua_err)
07072  )
07073   goto tolua_lerror;
07074  else
07075 #endif
07076  {
07077   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
07078 #ifndef TOLUA_RELEASE
07079   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_r_shoulder_pitch'", NULL);
07080 #endif
07081   {
07082    int tolua_ret = (int)  self->maxlenof_r_shoulder_pitch();
07083    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07084   }
07085  }
07086  return 1;
07087 #ifndef TOLUA_RELEASE
07088  tolua_lerror:
07089  tolua_error(tolua_S,"#ferror in function 'maxlenof_r_shoulder_pitch'.",&tolua_err);
07090  return 0;
07091 #endif
07092 }
07093 #endif //#ifndef TOLUA_DISABLE
07094 
07095 /* method: r_shoulder_roll of class  SetStiffnessParamsMessage */
07096 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_shoulder_roll00
07097 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_shoulder_roll00(lua_State* tolua_S)
07098 {
07099 #ifndef TOLUA_RELEASE
07100  tolua_Error tolua_err;
07101  if (
07102      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
07103      !tolua_isnoobj(tolua_S,2,&tolua_err)
07104  )
07105   goto tolua_lerror;
07106  else
07107 #endif
07108  {
07109   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
07110 #ifndef TOLUA_RELEASE
07111   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'r_shoulder_roll'", NULL);
07112 #endif
07113   {
07114    float tolua_ret = (float)  self->r_shoulder_roll();
07115    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07116   }
07117  }
07118  return 1;
07119 #ifndef TOLUA_RELEASE
07120  tolua_lerror:
07121  tolua_error(tolua_S,"#ferror in function 'r_shoulder_roll'.",&tolua_err);
07122  return 0;
07123 #endif
07124 }
07125 #endif //#ifndef TOLUA_DISABLE
07126 
07127 /* method: set_r_shoulder_roll of class  SetStiffnessParamsMessage */
07128 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_shoulder_roll00
07129 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_shoulder_roll00(lua_State* tolua_S)
07130 {
07131 #ifndef TOLUA_RELEASE
07132  tolua_Error tolua_err;
07133  if (
07134      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
07135      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07136      !tolua_isnoobj(tolua_S,3,&tolua_err)
07137  )
07138   goto tolua_lerror;
07139  else
07140 #endif
07141  {
07142   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
07143   const float new_r_shoulder_roll = ((const float)  tolua_tonumber(tolua_S,2,0));
07144 #ifndef TOLUA_RELEASE
07145   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_r_shoulder_roll'", NULL);
07146 #endif
07147   {
07148    self->set_r_shoulder_roll(new_r_shoulder_roll);
07149   }
07150  }
07151  return 0;
07152 #ifndef TOLUA_RELEASE
07153  tolua_lerror:
07154  tolua_error(tolua_S,"#ferror in function 'set_r_shoulder_roll'.",&tolua_err);
07155  return 0;
07156 #endif
07157 }
07158 #endif //#ifndef TOLUA_DISABLE
07159 
07160 /* method: maxlenof_r_shoulder_roll of class  SetStiffnessParamsMessage */
07161 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_shoulder_roll00
07162 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_shoulder_roll00(lua_State* tolua_S)
07163 {
07164 #ifndef TOLUA_RELEASE
07165  tolua_Error tolua_err;
07166  if (
07167      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
07168      !tolua_isnoobj(tolua_S,2,&tolua_err)
07169  )
07170   goto tolua_lerror;
07171  else
07172 #endif
07173  {
07174   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
07175 #ifndef TOLUA_RELEASE
07176   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_r_shoulder_roll'", NULL);
07177 #endif
07178   {
07179    int tolua_ret = (int)  self->maxlenof_r_shoulder_roll();
07180    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07181   }
07182  }
07183  return 1;
07184 #ifndef TOLUA_RELEASE
07185  tolua_lerror:
07186  tolua_error(tolua_S,"#ferror in function 'maxlenof_r_shoulder_roll'.",&tolua_err);
07187  return 0;
07188 #endif
07189 }
07190 #endif //#ifndef TOLUA_DISABLE
07191 
07192 /* method: r_elbow_yaw of class  SetStiffnessParamsMessage */
07193 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_elbow_yaw00
07194 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_elbow_yaw00(lua_State* tolua_S)
07195 {
07196 #ifndef TOLUA_RELEASE
07197  tolua_Error tolua_err;
07198  if (
07199      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
07200      !tolua_isnoobj(tolua_S,2,&tolua_err)
07201  )
07202   goto tolua_lerror;
07203  else
07204 #endif
07205  {
07206   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
07207 #ifndef TOLUA_RELEASE
07208   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'r_elbow_yaw'", NULL);
07209 #endif
07210   {
07211    float tolua_ret = (float)  self->r_elbow_yaw();
07212    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07213   }
07214  }
07215  return 1;
07216 #ifndef TOLUA_RELEASE
07217  tolua_lerror:
07218  tolua_error(tolua_S,"#ferror in function 'r_elbow_yaw'.",&tolua_err);
07219  return 0;
07220 #endif
07221 }
07222 #endif //#ifndef TOLUA_DISABLE
07223 
07224 /* method: set_r_elbow_yaw of class  SetStiffnessParamsMessage */
07225 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_elbow_yaw00
07226 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_elbow_yaw00(lua_State* tolua_S)
07227 {
07228 #ifndef TOLUA_RELEASE
07229  tolua_Error tolua_err;
07230  if (
07231      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
07232      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07233      !tolua_isnoobj(tolua_S,3,&tolua_err)
07234  )
07235   goto tolua_lerror;
07236  else
07237 #endif
07238  {
07239   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
07240   const float new_r_elbow_yaw = ((const float)  tolua_tonumber(tolua_S,2,0));
07241 #ifndef TOLUA_RELEASE
07242   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_r_elbow_yaw'", NULL);
07243 #endif
07244   {
07245    self->set_r_elbow_yaw(new_r_elbow_yaw);
07246   }
07247  }
07248  return 0;
07249 #ifndef TOLUA_RELEASE
07250  tolua_lerror:
07251  tolua_error(tolua_S,"#ferror in function 'set_r_elbow_yaw'.",&tolua_err);
07252  return 0;
07253 #endif
07254 }
07255 #endif //#ifndef TOLUA_DISABLE
07256 
07257 /* method: maxlenof_r_elbow_yaw of class  SetStiffnessParamsMessage */
07258 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_elbow_yaw00
07259 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_elbow_yaw00(lua_State* tolua_S)
07260 {
07261 #ifndef TOLUA_RELEASE
07262  tolua_Error tolua_err;
07263  if (
07264      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
07265      !tolua_isnoobj(tolua_S,2,&tolua_err)
07266  )
07267   goto tolua_lerror;
07268  else
07269 #endif
07270  {
07271   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
07272 #ifndef TOLUA_RELEASE
07273   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_r_elbow_yaw'", NULL);
07274 #endif
07275   {
07276    int tolua_ret = (int)  self->maxlenof_r_elbow_yaw();
07277    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07278   }
07279  }
07280  return 1;
07281 #ifndef TOLUA_RELEASE
07282  tolua_lerror:
07283  tolua_error(tolua_S,"#ferror in function 'maxlenof_r_elbow_yaw'.",&tolua_err);
07284  return 0;
07285 #endif
07286 }
07287 #endif //#ifndef TOLUA_DISABLE
07288 
07289 /* method: r_elbow_roll of class  SetStiffnessParamsMessage */
07290 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_elbow_roll00
07291 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_elbow_roll00(lua_State* tolua_S)
07292 {
07293 #ifndef TOLUA_RELEASE
07294  tolua_Error tolua_err;
07295  if (
07296      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
07297      !tolua_isnoobj(tolua_S,2,&tolua_err)
07298  )
07299   goto tolua_lerror;
07300  else
07301 #endif
07302  {
07303   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
07304 #ifndef TOLUA_RELEASE
07305   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'r_elbow_roll'", NULL);
07306 #endif
07307   {
07308    float tolua_ret = (float)  self->r_elbow_roll();
07309    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07310   }
07311  }
07312  return 1;
07313 #ifndef TOLUA_RELEASE
07314  tolua_lerror:
07315  tolua_error(tolua_S,"#ferror in function 'r_elbow_roll'.",&tolua_err);
07316  return 0;
07317 #endif
07318 }
07319 #endif //#ifndef TOLUA_DISABLE
07320 
07321 /* method: set_r_elbow_roll of class  SetStiffnessParamsMessage */
07322 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_elbow_roll00
07323 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_elbow_roll00(lua_State* tolua_S)
07324 {
07325 #ifndef TOLUA_RELEASE
07326  tolua_Error tolua_err;
07327  if (
07328      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
07329      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07330      !tolua_isnoobj(tolua_S,3,&tolua_err)
07331  )
07332   goto tolua_lerror;
07333  else
07334 #endif
07335  {
07336   fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
07337   const float new_r_elbow_roll = ((const float)  tolua_tonumber(tolua_S,2,0));
07338 #ifndef TOLUA_RELEASE
07339   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_r_elbow_roll'", NULL);
07340 #endif
07341   {
07342    self->set_r_elbow_roll(new_r_elbow_roll);
07343   }
07344  }
07345  return 0;
07346 #ifndef TOLUA_RELEASE
07347  tolua_lerror:
07348  tolua_error(tolua_S,"#ferror in function 'set_r_elbow_roll'.",&tolua_err);
07349  return 0;
07350 #endif
07351 }
07352 #endif //#ifndef TOLUA_DISABLE
07353 
07354 /* method: maxlenof_r_elbow_roll of class  SetStiffnessParamsMessage */
07355 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_elbow_roll00
07356 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_elbow_roll00(lua_State* tolua_S)
07357 {
07358 #ifndef TOLUA_RELEASE
07359  tolua_Error tolua_err;
07360  if (
07361      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage",0,&tolua_err) ||
07362      !tolua_isnoobj(tolua_S,2,&tolua_err)
07363  )
07364   goto tolua_lerror;
07365  else
07366 #endif
07367  {
07368   const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage* self = (const fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage*)  tolua_tousertype(tolua_S,1,0);
07369 #ifndef TOLUA_RELEASE
07370   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_r_elbow_roll'", NULL);
07371 #endif
07372   {
07373    int tolua_ret = (int)  self->maxlenof_r_elbow_roll();
07374    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07375   }
07376  }
07377  return 1;
07378 #ifndef TOLUA_RELEASE
07379  tolua_lerror:
07380  tolua_error(tolua_S,"#ferror in function 'maxlenof_r_elbow_roll'.",&tolua_err);
07381  return 0;
07382 #endif
07383 }
07384 #endif //#ifndef TOLUA_DISABLE
07385 
07386 /* method: is_moving of class  fawkes::HumanoidMotionInterface */
07387 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_moving00
07388 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_moving00(lua_State* tolua_S)
07389 {
07390 #ifndef TOLUA_RELEASE
07391  tolua_Error tolua_err;
07392  if (
07393      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07394      !tolua_isnoobj(tolua_S,2,&tolua_err)
07395  )
07396   goto tolua_lerror;
07397  else
07398 #endif
07399  {
07400   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07401 #ifndef TOLUA_RELEASE
07402   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_moving'", NULL);
07403 #endif
07404   {
07405    bool tolua_ret = (bool)  self->is_moving();
07406    tolua_pushboolean(tolua_S,(bool)tolua_ret);
07407   }
07408  }
07409  return 1;
07410 #ifndef TOLUA_RELEASE
07411  tolua_lerror:
07412  tolua_error(tolua_S,"#ferror in function 'is_moving'.",&tolua_err);
07413  return 0;
07414 #endif
07415 }
07416 #endif //#ifndef TOLUA_DISABLE
07417 
07418 /* method: set_moving of class  fawkes::HumanoidMotionInterface */
07419 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_moving00
07420 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_moving00(lua_State* tolua_S)
07421 {
07422 #ifndef TOLUA_RELEASE
07423  tolua_Error tolua_err;
07424  if (
07425      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07426      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
07427      !tolua_isnoobj(tolua_S,3,&tolua_err)
07428  )
07429   goto tolua_lerror;
07430  else
07431 #endif
07432  {
07433   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07434   const bool new_moving = ((const bool)  tolua_toboolean(tolua_S,2,0));
07435 #ifndef TOLUA_RELEASE
07436   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_moving'", NULL);
07437 #endif
07438   {
07439    self->set_moving(new_moving);
07440   }
07441  }
07442  return 0;
07443 #ifndef TOLUA_RELEASE
07444  tolua_lerror:
07445  tolua_error(tolua_S,"#ferror in function 'set_moving'.",&tolua_err);
07446  return 0;
07447 #endif
07448 }
07449 #endif //#ifndef TOLUA_DISABLE
07450 
07451 /* method: maxlenof_moving of class  fawkes::HumanoidMotionInterface */
07452 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_moving00
07453 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_moving00(lua_State* tolua_S)
07454 {
07455 #ifndef TOLUA_RELEASE
07456  tolua_Error tolua_err;
07457  if (
07458      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07459      !tolua_isnoobj(tolua_S,2,&tolua_err)
07460  )
07461   goto tolua_lerror;
07462  else
07463 #endif
07464  {
07465   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07466 #ifndef TOLUA_RELEASE
07467   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_moving'", NULL);
07468 #endif
07469   {
07470    int tolua_ret = (int)  self->maxlenof_moving();
07471    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07472   }
07473  }
07474  return 1;
07475 #ifndef TOLUA_RELEASE
07476  tolua_lerror:
07477  tolua_error(tolua_S,"#ferror in function 'maxlenof_moving'.",&tolua_err);
07478  return 0;
07479 #endif
07480 }
07481 #endif //#ifndef TOLUA_DISABLE
07482 
07483 /* method: supporting_leg of class  fawkes::HumanoidMotionInterface */
07484 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_supporting_leg00
07485 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_supporting_leg00(lua_State* tolua_S)
07486 {
07487 #ifndef TOLUA_RELEASE
07488  tolua_Error tolua_err;
07489  if (
07490      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07491      !tolua_isnoobj(tolua_S,2,&tolua_err)
07492  )
07493   goto tolua_lerror;
07494  else
07495 #endif
07496  {
07497   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07498 #ifndef TOLUA_RELEASE
07499   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'supporting_leg'", NULL);
07500 #endif
07501   {
07502    fawkes::HumanoidMotionInterface::LegEnum tolua_ret = (fawkes::HumanoidMotionInterface::LegEnum)  self->supporting_leg();
07503    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07504   }
07505  }
07506  return 1;
07507 #ifndef TOLUA_RELEASE
07508  tolua_lerror:
07509  tolua_error(tolua_S,"#ferror in function 'supporting_leg'.",&tolua_err);
07510  return 0;
07511 #endif
07512 }
07513 #endif //#ifndef TOLUA_DISABLE
07514 
07515 /* method: set_supporting_leg of class  fawkes::HumanoidMotionInterface */
07516 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_supporting_leg00
07517 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_supporting_leg00(lua_State* tolua_S)
07518 {
07519 #ifndef TOLUA_RELEASE
07520  tolua_Error tolua_err;
07521  if (
07522      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07523      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07524      !tolua_isnoobj(tolua_S,3,&tolua_err)
07525  )
07526   goto tolua_lerror;
07527  else
07528 #endif
07529  {
07530   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07531   const fawkes::HumanoidMotionInterface::LegEnum new_supporting_leg = ((const fawkes::HumanoidMotionInterface::LegEnum) (int)  tolua_tonumber(tolua_S,2,0));
07532 #ifndef TOLUA_RELEASE
07533   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_supporting_leg'", NULL);
07534 #endif
07535   {
07536    self->set_supporting_leg(new_supporting_leg);
07537   }
07538  }
07539  return 0;
07540 #ifndef TOLUA_RELEASE
07541  tolua_lerror:
07542  tolua_error(tolua_S,"#ferror in function 'set_supporting_leg'.",&tolua_err);
07543  return 0;
07544 #endif
07545 }
07546 #endif //#ifndef TOLUA_DISABLE
07547 
07548 /* method: maxlenof_supporting_leg of class  fawkes::HumanoidMotionInterface */
07549 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_supporting_leg00
07550 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_supporting_leg00(lua_State* tolua_S)
07551 {
07552 #ifndef TOLUA_RELEASE
07553  tolua_Error tolua_err;
07554  if (
07555      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07556      !tolua_isnoobj(tolua_S,2,&tolua_err)
07557  )
07558   goto tolua_lerror;
07559  else
07560 #endif
07561  {
07562   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07563 #ifndef TOLUA_RELEASE
07564   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_supporting_leg'", NULL);
07565 #endif
07566   {
07567    int tolua_ret = (int)  self->maxlenof_supporting_leg();
07568    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07569   }
07570  }
07571  return 1;
07572 #ifndef TOLUA_RELEASE
07573  tolua_lerror:
07574  tolua_error(tolua_S,"#ferror in function 'maxlenof_supporting_leg'.",&tolua_err);
07575  return 0;
07576 #endif
07577 }
07578 #endif //#ifndef TOLUA_DISABLE
07579 
07580 /* method: max_step_length of class  fawkes::HumanoidMotionInterface */
07581 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_max_step_length00
07582 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_max_step_length00(lua_State* tolua_S)
07583 {
07584 #ifndef TOLUA_RELEASE
07585  tolua_Error tolua_err;
07586  if (
07587      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07588      !tolua_isnoobj(tolua_S,2,&tolua_err)
07589  )
07590   goto tolua_lerror;
07591  else
07592 #endif
07593  {
07594   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07595 #ifndef TOLUA_RELEASE
07596   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_step_length'", NULL);
07597 #endif
07598   {
07599    float tolua_ret = (float)  self->max_step_length();
07600    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07601   }
07602  }
07603  return 1;
07604 #ifndef TOLUA_RELEASE
07605  tolua_lerror:
07606  tolua_error(tolua_S,"#ferror in function 'max_step_length'.",&tolua_err);
07607  return 0;
07608 #endif
07609 }
07610 #endif //#ifndef TOLUA_DISABLE
07611 
07612 /* method: set_max_step_length of class  fawkes::HumanoidMotionInterface */
07613 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_max_step_length00
07614 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_max_step_length00(lua_State* tolua_S)
07615 {
07616 #ifndef TOLUA_RELEASE
07617  tolua_Error tolua_err;
07618  if (
07619      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07620      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07621      !tolua_isnoobj(tolua_S,3,&tolua_err)
07622  )
07623   goto tolua_lerror;
07624  else
07625 #endif
07626  {
07627   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07628   const float new_max_step_length = ((const float)  tolua_tonumber(tolua_S,2,0));
07629 #ifndef TOLUA_RELEASE
07630   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_step_length'", NULL);
07631 #endif
07632   {
07633    self->set_max_step_length(new_max_step_length);
07634   }
07635  }
07636  return 0;
07637 #ifndef TOLUA_RELEASE
07638  tolua_lerror:
07639  tolua_error(tolua_S,"#ferror in function 'set_max_step_length'.",&tolua_err);
07640  return 0;
07641 #endif
07642 }
07643 #endif //#ifndef TOLUA_DISABLE
07644 
07645 /* method: maxlenof_max_step_length of class  fawkes::HumanoidMotionInterface */
07646 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_max_step_length00
07647 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_max_step_length00(lua_State* tolua_S)
07648 {
07649 #ifndef TOLUA_RELEASE
07650  tolua_Error tolua_err;
07651  if (
07652      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07653      !tolua_isnoobj(tolua_S,2,&tolua_err)
07654  )
07655   goto tolua_lerror;
07656  else
07657 #endif
07658  {
07659   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07660 #ifndef TOLUA_RELEASE
07661   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_step_length'", NULL);
07662 #endif
07663   {
07664    int tolua_ret = (int)  self->maxlenof_max_step_length();
07665    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07666   }
07667  }
07668  return 1;
07669 #ifndef TOLUA_RELEASE
07670  tolua_lerror:
07671  tolua_error(tolua_S,"#ferror in function 'maxlenof_max_step_length'.",&tolua_err);
07672  return 0;
07673 #endif
07674 }
07675 #endif //#ifndef TOLUA_DISABLE
07676 
07677 /* method: max_step_height of class  fawkes::HumanoidMotionInterface */
07678 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_max_step_height00
07679 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_max_step_height00(lua_State* tolua_S)
07680 {
07681 #ifndef TOLUA_RELEASE
07682  tolua_Error tolua_err;
07683  if (
07684      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07685      !tolua_isnoobj(tolua_S,2,&tolua_err)
07686  )
07687   goto tolua_lerror;
07688  else
07689 #endif
07690  {
07691   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07692 #ifndef TOLUA_RELEASE
07693   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_step_height'", NULL);
07694 #endif
07695   {
07696    float tolua_ret = (float)  self->max_step_height();
07697    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07698   }
07699  }
07700  return 1;
07701 #ifndef TOLUA_RELEASE
07702  tolua_lerror:
07703  tolua_error(tolua_S,"#ferror in function 'max_step_height'.",&tolua_err);
07704  return 0;
07705 #endif
07706 }
07707 #endif //#ifndef TOLUA_DISABLE
07708 
07709 /* method: set_max_step_height of class  fawkes::HumanoidMotionInterface */
07710 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_max_step_height00
07711 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_max_step_height00(lua_State* tolua_S)
07712 {
07713 #ifndef TOLUA_RELEASE
07714  tolua_Error tolua_err;
07715  if (
07716      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07717      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07718      !tolua_isnoobj(tolua_S,3,&tolua_err)
07719  )
07720   goto tolua_lerror;
07721  else
07722 #endif
07723  {
07724   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07725   const float new_max_step_height = ((const float)  tolua_tonumber(tolua_S,2,0));
07726 #ifndef TOLUA_RELEASE
07727   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_step_height'", NULL);
07728 #endif
07729   {
07730    self->set_max_step_height(new_max_step_height);
07731   }
07732  }
07733  return 0;
07734 #ifndef TOLUA_RELEASE
07735  tolua_lerror:
07736  tolua_error(tolua_S,"#ferror in function 'set_max_step_height'.",&tolua_err);
07737  return 0;
07738 #endif
07739 }
07740 #endif //#ifndef TOLUA_DISABLE
07741 
07742 /* method: maxlenof_max_step_height of class  fawkes::HumanoidMotionInterface */
07743 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_max_step_height00
07744 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_max_step_height00(lua_State* tolua_S)
07745 {
07746 #ifndef TOLUA_RELEASE
07747  tolua_Error tolua_err;
07748  if (
07749      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07750      !tolua_isnoobj(tolua_S,2,&tolua_err)
07751  )
07752   goto tolua_lerror;
07753  else
07754 #endif
07755  {
07756   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07757 #ifndef TOLUA_RELEASE
07758   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_step_height'", NULL);
07759 #endif
07760   {
07761    int tolua_ret = (int)  self->maxlenof_max_step_height();
07762    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07763   }
07764  }
07765  return 1;
07766 #ifndef TOLUA_RELEASE
07767  tolua_lerror:
07768  tolua_error(tolua_S,"#ferror in function 'maxlenof_max_step_height'.",&tolua_err);
07769  return 0;
07770 #endif
07771 }
07772 #endif //#ifndef TOLUA_DISABLE
07773 
07774 /* method: max_step_side of class  fawkes::HumanoidMotionInterface */
07775 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_max_step_side00
07776 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_max_step_side00(lua_State* tolua_S)
07777 {
07778 #ifndef TOLUA_RELEASE
07779  tolua_Error tolua_err;
07780  if (
07781      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07782      !tolua_isnoobj(tolua_S,2,&tolua_err)
07783  )
07784   goto tolua_lerror;
07785  else
07786 #endif
07787  {
07788   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07789 #ifndef TOLUA_RELEASE
07790   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_step_side'", NULL);
07791 #endif
07792   {
07793    float tolua_ret = (float)  self->max_step_side();
07794    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07795   }
07796  }
07797  return 1;
07798 #ifndef TOLUA_RELEASE
07799  tolua_lerror:
07800  tolua_error(tolua_S,"#ferror in function 'max_step_side'.",&tolua_err);
07801  return 0;
07802 #endif
07803 }
07804 #endif //#ifndef TOLUA_DISABLE
07805 
07806 /* method: set_max_step_side of class  fawkes::HumanoidMotionInterface */
07807 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_max_step_side00
07808 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_max_step_side00(lua_State* tolua_S)
07809 {
07810 #ifndef TOLUA_RELEASE
07811  tolua_Error tolua_err;
07812  if (
07813      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07814      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07815      !tolua_isnoobj(tolua_S,3,&tolua_err)
07816  )
07817   goto tolua_lerror;
07818  else
07819 #endif
07820  {
07821   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07822   const float new_max_step_side = ((const float)  tolua_tonumber(tolua_S,2,0));
07823 #ifndef TOLUA_RELEASE
07824   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_step_side'", NULL);
07825 #endif
07826   {
07827    self->set_max_step_side(new_max_step_side);
07828   }
07829  }
07830  return 0;
07831 #ifndef TOLUA_RELEASE
07832  tolua_lerror:
07833  tolua_error(tolua_S,"#ferror in function 'set_max_step_side'.",&tolua_err);
07834  return 0;
07835 #endif
07836 }
07837 #endif //#ifndef TOLUA_DISABLE
07838 
07839 /* method: maxlenof_max_step_side of class  fawkes::HumanoidMotionInterface */
07840 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_max_step_side00
07841 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_max_step_side00(lua_State* tolua_S)
07842 {
07843 #ifndef TOLUA_RELEASE
07844  tolua_Error tolua_err;
07845  if (
07846      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07847      !tolua_isnoobj(tolua_S,2,&tolua_err)
07848  )
07849   goto tolua_lerror;
07850  else
07851 #endif
07852  {
07853   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07854 #ifndef TOLUA_RELEASE
07855   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_step_side'", NULL);
07856 #endif
07857   {
07858    int tolua_ret = (int)  self->maxlenof_max_step_side();
07859    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07860   }
07861  }
07862  return 1;
07863 #ifndef TOLUA_RELEASE
07864  tolua_lerror:
07865  tolua_error(tolua_S,"#ferror in function 'maxlenof_max_step_side'.",&tolua_err);
07866  return 0;
07867 #endif
07868 }
07869 #endif //#ifndef TOLUA_DISABLE
07870 
07871 /* method: max_step_turn of class  fawkes::HumanoidMotionInterface */
07872 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_max_step_turn00
07873 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_max_step_turn00(lua_State* tolua_S)
07874 {
07875 #ifndef TOLUA_RELEASE
07876  tolua_Error tolua_err;
07877  if (
07878      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07879      !tolua_isnoobj(tolua_S,2,&tolua_err)
07880  )
07881   goto tolua_lerror;
07882  else
07883 #endif
07884  {
07885   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07886 #ifndef TOLUA_RELEASE
07887   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_step_turn'", NULL);
07888 #endif
07889   {
07890    float tolua_ret = (float)  self->max_step_turn();
07891    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07892   }
07893  }
07894  return 1;
07895 #ifndef TOLUA_RELEASE
07896  tolua_lerror:
07897  tolua_error(tolua_S,"#ferror in function 'max_step_turn'.",&tolua_err);
07898  return 0;
07899 #endif
07900 }
07901 #endif //#ifndef TOLUA_DISABLE
07902 
07903 /* method: set_max_step_turn of class  fawkes::HumanoidMotionInterface */
07904 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_max_step_turn00
07905 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_max_step_turn00(lua_State* tolua_S)
07906 {
07907 #ifndef TOLUA_RELEASE
07908  tolua_Error tolua_err;
07909  if (
07910      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07911      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07912      !tolua_isnoobj(tolua_S,3,&tolua_err)
07913  )
07914   goto tolua_lerror;
07915  else
07916 #endif
07917  {
07918   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07919   const float new_max_step_turn = ((const float)  tolua_tonumber(tolua_S,2,0));
07920 #ifndef TOLUA_RELEASE
07921   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_step_turn'", NULL);
07922 #endif
07923   {
07924    self->set_max_step_turn(new_max_step_turn);
07925   }
07926  }
07927  return 0;
07928 #ifndef TOLUA_RELEASE
07929  tolua_lerror:
07930  tolua_error(tolua_S,"#ferror in function 'set_max_step_turn'.",&tolua_err);
07931  return 0;
07932 #endif
07933 }
07934 #endif //#ifndef TOLUA_DISABLE
07935 
07936 /* method: maxlenof_max_step_turn of class  fawkes::HumanoidMotionInterface */
07937 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_max_step_turn00
07938 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_max_step_turn00(lua_State* tolua_S)
07939 {
07940 #ifndef TOLUA_RELEASE
07941  tolua_Error tolua_err;
07942  if (
07943      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07944      !tolua_isnoobj(tolua_S,2,&tolua_err)
07945  )
07946   goto tolua_lerror;
07947  else
07948 #endif
07949  {
07950   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07951 #ifndef TOLUA_RELEASE
07952   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_step_turn'", NULL);
07953 #endif
07954   {
07955    int tolua_ret = (int)  self->maxlenof_max_step_turn();
07956    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07957   }
07958  }
07959  return 1;
07960 #ifndef TOLUA_RELEASE
07961  tolua_lerror:
07962  tolua_error(tolua_S,"#ferror in function 'maxlenof_max_step_turn'.",&tolua_err);
07963  return 0;
07964 #endif
07965 }
07966 #endif //#ifndef TOLUA_DISABLE
07967 
07968 /* method: zmp_offset_forward of class  fawkes::HumanoidMotionInterface */
07969 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_zmp_offset_forward00
07970 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_zmp_offset_forward00(lua_State* tolua_S)
07971 {
07972 #ifndef TOLUA_RELEASE
07973  tolua_Error tolua_err;
07974  if (
07975      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
07976      !tolua_isnoobj(tolua_S,2,&tolua_err)
07977  )
07978   goto tolua_lerror;
07979  else
07980 #endif
07981  {
07982   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
07983 #ifndef TOLUA_RELEASE
07984   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'zmp_offset_forward'", NULL);
07985 #endif
07986   {
07987    float tolua_ret = (float)  self->zmp_offset_forward();
07988    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07989   }
07990  }
07991  return 1;
07992 #ifndef TOLUA_RELEASE
07993  tolua_lerror:
07994  tolua_error(tolua_S,"#ferror in function 'zmp_offset_forward'.",&tolua_err);
07995  return 0;
07996 #endif
07997 }
07998 #endif //#ifndef TOLUA_DISABLE
07999 
08000 /* method: set_zmp_offset_forward of class  fawkes::HumanoidMotionInterface */
08001 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_zmp_offset_forward00
08002 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_zmp_offset_forward00(lua_State* tolua_S)
08003 {
08004 #ifndef TOLUA_RELEASE
08005  tolua_Error tolua_err;
08006  if (
08007      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08008      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
08009      !tolua_isnoobj(tolua_S,3,&tolua_err)
08010  )
08011   goto tolua_lerror;
08012  else
08013 #endif
08014  {
08015   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08016   const float new_zmp_offset_forward = ((const float)  tolua_tonumber(tolua_S,2,0));
08017 #ifndef TOLUA_RELEASE
08018   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_zmp_offset_forward'", NULL);
08019 #endif
08020   {
08021    self->set_zmp_offset_forward(new_zmp_offset_forward);
08022   }
08023  }
08024  return 0;
08025 #ifndef TOLUA_RELEASE
08026  tolua_lerror:
08027  tolua_error(tolua_S,"#ferror in function 'set_zmp_offset_forward'.",&tolua_err);
08028  return 0;
08029 #endif
08030 }
08031 #endif //#ifndef TOLUA_DISABLE
08032 
08033 /* method: maxlenof_zmp_offset_forward of class  fawkes::HumanoidMotionInterface */
08034 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_zmp_offset_forward00
08035 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_zmp_offset_forward00(lua_State* tolua_S)
08036 {
08037 #ifndef TOLUA_RELEASE
08038  tolua_Error tolua_err;
08039  if (
08040      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08041      !tolua_isnoobj(tolua_S,2,&tolua_err)
08042  )
08043   goto tolua_lerror;
08044  else
08045 #endif
08046  {
08047   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08048 #ifndef TOLUA_RELEASE
08049   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_zmp_offset_forward'", NULL);
08050 #endif
08051   {
08052    int tolua_ret = (int)  self->maxlenof_zmp_offset_forward();
08053    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08054   }
08055  }
08056  return 1;
08057 #ifndef TOLUA_RELEASE
08058  tolua_lerror:
08059  tolua_error(tolua_S,"#ferror in function 'maxlenof_zmp_offset_forward'.",&tolua_err);
08060  return 0;
08061 #endif
08062 }
08063 #endif //#ifndef TOLUA_DISABLE
08064 
08065 /* method: zmp_offset_sideward of class  fawkes::HumanoidMotionInterface */
08066 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_zmp_offset_sideward00
08067 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_zmp_offset_sideward00(lua_State* tolua_S)
08068 {
08069 #ifndef TOLUA_RELEASE
08070  tolua_Error tolua_err;
08071  if (
08072      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08073      !tolua_isnoobj(tolua_S,2,&tolua_err)
08074  )
08075   goto tolua_lerror;
08076  else
08077 #endif
08078  {
08079   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08080 #ifndef TOLUA_RELEASE
08081   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'zmp_offset_sideward'", NULL);
08082 #endif
08083   {
08084    float tolua_ret = (float)  self->zmp_offset_sideward();
08085    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08086   }
08087  }
08088  return 1;
08089 #ifndef TOLUA_RELEASE
08090  tolua_lerror:
08091  tolua_error(tolua_S,"#ferror in function 'zmp_offset_sideward'.",&tolua_err);
08092  return 0;
08093 #endif
08094 }
08095 #endif //#ifndef TOLUA_DISABLE
08096 
08097 /* method: set_zmp_offset_sideward of class  fawkes::HumanoidMotionInterface */
08098 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_zmp_offset_sideward00
08099 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_zmp_offset_sideward00(lua_State* tolua_S)
08100 {
08101 #ifndef TOLUA_RELEASE
08102  tolua_Error tolua_err;
08103  if (
08104      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08105      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
08106      !tolua_isnoobj(tolua_S,3,&tolua_err)
08107  )
08108   goto tolua_lerror;
08109  else
08110 #endif
08111  {
08112   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08113   const float new_zmp_offset_sideward = ((const float)  tolua_tonumber(tolua_S,2,0));
08114 #ifndef TOLUA_RELEASE
08115   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_zmp_offset_sideward'", NULL);
08116 #endif
08117   {
08118    self->set_zmp_offset_sideward(new_zmp_offset_sideward);
08119   }
08120  }
08121  return 0;
08122 #ifndef TOLUA_RELEASE
08123  tolua_lerror:
08124  tolua_error(tolua_S,"#ferror in function 'set_zmp_offset_sideward'.",&tolua_err);
08125  return 0;
08126 #endif
08127 }
08128 #endif //#ifndef TOLUA_DISABLE
08129 
08130 /* method: maxlenof_zmp_offset_sideward of class  fawkes::HumanoidMotionInterface */
08131 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_zmp_offset_sideward00
08132 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_zmp_offset_sideward00(lua_State* tolua_S)
08133 {
08134 #ifndef TOLUA_RELEASE
08135  tolua_Error tolua_err;
08136  if (
08137      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08138      !tolua_isnoobj(tolua_S,2,&tolua_err)
08139  )
08140   goto tolua_lerror;
08141  else
08142 #endif
08143  {
08144   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08145 #ifndef TOLUA_RELEASE
08146   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_zmp_offset_sideward'", NULL);
08147 #endif
08148   {
08149    int tolua_ret = (int)  self->maxlenof_zmp_offset_sideward();
08150    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08151   }
08152  }
08153  return 1;
08154 #ifndef TOLUA_RELEASE
08155  tolua_lerror:
08156  tolua_error(tolua_S,"#ferror in function 'maxlenof_zmp_offset_sideward'.",&tolua_err);
08157  return 0;
08158 #endif
08159 }
08160 #endif //#ifndef TOLUA_DISABLE
08161 
08162 /* method: l_hip_roll_compensation of class  fawkes::HumanoidMotionInterface */
08163 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_l_hip_roll_compensation00
08164 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_l_hip_roll_compensation00(lua_State* tolua_S)
08165 {
08166 #ifndef TOLUA_RELEASE
08167  tolua_Error tolua_err;
08168  if (
08169      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08170      !tolua_isnoobj(tolua_S,2,&tolua_err)
08171  )
08172   goto tolua_lerror;
08173  else
08174 #endif
08175  {
08176   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08177 #ifndef TOLUA_RELEASE
08178   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'l_hip_roll_compensation'", NULL);
08179 #endif
08180   {
08181    float tolua_ret = (float)  self->l_hip_roll_compensation();
08182    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08183   }
08184  }
08185  return 1;
08186 #ifndef TOLUA_RELEASE
08187  tolua_lerror:
08188  tolua_error(tolua_S,"#ferror in function 'l_hip_roll_compensation'.",&tolua_err);
08189  return 0;
08190 #endif
08191 }
08192 #endif //#ifndef TOLUA_DISABLE
08193 
08194 /* method: set_l_hip_roll_compensation of class  fawkes::HumanoidMotionInterface */
08195 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_l_hip_roll_compensation00
08196 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_l_hip_roll_compensation00(lua_State* tolua_S)
08197 {
08198 #ifndef TOLUA_RELEASE
08199  tolua_Error tolua_err;
08200  if (
08201      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08202      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
08203      !tolua_isnoobj(tolua_S,3,&tolua_err)
08204  )
08205   goto tolua_lerror;
08206  else
08207 #endif
08208  {
08209   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08210   const float new_l_hip_roll_compensation = ((const float)  tolua_tonumber(tolua_S,2,0));
08211 #ifndef TOLUA_RELEASE
08212   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_l_hip_roll_compensation'", NULL);
08213 #endif
08214   {
08215    self->set_l_hip_roll_compensation(new_l_hip_roll_compensation);
08216   }
08217  }
08218  return 0;
08219 #ifndef TOLUA_RELEASE
08220  tolua_lerror:
08221  tolua_error(tolua_S,"#ferror in function 'set_l_hip_roll_compensation'.",&tolua_err);
08222  return 0;
08223 #endif
08224 }
08225 #endif //#ifndef TOLUA_DISABLE
08226 
08227 /* method: maxlenof_l_hip_roll_compensation of class  fawkes::HumanoidMotionInterface */
08228 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_l_hip_roll_compensation00
08229 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_l_hip_roll_compensation00(lua_State* tolua_S)
08230 {
08231 #ifndef TOLUA_RELEASE
08232  tolua_Error tolua_err;
08233  if (
08234      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08235      !tolua_isnoobj(tolua_S,2,&tolua_err)
08236  )
08237   goto tolua_lerror;
08238  else
08239 #endif
08240  {
08241   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08242 #ifndef TOLUA_RELEASE
08243   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_l_hip_roll_compensation'", NULL);
08244 #endif
08245   {
08246    int tolua_ret = (int)  self->maxlenof_l_hip_roll_compensation();
08247    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08248   }
08249  }
08250  return 1;
08251 #ifndef TOLUA_RELEASE
08252  tolua_lerror:
08253  tolua_error(tolua_S,"#ferror in function 'maxlenof_l_hip_roll_compensation'.",&tolua_err);
08254  return 0;
08255 #endif
08256 }
08257 #endif //#ifndef TOLUA_DISABLE
08258 
08259 /* method: r_hip_roll_compensation of class  fawkes::HumanoidMotionInterface */
08260 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_r_hip_roll_compensation00
08261 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_r_hip_roll_compensation00(lua_State* tolua_S)
08262 {
08263 #ifndef TOLUA_RELEASE
08264  tolua_Error tolua_err;
08265  if (
08266      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08267      !tolua_isnoobj(tolua_S,2,&tolua_err)
08268  )
08269   goto tolua_lerror;
08270  else
08271 #endif
08272  {
08273   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08274 #ifndef TOLUA_RELEASE
08275   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'r_hip_roll_compensation'", NULL);
08276 #endif
08277   {
08278    float tolua_ret = (float)  self->r_hip_roll_compensation();
08279    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08280   }
08281  }
08282  return 1;
08283 #ifndef TOLUA_RELEASE
08284  tolua_lerror:
08285  tolua_error(tolua_S,"#ferror in function 'r_hip_roll_compensation'.",&tolua_err);
08286  return 0;
08287 #endif
08288 }
08289 #endif //#ifndef TOLUA_DISABLE
08290 
08291 /* method: set_r_hip_roll_compensation of class  fawkes::HumanoidMotionInterface */
08292 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_r_hip_roll_compensation00
08293 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_r_hip_roll_compensation00(lua_State* tolua_S)
08294 {
08295 #ifndef TOLUA_RELEASE
08296  tolua_Error tolua_err;
08297  if (
08298      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08299      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
08300      !tolua_isnoobj(tolua_S,3,&tolua_err)
08301  )
08302   goto tolua_lerror;
08303  else
08304 #endif
08305  {
08306   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08307   const float new_r_hip_roll_compensation = ((const float)  tolua_tonumber(tolua_S,2,0));
08308 #ifndef TOLUA_RELEASE
08309   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_r_hip_roll_compensation'", NULL);
08310 #endif
08311   {
08312    self->set_r_hip_roll_compensation(new_r_hip_roll_compensation);
08313   }
08314  }
08315  return 0;
08316 #ifndef TOLUA_RELEASE
08317  tolua_lerror:
08318  tolua_error(tolua_S,"#ferror in function 'set_r_hip_roll_compensation'.",&tolua_err);
08319  return 0;
08320 #endif
08321 }
08322 #endif //#ifndef TOLUA_DISABLE
08323 
08324 /* method: maxlenof_r_hip_roll_compensation of class  fawkes::HumanoidMotionInterface */
08325 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_r_hip_roll_compensation00
08326 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_r_hip_roll_compensation00(lua_State* tolua_S)
08327 {
08328 #ifndef TOLUA_RELEASE
08329  tolua_Error tolua_err;
08330  if (
08331      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08332      !tolua_isnoobj(tolua_S,2,&tolua_err)
08333  )
08334   goto tolua_lerror;
08335  else
08336 #endif
08337  {
08338   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08339 #ifndef TOLUA_RELEASE
08340   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_r_hip_roll_compensation'", NULL);
08341 #endif
08342   {
08343    int tolua_ret = (int)  self->maxlenof_r_hip_roll_compensation();
08344    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08345   }
08346  }
08347  return 1;
08348 #ifndef TOLUA_RELEASE
08349  tolua_lerror:
08350  tolua_error(tolua_S,"#ferror in function 'maxlenof_r_hip_roll_compensation'.",&tolua_err);
08351  return 0;
08352 #endif
08353 }
08354 #endif //#ifndef TOLUA_DISABLE
08355 
08356 /* method: hip_height of class  fawkes::HumanoidMotionInterface */
08357 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hip_height00
08358 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hip_height00(lua_State* tolua_S)
08359 {
08360 #ifndef TOLUA_RELEASE
08361  tolua_Error tolua_err;
08362  if (
08363      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08364      !tolua_isnoobj(tolua_S,2,&tolua_err)
08365  )
08366   goto tolua_lerror;
08367  else
08368 #endif
08369  {
08370   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08371 #ifndef TOLUA_RELEASE
08372   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hip_height'", NULL);
08373 #endif
08374   {
08375    float tolua_ret = (float)  self->hip_height();
08376    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08377   }
08378  }
08379  return 1;
08380 #ifndef TOLUA_RELEASE
08381  tolua_lerror:
08382  tolua_error(tolua_S,"#ferror in function 'hip_height'.",&tolua_err);
08383  return 0;
08384 #endif
08385 }
08386 #endif //#ifndef TOLUA_DISABLE
08387 
08388 /* method: set_hip_height of class  fawkes::HumanoidMotionInterface */
08389 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_hip_height00
08390 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_hip_height00(lua_State* tolua_S)
08391 {
08392 #ifndef TOLUA_RELEASE
08393  tolua_Error tolua_err;
08394  if (
08395      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08396      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
08397      !tolua_isnoobj(tolua_S,3,&tolua_err)
08398  )
08399   goto tolua_lerror;
08400  else
08401 #endif
08402  {
08403   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08404   const float new_hip_height = ((const float)  tolua_tonumber(tolua_S,2,0));
08405 #ifndef TOLUA_RELEASE
08406   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_hip_height'", NULL);
08407 #endif
08408   {
08409    self->set_hip_height(new_hip_height);
08410   }
08411  }
08412  return 0;
08413 #ifndef TOLUA_RELEASE
08414  tolua_lerror:
08415  tolua_error(tolua_S,"#ferror in function 'set_hip_height'.",&tolua_err);
08416  return 0;
08417 #endif
08418 }
08419 #endif //#ifndef TOLUA_DISABLE
08420 
08421 /* method: maxlenof_hip_height of class  fawkes::HumanoidMotionInterface */
08422 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_hip_height00
08423 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_hip_height00(lua_State* tolua_S)
08424 {
08425 #ifndef TOLUA_RELEASE
08426  tolua_Error tolua_err;
08427  if (
08428      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08429      !tolua_isnoobj(tolua_S,2,&tolua_err)
08430  )
08431   goto tolua_lerror;
08432  else
08433 #endif
08434  {
08435   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08436 #ifndef TOLUA_RELEASE
08437   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_hip_height'", NULL);
08438 #endif
08439   {
08440    int tolua_ret = (int)  self->maxlenof_hip_height();
08441    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08442   }
08443  }
08444  return 1;
08445 #ifndef TOLUA_RELEASE
08446  tolua_lerror:
08447  tolua_error(tolua_S,"#ferror in function 'maxlenof_hip_height'.",&tolua_err);
08448  return 0;
08449 #endif
08450 }
08451 #endif //#ifndef TOLUA_DISABLE
08452 
08453 /* method: torso_sideward_orientation of class  fawkes::HumanoidMotionInterface */
08454 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_torso_sideward_orientation00
08455 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_torso_sideward_orientation00(lua_State* tolua_S)
08456 {
08457 #ifndef TOLUA_RELEASE
08458  tolua_Error tolua_err;
08459  if (
08460      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08461      !tolua_isnoobj(tolua_S,2,&tolua_err)
08462  )
08463   goto tolua_lerror;
08464  else
08465 #endif
08466  {
08467   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08468 #ifndef TOLUA_RELEASE
08469   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'torso_sideward_orientation'", NULL);
08470 #endif
08471   {
08472    float tolua_ret = (float)  self->torso_sideward_orientation();
08473    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08474   }
08475  }
08476  return 1;
08477 #ifndef TOLUA_RELEASE
08478  tolua_lerror:
08479  tolua_error(tolua_S,"#ferror in function 'torso_sideward_orientation'.",&tolua_err);
08480  return 0;
08481 #endif
08482 }
08483 #endif //#ifndef TOLUA_DISABLE
08484 
08485 /* method: set_torso_sideward_orientation of class  fawkes::HumanoidMotionInterface */
08486 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_torso_sideward_orientation00
08487 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_torso_sideward_orientation00(lua_State* tolua_S)
08488 {
08489 #ifndef TOLUA_RELEASE
08490  tolua_Error tolua_err;
08491  if (
08492      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08493      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
08494      !tolua_isnoobj(tolua_S,3,&tolua_err)
08495  )
08496   goto tolua_lerror;
08497  else
08498 #endif
08499  {
08500   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08501   const float new_torso_sideward_orientation = ((const float)  tolua_tonumber(tolua_S,2,0));
08502 #ifndef TOLUA_RELEASE
08503   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_torso_sideward_orientation'", NULL);
08504 #endif
08505   {
08506    self->set_torso_sideward_orientation(new_torso_sideward_orientation);
08507   }
08508  }
08509  return 0;
08510 #ifndef TOLUA_RELEASE
08511  tolua_lerror:
08512  tolua_error(tolua_S,"#ferror in function 'set_torso_sideward_orientation'.",&tolua_err);
08513  return 0;
08514 #endif
08515 }
08516 #endif //#ifndef TOLUA_DISABLE
08517 
08518 /* method: maxlenof_torso_sideward_orientation of class  fawkes::HumanoidMotionInterface */
08519 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_torso_sideward_orientation00
08520 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_torso_sideward_orientation00(lua_State* tolua_S)
08521 {
08522 #ifndef TOLUA_RELEASE
08523  tolua_Error tolua_err;
08524  if (
08525      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08526      !tolua_isnoobj(tolua_S,2,&tolua_err)
08527  )
08528   goto tolua_lerror;
08529  else
08530 #endif
08531  {
08532   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08533 #ifndef TOLUA_RELEASE
08534   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_torso_sideward_orientation'", NULL);
08535 #endif
08536   {
08537    int tolua_ret = (int)  self->maxlenof_torso_sideward_orientation();
08538    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08539   }
08540  }
08541  return 1;
08542 #ifndef TOLUA_RELEASE
08543  tolua_lerror:
08544  tolua_error(tolua_S,"#ferror in function 'maxlenof_torso_sideward_orientation'.",&tolua_err);
08545  return 0;
08546 #endif
08547 }
08548 #endif //#ifndef TOLUA_DISABLE
08549 
08550 /* method: is_arms_enabled of class  fawkes::HumanoidMotionInterface */
08551 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_arms_enabled00
08552 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_arms_enabled00(lua_State* tolua_S)
08553 {
08554 #ifndef TOLUA_RELEASE
08555  tolua_Error tolua_err;
08556  if (
08557      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08558      !tolua_isnoobj(tolua_S,2,&tolua_err)
08559  )
08560   goto tolua_lerror;
08561  else
08562 #endif
08563  {
08564   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08565 #ifndef TOLUA_RELEASE
08566   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_arms_enabled'", NULL);
08567 #endif
08568   {
08569    bool tolua_ret = (bool)  self->is_arms_enabled();
08570    tolua_pushboolean(tolua_S,(bool)tolua_ret);
08571   }
08572  }
08573  return 1;
08574 #ifndef TOLUA_RELEASE
08575  tolua_lerror:
08576  tolua_error(tolua_S,"#ferror in function 'is_arms_enabled'.",&tolua_err);
08577  return 0;
08578 #endif
08579 }
08580 #endif //#ifndef TOLUA_DISABLE
08581 
08582 /* method: set_arms_enabled of class  fawkes::HumanoidMotionInterface */
08583 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_arms_enabled00
08584 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_arms_enabled00(lua_State* tolua_S)
08585 {
08586 #ifndef TOLUA_RELEASE
08587  tolua_Error tolua_err;
08588  if (
08589      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08590      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
08591      !tolua_isnoobj(tolua_S,3,&tolua_err)
08592  )
08593   goto tolua_lerror;
08594  else
08595 #endif
08596  {
08597   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08598   const bool new_arms_enabled = ((const bool)  tolua_toboolean(tolua_S,2,0));
08599 #ifndef TOLUA_RELEASE
08600   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_arms_enabled'", NULL);
08601 #endif
08602   {
08603    self->set_arms_enabled(new_arms_enabled);
08604   }
08605  }
08606  return 0;
08607 #ifndef TOLUA_RELEASE
08608  tolua_lerror:
08609  tolua_error(tolua_S,"#ferror in function 'set_arms_enabled'.",&tolua_err);
08610  return 0;
08611 #endif
08612 }
08613 #endif //#ifndef TOLUA_DISABLE
08614 
08615 /* method: maxlenof_arms_enabled of class  fawkes::HumanoidMotionInterface */
08616 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_arms_enabled00
08617 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_arms_enabled00(lua_State* tolua_S)
08618 {
08619 #ifndef TOLUA_RELEASE
08620  tolua_Error tolua_err;
08621  if (
08622      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08623      !tolua_isnoobj(tolua_S,2,&tolua_err)
08624  )
08625   goto tolua_lerror;
08626  else
08627 #endif
08628  {
08629   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08630 #ifndef TOLUA_RELEASE
08631   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_arms_enabled'", NULL);
08632 #endif
08633   {
08634    int tolua_ret = (int)  self->maxlenof_arms_enabled();
08635    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08636   }
08637  }
08638  return 1;
08639 #ifndef TOLUA_RELEASE
08640  tolua_lerror:
08641  tolua_error(tolua_S,"#ferror in function 'maxlenof_arms_enabled'.",&tolua_err);
08642  return 0;
08643 #endif
08644 }
08645 #endif //#ifndef TOLUA_DISABLE
08646 
08647 /* method: shoulder_pitch_median of class  fawkes::HumanoidMotionInterface */
08648 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_shoulder_pitch_median00
08649 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_shoulder_pitch_median00(lua_State* tolua_S)
08650 {
08651 #ifndef TOLUA_RELEASE
08652  tolua_Error tolua_err;
08653  if (
08654      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08655      !tolua_isnoobj(tolua_S,2,&tolua_err)
08656  )
08657   goto tolua_lerror;
08658  else
08659 #endif
08660  {
08661   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08662 #ifndef TOLUA_RELEASE
08663   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'shoulder_pitch_median'", NULL);
08664 #endif
08665   {
08666    float tolua_ret = (float)  self->shoulder_pitch_median();
08667    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08668   }
08669  }
08670  return 1;
08671 #ifndef TOLUA_RELEASE
08672  tolua_lerror:
08673  tolua_error(tolua_S,"#ferror in function 'shoulder_pitch_median'.",&tolua_err);
08674  return 0;
08675 #endif
08676 }
08677 #endif //#ifndef TOLUA_DISABLE
08678 
08679 /* method: set_shoulder_pitch_median of class  fawkes::HumanoidMotionInterface */
08680 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_shoulder_pitch_median00
08681 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_shoulder_pitch_median00(lua_State* tolua_S)
08682 {
08683 #ifndef TOLUA_RELEASE
08684  tolua_Error tolua_err;
08685  if (
08686      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08687      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
08688      !tolua_isnoobj(tolua_S,3,&tolua_err)
08689  )
08690   goto tolua_lerror;
08691  else
08692 #endif
08693  {
08694   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08695   const float new_shoulder_pitch_median = ((const float)  tolua_tonumber(tolua_S,2,0));
08696 #ifndef TOLUA_RELEASE
08697   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_shoulder_pitch_median'", NULL);
08698 #endif
08699   {
08700    self->set_shoulder_pitch_median(new_shoulder_pitch_median);
08701   }
08702  }
08703  return 0;
08704 #ifndef TOLUA_RELEASE
08705  tolua_lerror:
08706  tolua_error(tolua_S,"#ferror in function 'set_shoulder_pitch_median'.",&tolua_err);
08707  return 0;
08708 #endif
08709 }
08710 #endif //#ifndef TOLUA_DISABLE
08711 
08712 /* method: maxlenof_shoulder_pitch_median of class  fawkes::HumanoidMotionInterface */
08713 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_shoulder_pitch_median00
08714 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_shoulder_pitch_median00(lua_State* tolua_S)
08715 {
08716 #ifndef TOLUA_RELEASE
08717  tolua_Error tolua_err;
08718  if (
08719      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08720      !tolua_isnoobj(tolua_S,2,&tolua_err)
08721  )
08722   goto tolua_lerror;
08723  else
08724 #endif
08725  {
08726   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08727 #ifndef TOLUA_RELEASE
08728   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_shoulder_pitch_median'", NULL);
08729 #endif
08730   {
08731    int tolua_ret = (int)  self->maxlenof_shoulder_pitch_median();
08732    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08733   }
08734  }
08735  return 1;
08736 #ifndef TOLUA_RELEASE
08737  tolua_lerror:
08738  tolua_error(tolua_S,"#ferror in function 'maxlenof_shoulder_pitch_median'.",&tolua_err);
08739  return 0;
08740 #endif
08741 }
08742 #endif //#ifndef TOLUA_DISABLE
08743 
08744 /* method: shoulder_pitch_amplitude of class  fawkes::HumanoidMotionInterface */
08745 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_shoulder_pitch_amplitude00
08746 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_shoulder_pitch_amplitude00(lua_State* tolua_S)
08747 {
08748 #ifndef TOLUA_RELEASE
08749  tolua_Error tolua_err;
08750  if (
08751      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08752      !tolua_isnoobj(tolua_S,2,&tolua_err)
08753  )
08754   goto tolua_lerror;
08755  else
08756 #endif
08757  {
08758   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08759 #ifndef TOLUA_RELEASE
08760   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'shoulder_pitch_amplitude'", NULL);
08761 #endif
08762   {
08763    float tolua_ret = (float)  self->shoulder_pitch_amplitude();
08764    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08765   }
08766  }
08767  return 1;
08768 #ifndef TOLUA_RELEASE
08769  tolua_lerror:
08770  tolua_error(tolua_S,"#ferror in function 'shoulder_pitch_amplitude'.",&tolua_err);
08771  return 0;
08772 #endif
08773 }
08774 #endif //#ifndef TOLUA_DISABLE
08775 
08776 /* method: set_shoulder_pitch_amplitude of class  fawkes::HumanoidMotionInterface */
08777 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_shoulder_pitch_amplitude00
08778 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_shoulder_pitch_amplitude00(lua_State* tolua_S)
08779 {
08780 #ifndef TOLUA_RELEASE
08781  tolua_Error tolua_err;
08782  if (
08783      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08784      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
08785      !tolua_isnoobj(tolua_S,3,&tolua_err)
08786  )
08787   goto tolua_lerror;
08788  else
08789 #endif
08790  {
08791   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08792   const float new_shoulder_pitch_amplitude = ((const float)  tolua_tonumber(tolua_S,2,0));
08793 #ifndef TOLUA_RELEASE
08794   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_shoulder_pitch_amplitude'", NULL);
08795 #endif
08796   {
08797    self->set_shoulder_pitch_amplitude(new_shoulder_pitch_amplitude);
08798   }
08799  }
08800  return 0;
08801 #ifndef TOLUA_RELEASE
08802  tolua_lerror:
08803  tolua_error(tolua_S,"#ferror in function 'set_shoulder_pitch_amplitude'.",&tolua_err);
08804  return 0;
08805 #endif
08806 }
08807 #endif //#ifndef TOLUA_DISABLE
08808 
08809 /* method: maxlenof_shoulder_pitch_amplitude of class  fawkes::HumanoidMotionInterface */
08810 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_shoulder_pitch_amplitude00
08811 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_shoulder_pitch_amplitude00(lua_State* tolua_S)
08812 {
08813 #ifndef TOLUA_RELEASE
08814  tolua_Error tolua_err;
08815  if (
08816      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08817      !tolua_isnoobj(tolua_S,2,&tolua_err)
08818  )
08819   goto tolua_lerror;
08820  else
08821 #endif
08822  {
08823   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08824 #ifndef TOLUA_RELEASE
08825   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_shoulder_pitch_amplitude'", NULL);
08826 #endif
08827   {
08828    int tolua_ret = (int)  self->maxlenof_shoulder_pitch_amplitude();
08829    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08830   }
08831  }
08832  return 1;
08833 #ifndef TOLUA_RELEASE
08834  tolua_lerror:
08835  tolua_error(tolua_S,"#ferror in function 'maxlenof_shoulder_pitch_amplitude'.",&tolua_err);
08836  return 0;
08837 #endif
08838 }
08839 #endif //#ifndef TOLUA_DISABLE
08840 
08841 /* method: elbow_roll_median of class  fawkes::HumanoidMotionInterface */
08842 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_elbow_roll_median00
08843 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_elbow_roll_median00(lua_State* tolua_S)
08844 {
08845 #ifndef TOLUA_RELEASE
08846  tolua_Error tolua_err;
08847  if (
08848      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08849      !tolua_isnoobj(tolua_S,2,&tolua_err)
08850  )
08851   goto tolua_lerror;
08852  else
08853 #endif
08854  {
08855   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08856 #ifndef TOLUA_RELEASE
08857   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'elbow_roll_median'", NULL);
08858 #endif
08859   {
08860    float tolua_ret = (float)  self->elbow_roll_median();
08861    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08862   }
08863  }
08864  return 1;
08865 #ifndef TOLUA_RELEASE
08866  tolua_lerror:
08867  tolua_error(tolua_S,"#ferror in function 'elbow_roll_median'.",&tolua_err);
08868  return 0;
08869 #endif
08870 }
08871 #endif //#ifndef TOLUA_DISABLE
08872 
08873 /* method: set_elbow_roll_median of class  fawkes::HumanoidMotionInterface */
08874 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_elbow_roll_median00
08875 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_elbow_roll_median00(lua_State* tolua_S)
08876 {
08877 #ifndef TOLUA_RELEASE
08878  tolua_Error tolua_err;
08879  if (
08880      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08881      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
08882      !tolua_isnoobj(tolua_S,3,&tolua_err)
08883  )
08884   goto tolua_lerror;
08885  else
08886 #endif
08887  {
08888   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08889   const float new_elbow_roll_median = ((const float)  tolua_tonumber(tolua_S,2,0));
08890 #ifndef TOLUA_RELEASE
08891   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_elbow_roll_median'", NULL);
08892 #endif
08893   {
08894    self->set_elbow_roll_median(new_elbow_roll_median);
08895   }
08896  }
08897  return 0;
08898 #ifndef TOLUA_RELEASE
08899  tolua_lerror:
08900  tolua_error(tolua_S,"#ferror in function 'set_elbow_roll_median'.",&tolua_err);
08901  return 0;
08902 #endif
08903 }
08904 #endif //#ifndef TOLUA_DISABLE
08905 
08906 /* method: maxlenof_elbow_roll_median of class  fawkes::HumanoidMotionInterface */
08907 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_elbow_roll_median00
08908 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_elbow_roll_median00(lua_State* tolua_S)
08909 {
08910 #ifndef TOLUA_RELEASE
08911  tolua_Error tolua_err;
08912  if (
08913      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08914      !tolua_isnoobj(tolua_S,2,&tolua_err)
08915  )
08916   goto tolua_lerror;
08917  else
08918 #endif
08919  {
08920   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08921 #ifndef TOLUA_RELEASE
08922   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_elbow_roll_median'", NULL);
08923 #endif
08924   {
08925    int tolua_ret = (int)  self->maxlenof_elbow_roll_median();
08926    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08927   }
08928  }
08929  return 1;
08930 #ifndef TOLUA_RELEASE
08931  tolua_lerror:
08932  tolua_error(tolua_S,"#ferror in function 'maxlenof_elbow_roll_median'.",&tolua_err);
08933  return 0;
08934 #endif
08935 }
08936 #endif //#ifndef TOLUA_DISABLE
08937 
08938 /* method: elbow_roll_amplitude of class  fawkes::HumanoidMotionInterface */
08939 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_elbow_roll_amplitude00
08940 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_elbow_roll_amplitude00(lua_State* tolua_S)
08941 {
08942 #ifndef TOLUA_RELEASE
08943  tolua_Error tolua_err;
08944  if (
08945      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08946      !tolua_isnoobj(tolua_S,2,&tolua_err)
08947  )
08948   goto tolua_lerror;
08949  else
08950 #endif
08951  {
08952   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08953 #ifndef TOLUA_RELEASE
08954   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'elbow_roll_amplitude'", NULL);
08955 #endif
08956   {
08957    float tolua_ret = (float)  self->elbow_roll_amplitude();
08958    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08959   }
08960  }
08961  return 1;
08962 #ifndef TOLUA_RELEASE
08963  tolua_lerror:
08964  tolua_error(tolua_S,"#ferror in function 'elbow_roll_amplitude'.",&tolua_err);
08965  return 0;
08966 #endif
08967 }
08968 #endif //#ifndef TOLUA_DISABLE
08969 
08970 /* method: set_elbow_roll_amplitude of class  fawkes::HumanoidMotionInterface */
08971 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_elbow_roll_amplitude00
08972 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_elbow_roll_amplitude00(lua_State* tolua_S)
08973 {
08974 #ifndef TOLUA_RELEASE
08975  tolua_Error tolua_err;
08976  if (
08977      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
08978      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
08979      !tolua_isnoobj(tolua_S,3,&tolua_err)
08980  )
08981   goto tolua_lerror;
08982  else
08983 #endif
08984  {
08985   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
08986   const float new_elbow_roll_amplitude = ((const float)  tolua_tonumber(tolua_S,2,0));
08987 #ifndef TOLUA_RELEASE
08988   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_elbow_roll_amplitude'", NULL);
08989 #endif
08990   {
08991    self->set_elbow_roll_amplitude(new_elbow_roll_amplitude);
08992   }
08993  }
08994  return 0;
08995 #ifndef TOLUA_RELEASE
08996  tolua_lerror:
08997  tolua_error(tolua_S,"#ferror in function 'set_elbow_roll_amplitude'.",&tolua_err);
08998  return 0;
08999 #endif
09000 }
09001 #endif //#ifndef TOLUA_DISABLE
09002 
09003 /* method: maxlenof_elbow_roll_amplitude of class  fawkes::HumanoidMotionInterface */
09004 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_elbow_roll_amplitude00
09005 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_elbow_roll_amplitude00(lua_State* tolua_S)
09006 {
09007 #ifndef TOLUA_RELEASE
09008  tolua_Error tolua_err;
09009  if (
09010      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09011      !tolua_isnoobj(tolua_S,2,&tolua_err)
09012  )
09013   goto tolua_lerror;
09014  else
09015 #endif
09016  {
09017   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09018 #ifndef TOLUA_RELEASE
09019   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_elbow_roll_amplitude'", NULL);
09020 #endif
09021   {
09022    int tolua_ret = (int)  self->maxlenof_elbow_roll_amplitude();
09023    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
09024   }
09025  }
09026  return 1;
09027 #ifndef TOLUA_RELEASE
09028  tolua_lerror:
09029  tolua_error(tolua_S,"#ferror in function 'maxlenof_elbow_roll_amplitude'.",&tolua_err);
09030  return 0;
09031 #endif
09032 }
09033 #endif //#ifndef TOLUA_DISABLE
09034 
09035 /* method: msgid of class  fawkes::HumanoidMotionInterface */
09036 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgid00
09037 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgid00(lua_State* tolua_S)
09038 {
09039 #ifndef TOLUA_RELEASE
09040  tolua_Error tolua_err;
09041  if (
09042      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09043      !tolua_isnoobj(tolua_S,2,&tolua_err)
09044  )
09045   goto tolua_lerror;
09046  else
09047 #endif
09048  {
09049   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09050 #ifndef TOLUA_RELEASE
09051   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgid'", NULL);
09052 #endif
09053   {
09054    unsigned int tolua_ret = (unsigned int)  self->msgid();
09055    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
09056   }
09057  }
09058  return 1;
09059 #ifndef TOLUA_RELEASE
09060  tolua_lerror:
09061  tolua_error(tolua_S,"#ferror in function 'msgid'.",&tolua_err);
09062  return 0;
09063 #endif
09064 }
09065 #endif //#ifndef TOLUA_DISABLE
09066 
09067 /* method: set_msgid of class  fawkes::HumanoidMotionInterface */
09068 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_msgid00
09069 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_msgid00(lua_State* tolua_S)
09070 {
09071 #ifndef TOLUA_RELEASE
09072  tolua_Error tolua_err;
09073  if (
09074      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09075      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
09076      !tolua_isnoobj(tolua_S,3,&tolua_err)
09077  )
09078   goto tolua_lerror;
09079  else
09080 #endif
09081  {
09082   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09083   unsigned const int new_msgid = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
09084 #ifndef TOLUA_RELEASE
09085   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_msgid'", NULL);
09086 #endif
09087   {
09088    self->set_msgid(new_msgid);
09089   }
09090  }
09091  return 0;
09092 #ifndef TOLUA_RELEASE
09093  tolua_lerror:
09094  tolua_error(tolua_S,"#ferror in function 'set_msgid'.",&tolua_err);
09095  return 0;
09096 #endif
09097 }
09098 #endif //#ifndef TOLUA_DISABLE
09099 
09100 /* method: maxlenof_msgid of class  fawkes::HumanoidMotionInterface */
09101 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_msgid00
09102 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_msgid00(lua_State* tolua_S)
09103 {
09104 #ifndef TOLUA_RELEASE
09105  tolua_Error tolua_err;
09106  if (
09107      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09108      !tolua_isnoobj(tolua_S,2,&tolua_err)
09109  )
09110   goto tolua_lerror;
09111  else
09112 #endif
09113  {
09114   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09115 #ifndef TOLUA_RELEASE
09116   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_msgid'", NULL);
09117 #endif
09118   {
09119    int tolua_ret = (int)  self->maxlenof_msgid();
09120    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
09121   }
09122  }
09123  return 1;
09124 #ifndef TOLUA_RELEASE
09125  tolua_lerror:
09126  tolua_error(tolua_S,"#ferror in function 'maxlenof_msgid'.",&tolua_err);
09127  return 0;
09128 #endif
09129 }
09130 #endif //#ifndef TOLUA_DISABLE
09131 
09132 /* method: oftype of class  fawkes::HumanoidMotionInterface */
09133 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_oftype00
09134 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_oftype00(lua_State* tolua_S)
09135 {
09136 #ifndef TOLUA_RELEASE
09137  tolua_Error tolua_err;
09138  if (
09139      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09140      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
09141      !tolua_isnoobj(tolua_S,3,&tolua_err)
09142  )
09143   goto tolua_lerror;
09144  else
09145 #endif
09146  {
09147   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09148   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
09149 #ifndef TOLUA_RELEASE
09150   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL);
09151 #endif
09152   {
09153    bool tolua_ret = (bool)  self->oftype(interface_type);
09154    tolua_pushboolean(tolua_S,(bool)tolua_ret);
09155   }
09156  }
09157  return 1;
09158 #ifndef TOLUA_RELEASE
09159  tolua_lerror:
09160  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
09161  return 0;
09162 #endif
09163 }
09164 #endif //#ifndef TOLUA_DISABLE
09165 
09166 /* method: datachunk of class  fawkes::HumanoidMotionInterface */
09167 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_datachunk00
09168 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_datachunk00(lua_State* tolua_S)
09169 {
09170 #ifndef TOLUA_RELEASE
09171  tolua_Error tolua_err;
09172  if (
09173      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09174      !tolua_isnoobj(tolua_S,2,&tolua_err)
09175  )
09176   goto tolua_lerror;
09177  else
09178 #endif
09179  {
09180   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09181 #ifndef TOLUA_RELEASE
09182   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL);
09183 #endif
09184   {
09185    const void* tolua_ret = (const void*)  self->datachunk();
09186    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
09187   }
09188  }
09189  return 1;
09190 #ifndef TOLUA_RELEASE
09191  tolua_lerror:
09192  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
09193  return 0;
09194 #endif
09195 }
09196 #endif //#ifndef TOLUA_DISABLE
09197 
09198 /* method: datasize of class  fawkes::HumanoidMotionInterface */
09199 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_datasize00
09200 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_datasize00(lua_State* tolua_S)
09201 {
09202 #ifndef TOLUA_RELEASE
09203  tolua_Error tolua_err;
09204  if (
09205      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09206      !tolua_isnoobj(tolua_S,2,&tolua_err)
09207  )
09208   goto tolua_lerror;
09209  else
09210 #endif
09211  {
09212   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09213 #ifndef TOLUA_RELEASE
09214   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL);
09215 #endif
09216   {
09217    unsigned int tolua_ret = (unsigned int)  self->datasize();
09218    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
09219   }
09220  }
09221  return 1;
09222 #ifndef TOLUA_RELEASE
09223  tolua_lerror:
09224  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
09225  return 0;
09226 #endif
09227 }
09228 #endif //#ifndef TOLUA_DISABLE
09229 
09230 /* method: type of class  fawkes::HumanoidMotionInterface */
09231 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_type00
09232 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_type00(lua_State* tolua_S)
09233 {
09234 #ifndef TOLUA_RELEASE
09235  tolua_Error tolua_err;
09236  if (
09237      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09238      !tolua_isnoobj(tolua_S,2,&tolua_err)
09239  )
09240   goto tolua_lerror;
09241  else
09242 #endif
09243  {
09244   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09245 #ifndef TOLUA_RELEASE
09246   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
09247 #endif
09248   {
09249    const char* tolua_ret = (const char*)  self->type();
09250    tolua_pushstring(tolua_S,(const char*)tolua_ret);
09251   }
09252  }
09253  return 1;
09254 #ifndef TOLUA_RELEASE
09255  tolua_lerror:
09256  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
09257  return 0;
09258 #endif
09259 }
09260 #endif //#ifndef TOLUA_DISABLE
09261 
09262 /* method: id of class  fawkes::HumanoidMotionInterface */
09263 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_id00
09264 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_id00(lua_State* tolua_S)
09265 {
09266 #ifndef TOLUA_RELEASE
09267  tolua_Error tolua_err;
09268  if (
09269      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09270      !tolua_isnoobj(tolua_S,2,&tolua_err)
09271  )
09272   goto tolua_lerror;
09273  else
09274 #endif
09275  {
09276   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09277 #ifndef TOLUA_RELEASE
09278   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL);
09279 #endif
09280   {
09281    const char* tolua_ret = (const char*)  self->id();
09282    tolua_pushstring(tolua_S,(const char*)tolua_ret);
09283   }
09284  }
09285  return 1;
09286 #ifndef TOLUA_RELEASE
09287  tolua_lerror:
09288  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
09289  return 0;
09290 #endif
09291 }
09292 #endif //#ifndef TOLUA_DISABLE
09293 
09294 /* method: uid of class  fawkes::HumanoidMotionInterface */
09295 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_uid00
09296 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_uid00(lua_State* tolua_S)
09297 {
09298 #ifndef TOLUA_RELEASE
09299  tolua_Error tolua_err;
09300  if (
09301      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09302      !tolua_isnoobj(tolua_S,2,&tolua_err)
09303  )
09304   goto tolua_lerror;
09305  else
09306 #endif
09307  {
09308   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09309 #ifndef TOLUA_RELEASE
09310   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL);
09311 #endif
09312   {
09313    const char* tolua_ret = (const char*)  self->uid();
09314    tolua_pushstring(tolua_S,(const char*)tolua_ret);
09315   }
09316  }
09317  return 1;
09318 #ifndef TOLUA_RELEASE
09319  tolua_lerror:
09320  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
09321  return 0;
09322 #endif
09323 }
09324 #endif //#ifndef TOLUA_DISABLE
09325 
09326 /* method: serial of class  fawkes::HumanoidMotionInterface */
09327 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_serial00
09328 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_serial00(lua_State* tolua_S)
09329 {
09330 #ifndef TOLUA_RELEASE
09331  tolua_Error tolua_err;
09332  if (
09333      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09334      !tolua_isnoobj(tolua_S,2,&tolua_err)
09335  )
09336   goto tolua_lerror;
09337  else
09338 #endif
09339  {
09340   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09341 #ifndef TOLUA_RELEASE
09342   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL);
09343 #endif
09344   {
09345    unsigned int tolua_ret = (unsigned int)  self->serial();
09346    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
09347   }
09348  }
09349  return 1;
09350 #ifndef TOLUA_RELEASE
09351  tolua_lerror:
09352  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
09353  return 0;
09354 #endif
09355 }
09356 #endif //#ifndef TOLUA_DISABLE
09357 
09358 /* method: mem_serial of class  fawkes::HumanoidMotionInterface */
09359 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_mem_serial00
09360 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_mem_serial00(lua_State* tolua_S)
09361 {
09362 #ifndef TOLUA_RELEASE
09363  tolua_Error tolua_err;
09364  if (
09365      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09366      !tolua_isnoobj(tolua_S,2,&tolua_err)
09367  )
09368   goto tolua_lerror;
09369  else
09370 #endif
09371  {
09372   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09373 #ifndef TOLUA_RELEASE
09374   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL);
09375 #endif
09376   {
09377    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
09378    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
09379   }
09380  }
09381  return 1;
09382 #ifndef TOLUA_RELEASE
09383  tolua_lerror:
09384  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
09385  return 0;
09386 #endif
09387 }
09388 #endif //#ifndef TOLUA_DISABLE
09389 
09390 /* method: operator== of class  fawkes::HumanoidMotionInterface */
09391 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface__eq00
09392 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface__eq00(lua_State* tolua_S)
09393 {
09394 #ifndef TOLUA_RELEASE
09395  tolua_Error tolua_err;
09396  if (
09397      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09398      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) ||
09399      !tolua_isnoobj(tolua_S,3,&tolua_err)
09400  )
09401   goto tolua_lerror;
09402  else
09403 #endif
09404  {
09405   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09406   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
09407 #ifndef TOLUA_RELEASE
09408   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
09409 #endif
09410   {
09411    bool tolua_ret = (bool)  self->operator==(*comp);
09412    tolua_pushboolean(tolua_S,(bool)tolua_ret);
09413   }
09414  }
09415  return 1;
09416 #ifndef TOLUA_RELEASE
09417  tolua_lerror:
09418  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
09419  return 0;
09420 #endif
09421 }
09422 #endif //#ifndef TOLUA_DISABLE
09423 
09424 /* method: hash of class  fawkes::HumanoidMotionInterface */
09425 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash00
09426 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash00(lua_State* tolua_S)
09427 {
09428 #ifndef TOLUA_RELEASE
09429  tolua_Error tolua_err;
09430  if (
09431      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09432      !tolua_isnoobj(tolua_S,2,&tolua_err)
09433  )
09434   goto tolua_lerror;
09435  else
09436 #endif
09437  {
09438   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09439 #ifndef TOLUA_RELEASE
09440   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL);
09441 #endif
09442   {
09443    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
09444    tolua_pushstring(tolua_S,(const char*)tolua_ret);
09445   }
09446  }
09447  return 1;
09448 #ifndef TOLUA_RELEASE
09449  tolua_lerror:
09450  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
09451  return 0;
09452 #endif
09453 }
09454 #endif //#ifndef TOLUA_DISABLE
09455 
09456 /* method: hash_size of class  fawkes::HumanoidMotionInterface */
09457 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash_size00
09458 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash_size00(lua_State* tolua_S)
09459 {
09460 #ifndef TOLUA_RELEASE
09461  tolua_Error tolua_err;
09462  if (
09463      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09464      !tolua_isnoobj(tolua_S,2,&tolua_err)
09465  )
09466   goto tolua_lerror;
09467  else
09468 #endif
09469  {
09470   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09471 #ifndef TOLUA_RELEASE
09472   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL);
09473 #endif
09474   {
09475    int tolua_ret = (int)  self->hash_size();
09476    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
09477   }
09478  }
09479  return 1;
09480 #ifndef TOLUA_RELEASE
09481  tolua_lerror:
09482  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
09483  return 0;
09484 #endif
09485 }
09486 #endif //#ifndef TOLUA_DISABLE
09487 
09488 /* method: hash_printable of class  fawkes::HumanoidMotionInterface */
09489 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash_printable00
09490 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash_printable00(lua_State* tolua_S)
09491 {
09492 #ifndef TOLUA_RELEASE
09493  tolua_Error tolua_err;
09494  if (
09495      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09496      !tolua_isnoobj(tolua_S,2,&tolua_err)
09497  )
09498   goto tolua_lerror;
09499  else
09500 #endif
09501  {
09502   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09503 #ifndef TOLUA_RELEASE
09504   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL);
09505 #endif
09506   {
09507    const char* tolua_ret = (const char*)  self->hash_printable();
09508    tolua_pushstring(tolua_S,(const char*)tolua_ret);
09509   }
09510  }
09511  return 1;
09512 #ifndef TOLUA_RELEASE
09513  tolua_lerror:
09514  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
09515  return 0;
09516 #endif
09517 }
09518 #endif //#ifndef TOLUA_DISABLE
09519 
09520 /* method: is_writer of class  fawkes::HumanoidMotionInterface */
09521 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_writer00
09522 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_writer00(lua_State* tolua_S)
09523 {
09524 #ifndef TOLUA_RELEASE
09525  tolua_Error tolua_err;
09526  if (
09527      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09528      !tolua_isnoobj(tolua_S,2,&tolua_err)
09529  )
09530   goto tolua_lerror;
09531  else
09532 #endif
09533  {
09534   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09535 #ifndef TOLUA_RELEASE
09536   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL);
09537 #endif
09538   {
09539    bool tolua_ret = (bool)  self->is_writer();
09540    tolua_pushboolean(tolua_S,(bool)tolua_ret);
09541   }
09542  }
09543  return 1;
09544 #ifndef TOLUA_RELEASE
09545  tolua_lerror:
09546  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
09547  return 0;
09548 #endif
09549 }
09550 #endif //#ifndef TOLUA_DISABLE
09551 
09552 /* method: set_from_chunk of class  fawkes::HumanoidMotionInterface */
09553 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_from_chunk00
09554 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_from_chunk00(lua_State* tolua_S)
09555 {
09556 #ifndef TOLUA_RELEASE
09557  tolua_Error tolua_err;
09558  if (
09559      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09560      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
09561      !tolua_isnoobj(tolua_S,3,&tolua_err)
09562  )
09563   goto tolua_lerror;
09564  else
09565 #endif
09566  {
09567   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09568   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
09569 #ifndef TOLUA_RELEASE
09570   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL);
09571 #endif
09572   {
09573    self->set_from_chunk(chunk);
09574   }
09575  }
09576  return 0;
09577 #ifndef TOLUA_RELEASE
09578  tolua_lerror:
09579  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
09580  return 0;
09581 #endif
09582 }
09583 #endif //#ifndef TOLUA_DISABLE
09584 
09585 /* method: create_message of class  fawkes::HumanoidMotionInterface */
09586 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_create_message00
09587 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_create_message00(lua_State* tolua_S)
09588 {
09589 #ifndef TOLUA_RELEASE
09590  tolua_Error tolua_err;
09591  if (
09592      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09593      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
09594      !tolua_isnoobj(tolua_S,3,&tolua_err)
09595  )
09596   goto tolua_lerror;
09597  else
09598 #endif
09599  {
09600   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09601   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
09602 #ifndef TOLUA_RELEASE
09603   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL);
09604 #endif
09605   {
09606    Message* tolua_ret = (Message*)  self->create_message(type);
09607     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
09608   }
09609  }
09610  return 1;
09611 #ifndef TOLUA_RELEASE
09612  tolua_lerror:
09613  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
09614  return 0;
09615 #endif
09616 }
09617 #endif //#ifndef TOLUA_DISABLE
09618 
09619 /* method: read of class  fawkes::HumanoidMotionInterface */
09620 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_read00
09621 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_read00(lua_State* tolua_S)
09622 {
09623 #ifndef TOLUA_RELEASE
09624  tolua_Error tolua_err;
09625  if (
09626      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09627      !tolua_isnoobj(tolua_S,2,&tolua_err)
09628  )
09629   goto tolua_lerror;
09630  else
09631 #endif
09632  {
09633   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09634 #ifndef TOLUA_RELEASE
09635   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
09636 #endif
09637   {
09638    self->read();
09639   }
09640  }
09641  return 0;
09642 #ifndef TOLUA_RELEASE
09643  tolua_lerror:
09644  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
09645  return 0;
09646 #endif
09647 }
09648 #endif //#ifndef TOLUA_DISABLE
09649 
09650 /* method: write of class  fawkes::HumanoidMotionInterface */
09651 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_write00
09652 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_write00(lua_State* tolua_S)
09653 {
09654 #ifndef TOLUA_RELEASE
09655  tolua_Error tolua_err;
09656  if (
09657      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09658      !tolua_isnoobj(tolua_S,2,&tolua_err)
09659  )
09660   goto tolua_lerror;
09661  else
09662 #endif
09663  {
09664   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09665 #ifndef TOLUA_RELEASE
09666   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
09667 #endif
09668   {
09669    self->write();
09670   }
09671  }
09672  return 0;
09673 #ifndef TOLUA_RELEASE
09674  tolua_lerror:
09675  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
09676  return 0;
09677 #endif
09678 }
09679 #endif //#ifndef TOLUA_DISABLE
09680 
09681 /* method: has_writer of class  fawkes::HumanoidMotionInterface */
09682 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_has_writer00
09683 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_has_writer00(lua_State* tolua_S)
09684 {
09685 #ifndef TOLUA_RELEASE
09686  tolua_Error tolua_err;
09687  if (
09688      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09689      !tolua_isnoobj(tolua_S,2,&tolua_err)
09690  )
09691   goto tolua_lerror;
09692  else
09693 #endif
09694  {
09695   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09696 #ifndef TOLUA_RELEASE
09697   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL);
09698 #endif
09699   {
09700    bool tolua_ret = (bool)  self->has_writer();
09701    tolua_pushboolean(tolua_S,(bool)tolua_ret);
09702   }
09703  }
09704  return 1;
09705 #ifndef TOLUA_RELEASE
09706  tolua_lerror:
09707  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
09708  return 0;
09709 #endif
09710 }
09711 #endif //#ifndef TOLUA_DISABLE
09712 
09713 /* method: num_readers of class  fawkes::HumanoidMotionInterface */
09714 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_num_readers00
09715 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_num_readers00(lua_State* tolua_S)
09716 {
09717 #ifndef TOLUA_RELEASE
09718  tolua_Error tolua_err;
09719  if (
09720      !tolua_isusertype(tolua_S,1,"const fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09721      !tolua_isnoobj(tolua_S,2,&tolua_err)
09722  )
09723   goto tolua_lerror;
09724  else
09725 #endif
09726  {
09727   const fawkes::HumanoidMotionInterface* self = (const fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09728 #ifndef TOLUA_RELEASE
09729   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL);
09730 #endif
09731   {
09732    unsigned int tolua_ret = (unsigned int)  self->num_readers();
09733    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
09734   }
09735  }
09736  return 1;
09737 #ifndef TOLUA_RELEASE
09738  tolua_lerror:
09739  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
09740  return 0;
09741 #endif
09742 }
09743 #endif //#ifndef TOLUA_DISABLE
09744 
09745 /* method: msgq_enqueue_copy of class  fawkes::HumanoidMotionInterface */
09746 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_enqueue_copy00
09747 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_enqueue_copy00(lua_State* tolua_S)
09748 {
09749 #ifndef TOLUA_RELEASE
09750  tolua_Error tolua_err;
09751  if (
09752      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09753      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
09754      !tolua_isnoobj(tolua_S,3,&tolua_err)
09755  )
09756   goto tolua_lerror;
09757  else
09758 #endif
09759  {
09760   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09761   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
09762 #ifndef TOLUA_RELEASE
09763   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL);
09764 #endif
09765   {
09766    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
09767    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
09768   }
09769  }
09770  return 1;
09771 #ifndef TOLUA_RELEASE
09772  tolua_lerror:
09773  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
09774  return 0;
09775 #endif
09776 }
09777 #endif //#ifndef TOLUA_DISABLE
09778 
09779 /* method: msgq_remove of class  fawkes::HumanoidMotionInterface */
09780 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_remove00
09781 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_remove00(lua_State* tolua_S)
09782 {
09783 #ifndef TOLUA_RELEASE
09784  tolua_Error tolua_err;
09785  if (
09786      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09787      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
09788      !tolua_isnoobj(tolua_S,3,&tolua_err)
09789  )
09790   goto tolua_lerror;
09791  else
09792 #endif
09793  {
09794   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09795   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
09796 #ifndef TOLUA_RELEASE
09797   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
09798 #endif
09799   {
09800    self->msgq_remove(message);
09801   }
09802  }
09803  return 0;
09804 #ifndef TOLUA_RELEASE
09805  tolua_lerror:
09806  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
09807  return 0;
09808 #endif
09809 }
09810 #endif //#ifndef TOLUA_DISABLE
09811 
09812 /* method: msgq_remove of class  fawkes::HumanoidMotionInterface */
09813 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_remove01
09814 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_remove01(lua_State* tolua_S)
09815 {
09816  tolua_Error tolua_err;
09817  if (
09818      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09819      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
09820      !tolua_isnoobj(tolua_S,3,&tolua_err)
09821  )
09822   goto tolua_lerror;
09823  else
09824  {
09825   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09826   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
09827 #ifndef TOLUA_RELEASE
09828   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
09829 #endif
09830   {
09831    self->msgq_remove(message_id);
09832   }
09833  }
09834  return 0;
09835 tolua_lerror:
09836  return tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_remove00(tolua_S);
09837 }
09838 #endif //#ifndef TOLUA_DISABLE
09839 
09840 /* method: msgq_size of class  fawkes::HumanoidMotionInterface */
09841 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_size00
09842 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_size00(lua_State* tolua_S)
09843 {
09844 #ifndef TOLUA_RELEASE
09845  tolua_Error tolua_err;
09846  if (
09847      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09848      !tolua_isnoobj(tolua_S,2,&tolua_err)
09849  )
09850   goto tolua_lerror;
09851  else
09852 #endif
09853  {
09854   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09855 #ifndef TOLUA_RELEASE
09856   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL);
09857 #endif
09858   {
09859    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
09860    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
09861   }
09862  }
09863  return 1;
09864 #ifndef TOLUA_RELEASE
09865  tolua_lerror:
09866  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
09867  return 0;
09868 #endif
09869 }
09870 #endif //#ifndef TOLUA_DISABLE
09871 
09872 /* method: msgq_flush of class  fawkes::HumanoidMotionInterface */
09873 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_flush00
09874 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_flush00(lua_State* tolua_S)
09875 {
09876 #ifndef TOLUA_RELEASE
09877  tolua_Error tolua_err;
09878  if (
09879      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09880      !tolua_isnoobj(tolua_S,2,&tolua_err)
09881  )
09882   goto tolua_lerror;
09883  else
09884 #endif
09885  {
09886   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09887 #ifndef TOLUA_RELEASE
09888   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL);
09889 #endif
09890   {
09891    self->msgq_flush();
09892   }
09893  }
09894  return 0;
09895 #ifndef TOLUA_RELEASE
09896  tolua_lerror:
09897  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
09898  return 0;
09899 #endif
09900 }
09901 #endif //#ifndef TOLUA_DISABLE
09902 
09903 /* method: msgq_lock of class  fawkes::HumanoidMotionInterface */
09904 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_lock00
09905 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_lock00(lua_State* tolua_S)
09906 {
09907 #ifndef TOLUA_RELEASE
09908  tolua_Error tolua_err;
09909  if (
09910      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09911      !tolua_isnoobj(tolua_S,2,&tolua_err)
09912  )
09913   goto tolua_lerror;
09914  else
09915 #endif
09916  {
09917   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09918 #ifndef TOLUA_RELEASE
09919   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL);
09920 #endif
09921   {
09922    self->msgq_lock();
09923   }
09924  }
09925  return 0;
09926 #ifndef TOLUA_RELEASE
09927  tolua_lerror:
09928  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
09929  return 0;
09930 #endif
09931 }
09932 #endif //#ifndef TOLUA_DISABLE
09933 
09934 /* method: msgq_try_lock of class  fawkes::HumanoidMotionInterface */
09935 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_try_lock00
09936 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_try_lock00(lua_State* tolua_S)
09937 {
09938 #ifndef TOLUA_RELEASE
09939  tolua_Error tolua_err;
09940  if (
09941      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09942      !tolua_isnoobj(tolua_S,2,&tolua_err)
09943  )
09944   goto tolua_lerror;
09945  else
09946 #endif
09947  {
09948   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09949 #ifndef TOLUA_RELEASE
09950   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL);
09951 #endif
09952   {
09953    bool tolua_ret = (bool)  self->msgq_try_lock();
09954    tolua_pushboolean(tolua_S,(bool)tolua_ret);
09955   }
09956  }
09957  return 1;
09958 #ifndef TOLUA_RELEASE
09959  tolua_lerror:
09960  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
09961  return 0;
09962 #endif
09963 }
09964 #endif //#ifndef TOLUA_DISABLE
09965 
09966 /* method: msgq_unlock of class  fawkes::HumanoidMotionInterface */
09967 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_unlock00
09968 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_unlock00(lua_State* tolua_S)
09969 {
09970 #ifndef TOLUA_RELEASE
09971  tolua_Error tolua_err;
09972  if (
09973      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
09974      !tolua_isnoobj(tolua_S,2,&tolua_err)
09975  )
09976   goto tolua_lerror;
09977  else
09978 #endif
09979  {
09980   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
09981 #ifndef TOLUA_RELEASE
09982   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL);
09983 #endif
09984   {
09985    self->msgq_unlock();
09986   }
09987  }
09988  return 0;
09989 #ifndef TOLUA_RELEASE
09990  tolua_lerror:
09991  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
09992  return 0;
09993 #endif
09994 }
09995 #endif //#ifndef TOLUA_DISABLE
09996 
09997 /* method: msgq_pop of class  fawkes::HumanoidMotionInterface */
09998 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_pop00
09999 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_pop00(lua_State* tolua_S)
10000 {
10001 #ifndef TOLUA_RELEASE
10002  tolua_Error tolua_err;
10003  if (
10004      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
10005      !tolua_isnoobj(tolua_S,2,&tolua_err)
10006  )
10007   goto tolua_lerror;
10008  else
10009 #endif
10010  {
10011   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
10012 #ifndef TOLUA_RELEASE
10013   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL);
10014 #endif
10015   {
10016    self->msgq_pop();
10017   }
10018  }
10019  return 0;
10020 #ifndef TOLUA_RELEASE
10021  tolua_lerror:
10022  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
10023  return 0;
10024 #endif
10025 }
10026 #endif //#ifndef TOLUA_DISABLE
10027 
10028 /* method: msgq_first of class  fawkes::HumanoidMotionInterface */
10029 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_first00
10030 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_first00(lua_State* tolua_S)
10031 {
10032 #ifndef TOLUA_RELEASE
10033  tolua_Error tolua_err;
10034  if (
10035      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
10036      !tolua_isnoobj(tolua_S,2,&tolua_err)
10037  )
10038   goto tolua_lerror;
10039  else
10040 #endif
10041  {
10042   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
10043 #ifndef TOLUA_RELEASE
10044   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL);
10045 #endif
10046   {
10047    Message* tolua_ret = (Message*)  self->msgq_first();
10048     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
10049   }
10050  }
10051  return 1;
10052 #ifndef TOLUA_RELEASE
10053  tolua_lerror:
10054  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
10055  return 0;
10056 #endif
10057 }
10058 #endif //#ifndef TOLUA_DISABLE
10059 
10060 /* method: msgq_empty of class  fawkes::HumanoidMotionInterface */
10061 #ifndef TOLUA_DISABLE_tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_empty00
10062 static int tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_empty00(lua_State* tolua_S)
10063 {
10064 #ifndef TOLUA_RELEASE
10065  tolua_Error tolua_err;
10066  if (
10067      !tolua_isusertype(tolua_S,1,"fawkes::HumanoidMotionInterface",0,&tolua_err) ||
10068      !tolua_isnoobj(tolua_S,2,&tolua_err)
10069  )
10070   goto tolua_lerror;
10071  else
10072 #endif
10073  {
10074   fawkes::HumanoidMotionInterface* self = (fawkes::HumanoidMotionInterface*)  tolua_tousertype(tolua_S,1,0);
10075 #ifndef TOLUA_RELEASE
10076   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL);
10077 #endif
10078   {
10079    bool tolua_ret = (bool)  self->msgq_empty();
10080    tolua_pushboolean(tolua_S,(bool)tolua_ret);
10081   }
10082  }
10083  return 1;
10084 #ifndef TOLUA_RELEASE
10085  tolua_lerror:
10086  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
10087  return 0;
10088 #endif
10089 }
10090 #endif //#ifndef TOLUA_DISABLE
10091 
10092 /* Open function */
10093 TOLUA_API int tolua_interfaces_HumanoidMotionInterface_open (lua_State* tolua_S)
10094 {
10095  tolua_open(tolua_S);
10096  tolua_reg_types(tolua_S);
10097  tolua_module(tolua_S,NULL,0);
10098  tolua_beginmodule(tolua_S,NULL);
10099   tolua_module(tolua_S,"fawkes",0);
10100   tolua_beginmodule(tolua_S,"fawkes");
10101    tolua_cclass(tolua_S,"HumanoidMotionInterface","fawkes::HumanoidMotionInterface","Interface",NULL);
10102    tolua_beginmodule(tolua_S,"HumanoidMotionInterface");
10103     tolua_constant(tolua_S,"LEG_LEFT",fawkes::HumanoidMotionInterface::LEG_LEFT);
10104     tolua_constant(tolua_S,"LEG_RIGHT",fawkes::HumanoidMotionInterface::LEG_RIGHT);
10105     tolua_constant(tolua_S,"STANDUP_DETECT",fawkes::HumanoidMotionInterface::STANDUP_DETECT);
10106     tolua_constant(tolua_S,"STANDUP_BACK",fawkes::HumanoidMotionInterface::STANDUP_BACK);
10107     tolua_constant(tolua_S,"STANDUP_FRONT",fawkes::HumanoidMotionInterface::STANDUP_FRONT);
10108     tolua_constant(tolua_S,"WALK",fawkes::HumanoidMotionInterface::WALK);
10109     tolua_constant(tolua_S,"KICK",fawkes::HumanoidMotionInterface::KICK);
10110     #ifdef __cplusplus
10111     tolua_cclass(tolua_S,"SetWalkParamsMessage","fawkes::HumanoidMotionInterface::SetWalkParamsMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__SetWalkParamsMessage);
10112     #else
10113     tolua_cclass(tolua_S,"SetWalkParamsMessage","fawkes::HumanoidMotionInterface::SetWalkParamsMessage","Message",NULL);
10114     #endif
10115     tolua_beginmodule(tolua_S,"SetWalkParamsMessage");
10116      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new00);
10117      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new00_local);
10118      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new00_local);
10119      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new01);
10120      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new01_local);
10121      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_new01_local);
10122      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_delete00);
10123      tolua_function(tolua_S,"max_step_length",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_max_step_length00);
10124      tolua_function(tolua_S,"set_max_step_length",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_max_step_length00);
10125      tolua_function(tolua_S,"maxlenof_max_step_length",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_max_step_length00);
10126      tolua_function(tolua_S,"max_step_height",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_max_step_height00);
10127      tolua_function(tolua_S,"set_max_step_height",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_max_step_height00);
10128      tolua_function(tolua_S,"maxlenof_max_step_height",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_max_step_height00);
10129      tolua_function(tolua_S,"max_step_side",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_max_step_side00);
10130      tolua_function(tolua_S,"set_max_step_side",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_max_step_side00);
10131      tolua_function(tolua_S,"maxlenof_max_step_side",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_max_step_side00);
10132      tolua_function(tolua_S,"max_step_turn",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_max_step_turn00);
10133      tolua_function(tolua_S,"set_max_step_turn",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_max_step_turn00);
10134      tolua_function(tolua_S,"maxlenof_max_step_turn",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_max_step_turn00);
10135      tolua_function(tolua_S,"zmp_offset_forward",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_zmp_offset_forward00);
10136      tolua_function(tolua_S,"set_zmp_offset_forward",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_zmp_offset_forward00);
10137      tolua_function(tolua_S,"maxlenof_zmp_offset_forward",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_zmp_offset_forward00);
10138      tolua_function(tolua_S,"zmp_offset_sideward",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_zmp_offset_sideward00);
10139      tolua_function(tolua_S,"set_zmp_offset_sideward",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_zmp_offset_sideward00);
10140      tolua_function(tolua_S,"maxlenof_zmp_offset_sideward",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_zmp_offset_sideward00);
10141      tolua_function(tolua_S,"l_hip_roll_compensation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_l_hip_roll_compensation00);
10142      tolua_function(tolua_S,"set_l_hip_roll_compensation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_l_hip_roll_compensation00);
10143      tolua_function(tolua_S,"maxlenof_l_hip_roll_compensation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_l_hip_roll_compensation00);
10144      tolua_function(tolua_S,"r_hip_roll_compensation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_r_hip_roll_compensation00);
10145      tolua_function(tolua_S,"set_r_hip_roll_compensation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_r_hip_roll_compensation00);
10146      tolua_function(tolua_S,"maxlenof_r_hip_roll_compensation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_r_hip_roll_compensation00);
10147      tolua_function(tolua_S,"hip_height",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_hip_height00);
10148      tolua_function(tolua_S,"set_hip_height",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_hip_height00);
10149      tolua_function(tolua_S,"maxlenof_hip_height",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_hip_height00);
10150      tolua_function(tolua_S,"torso_sideward_orientation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_torso_sideward_orientation00);
10151      tolua_function(tolua_S,"set_torso_sideward_orientation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_set_torso_sideward_orientation00);
10152      tolua_function(tolua_S,"maxlenof_torso_sideward_orientation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkParamsMessage_maxlenof_torso_sideward_orientation00);
10153     tolua_endmodule(tolua_S);
10154     #ifdef __cplusplus
10155     tolua_cclass(tolua_S,"SetWalkArmsParamsMessage","fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__SetWalkArmsParamsMessage);
10156     #else
10157     tolua_cclass(tolua_S,"SetWalkArmsParamsMessage","fawkes::HumanoidMotionInterface::SetWalkArmsParamsMessage","Message",NULL);
10158     #endif
10159     tolua_beginmodule(tolua_S,"SetWalkArmsParamsMessage");
10160      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new00);
10161      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new00_local);
10162      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new00_local);
10163      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new01);
10164      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new01_local);
10165      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_new01_local);
10166      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_delete00);
10167      tolua_function(tolua_S,"is_arms_enabled",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_is_arms_enabled00);
10168      tolua_function(tolua_S,"set_arms_enabled",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_arms_enabled00);
10169      tolua_function(tolua_S,"maxlenof_arms_enabled",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_arms_enabled00);
10170      tolua_function(tolua_S,"shoulder_pitch_median",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_shoulder_pitch_median00);
10171      tolua_function(tolua_S,"set_shoulder_pitch_median",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_shoulder_pitch_median00);
10172      tolua_function(tolua_S,"maxlenof_shoulder_pitch_median",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_shoulder_pitch_median00);
10173      tolua_function(tolua_S,"shoulder_pitch_amplitude",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_shoulder_pitch_amplitude00);
10174      tolua_function(tolua_S,"set_shoulder_pitch_amplitude",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_shoulder_pitch_amplitude00);
10175      tolua_function(tolua_S,"maxlenof_shoulder_pitch_amplitude",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_shoulder_pitch_amplitude00);
10176      tolua_function(tolua_S,"elbow_roll_median",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_elbow_roll_median00);
10177      tolua_function(tolua_S,"set_elbow_roll_median",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_elbow_roll_median00);
10178      tolua_function(tolua_S,"maxlenof_elbow_roll_median",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_elbow_roll_median00);
10179      tolua_function(tolua_S,"elbow_roll_amplitude",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_elbow_roll_amplitude00);
10180      tolua_function(tolua_S,"set_elbow_roll_amplitude",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_set_elbow_roll_amplitude00);
10181      tolua_function(tolua_S,"maxlenof_elbow_roll_amplitude",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetWalkArmsParamsMessage_maxlenof_elbow_roll_amplitude00);
10182     tolua_endmodule(tolua_S);
10183     #ifdef __cplusplus
10184     tolua_cclass(tolua_S,"StopMessage","fawkes::HumanoidMotionInterface::StopMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__StopMessage);
10185     #else
10186     tolua_cclass(tolua_S,"StopMessage","fawkes::HumanoidMotionInterface::StopMessage","Message",NULL);
10187     #endif
10188     tolua_beginmodule(tolua_S,"StopMessage");
10189      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_new00);
10190      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_new00_local);
10191      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_new00_local);
10192      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StopMessage_delete00);
10193     tolua_endmodule(tolua_S);
10194     #ifdef __cplusplus
10195     tolua_cclass(tolua_S,"WalkStraightMessage","fawkes::HumanoidMotionInterface::WalkStraightMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__WalkStraightMessage);
10196     #else
10197     tolua_cclass(tolua_S,"WalkStraightMessage","fawkes::HumanoidMotionInterface::WalkStraightMessage","Message",NULL);
10198     #endif
10199     tolua_beginmodule(tolua_S,"WalkStraightMessage");
10200      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00);
10201      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00_local);
10202      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new00_local);
10203      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new01);
10204      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new01_local);
10205      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_new01_local);
10206      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_delete00);
10207      tolua_function(tolua_S,"distance",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_distance00);
10208      tolua_function(tolua_S,"set_distance",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_set_distance00);
10209      tolua_function(tolua_S,"maxlenof_distance",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_maxlenof_distance00);
10210      tolua_function(tolua_S,"num_samples",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_num_samples00);
10211      tolua_function(tolua_S,"set_num_samples",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_set_num_samples00);
10212      tolua_function(tolua_S,"maxlenof_num_samples",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkStraightMessage_maxlenof_num_samples00);
10213     tolua_endmodule(tolua_S);
10214     #ifdef __cplusplus
10215     tolua_cclass(tolua_S,"WalkSidewaysMessage","fawkes::HumanoidMotionInterface::WalkSidewaysMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__WalkSidewaysMessage);
10216     #else
10217     tolua_cclass(tolua_S,"WalkSidewaysMessage","fawkes::HumanoidMotionInterface::WalkSidewaysMessage","Message",NULL);
10218     #endif
10219     tolua_beginmodule(tolua_S,"WalkSidewaysMessage");
10220      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00);
10221      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00_local);
10222      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new00_local);
10223      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new01);
10224      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new01_local);
10225      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_new01_local);
10226      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_delete00);
10227      tolua_function(tolua_S,"distance",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_distance00);
10228      tolua_function(tolua_S,"set_distance",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_set_distance00);
10229      tolua_function(tolua_S,"maxlenof_distance",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_maxlenof_distance00);
10230      tolua_function(tolua_S,"num_samples",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_num_samples00);
10231      tolua_function(tolua_S,"set_num_samples",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_set_num_samples00);
10232      tolua_function(tolua_S,"maxlenof_num_samples",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkSidewaysMessage_maxlenof_num_samples00);
10233     tolua_endmodule(tolua_S);
10234     #ifdef __cplusplus
10235     tolua_cclass(tolua_S,"WalkArcMessage","fawkes::HumanoidMotionInterface::WalkArcMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__WalkArcMessage);
10236     #else
10237     tolua_cclass(tolua_S,"WalkArcMessage","fawkes::HumanoidMotionInterface::WalkArcMessage","Message",NULL);
10238     #endif
10239     tolua_beginmodule(tolua_S,"WalkArcMessage");
10240      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00);
10241      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00_local);
10242      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new00_local);
10243      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new01);
10244      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new01_local);
10245      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_new01_local);
10246      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_delete00);
10247      tolua_function(tolua_S,"angle",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_angle00);
10248      tolua_function(tolua_S,"set_angle",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_angle00);
10249      tolua_function(tolua_S,"maxlenof_angle",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_angle00);
10250      tolua_function(tolua_S,"radius",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_radius00);
10251      tolua_function(tolua_S,"set_radius",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_radius00);
10252      tolua_function(tolua_S,"maxlenof_radius",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_radius00);
10253      tolua_function(tolua_S,"num_samples",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_num_samples00);
10254      tolua_function(tolua_S,"set_num_samples",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_set_num_samples00);
10255      tolua_function(tolua_S,"maxlenof_num_samples",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_WalkArcMessage_maxlenof_num_samples00);
10256     tolua_endmodule(tolua_S);
10257     #ifdef __cplusplus
10258     tolua_cclass(tolua_S,"TurnMessage","fawkes::HumanoidMotionInterface::TurnMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__TurnMessage);
10259     #else
10260     tolua_cclass(tolua_S,"TurnMessage","fawkes::HumanoidMotionInterface::TurnMessage","Message",NULL);
10261     #endif
10262     tolua_beginmodule(tolua_S,"TurnMessage");
10263      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00);
10264      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00_local);
10265      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new00_local);
10266      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new01);
10267      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new01_local);
10268      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_new01_local);
10269      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_delete00);
10270      tolua_function(tolua_S,"angle",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_angle00);
10271      tolua_function(tolua_S,"set_angle",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_set_angle00);
10272      tolua_function(tolua_S,"maxlenof_angle",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_maxlenof_angle00);
10273      tolua_function(tolua_S,"num_samples",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_num_samples00);
10274      tolua_function(tolua_S,"set_num_samples",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_set_num_samples00);
10275      tolua_function(tolua_S,"maxlenof_num_samples",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_TurnMessage_maxlenof_num_samples00);
10276     tolua_endmodule(tolua_S);
10277     #ifdef __cplusplus
10278     tolua_cclass(tolua_S,"KickMessage","fawkes::HumanoidMotionInterface::KickMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__KickMessage);
10279     #else
10280     tolua_cclass(tolua_S,"KickMessage","fawkes::HumanoidMotionInterface::KickMessage","Message",NULL);
10281     #endif
10282     tolua_beginmodule(tolua_S,"KickMessage");
10283      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00);
10284      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00_local);
10285      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new00_local);
10286      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new01);
10287      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new01_local);
10288      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_new01_local);
10289      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_delete00);
10290      tolua_function(tolua_S,"leg",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_leg00);
10291      tolua_function(tolua_S,"set_leg",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_set_leg00);
10292      tolua_function(tolua_S,"maxlenof_leg",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_maxlenof_leg00);
10293      tolua_function(tolua_S,"strength",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_strength00);
10294      tolua_function(tolua_S,"set_strength",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_set_strength00);
10295      tolua_function(tolua_S,"maxlenof_strength",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_KickMessage_maxlenof_strength00);
10296     tolua_endmodule(tolua_S);
10297     #ifdef __cplusplus
10298     tolua_cclass(tolua_S,"ParkMessage","fawkes::HumanoidMotionInterface::ParkMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__ParkMessage);
10299     #else
10300     tolua_cclass(tolua_S,"ParkMessage","fawkes::HumanoidMotionInterface::ParkMessage","Message",NULL);
10301     #endif
10302     tolua_beginmodule(tolua_S,"ParkMessage");
10303      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00);
10304      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00_local);
10305      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new00_local);
10306      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new01);
10307      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new01_local);
10308      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_new01_local);
10309      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_delete00);
10310      tolua_function(tolua_S,"time_sec",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_time_sec00);
10311      tolua_function(tolua_S,"set_time_sec",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_set_time_sec00);
10312      tolua_function(tolua_S,"maxlenof_time_sec",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_ParkMessage_maxlenof_time_sec00);
10313     tolua_endmodule(tolua_S);
10314     #ifdef __cplusplus
10315     tolua_cclass(tolua_S,"GetUpMessage","fawkes::HumanoidMotionInterface::GetUpMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__GetUpMessage);
10316     #else
10317     tolua_cclass(tolua_S,"GetUpMessage","fawkes::HumanoidMotionInterface::GetUpMessage","Message",NULL);
10318     #endif
10319     tolua_beginmodule(tolua_S,"GetUpMessage");
10320      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00);
10321      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00_local);
10322      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new00_local);
10323      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new01);
10324      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new01_local);
10325      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_new01_local);
10326      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_delete00);
10327      tolua_function(tolua_S,"time_sec",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_time_sec00);
10328      tolua_function(tolua_S,"set_time_sec",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_set_time_sec00);
10329      tolua_function(tolua_S,"maxlenof_time_sec",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_GetUpMessage_maxlenof_time_sec00);
10330     tolua_endmodule(tolua_S);
10331     #ifdef __cplusplus
10332     tolua_cclass(tolua_S,"StandupMessage","fawkes::HumanoidMotionInterface::StandupMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__StandupMessage);
10333     #else
10334     tolua_cclass(tolua_S,"StandupMessage","fawkes::HumanoidMotionInterface::StandupMessage","Message",NULL);
10335     #endif
10336     tolua_beginmodule(tolua_S,"StandupMessage");
10337      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00);
10338      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00_local);
10339      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new00_local);
10340      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new01);
10341      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new01_local);
10342      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_new01_local);
10343      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_delete00);
10344      tolua_function(tolua_S,"from_pos",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_from_pos00);
10345      tolua_function(tolua_S,"set_from_pos",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_set_from_pos00);
10346      tolua_function(tolua_S,"maxlenof_from_pos",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_StandupMessage_maxlenof_from_pos00);
10347     tolua_endmodule(tolua_S);
10348     #ifdef __cplusplus
10349     tolua_cclass(tolua_S,"YawPitchHeadMessage","fawkes::HumanoidMotionInterface::YawPitchHeadMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__YawPitchHeadMessage);
10350     #else
10351     tolua_cclass(tolua_S,"YawPitchHeadMessage","fawkes::HumanoidMotionInterface::YawPitchHeadMessage","Message",NULL);
10352     #endif
10353     tolua_beginmodule(tolua_S,"YawPitchHeadMessage");
10354      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new00);
10355      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new00_local);
10356      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new00_local);
10357      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new01);
10358      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new01_local);
10359      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_new01_local);
10360      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_delete00);
10361      tolua_function(tolua_S,"yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_yaw00);
10362      tolua_function(tolua_S,"set_yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_set_yaw00);
10363      tolua_function(tolua_S,"maxlenof_yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_maxlenof_yaw00);
10364      tolua_function(tolua_S,"pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_pitch00);
10365      tolua_function(tolua_S,"set_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_set_pitch00);
10366      tolua_function(tolua_S,"maxlenof_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_maxlenof_pitch00);
10367      tolua_function(tolua_S,"time_sec",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_time_sec00);
10368      tolua_function(tolua_S,"set_time_sec",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_set_time_sec00);
10369      tolua_function(tolua_S,"maxlenof_time_sec",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_YawPitchHeadMessage_maxlenof_time_sec00);
10370     tolua_endmodule(tolua_S);
10371     #ifdef __cplusplus
10372     tolua_cclass(tolua_S,"SetStiffnessParamsMessage","fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage","Message",tolua_collect_fawkes__HumanoidMotionInterface__SetStiffnessParamsMessage);
10373     #else
10374     tolua_cclass(tolua_S,"SetStiffnessParamsMessage","fawkes::HumanoidMotionInterface::SetStiffnessParamsMessage","Message",NULL);
10375     #endif
10376     tolua_beginmodule(tolua_S,"SetStiffnessParamsMessage");
10377      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new00);
10378      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new00_local);
10379      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new00_local);
10380      tolua_function(tolua_S,"new",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new01);
10381      tolua_function(tolua_S,"new_local",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new01_local);
10382      tolua_function(tolua_S,".call",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_new01_local);
10383      tolua_function(tolua_S,"delete",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_delete00);
10384      tolua_function(tolua_S,"motion_pattern",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_motion_pattern00);
10385      tolua_function(tolua_S,"set_motion_pattern",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_motion_pattern00);
10386      tolua_function(tolua_S,"maxlenof_motion_pattern",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_motion_pattern00);
10387      tolua_function(tolua_S,"head_yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_head_yaw00);
10388      tolua_function(tolua_S,"set_head_yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_head_yaw00);
10389      tolua_function(tolua_S,"maxlenof_head_yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_head_yaw00);
10390      tolua_function(tolua_S,"head_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_head_pitch00);
10391      tolua_function(tolua_S,"set_head_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_head_pitch00);
10392      tolua_function(tolua_S,"maxlenof_head_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_head_pitch00);
10393      tolua_function(tolua_S,"l_shoulder_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_shoulder_pitch00);
10394      tolua_function(tolua_S,"set_l_shoulder_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_shoulder_pitch00);
10395      tolua_function(tolua_S,"maxlenof_l_shoulder_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_shoulder_pitch00);
10396      tolua_function(tolua_S,"l_shoulder_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_shoulder_roll00);
10397      tolua_function(tolua_S,"set_l_shoulder_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_shoulder_roll00);
10398      tolua_function(tolua_S,"maxlenof_l_shoulder_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_shoulder_roll00);
10399      tolua_function(tolua_S,"l_elbow_yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_elbow_yaw00);
10400      tolua_function(tolua_S,"set_l_elbow_yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_elbow_yaw00);
10401      tolua_function(tolua_S,"maxlenof_l_elbow_yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_elbow_yaw00);
10402      tolua_function(tolua_S,"l_elbow_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_elbow_roll00);
10403      tolua_function(tolua_S,"set_l_elbow_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_elbow_roll00);
10404      tolua_function(tolua_S,"maxlenof_l_elbow_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_elbow_roll00);
10405      tolua_function(tolua_S,"l_hip_yaw_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_hip_yaw_pitch00);
10406      tolua_function(tolua_S,"set_l_hip_yaw_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_hip_yaw_pitch00);
10407      tolua_function(tolua_S,"maxlenof_l_hip_yaw_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_hip_yaw_pitch00);
10408      tolua_function(tolua_S,"l_hip_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_hip_roll00);
10409      tolua_function(tolua_S,"set_l_hip_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_hip_roll00);
10410      tolua_function(tolua_S,"maxlenof_l_hip_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_hip_roll00);
10411      tolua_function(tolua_S,"l_hip_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_hip_pitch00);
10412      tolua_function(tolua_S,"set_l_hip_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_hip_pitch00);
10413      tolua_function(tolua_S,"maxlenof_l_hip_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_hip_pitch00);
10414      tolua_function(tolua_S,"l_knee_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_knee_pitch00);
10415      tolua_function(tolua_S,"set_l_knee_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_knee_pitch00);
10416      tolua_function(tolua_S,"maxlenof_l_knee_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_knee_pitch00);
10417      tolua_function(tolua_S,"l_ankle_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_ankle_pitch00);
10418      tolua_function(tolua_S,"set_l_ankle_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_ankle_pitch00);
10419      tolua_function(tolua_S,"maxlenof_l_ankle_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_ankle_pitch00);
10420      tolua_function(tolua_S,"l_ankle_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_l_ankle_roll00);
10421      tolua_function(tolua_S,"set_l_ankle_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_l_ankle_roll00);
10422      tolua_function(tolua_S,"maxlenof_l_ankle_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_l_ankle_roll00);
10423      tolua_function(tolua_S,"r_hip_yaw_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_hip_yaw_pitch00);
10424      tolua_function(tolua_S,"set_r_hip_yaw_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_hip_yaw_pitch00);
10425      tolua_function(tolua_S,"maxlenof_r_hip_yaw_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_hip_yaw_pitch00);
10426      tolua_function(tolua_S,"r_hip_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_hip_roll00);
10427      tolua_function(tolua_S,"set_r_hip_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_hip_roll00);
10428      tolua_function(tolua_S,"maxlenof_r_hip_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_hip_roll00);
10429      tolua_function(tolua_S,"r_hip_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_hip_pitch00);
10430      tolua_function(tolua_S,"set_r_hip_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_hip_pitch00);
10431      tolua_function(tolua_S,"maxlenof_r_hip_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_hip_pitch00);
10432      tolua_function(tolua_S,"r_knee_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_knee_pitch00);
10433      tolua_function(tolua_S,"set_r_knee_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_knee_pitch00);
10434      tolua_function(tolua_S,"maxlenof_r_knee_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_knee_pitch00);
10435      tolua_function(tolua_S,"r_ankle_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_ankle_pitch00);
10436      tolua_function(tolua_S,"set_r_ankle_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_ankle_pitch00);
10437      tolua_function(tolua_S,"maxlenof_r_ankle_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_ankle_pitch00);
10438      tolua_function(tolua_S,"r_ankle_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_ankle_roll00);
10439      tolua_function(tolua_S,"set_r_ankle_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_ankle_roll00);
10440      tolua_function(tolua_S,"maxlenof_r_ankle_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_ankle_roll00);
10441      tolua_function(tolua_S,"r_shoulder_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_shoulder_pitch00);
10442      tolua_function(tolua_S,"set_r_shoulder_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_shoulder_pitch00);
10443      tolua_function(tolua_S,"maxlenof_r_shoulder_pitch",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_shoulder_pitch00);
10444      tolua_function(tolua_S,"r_shoulder_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_shoulder_roll00);
10445      tolua_function(tolua_S,"set_r_shoulder_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_shoulder_roll00);
10446      tolua_function(tolua_S,"maxlenof_r_shoulder_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_shoulder_roll00);
10447      tolua_function(tolua_S,"r_elbow_yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_elbow_yaw00);
10448      tolua_function(tolua_S,"set_r_elbow_yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_elbow_yaw00);
10449      tolua_function(tolua_S,"maxlenof_r_elbow_yaw",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_elbow_yaw00);
10450      tolua_function(tolua_S,"r_elbow_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_r_elbow_roll00);
10451      tolua_function(tolua_S,"set_r_elbow_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_set_r_elbow_roll00);
10452      tolua_function(tolua_S,"maxlenof_r_elbow_roll",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_SetStiffnessParamsMessage_maxlenof_r_elbow_roll00);
10453     tolua_endmodule(tolua_S);
10454     tolua_function(tolua_S,"is_moving",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_moving00);
10455     tolua_function(tolua_S,"set_moving",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_moving00);
10456     tolua_function(tolua_S,"maxlenof_moving",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_moving00);
10457     tolua_function(tolua_S,"supporting_leg",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_supporting_leg00);
10458     tolua_function(tolua_S,"set_supporting_leg",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_supporting_leg00);
10459     tolua_function(tolua_S,"maxlenof_supporting_leg",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_supporting_leg00);
10460     tolua_function(tolua_S,"max_step_length",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_max_step_length00);
10461     tolua_function(tolua_S,"set_max_step_length",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_max_step_length00);
10462     tolua_function(tolua_S,"maxlenof_max_step_length",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_max_step_length00);
10463     tolua_function(tolua_S,"max_step_height",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_max_step_height00);
10464     tolua_function(tolua_S,"set_max_step_height",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_max_step_height00);
10465     tolua_function(tolua_S,"maxlenof_max_step_height",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_max_step_height00);
10466     tolua_function(tolua_S,"max_step_side",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_max_step_side00);
10467     tolua_function(tolua_S,"set_max_step_side",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_max_step_side00);
10468     tolua_function(tolua_S,"maxlenof_max_step_side",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_max_step_side00);
10469     tolua_function(tolua_S,"max_step_turn",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_max_step_turn00);
10470     tolua_function(tolua_S,"set_max_step_turn",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_max_step_turn00);
10471     tolua_function(tolua_S,"maxlenof_max_step_turn",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_max_step_turn00);
10472     tolua_function(tolua_S,"zmp_offset_forward",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_zmp_offset_forward00);
10473     tolua_function(tolua_S,"set_zmp_offset_forward",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_zmp_offset_forward00);
10474     tolua_function(tolua_S,"maxlenof_zmp_offset_forward",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_zmp_offset_forward00);
10475     tolua_function(tolua_S,"zmp_offset_sideward",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_zmp_offset_sideward00);
10476     tolua_function(tolua_S,"set_zmp_offset_sideward",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_zmp_offset_sideward00);
10477     tolua_function(tolua_S,"maxlenof_zmp_offset_sideward",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_zmp_offset_sideward00);
10478     tolua_function(tolua_S,"l_hip_roll_compensation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_l_hip_roll_compensation00);
10479     tolua_function(tolua_S,"set_l_hip_roll_compensation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_l_hip_roll_compensation00);
10480     tolua_function(tolua_S,"maxlenof_l_hip_roll_compensation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_l_hip_roll_compensation00);
10481     tolua_function(tolua_S,"r_hip_roll_compensation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_r_hip_roll_compensation00);
10482     tolua_function(tolua_S,"set_r_hip_roll_compensation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_r_hip_roll_compensation00);
10483     tolua_function(tolua_S,"maxlenof_r_hip_roll_compensation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_r_hip_roll_compensation00);
10484     tolua_function(tolua_S,"hip_height",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hip_height00);
10485     tolua_function(tolua_S,"set_hip_height",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_hip_height00);
10486     tolua_function(tolua_S,"maxlenof_hip_height",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_hip_height00);
10487     tolua_function(tolua_S,"torso_sideward_orientation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_torso_sideward_orientation00);
10488     tolua_function(tolua_S,"set_torso_sideward_orientation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_torso_sideward_orientation00);
10489     tolua_function(tolua_S,"maxlenof_torso_sideward_orientation",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_torso_sideward_orientation00);
10490     tolua_function(tolua_S,"is_arms_enabled",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_arms_enabled00);
10491     tolua_function(tolua_S,"set_arms_enabled",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_arms_enabled00);
10492     tolua_function(tolua_S,"maxlenof_arms_enabled",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_arms_enabled00);
10493     tolua_function(tolua_S,"shoulder_pitch_median",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_shoulder_pitch_median00);
10494     tolua_function(tolua_S,"set_shoulder_pitch_median",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_shoulder_pitch_median00);
10495     tolua_function(tolua_S,"maxlenof_shoulder_pitch_median",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_shoulder_pitch_median00);
10496     tolua_function(tolua_S,"shoulder_pitch_amplitude",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_shoulder_pitch_amplitude00);
10497     tolua_function(tolua_S,"set_shoulder_pitch_amplitude",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_shoulder_pitch_amplitude00);
10498     tolua_function(tolua_S,"maxlenof_shoulder_pitch_amplitude",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_shoulder_pitch_amplitude00);
10499     tolua_function(tolua_S,"elbow_roll_median",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_elbow_roll_median00);
10500     tolua_function(tolua_S,"set_elbow_roll_median",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_elbow_roll_median00);
10501     tolua_function(tolua_S,"maxlenof_elbow_roll_median",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_elbow_roll_median00);
10502     tolua_function(tolua_S,"elbow_roll_amplitude",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_elbow_roll_amplitude00);
10503     tolua_function(tolua_S,"set_elbow_roll_amplitude",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_elbow_roll_amplitude00);
10504     tolua_function(tolua_S,"maxlenof_elbow_roll_amplitude",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_elbow_roll_amplitude00);
10505     tolua_function(tolua_S,"msgid",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgid00);
10506     tolua_function(tolua_S,"set_msgid",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_msgid00);
10507     tolua_function(tolua_S,"maxlenof_msgid",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_maxlenof_msgid00);
10508     tolua_function(tolua_S,"oftype",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_oftype00);
10509     tolua_function(tolua_S,"datachunk",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_datachunk00);
10510     tolua_function(tolua_S,"datasize",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_datasize00);
10511     tolua_function(tolua_S,"type",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_type00);
10512     tolua_function(tolua_S,"id",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_id00);
10513     tolua_function(tolua_S,"uid",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_uid00);
10514     tolua_function(tolua_S,"serial",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_serial00);
10515     tolua_function(tolua_S,"mem_serial",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_mem_serial00);
10516     tolua_function(tolua_S,".eq",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface__eq00);
10517     tolua_function(tolua_S,"hash",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash00);
10518     tolua_function(tolua_S,"hash_size",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash_size00);
10519     tolua_function(tolua_S,"hash_printable",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_hash_printable00);
10520     tolua_function(tolua_S,"is_writer",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_is_writer00);
10521     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_set_from_chunk00);
10522     tolua_function(tolua_S,"create_message",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_create_message00);
10523     tolua_function(tolua_S,"read",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_read00);
10524     tolua_function(tolua_S,"write",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_write00);
10525     tolua_function(tolua_S,"has_writer",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_has_writer00);
10526     tolua_function(tolua_S,"num_readers",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_num_readers00);
10527     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_enqueue_copy00);
10528     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_remove00);
10529     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_remove01);
10530     tolua_function(tolua_S,"msgq_size",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_size00);
10531     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_flush00);
10532     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_lock00);
10533     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_try_lock00);
10534     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_unlock00);
10535     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_pop00);
10536     tolua_function(tolua_S,"msgq_first",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_first00);
10537     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_HumanoidMotionInterface_fawkes_HumanoidMotionInterface_msgq_empty00);
10538    tolua_endmodule(tolua_S);
10539   tolua_endmodule(tolua_S);
10540  tolua_endmodule(tolua_S);
10541  return 1;
10542 }
10543 
10544 
10545 extern "C" {
10546 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
10547  TOLUA_API int luaopen_interfaces_HumanoidMotionInterface (lua_State* tolua_S) {
10548  return tolua_interfaces_HumanoidMotionInterface_open(tolua_S);
10549 };
10550 #endif
10551 }
10552 
10553