Laser720Interface_tolua.cpp

00001 /*
00002 ** Lua binding: interfaces_Laser720Interface
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_Laser720Interface_open (lua_State* tolua_S);
00028 
00029 #include <interfaces/Laser720Interface.h>
00030 using namespace fawkes;
00031 
00032 /* function to register type */
00033 static void tolua_reg_types (lua_State* tolua_S)
00034 {
00035  tolua_usertype(tolua_S,"fawkes::Laser720Interface");
00036  tolua_usertype(tolua_S,"Message");
00037  tolua_usertype(tolua_S,"Interface");
00038 }
00039 
00040 /* method: distances of class  fawkes::Laser720Interface */
00041 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_distances00
00042 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_distances00(lua_State* tolua_S)
00043 {
00044 #ifndef TOLUA_RELEASE
00045  tolua_Error tolua_err;
00046  if (
00047      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
00048      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00049      !tolua_isnoobj(tolua_S,3,&tolua_err)
00050  )
00051   goto tolua_lerror;
00052  else
00053 #endif
00054  {
00055   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00056   int index = ((int)  tolua_tonumber(tolua_S,2,0));
00057 #ifndef TOLUA_RELEASE
00058   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'distances'", NULL);
00059 #endif
00060   {
00061    float tolua_ret = (float)  self->distances(index);
00062    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00063   }
00064  }
00065  return 1;
00066 #ifndef TOLUA_RELEASE
00067  tolua_lerror:
00068  tolua_error(tolua_S,"#ferror in function 'distances'.",&tolua_err);
00069  return 0;
00070 #endif
00071 }
00072 #endif //#ifndef TOLUA_DISABLE
00073 
00074 /* method: set_distances of class  fawkes::Laser720Interface */
00075 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_set_distances00
00076 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_set_distances00(lua_State* tolua_S)
00077 {
00078 #ifndef TOLUA_RELEASE
00079  tolua_Error tolua_err;
00080  if (
00081      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
00082      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00083      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00084      !tolua_isnoobj(tolua_S,4,&tolua_err)
00085  )
00086   goto tolua_lerror;
00087  else
00088 #endif
00089  {
00090   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00091   unsigned int index = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
00092   const float new_distances = ((const float)  tolua_tonumber(tolua_S,3,0));
00093 #ifndef TOLUA_RELEASE
00094   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_distances'", NULL);
00095 #endif
00096   {
00097    self->set_distances(index,new_distances);
00098   }
00099  }
00100  return 0;
00101 #ifndef TOLUA_RELEASE
00102  tolua_lerror:
00103  tolua_error(tolua_S,"#ferror in function 'set_distances'.",&tolua_err);
00104  return 0;
00105 #endif
00106 }
00107 #endif //#ifndef TOLUA_DISABLE
00108 
00109 /* method: maxlenof_distances of class  fawkes::Laser720Interface */
00110 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_maxlenof_distances00
00111 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_maxlenof_distances00(lua_State* tolua_S)
00112 {
00113 #ifndef TOLUA_RELEASE
00114  tolua_Error tolua_err;
00115  if (
00116      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00117      !tolua_isnoobj(tolua_S,2,&tolua_err)
00118  )
00119   goto tolua_lerror;
00120  else
00121 #endif
00122  {
00123   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00124 #ifndef TOLUA_RELEASE
00125   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_distances'", NULL);
00126 #endif
00127   {
00128    int tolua_ret = (int)  self->maxlenof_distances();
00129    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00130   }
00131  }
00132  return 1;
00133 #ifndef TOLUA_RELEASE
00134  tolua_lerror:
00135  tolua_error(tolua_S,"#ferror in function 'maxlenof_distances'.",&tolua_err);
00136  return 0;
00137 #endif
00138 }
00139 #endif //#ifndef TOLUA_DISABLE
00140 
00141 /* method: is_clockwise_angle of class  fawkes::Laser720Interface */
00142 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_is_clockwise_angle00
00143 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_is_clockwise_angle00(lua_State* tolua_S)
00144 {
00145 #ifndef TOLUA_RELEASE
00146  tolua_Error tolua_err;
00147  if (
00148      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
00149      !tolua_isnoobj(tolua_S,2,&tolua_err)
00150  )
00151   goto tolua_lerror;
00152  else
00153 #endif
00154  {
00155   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00156 #ifndef TOLUA_RELEASE
00157   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_clockwise_angle'", NULL);
00158 #endif
00159   {
00160    bool tolua_ret = (bool)  self->is_clockwise_angle();
00161    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00162   }
00163  }
00164  return 1;
00165 #ifndef TOLUA_RELEASE
00166  tolua_lerror:
00167  tolua_error(tolua_S,"#ferror in function 'is_clockwise_angle'.",&tolua_err);
00168  return 0;
00169 #endif
00170 }
00171 #endif //#ifndef TOLUA_DISABLE
00172 
00173 /* method: set_clockwise_angle of class  fawkes::Laser720Interface */
00174 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_set_clockwise_angle00
00175 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_set_clockwise_angle00(lua_State* tolua_S)
00176 {
00177 #ifndef TOLUA_RELEASE
00178  tolua_Error tolua_err;
00179  if (
00180      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
00181      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
00182      !tolua_isnoobj(tolua_S,3,&tolua_err)
00183  )
00184   goto tolua_lerror;
00185  else
00186 #endif
00187  {
00188   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00189   const bool new_clockwise_angle = ((const bool)  tolua_toboolean(tolua_S,2,0));
00190 #ifndef TOLUA_RELEASE
00191   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_clockwise_angle'", NULL);
00192 #endif
00193   {
00194    self->set_clockwise_angle(new_clockwise_angle);
00195   }
00196  }
00197  return 0;
00198 #ifndef TOLUA_RELEASE
00199  tolua_lerror:
00200  tolua_error(tolua_S,"#ferror in function 'set_clockwise_angle'.",&tolua_err);
00201  return 0;
00202 #endif
00203 }
00204 #endif //#ifndef TOLUA_DISABLE
00205 
00206 /* method: maxlenof_clockwise_angle of class  fawkes::Laser720Interface */
00207 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_maxlenof_clockwise_angle00
00208 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_maxlenof_clockwise_angle00(lua_State* tolua_S)
00209 {
00210 #ifndef TOLUA_RELEASE
00211  tolua_Error tolua_err;
00212  if (
00213      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00214      !tolua_isnoobj(tolua_S,2,&tolua_err)
00215  )
00216   goto tolua_lerror;
00217  else
00218 #endif
00219  {
00220   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00221 #ifndef TOLUA_RELEASE
00222   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_clockwise_angle'", NULL);
00223 #endif
00224   {
00225    int tolua_ret = (int)  self->maxlenof_clockwise_angle();
00226    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00227   }
00228  }
00229  return 1;
00230 #ifndef TOLUA_RELEASE
00231  tolua_lerror:
00232  tolua_error(tolua_S,"#ferror in function 'maxlenof_clockwise_angle'.",&tolua_err);
00233  return 0;
00234 #endif
00235 }
00236 #endif //#ifndef TOLUA_DISABLE
00237 
00238 /* method: oftype of class  fawkes::Laser720Interface */
00239 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_oftype00
00240 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_oftype00(lua_State* tolua_S)
00241 {
00242 #ifndef TOLUA_RELEASE
00243  tolua_Error tolua_err;
00244  if (
00245      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00246      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00247      !tolua_isnoobj(tolua_S,3,&tolua_err)
00248  )
00249   goto tolua_lerror;
00250  else
00251 #endif
00252  {
00253   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00254   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
00255 #ifndef TOLUA_RELEASE
00256   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL);
00257 #endif
00258   {
00259    bool tolua_ret = (bool)  self->oftype(interface_type);
00260    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00261   }
00262  }
00263  return 1;
00264 #ifndef TOLUA_RELEASE
00265  tolua_lerror:
00266  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
00267  return 0;
00268 #endif
00269 }
00270 #endif //#ifndef TOLUA_DISABLE
00271 
00272 /* method: datachunk of class  fawkes::Laser720Interface */
00273 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_datachunk00
00274 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_datachunk00(lua_State* tolua_S)
00275 {
00276 #ifndef TOLUA_RELEASE
00277  tolua_Error tolua_err;
00278  if (
00279      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00280      !tolua_isnoobj(tolua_S,2,&tolua_err)
00281  )
00282   goto tolua_lerror;
00283  else
00284 #endif
00285  {
00286   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00287 #ifndef TOLUA_RELEASE
00288   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL);
00289 #endif
00290   {
00291    const void* tolua_ret = (const void*)  self->datachunk();
00292    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
00293   }
00294  }
00295  return 1;
00296 #ifndef TOLUA_RELEASE
00297  tolua_lerror:
00298  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
00299  return 0;
00300 #endif
00301 }
00302 #endif //#ifndef TOLUA_DISABLE
00303 
00304 /* method: datasize of class  fawkes::Laser720Interface */
00305 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_datasize00
00306 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_datasize00(lua_State* tolua_S)
00307 {
00308 #ifndef TOLUA_RELEASE
00309  tolua_Error tolua_err;
00310  if (
00311      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00312      !tolua_isnoobj(tolua_S,2,&tolua_err)
00313  )
00314   goto tolua_lerror;
00315  else
00316 #endif
00317  {
00318   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00319 #ifndef TOLUA_RELEASE
00320   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL);
00321 #endif
00322   {
00323    unsigned int tolua_ret = (unsigned int)  self->datasize();
00324    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00325   }
00326  }
00327  return 1;
00328 #ifndef TOLUA_RELEASE
00329  tolua_lerror:
00330  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
00331  return 0;
00332 #endif
00333 }
00334 #endif //#ifndef TOLUA_DISABLE
00335 
00336 /* method: type of class  fawkes::Laser720Interface */
00337 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_type00
00338 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_type00(lua_State* tolua_S)
00339 {
00340 #ifndef TOLUA_RELEASE
00341  tolua_Error tolua_err;
00342  if (
00343      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00344      !tolua_isnoobj(tolua_S,2,&tolua_err)
00345  )
00346   goto tolua_lerror;
00347  else
00348 #endif
00349  {
00350   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00351 #ifndef TOLUA_RELEASE
00352   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
00353 #endif
00354   {
00355    const char* tolua_ret = (const char*)  self->type();
00356    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00357   }
00358  }
00359  return 1;
00360 #ifndef TOLUA_RELEASE
00361  tolua_lerror:
00362  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
00363  return 0;
00364 #endif
00365 }
00366 #endif //#ifndef TOLUA_DISABLE
00367 
00368 /* method: id of class  fawkes::Laser720Interface */
00369 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_id00
00370 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_id00(lua_State* tolua_S)
00371 {
00372 #ifndef TOLUA_RELEASE
00373  tolua_Error tolua_err;
00374  if (
00375      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00376      !tolua_isnoobj(tolua_S,2,&tolua_err)
00377  )
00378   goto tolua_lerror;
00379  else
00380 #endif
00381  {
00382   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00383 #ifndef TOLUA_RELEASE
00384   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL);
00385 #endif
00386   {
00387    const char* tolua_ret = (const char*)  self->id();
00388    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00389   }
00390  }
00391  return 1;
00392 #ifndef TOLUA_RELEASE
00393  tolua_lerror:
00394  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
00395  return 0;
00396 #endif
00397 }
00398 #endif //#ifndef TOLUA_DISABLE
00399 
00400 /* method: uid of class  fawkes::Laser720Interface */
00401 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_uid00
00402 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_uid00(lua_State* tolua_S)
00403 {
00404 #ifndef TOLUA_RELEASE
00405  tolua_Error tolua_err;
00406  if (
00407      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00408      !tolua_isnoobj(tolua_S,2,&tolua_err)
00409  )
00410   goto tolua_lerror;
00411  else
00412 #endif
00413  {
00414   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00415 #ifndef TOLUA_RELEASE
00416   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL);
00417 #endif
00418   {
00419    const char* tolua_ret = (const char*)  self->uid();
00420    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00421   }
00422  }
00423  return 1;
00424 #ifndef TOLUA_RELEASE
00425  tolua_lerror:
00426  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
00427  return 0;
00428 #endif
00429 }
00430 #endif //#ifndef TOLUA_DISABLE
00431 
00432 /* method: serial of class  fawkes::Laser720Interface */
00433 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_serial00
00434 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_serial00(lua_State* tolua_S)
00435 {
00436 #ifndef TOLUA_RELEASE
00437  tolua_Error tolua_err;
00438  if (
00439      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00440      !tolua_isnoobj(tolua_S,2,&tolua_err)
00441  )
00442   goto tolua_lerror;
00443  else
00444 #endif
00445  {
00446   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00447 #ifndef TOLUA_RELEASE
00448   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL);
00449 #endif
00450   {
00451    unsigned int tolua_ret = (unsigned int)  self->serial();
00452    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00453   }
00454  }
00455  return 1;
00456 #ifndef TOLUA_RELEASE
00457  tolua_lerror:
00458  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
00459  return 0;
00460 #endif
00461 }
00462 #endif //#ifndef TOLUA_DISABLE
00463 
00464 /* method: mem_serial of class  fawkes::Laser720Interface */
00465 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_mem_serial00
00466 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_mem_serial00(lua_State* tolua_S)
00467 {
00468 #ifndef TOLUA_RELEASE
00469  tolua_Error tolua_err;
00470  if (
00471      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00472      !tolua_isnoobj(tolua_S,2,&tolua_err)
00473  )
00474   goto tolua_lerror;
00475  else
00476 #endif
00477  {
00478   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00479 #ifndef TOLUA_RELEASE
00480   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL);
00481 #endif
00482   {
00483    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
00484    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00485   }
00486  }
00487  return 1;
00488 #ifndef TOLUA_RELEASE
00489  tolua_lerror:
00490  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
00491  return 0;
00492 #endif
00493 }
00494 #endif //#ifndef TOLUA_DISABLE
00495 
00496 /* method: operator== of class  fawkes::Laser720Interface */
00497 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface__eq00
00498 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface__eq00(lua_State* tolua_S)
00499 {
00500 #ifndef TOLUA_RELEASE
00501  tolua_Error tolua_err;
00502  if (
00503      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00504      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) ||
00505      !tolua_isnoobj(tolua_S,3,&tolua_err)
00506  )
00507   goto tolua_lerror;
00508  else
00509 #endif
00510  {
00511   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00512   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
00513 #ifndef TOLUA_RELEASE
00514   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
00515 #endif
00516   {
00517    bool tolua_ret = (bool)  self->operator==(*comp);
00518    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00519   }
00520  }
00521  return 1;
00522 #ifndef TOLUA_RELEASE
00523  tolua_lerror:
00524  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
00525  return 0;
00526 #endif
00527 }
00528 #endif //#ifndef TOLUA_DISABLE
00529 
00530 /* method: hash of class  fawkes::Laser720Interface */
00531 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_hash00
00532 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_hash00(lua_State* tolua_S)
00533 {
00534 #ifndef TOLUA_RELEASE
00535  tolua_Error tolua_err;
00536  if (
00537      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00538      !tolua_isnoobj(tolua_S,2,&tolua_err)
00539  )
00540   goto tolua_lerror;
00541  else
00542 #endif
00543  {
00544   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00545 #ifndef TOLUA_RELEASE
00546   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL);
00547 #endif
00548   {
00549    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
00550    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00551   }
00552  }
00553  return 1;
00554 #ifndef TOLUA_RELEASE
00555  tolua_lerror:
00556  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
00557  return 0;
00558 #endif
00559 }
00560 #endif //#ifndef TOLUA_DISABLE
00561 
00562 /* method: hash_size of class  fawkes::Laser720Interface */
00563 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_hash_size00
00564 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_hash_size00(lua_State* tolua_S)
00565 {
00566 #ifndef TOLUA_RELEASE
00567  tolua_Error tolua_err;
00568  if (
00569      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00570      !tolua_isnoobj(tolua_S,2,&tolua_err)
00571  )
00572   goto tolua_lerror;
00573  else
00574 #endif
00575  {
00576   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00577 #ifndef TOLUA_RELEASE
00578   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL);
00579 #endif
00580   {
00581    int tolua_ret = (int)  self->hash_size();
00582    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00583   }
00584  }
00585  return 1;
00586 #ifndef TOLUA_RELEASE
00587  tolua_lerror:
00588  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
00589  return 0;
00590 #endif
00591 }
00592 #endif //#ifndef TOLUA_DISABLE
00593 
00594 /* method: hash_printable of class  fawkes::Laser720Interface */
00595 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_hash_printable00
00596 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_hash_printable00(lua_State* tolua_S)
00597 {
00598 #ifndef TOLUA_RELEASE
00599  tolua_Error tolua_err;
00600  if (
00601      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00602      !tolua_isnoobj(tolua_S,2,&tolua_err)
00603  )
00604   goto tolua_lerror;
00605  else
00606 #endif
00607  {
00608   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00609 #ifndef TOLUA_RELEASE
00610   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL);
00611 #endif
00612   {
00613    const char* tolua_ret = (const char*)  self->hash_printable();
00614    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00615   }
00616  }
00617  return 1;
00618 #ifndef TOLUA_RELEASE
00619  tolua_lerror:
00620  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
00621  return 0;
00622 #endif
00623 }
00624 #endif //#ifndef TOLUA_DISABLE
00625 
00626 /* method: is_writer of class  fawkes::Laser720Interface */
00627 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_is_writer00
00628 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_is_writer00(lua_State* tolua_S)
00629 {
00630 #ifndef TOLUA_RELEASE
00631  tolua_Error tolua_err;
00632  if (
00633      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00634      !tolua_isnoobj(tolua_S,2,&tolua_err)
00635  )
00636   goto tolua_lerror;
00637  else
00638 #endif
00639  {
00640   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00641 #ifndef TOLUA_RELEASE
00642   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL);
00643 #endif
00644   {
00645    bool tolua_ret = (bool)  self->is_writer();
00646    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00647   }
00648  }
00649  return 1;
00650 #ifndef TOLUA_RELEASE
00651  tolua_lerror:
00652  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
00653  return 0;
00654 #endif
00655 }
00656 #endif //#ifndef TOLUA_DISABLE
00657 
00658 /* method: set_from_chunk of class  fawkes::Laser720Interface */
00659 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_set_from_chunk00
00660 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_set_from_chunk00(lua_State* tolua_S)
00661 {
00662 #ifndef TOLUA_RELEASE
00663  tolua_Error tolua_err;
00664  if (
00665      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
00666      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
00667      !tolua_isnoobj(tolua_S,3,&tolua_err)
00668  )
00669   goto tolua_lerror;
00670  else
00671 #endif
00672  {
00673   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00674   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
00675 #ifndef TOLUA_RELEASE
00676   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL);
00677 #endif
00678   {
00679    self->set_from_chunk(chunk);
00680   }
00681  }
00682  return 0;
00683 #ifndef TOLUA_RELEASE
00684  tolua_lerror:
00685  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
00686  return 0;
00687 #endif
00688 }
00689 #endif //#ifndef TOLUA_DISABLE
00690 
00691 /* method: create_message of class  fawkes::Laser720Interface */
00692 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_create_message00
00693 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_create_message00(lua_State* tolua_S)
00694 {
00695 #ifndef TOLUA_RELEASE
00696  tolua_Error tolua_err;
00697  if (
00698      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00699      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00700      !tolua_isnoobj(tolua_S,3,&tolua_err)
00701  )
00702   goto tolua_lerror;
00703  else
00704 #endif
00705  {
00706   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00707   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
00708 #ifndef TOLUA_RELEASE
00709   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL);
00710 #endif
00711   {
00712    Message* tolua_ret = (Message*)  self->create_message(type);
00713     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
00714   }
00715  }
00716  return 1;
00717 #ifndef TOLUA_RELEASE
00718  tolua_lerror:
00719  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
00720  return 0;
00721 #endif
00722 }
00723 #endif //#ifndef TOLUA_DISABLE
00724 
00725 /* method: read of class  fawkes::Laser720Interface */
00726 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_read00
00727 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_read00(lua_State* tolua_S)
00728 {
00729 #ifndef TOLUA_RELEASE
00730  tolua_Error tolua_err;
00731  if (
00732      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
00733      !tolua_isnoobj(tolua_S,2,&tolua_err)
00734  )
00735   goto tolua_lerror;
00736  else
00737 #endif
00738  {
00739   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00740 #ifndef TOLUA_RELEASE
00741   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
00742 #endif
00743   {
00744    self->read();
00745   }
00746  }
00747  return 0;
00748 #ifndef TOLUA_RELEASE
00749  tolua_lerror:
00750  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
00751  return 0;
00752 #endif
00753 }
00754 #endif //#ifndef TOLUA_DISABLE
00755 
00756 /* method: write of class  fawkes::Laser720Interface */
00757 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_write00
00758 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_write00(lua_State* tolua_S)
00759 {
00760 #ifndef TOLUA_RELEASE
00761  tolua_Error tolua_err;
00762  if (
00763      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
00764      !tolua_isnoobj(tolua_S,2,&tolua_err)
00765  )
00766   goto tolua_lerror;
00767  else
00768 #endif
00769  {
00770   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00771 #ifndef TOLUA_RELEASE
00772   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
00773 #endif
00774   {
00775    self->write();
00776   }
00777  }
00778  return 0;
00779 #ifndef TOLUA_RELEASE
00780  tolua_lerror:
00781  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
00782  return 0;
00783 #endif
00784 }
00785 #endif //#ifndef TOLUA_DISABLE
00786 
00787 /* method: has_writer of class  fawkes::Laser720Interface */
00788 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_has_writer00
00789 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_has_writer00(lua_State* tolua_S)
00790 {
00791 #ifndef TOLUA_RELEASE
00792  tolua_Error tolua_err;
00793  if (
00794      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00795      !tolua_isnoobj(tolua_S,2,&tolua_err)
00796  )
00797   goto tolua_lerror;
00798  else
00799 #endif
00800  {
00801   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00802 #ifndef TOLUA_RELEASE
00803   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL);
00804 #endif
00805   {
00806    bool tolua_ret = (bool)  self->has_writer();
00807    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00808   }
00809  }
00810  return 1;
00811 #ifndef TOLUA_RELEASE
00812  tolua_lerror:
00813  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
00814  return 0;
00815 #endif
00816 }
00817 #endif //#ifndef TOLUA_DISABLE
00818 
00819 /* method: num_readers of class  fawkes::Laser720Interface */
00820 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_num_readers00
00821 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_num_readers00(lua_State* tolua_S)
00822 {
00823 #ifndef TOLUA_RELEASE
00824  tolua_Error tolua_err;
00825  if (
00826      !tolua_isusertype(tolua_S,1,"const fawkes::Laser720Interface",0,&tolua_err) ||
00827      !tolua_isnoobj(tolua_S,2,&tolua_err)
00828  )
00829   goto tolua_lerror;
00830  else
00831 #endif
00832  {
00833   const fawkes::Laser720Interface* self = (const fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00834 #ifndef TOLUA_RELEASE
00835   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL);
00836 #endif
00837   {
00838    unsigned int tolua_ret = (unsigned int)  self->num_readers();
00839    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00840   }
00841  }
00842  return 1;
00843 #ifndef TOLUA_RELEASE
00844  tolua_lerror:
00845  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
00846  return 0;
00847 #endif
00848 }
00849 #endif //#ifndef TOLUA_DISABLE
00850 
00851 /* method: msgq_enqueue_copy of class  fawkes::Laser720Interface */
00852 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_enqueue_copy00
00853 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_enqueue_copy00(lua_State* tolua_S)
00854 {
00855 #ifndef TOLUA_RELEASE
00856  tolua_Error tolua_err;
00857  if (
00858      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
00859      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
00860      !tolua_isnoobj(tolua_S,3,&tolua_err)
00861  )
00862   goto tolua_lerror;
00863  else
00864 #endif
00865  {
00866   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00867   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
00868 #ifndef TOLUA_RELEASE
00869   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL);
00870 #endif
00871   {
00872    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
00873    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00874   }
00875  }
00876  return 1;
00877 #ifndef TOLUA_RELEASE
00878  tolua_lerror:
00879  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
00880  return 0;
00881 #endif
00882 }
00883 #endif //#ifndef TOLUA_DISABLE
00884 
00885 /* method: msgq_remove of class  fawkes::Laser720Interface */
00886 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_remove00
00887 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_remove00(lua_State* tolua_S)
00888 {
00889 #ifndef TOLUA_RELEASE
00890  tolua_Error tolua_err;
00891  if (
00892      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
00893      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
00894      !tolua_isnoobj(tolua_S,3,&tolua_err)
00895  )
00896   goto tolua_lerror;
00897  else
00898 #endif
00899  {
00900   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00901   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
00902 #ifndef TOLUA_RELEASE
00903   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
00904 #endif
00905   {
00906    self->msgq_remove(message);
00907   }
00908  }
00909  return 0;
00910 #ifndef TOLUA_RELEASE
00911  tolua_lerror:
00912  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
00913  return 0;
00914 #endif
00915 }
00916 #endif //#ifndef TOLUA_DISABLE
00917 
00918 /* method: msgq_remove of class  fawkes::Laser720Interface */
00919 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_remove01
00920 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_remove01(lua_State* tolua_S)
00921 {
00922  tolua_Error tolua_err;
00923  if (
00924      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
00925      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00926      !tolua_isnoobj(tolua_S,3,&tolua_err)
00927  )
00928   goto tolua_lerror;
00929  else
00930  {
00931   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00932   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
00933 #ifndef TOLUA_RELEASE
00934   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
00935 #endif
00936   {
00937    self->msgq_remove(message_id);
00938   }
00939  }
00940  return 0;
00941 tolua_lerror:
00942  return tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_remove00(tolua_S);
00943 }
00944 #endif //#ifndef TOLUA_DISABLE
00945 
00946 /* method: msgq_size of class  fawkes::Laser720Interface */
00947 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_size00
00948 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_size00(lua_State* tolua_S)
00949 {
00950 #ifndef TOLUA_RELEASE
00951  tolua_Error tolua_err;
00952  if (
00953      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
00954      !tolua_isnoobj(tolua_S,2,&tolua_err)
00955  )
00956   goto tolua_lerror;
00957  else
00958 #endif
00959  {
00960   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00961 #ifndef TOLUA_RELEASE
00962   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL);
00963 #endif
00964   {
00965    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
00966    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00967   }
00968  }
00969  return 1;
00970 #ifndef TOLUA_RELEASE
00971  tolua_lerror:
00972  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
00973  return 0;
00974 #endif
00975 }
00976 #endif //#ifndef TOLUA_DISABLE
00977 
00978 /* method: msgq_flush of class  fawkes::Laser720Interface */
00979 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_flush00
00980 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_flush00(lua_State* tolua_S)
00981 {
00982 #ifndef TOLUA_RELEASE
00983  tolua_Error tolua_err;
00984  if (
00985      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
00986      !tolua_isnoobj(tolua_S,2,&tolua_err)
00987  )
00988   goto tolua_lerror;
00989  else
00990 #endif
00991  {
00992   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
00993 #ifndef TOLUA_RELEASE
00994   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL);
00995 #endif
00996   {
00997    self->msgq_flush();
00998   }
00999  }
01000  return 0;
01001 #ifndef TOLUA_RELEASE
01002  tolua_lerror:
01003  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
01004  return 0;
01005 #endif
01006 }
01007 #endif //#ifndef TOLUA_DISABLE
01008 
01009 /* method: msgq_lock of class  fawkes::Laser720Interface */
01010 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_lock00
01011 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_lock00(lua_State* tolua_S)
01012 {
01013 #ifndef TOLUA_RELEASE
01014  tolua_Error tolua_err;
01015  if (
01016      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
01017      !tolua_isnoobj(tolua_S,2,&tolua_err)
01018  )
01019   goto tolua_lerror;
01020  else
01021 #endif
01022  {
01023   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
01024 #ifndef TOLUA_RELEASE
01025   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL);
01026 #endif
01027   {
01028    self->msgq_lock();
01029   }
01030  }
01031  return 0;
01032 #ifndef TOLUA_RELEASE
01033  tolua_lerror:
01034  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
01035  return 0;
01036 #endif
01037 }
01038 #endif //#ifndef TOLUA_DISABLE
01039 
01040 /* method: msgq_try_lock of class  fawkes::Laser720Interface */
01041 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_try_lock00
01042 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_try_lock00(lua_State* tolua_S)
01043 {
01044 #ifndef TOLUA_RELEASE
01045  tolua_Error tolua_err;
01046  if (
01047      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
01048      !tolua_isnoobj(tolua_S,2,&tolua_err)
01049  )
01050   goto tolua_lerror;
01051  else
01052 #endif
01053  {
01054   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
01055 #ifndef TOLUA_RELEASE
01056   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL);
01057 #endif
01058   {
01059    bool tolua_ret = (bool)  self->msgq_try_lock();
01060    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01061   }
01062  }
01063  return 1;
01064 #ifndef TOLUA_RELEASE
01065  tolua_lerror:
01066  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
01067  return 0;
01068 #endif
01069 }
01070 #endif //#ifndef TOLUA_DISABLE
01071 
01072 /* method: msgq_unlock of class  fawkes::Laser720Interface */
01073 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_unlock00
01074 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_unlock00(lua_State* tolua_S)
01075 {
01076 #ifndef TOLUA_RELEASE
01077  tolua_Error tolua_err;
01078  if (
01079      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
01080      !tolua_isnoobj(tolua_S,2,&tolua_err)
01081  )
01082   goto tolua_lerror;
01083  else
01084 #endif
01085  {
01086   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
01087 #ifndef TOLUA_RELEASE
01088   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL);
01089 #endif
01090   {
01091    self->msgq_unlock();
01092   }
01093  }
01094  return 0;
01095 #ifndef TOLUA_RELEASE
01096  tolua_lerror:
01097  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
01098  return 0;
01099 #endif
01100 }
01101 #endif //#ifndef TOLUA_DISABLE
01102 
01103 /* method: msgq_pop of class  fawkes::Laser720Interface */
01104 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_pop00
01105 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_pop00(lua_State* tolua_S)
01106 {
01107 #ifndef TOLUA_RELEASE
01108  tolua_Error tolua_err;
01109  if (
01110      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
01111      !tolua_isnoobj(tolua_S,2,&tolua_err)
01112  )
01113   goto tolua_lerror;
01114  else
01115 #endif
01116  {
01117   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
01118 #ifndef TOLUA_RELEASE
01119   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL);
01120 #endif
01121   {
01122    self->msgq_pop();
01123   }
01124  }
01125  return 0;
01126 #ifndef TOLUA_RELEASE
01127  tolua_lerror:
01128  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
01129  return 0;
01130 #endif
01131 }
01132 #endif //#ifndef TOLUA_DISABLE
01133 
01134 /* method: msgq_first of class  fawkes::Laser720Interface */
01135 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_first00
01136 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_first00(lua_State* tolua_S)
01137 {
01138 #ifndef TOLUA_RELEASE
01139  tolua_Error tolua_err;
01140  if (
01141      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
01142      !tolua_isnoobj(tolua_S,2,&tolua_err)
01143  )
01144   goto tolua_lerror;
01145  else
01146 #endif
01147  {
01148   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
01149 #ifndef TOLUA_RELEASE
01150   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL);
01151 #endif
01152   {
01153    Message* tolua_ret = (Message*)  self->msgq_first();
01154     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
01155   }
01156  }
01157  return 1;
01158 #ifndef TOLUA_RELEASE
01159  tolua_lerror:
01160  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
01161  return 0;
01162 #endif
01163 }
01164 #endif //#ifndef TOLUA_DISABLE
01165 
01166 /* method: msgq_empty of class  fawkes::Laser720Interface */
01167 #ifndef TOLUA_DISABLE_tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_empty00
01168 static int tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_empty00(lua_State* tolua_S)
01169 {
01170 #ifndef TOLUA_RELEASE
01171  tolua_Error tolua_err;
01172  if (
01173      !tolua_isusertype(tolua_S,1,"fawkes::Laser720Interface",0,&tolua_err) ||
01174      !tolua_isnoobj(tolua_S,2,&tolua_err)
01175  )
01176   goto tolua_lerror;
01177  else
01178 #endif
01179  {
01180   fawkes::Laser720Interface* self = (fawkes::Laser720Interface*)  tolua_tousertype(tolua_S,1,0);
01181 #ifndef TOLUA_RELEASE
01182   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL);
01183 #endif
01184   {
01185    bool tolua_ret = (bool)  self->msgq_empty();
01186    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01187   }
01188  }
01189  return 1;
01190 #ifndef TOLUA_RELEASE
01191  tolua_lerror:
01192  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
01193  return 0;
01194 #endif
01195 }
01196 #endif //#ifndef TOLUA_DISABLE
01197 
01198 /* Open function */
01199 TOLUA_API int tolua_interfaces_Laser720Interface_open (lua_State* tolua_S)
01200 {
01201  tolua_open(tolua_S);
01202  tolua_reg_types(tolua_S);
01203  tolua_module(tolua_S,NULL,0);
01204  tolua_beginmodule(tolua_S,NULL);
01205   tolua_module(tolua_S,"fawkes",0);
01206   tolua_beginmodule(tolua_S,"fawkes");
01207    tolua_cclass(tolua_S,"Laser720Interface","fawkes::Laser720Interface","Interface",NULL);
01208    tolua_beginmodule(tolua_S,"Laser720Interface");
01209     tolua_function(tolua_S,"distances",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_distances00);
01210     tolua_function(tolua_S,"set_distances",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_set_distances00);
01211     tolua_function(tolua_S,"maxlenof_distances",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_maxlenof_distances00);
01212     tolua_function(tolua_S,"is_clockwise_angle",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_is_clockwise_angle00);
01213     tolua_function(tolua_S,"set_clockwise_angle",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_set_clockwise_angle00);
01214     tolua_function(tolua_S,"maxlenof_clockwise_angle",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_maxlenof_clockwise_angle00);
01215     tolua_function(tolua_S,"oftype",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_oftype00);
01216     tolua_function(tolua_S,"datachunk",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_datachunk00);
01217     tolua_function(tolua_S,"datasize",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_datasize00);
01218     tolua_function(tolua_S,"type",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_type00);
01219     tolua_function(tolua_S,"id",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_id00);
01220     tolua_function(tolua_S,"uid",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_uid00);
01221     tolua_function(tolua_S,"serial",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_serial00);
01222     tolua_function(tolua_S,"mem_serial",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_mem_serial00);
01223     tolua_function(tolua_S,".eq",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface__eq00);
01224     tolua_function(tolua_S,"hash",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_hash00);
01225     tolua_function(tolua_S,"hash_size",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_hash_size00);
01226     tolua_function(tolua_S,"hash_printable",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_hash_printable00);
01227     tolua_function(tolua_S,"is_writer",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_is_writer00);
01228     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_set_from_chunk00);
01229     tolua_function(tolua_S,"create_message",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_create_message00);
01230     tolua_function(tolua_S,"read",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_read00);
01231     tolua_function(tolua_S,"write",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_write00);
01232     tolua_function(tolua_S,"has_writer",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_has_writer00);
01233     tolua_function(tolua_S,"num_readers",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_num_readers00);
01234     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_enqueue_copy00);
01235     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_remove00);
01236     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_remove01);
01237     tolua_function(tolua_S,"msgq_size",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_size00);
01238     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_flush00);
01239     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_lock00);
01240     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_try_lock00);
01241     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_unlock00);
01242     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_pop00);
01243     tolua_function(tolua_S,"msgq_first",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_first00);
01244     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_Laser720Interface_fawkes_Laser720Interface_msgq_empty00);
01245    tolua_endmodule(tolua_S);
01246   tolua_endmodule(tolua_S);
01247  tolua_endmodule(tolua_S);
01248  return 1;
01249 }
01250 
01251 
01252 extern "C" {
01253 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
01254  TOLUA_API int luaopen_interfaces_Laser720Interface (lua_State* tolua_S) {
01255  return tolua_interfaces_Laser720Interface_open(tolua_S);
01256 };
01257 #endif
01258 }
01259 
01260 

Generated on Tue Feb 22 13:32:21 2011 for Fawkes API by  doxygen 1.4.7