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