KatanaInterface_tolua.cpp

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