Fawkes API  Fawkes Development Version
TransformInterface_tolua.cpp
00001 /*
00002 ** Lua binding: interfaces_TransformInterface
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_TransformInterface_open (lua_State* tolua_S);
00028 
00029 #include <interfaces/TransformInterface.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,"Message");
00036  tolua_usertype(tolua_S,"Interface");
00037  tolua_usertype(tolua_S,"fawkes::TransformInterface");
00038 }
00039 
00040 /* method: frame of class  fawkes::TransformInterface */
00041 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_frame00
00042 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_frame00(lua_State* tolua_S)
00043 {
00044 #ifndef TOLUA_RELEASE
00045  tolua_Error tolua_err;
00046  if (
00047      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
00048      !tolua_isnoobj(tolua_S,2,&tolua_err)
00049  )
00050   goto tolua_lerror;
00051  else
00052 #endif
00053  {
00054   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00055 #ifndef TOLUA_RELEASE
00056   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'frame'", NULL);
00057 #endif
00058   {
00059    char* tolua_ret = (char*)  self->frame();
00060    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00061   }
00062  }
00063  return 1;
00064 #ifndef TOLUA_RELEASE
00065  tolua_lerror:
00066  tolua_error(tolua_S,"#ferror in function 'frame'.",&tolua_err);
00067  return 0;
00068 #endif
00069 }
00070 #endif //#ifndef TOLUA_DISABLE
00071 
00072 /* method: set_frame of class  fawkes::TransformInterface */
00073 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_frame00
00074 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_frame00(lua_State* tolua_S)
00075 {
00076 #ifndef TOLUA_RELEASE
00077  tolua_Error tolua_err;
00078  if (
00079      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
00080      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00081      !tolua_isnoobj(tolua_S,3,&tolua_err)
00082  )
00083   goto tolua_lerror;
00084  else
00085 #endif
00086  {
00087   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00088   const char* new_frame = ((const char*)  tolua_tostring(tolua_S,2,0));
00089 #ifndef TOLUA_RELEASE
00090   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_frame'", NULL);
00091 #endif
00092   {
00093    self->set_frame(new_frame);
00094   }
00095  }
00096  return 0;
00097 #ifndef TOLUA_RELEASE
00098  tolua_lerror:
00099  tolua_error(tolua_S,"#ferror in function 'set_frame'.",&tolua_err);
00100  return 0;
00101 #endif
00102 }
00103 #endif //#ifndef TOLUA_DISABLE
00104 
00105 /* method: maxlenof_frame of class  fawkes::TransformInterface */
00106 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_frame00
00107 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_frame00(lua_State* tolua_S)
00108 {
00109 #ifndef TOLUA_RELEASE
00110  tolua_Error tolua_err;
00111  if (
00112      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00113      !tolua_isnoobj(tolua_S,2,&tolua_err)
00114  )
00115   goto tolua_lerror;
00116  else
00117 #endif
00118  {
00119   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00120 #ifndef TOLUA_RELEASE
00121   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_frame'", NULL);
00122 #endif
00123   {
00124    int tolua_ret = (int)  self->maxlenof_frame();
00125    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00126   }
00127  }
00128  return 1;
00129 #ifndef TOLUA_RELEASE
00130  tolua_lerror:
00131  tolua_error(tolua_S,"#ferror in function 'maxlenof_frame'.",&tolua_err);
00132  return 0;
00133 #endif
00134 }
00135 #endif //#ifndef TOLUA_DISABLE
00136 
00137 /* method: child_frame of class  fawkes::TransformInterface */
00138 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_child_frame00
00139 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_child_frame00(lua_State* tolua_S)
00140 {
00141 #ifndef TOLUA_RELEASE
00142  tolua_Error tolua_err;
00143  if (
00144      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
00145      !tolua_isnoobj(tolua_S,2,&tolua_err)
00146  )
00147   goto tolua_lerror;
00148  else
00149 #endif
00150  {
00151   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00152 #ifndef TOLUA_RELEASE
00153   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'child_frame'", NULL);
00154 #endif
00155   {
00156    char* tolua_ret = (char*)  self->child_frame();
00157    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00158   }
00159  }
00160  return 1;
00161 #ifndef TOLUA_RELEASE
00162  tolua_lerror:
00163  tolua_error(tolua_S,"#ferror in function 'child_frame'.",&tolua_err);
00164  return 0;
00165 #endif
00166 }
00167 #endif //#ifndef TOLUA_DISABLE
00168 
00169 /* method: set_child_frame of class  fawkes::TransformInterface */
00170 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_child_frame00
00171 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_child_frame00(lua_State* tolua_S)
00172 {
00173 #ifndef TOLUA_RELEASE
00174  tolua_Error tolua_err;
00175  if (
00176      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
00177      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00178      !tolua_isnoobj(tolua_S,3,&tolua_err)
00179  )
00180   goto tolua_lerror;
00181  else
00182 #endif
00183  {
00184   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00185   const char* new_child_frame = ((const char*)  tolua_tostring(tolua_S,2,0));
00186 #ifndef TOLUA_RELEASE
00187   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_child_frame'", NULL);
00188 #endif
00189   {
00190    self->set_child_frame(new_child_frame);
00191   }
00192  }
00193  return 0;
00194 #ifndef TOLUA_RELEASE
00195  tolua_lerror:
00196  tolua_error(tolua_S,"#ferror in function 'set_child_frame'.",&tolua_err);
00197  return 0;
00198 #endif
00199 }
00200 #endif //#ifndef TOLUA_DISABLE
00201 
00202 /* method: maxlenof_child_frame of class  fawkes::TransformInterface */
00203 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_child_frame00
00204 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_child_frame00(lua_State* tolua_S)
00205 {
00206 #ifndef TOLUA_RELEASE
00207  tolua_Error tolua_err;
00208  if (
00209      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00210      !tolua_isnoobj(tolua_S,2,&tolua_err)
00211  )
00212   goto tolua_lerror;
00213  else
00214 #endif
00215  {
00216   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00217 #ifndef TOLUA_RELEASE
00218   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_child_frame'", NULL);
00219 #endif
00220   {
00221    int tolua_ret = (int)  self->maxlenof_child_frame();
00222    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00223   }
00224  }
00225  return 1;
00226 #ifndef TOLUA_RELEASE
00227  tolua_lerror:
00228  tolua_error(tolua_S,"#ferror in function 'maxlenof_child_frame'.",&tolua_err);
00229  return 0;
00230 #endif
00231 }
00232 #endif //#ifndef TOLUA_DISABLE
00233 
00234 /* method: translation of class  fawkes::TransformInterface */
00235 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_translation00
00236 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_translation00(lua_State* tolua_S)
00237 {
00238 #ifndef TOLUA_RELEASE
00239  tolua_Error tolua_err;
00240  if (
00241      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
00242      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00243      !tolua_isnoobj(tolua_S,3,&tolua_err)
00244  )
00245   goto tolua_lerror;
00246  else
00247 #endif
00248  {
00249   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00250   int index = ((int)  tolua_tonumber(tolua_S,2,0));
00251 #ifndef TOLUA_RELEASE
00252   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'translation'", NULL);
00253 #endif
00254   {
00255    double tolua_ret = (double)  self->translation(index);
00256    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00257   }
00258  }
00259  return 1;
00260 #ifndef TOLUA_RELEASE
00261  tolua_lerror:
00262  tolua_error(tolua_S,"#ferror in function 'translation'.",&tolua_err);
00263  return 0;
00264 #endif
00265 }
00266 #endif //#ifndef TOLUA_DISABLE
00267 
00268 /* method: set_translation of class  fawkes::TransformInterface */
00269 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_translation00
00270 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_translation00(lua_State* tolua_S)
00271 {
00272 #ifndef TOLUA_RELEASE
00273  tolua_Error tolua_err;
00274  if (
00275      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
00276      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00277      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00278      !tolua_isnoobj(tolua_S,4,&tolua_err)
00279  )
00280   goto tolua_lerror;
00281  else
00282 #endif
00283  {
00284   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00285   unsigned int index = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
00286   const double new_translation = ((const double)  tolua_tonumber(tolua_S,3,0));
00287 #ifndef TOLUA_RELEASE
00288   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_translation'", NULL);
00289 #endif
00290   {
00291    self->set_translation(index,new_translation);
00292   }
00293  }
00294  return 0;
00295 #ifndef TOLUA_RELEASE
00296  tolua_lerror:
00297  tolua_error(tolua_S,"#ferror in function 'set_translation'.",&tolua_err);
00298  return 0;
00299 #endif
00300 }
00301 #endif //#ifndef TOLUA_DISABLE
00302 
00303 /* method: maxlenof_translation of class  fawkes::TransformInterface */
00304 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_translation00
00305 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_translation00(lua_State* tolua_S)
00306 {
00307 #ifndef TOLUA_RELEASE
00308  tolua_Error tolua_err;
00309  if (
00310      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00311      !tolua_isnoobj(tolua_S,2,&tolua_err)
00312  )
00313   goto tolua_lerror;
00314  else
00315 #endif
00316  {
00317   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00318 #ifndef TOLUA_RELEASE
00319   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_translation'", NULL);
00320 #endif
00321   {
00322    int tolua_ret = (int)  self->maxlenof_translation();
00323    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00324   }
00325  }
00326  return 1;
00327 #ifndef TOLUA_RELEASE
00328  tolua_lerror:
00329  tolua_error(tolua_S,"#ferror in function 'maxlenof_translation'.",&tolua_err);
00330  return 0;
00331 #endif
00332 }
00333 #endif //#ifndef TOLUA_DISABLE
00334 
00335 /* method: rotation of class  fawkes::TransformInterface */
00336 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_rotation00
00337 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_rotation00(lua_State* tolua_S)
00338 {
00339 #ifndef TOLUA_RELEASE
00340  tolua_Error tolua_err;
00341  if (
00342      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
00343      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00344      !tolua_isnoobj(tolua_S,3,&tolua_err)
00345  )
00346   goto tolua_lerror;
00347  else
00348 #endif
00349  {
00350   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00351   int index = ((int)  tolua_tonumber(tolua_S,2,0));
00352 #ifndef TOLUA_RELEASE
00353   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotation'", NULL);
00354 #endif
00355   {
00356    double tolua_ret = (double)  self->rotation(index);
00357    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00358   }
00359  }
00360  return 1;
00361 #ifndef TOLUA_RELEASE
00362  tolua_lerror:
00363  tolua_error(tolua_S,"#ferror in function 'rotation'.",&tolua_err);
00364  return 0;
00365 #endif
00366 }
00367 #endif //#ifndef TOLUA_DISABLE
00368 
00369 /* method: set_rotation of class  fawkes::TransformInterface */
00370 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_rotation00
00371 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_rotation00(lua_State* tolua_S)
00372 {
00373 #ifndef TOLUA_RELEASE
00374  tolua_Error tolua_err;
00375  if (
00376      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
00377      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00378      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00379      !tolua_isnoobj(tolua_S,4,&tolua_err)
00380  )
00381   goto tolua_lerror;
00382  else
00383 #endif
00384  {
00385   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00386   unsigned int index = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
00387   const double new_rotation = ((const double)  tolua_tonumber(tolua_S,3,0));
00388 #ifndef TOLUA_RELEASE
00389   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_rotation'", NULL);
00390 #endif
00391   {
00392    self->set_rotation(index,new_rotation);
00393   }
00394  }
00395  return 0;
00396 #ifndef TOLUA_RELEASE
00397  tolua_lerror:
00398  tolua_error(tolua_S,"#ferror in function 'set_rotation'.",&tolua_err);
00399  return 0;
00400 #endif
00401 }
00402 #endif //#ifndef TOLUA_DISABLE
00403 
00404 /* method: maxlenof_rotation of class  fawkes::TransformInterface */
00405 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_rotation00
00406 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_rotation00(lua_State* tolua_S)
00407 {
00408 #ifndef TOLUA_RELEASE
00409  tolua_Error tolua_err;
00410  if (
00411      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00412      !tolua_isnoobj(tolua_S,2,&tolua_err)
00413  )
00414   goto tolua_lerror;
00415  else
00416 #endif
00417  {
00418   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00419 #ifndef TOLUA_RELEASE
00420   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_rotation'", NULL);
00421 #endif
00422   {
00423    int tolua_ret = (int)  self->maxlenof_rotation();
00424    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00425   }
00426  }
00427  return 1;
00428 #ifndef TOLUA_RELEASE
00429  tolua_lerror:
00430  tolua_error(tolua_S,"#ferror in function 'maxlenof_rotation'.",&tolua_err);
00431  return 0;
00432 #endif
00433 }
00434 #endif //#ifndef TOLUA_DISABLE
00435 
00436 /* method: oftype of class  fawkes::TransformInterface */
00437 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_oftype00
00438 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_oftype00(lua_State* tolua_S)
00439 {
00440 #ifndef TOLUA_RELEASE
00441  tolua_Error tolua_err;
00442  if (
00443      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00444      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00445      !tolua_isnoobj(tolua_S,3,&tolua_err)
00446  )
00447   goto tolua_lerror;
00448  else
00449 #endif
00450  {
00451   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00452   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
00453 #ifndef TOLUA_RELEASE
00454   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL);
00455 #endif
00456   {
00457    bool tolua_ret = (bool)  self->oftype(interface_type);
00458    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00459   }
00460  }
00461  return 1;
00462 #ifndef TOLUA_RELEASE
00463  tolua_lerror:
00464  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
00465  return 0;
00466 #endif
00467 }
00468 #endif //#ifndef TOLUA_DISABLE
00469 
00470 /* method: datachunk of class  fawkes::TransformInterface */
00471 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_datachunk00
00472 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_datachunk00(lua_State* tolua_S)
00473 {
00474 #ifndef TOLUA_RELEASE
00475  tolua_Error tolua_err;
00476  if (
00477      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00478      !tolua_isnoobj(tolua_S,2,&tolua_err)
00479  )
00480   goto tolua_lerror;
00481  else
00482 #endif
00483  {
00484   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00485 #ifndef TOLUA_RELEASE
00486   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL);
00487 #endif
00488   {
00489    const void* tolua_ret = (const void*)  self->datachunk();
00490    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
00491   }
00492  }
00493  return 1;
00494 #ifndef TOLUA_RELEASE
00495  tolua_lerror:
00496  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
00497  return 0;
00498 #endif
00499 }
00500 #endif //#ifndef TOLUA_DISABLE
00501 
00502 /* method: datasize of class  fawkes::TransformInterface */
00503 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_datasize00
00504 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_datasize00(lua_State* tolua_S)
00505 {
00506 #ifndef TOLUA_RELEASE
00507  tolua_Error tolua_err;
00508  if (
00509      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00510      !tolua_isnoobj(tolua_S,2,&tolua_err)
00511  )
00512   goto tolua_lerror;
00513  else
00514 #endif
00515  {
00516   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00517 #ifndef TOLUA_RELEASE
00518   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL);
00519 #endif
00520   {
00521    unsigned int tolua_ret = (unsigned int)  self->datasize();
00522    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00523   }
00524  }
00525  return 1;
00526 #ifndef TOLUA_RELEASE
00527  tolua_lerror:
00528  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
00529  return 0;
00530 #endif
00531 }
00532 #endif //#ifndef TOLUA_DISABLE
00533 
00534 /* method: type of class  fawkes::TransformInterface */
00535 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_type00
00536 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_type00(lua_State* tolua_S)
00537 {
00538 #ifndef TOLUA_RELEASE
00539  tolua_Error tolua_err;
00540  if (
00541      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00542      !tolua_isnoobj(tolua_S,2,&tolua_err)
00543  )
00544   goto tolua_lerror;
00545  else
00546 #endif
00547  {
00548   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00549 #ifndef TOLUA_RELEASE
00550   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
00551 #endif
00552   {
00553    const char* tolua_ret = (const char*)  self->type();
00554    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00555   }
00556  }
00557  return 1;
00558 #ifndef TOLUA_RELEASE
00559  tolua_lerror:
00560  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
00561  return 0;
00562 #endif
00563 }
00564 #endif //#ifndef TOLUA_DISABLE
00565 
00566 /* method: id of class  fawkes::TransformInterface */
00567 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_id00
00568 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_id00(lua_State* tolua_S)
00569 {
00570 #ifndef TOLUA_RELEASE
00571  tolua_Error tolua_err;
00572  if (
00573      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00574      !tolua_isnoobj(tolua_S,2,&tolua_err)
00575  )
00576   goto tolua_lerror;
00577  else
00578 #endif
00579  {
00580   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00581 #ifndef TOLUA_RELEASE
00582   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL);
00583 #endif
00584   {
00585    const char* tolua_ret = (const char*)  self->id();
00586    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00587   }
00588  }
00589  return 1;
00590 #ifndef TOLUA_RELEASE
00591  tolua_lerror:
00592  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
00593  return 0;
00594 #endif
00595 }
00596 #endif //#ifndef TOLUA_DISABLE
00597 
00598 /* method: uid of class  fawkes::TransformInterface */
00599 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_uid00
00600 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_uid00(lua_State* tolua_S)
00601 {
00602 #ifndef TOLUA_RELEASE
00603  tolua_Error tolua_err;
00604  if (
00605      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00606      !tolua_isnoobj(tolua_S,2,&tolua_err)
00607  )
00608   goto tolua_lerror;
00609  else
00610 #endif
00611  {
00612   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00613 #ifndef TOLUA_RELEASE
00614   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL);
00615 #endif
00616   {
00617    const char* tolua_ret = (const char*)  self->uid();
00618    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00619   }
00620  }
00621  return 1;
00622 #ifndef TOLUA_RELEASE
00623  tolua_lerror:
00624  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
00625  return 0;
00626 #endif
00627 }
00628 #endif //#ifndef TOLUA_DISABLE
00629 
00630 /* method: serial of class  fawkes::TransformInterface */
00631 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_serial00
00632 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_serial00(lua_State* tolua_S)
00633 {
00634 #ifndef TOLUA_RELEASE
00635  tolua_Error tolua_err;
00636  if (
00637      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00638      !tolua_isnoobj(tolua_S,2,&tolua_err)
00639  )
00640   goto tolua_lerror;
00641  else
00642 #endif
00643  {
00644   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00645 #ifndef TOLUA_RELEASE
00646   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL);
00647 #endif
00648   {
00649    unsigned int tolua_ret = (unsigned int)  self->serial();
00650    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00651   }
00652  }
00653  return 1;
00654 #ifndef TOLUA_RELEASE
00655  tolua_lerror:
00656  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
00657  return 0;
00658 #endif
00659 }
00660 #endif //#ifndef TOLUA_DISABLE
00661 
00662 /* method: mem_serial of class  fawkes::TransformInterface */
00663 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_mem_serial00
00664 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_mem_serial00(lua_State* tolua_S)
00665 {
00666 #ifndef TOLUA_RELEASE
00667  tolua_Error tolua_err;
00668  if (
00669      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00670      !tolua_isnoobj(tolua_S,2,&tolua_err)
00671  )
00672   goto tolua_lerror;
00673  else
00674 #endif
00675  {
00676   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00677 #ifndef TOLUA_RELEASE
00678   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL);
00679 #endif
00680   {
00681    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
00682    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00683   }
00684  }
00685  return 1;
00686 #ifndef TOLUA_RELEASE
00687  tolua_lerror:
00688  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
00689  return 0;
00690 #endif
00691 }
00692 #endif //#ifndef TOLUA_DISABLE
00693 
00694 /* method: operator== of class  fawkes::TransformInterface */
00695 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface__eq00
00696 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface__eq00(lua_State* tolua_S)
00697 {
00698 #ifndef TOLUA_RELEASE
00699  tolua_Error tolua_err;
00700  if (
00701      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00702      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) ||
00703      !tolua_isnoobj(tolua_S,3,&tolua_err)
00704  )
00705   goto tolua_lerror;
00706  else
00707 #endif
00708  {
00709   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00710   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
00711 #ifndef TOLUA_RELEASE
00712   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
00713 #endif
00714   {
00715    bool tolua_ret = (bool)  self->operator==(*comp);
00716    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00717   }
00718  }
00719  return 1;
00720 #ifndef TOLUA_RELEASE
00721  tolua_lerror:
00722  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
00723  return 0;
00724 #endif
00725 }
00726 #endif //#ifndef TOLUA_DISABLE
00727 
00728 /* method: hash of class  fawkes::TransformInterface */
00729 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash00
00730 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash00(lua_State* tolua_S)
00731 {
00732 #ifndef TOLUA_RELEASE
00733  tolua_Error tolua_err;
00734  if (
00735      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00736      !tolua_isnoobj(tolua_S,2,&tolua_err)
00737  )
00738   goto tolua_lerror;
00739  else
00740 #endif
00741  {
00742   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00743 #ifndef TOLUA_RELEASE
00744   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL);
00745 #endif
00746   {
00747    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
00748    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00749   }
00750  }
00751  return 1;
00752 #ifndef TOLUA_RELEASE
00753  tolua_lerror:
00754  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
00755  return 0;
00756 #endif
00757 }
00758 #endif //#ifndef TOLUA_DISABLE
00759 
00760 /* method: hash_size of class  fawkes::TransformInterface */
00761 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash_size00
00762 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash_size00(lua_State* tolua_S)
00763 {
00764 #ifndef TOLUA_RELEASE
00765  tolua_Error tolua_err;
00766  if (
00767      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00768      !tolua_isnoobj(tolua_S,2,&tolua_err)
00769  )
00770   goto tolua_lerror;
00771  else
00772 #endif
00773  {
00774   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00775 #ifndef TOLUA_RELEASE
00776   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL);
00777 #endif
00778   {
00779    int tolua_ret = (int)  self->hash_size();
00780    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00781   }
00782  }
00783  return 1;
00784 #ifndef TOLUA_RELEASE
00785  tolua_lerror:
00786  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
00787  return 0;
00788 #endif
00789 }
00790 #endif //#ifndef TOLUA_DISABLE
00791 
00792 /* method: hash_printable of class  fawkes::TransformInterface */
00793 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash_printable00
00794 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash_printable00(lua_State* tolua_S)
00795 {
00796 #ifndef TOLUA_RELEASE
00797  tolua_Error tolua_err;
00798  if (
00799      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00800      !tolua_isnoobj(tolua_S,2,&tolua_err)
00801  )
00802   goto tolua_lerror;
00803  else
00804 #endif
00805  {
00806   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00807 #ifndef TOLUA_RELEASE
00808   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL);
00809 #endif
00810   {
00811    const char* tolua_ret = (const char*)  self->hash_printable();
00812    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00813   }
00814  }
00815  return 1;
00816 #ifndef TOLUA_RELEASE
00817  tolua_lerror:
00818  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
00819  return 0;
00820 #endif
00821 }
00822 #endif //#ifndef TOLUA_DISABLE
00823 
00824 /* method: is_writer of class  fawkes::TransformInterface */
00825 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_is_writer00
00826 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_is_writer00(lua_State* tolua_S)
00827 {
00828 #ifndef TOLUA_RELEASE
00829  tolua_Error tolua_err;
00830  if (
00831      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00832      !tolua_isnoobj(tolua_S,2,&tolua_err)
00833  )
00834   goto tolua_lerror;
00835  else
00836 #endif
00837  {
00838   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00839 #ifndef TOLUA_RELEASE
00840   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL);
00841 #endif
00842   {
00843    bool tolua_ret = (bool)  self->is_writer();
00844    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00845   }
00846  }
00847  return 1;
00848 #ifndef TOLUA_RELEASE
00849  tolua_lerror:
00850  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
00851  return 0;
00852 #endif
00853 }
00854 #endif //#ifndef TOLUA_DISABLE
00855 
00856 /* method: set_from_chunk of class  fawkes::TransformInterface */
00857 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_from_chunk00
00858 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_from_chunk00(lua_State* tolua_S)
00859 {
00860 #ifndef TOLUA_RELEASE
00861  tolua_Error tolua_err;
00862  if (
00863      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
00864      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
00865      !tolua_isnoobj(tolua_S,3,&tolua_err)
00866  )
00867   goto tolua_lerror;
00868  else
00869 #endif
00870  {
00871   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00872   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
00873 #ifndef TOLUA_RELEASE
00874   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL);
00875 #endif
00876   {
00877    self->set_from_chunk(chunk);
00878   }
00879  }
00880  return 0;
00881 #ifndef TOLUA_RELEASE
00882  tolua_lerror:
00883  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
00884  return 0;
00885 #endif
00886 }
00887 #endif //#ifndef TOLUA_DISABLE
00888 
00889 /* method: create_message of class  fawkes::TransformInterface */
00890 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_create_message00
00891 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_create_message00(lua_State* tolua_S)
00892 {
00893 #ifndef TOLUA_RELEASE
00894  tolua_Error tolua_err;
00895  if (
00896      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00897      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00898      !tolua_isnoobj(tolua_S,3,&tolua_err)
00899  )
00900   goto tolua_lerror;
00901  else
00902 #endif
00903  {
00904   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00905   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
00906 #ifndef TOLUA_RELEASE
00907   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL);
00908 #endif
00909   {
00910    Message* tolua_ret = (Message*)  self->create_message(type);
00911     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
00912   }
00913  }
00914  return 1;
00915 #ifndef TOLUA_RELEASE
00916  tolua_lerror:
00917  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
00918  return 0;
00919 #endif
00920 }
00921 #endif //#ifndef TOLUA_DISABLE
00922 
00923 /* method: read of class  fawkes::TransformInterface */
00924 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_read00
00925 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_read00(lua_State* tolua_S)
00926 {
00927 #ifndef TOLUA_RELEASE
00928  tolua_Error tolua_err;
00929  if (
00930      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
00931      !tolua_isnoobj(tolua_S,2,&tolua_err)
00932  )
00933   goto tolua_lerror;
00934  else
00935 #endif
00936  {
00937   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00938 #ifndef TOLUA_RELEASE
00939   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
00940 #endif
00941   {
00942    self->read();
00943   }
00944  }
00945  return 0;
00946 #ifndef TOLUA_RELEASE
00947  tolua_lerror:
00948  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
00949  return 0;
00950 #endif
00951 }
00952 #endif //#ifndef TOLUA_DISABLE
00953 
00954 /* method: write of class  fawkes::TransformInterface */
00955 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_write00
00956 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_write00(lua_State* tolua_S)
00957 {
00958 #ifndef TOLUA_RELEASE
00959  tolua_Error tolua_err;
00960  if (
00961      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
00962      !tolua_isnoobj(tolua_S,2,&tolua_err)
00963  )
00964   goto tolua_lerror;
00965  else
00966 #endif
00967  {
00968   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
00969 #ifndef TOLUA_RELEASE
00970   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
00971 #endif
00972   {
00973    self->write();
00974   }
00975  }
00976  return 0;
00977 #ifndef TOLUA_RELEASE
00978  tolua_lerror:
00979  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
00980  return 0;
00981 #endif
00982 }
00983 #endif //#ifndef TOLUA_DISABLE
00984 
00985 /* method: has_writer of class  fawkes::TransformInterface */
00986 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_has_writer00
00987 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_has_writer00(lua_State* tolua_S)
00988 {
00989 #ifndef TOLUA_RELEASE
00990  tolua_Error tolua_err;
00991  if (
00992      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
00993      !tolua_isnoobj(tolua_S,2,&tolua_err)
00994  )
00995   goto tolua_lerror;
00996  else
00997 #endif
00998  {
00999   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
01000 #ifndef TOLUA_RELEASE
01001   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL);
01002 #endif
01003   {
01004    bool tolua_ret = (bool)  self->has_writer();
01005    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01006   }
01007  }
01008  return 1;
01009 #ifndef TOLUA_RELEASE
01010  tolua_lerror:
01011  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
01012  return 0;
01013 #endif
01014 }
01015 #endif //#ifndef TOLUA_DISABLE
01016 
01017 /* method: num_readers of class  fawkes::TransformInterface */
01018 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_num_readers00
01019 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_num_readers00(lua_State* tolua_S)
01020 {
01021 #ifndef TOLUA_RELEASE
01022  tolua_Error tolua_err;
01023  if (
01024      !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) ||
01025      !tolua_isnoobj(tolua_S,2,&tolua_err)
01026  )
01027   goto tolua_lerror;
01028  else
01029 #endif
01030  {
01031   const fawkes::TransformInterface* self = (const fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
01032 #ifndef TOLUA_RELEASE
01033   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL);
01034 #endif
01035   {
01036    unsigned int tolua_ret = (unsigned int)  self->num_readers();
01037    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01038   }
01039  }
01040  return 1;
01041 #ifndef TOLUA_RELEASE
01042  tolua_lerror:
01043  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
01044  return 0;
01045 #endif
01046 }
01047 #endif //#ifndef TOLUA_DISABLE
01048 
01049 /* method: msgq_enqueue_copy of class  fawkes::TransformInterface */
01050 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_enqueue_copy00
01051 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_enqueue_copy00(lua_State* tolua_S)
01052 {
01053 #ifndef TOLUA_RELEASE
01054  tolua_Error tolua_err;
01055  if (
01056      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
01057      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
01058      !tolua_isnoobj(tolua_S,3,&tolua_err)
01059  )
01060   goto tolua_lerror;
01061  else
01062 #endif
01063  {
01064   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
01065   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
01066 #ifndef TOLUA_RELEASE
01067   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL);
01068 #endif
01069   {
01070    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
01071    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01072   }
01073  }
01074  return 1;
01075 #ifndef TOLUA_RELEASE
01076  tolua_lerror:
01077  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
01078  return 0;
01079 #endif
01080 }
01081 #endif //#ifndef TOLUA_DISABLE
01082 
01083 /* method: msgq_remove of class  fawkes::TransformInterface */
01084 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_remove00
01085 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_remove00(lua_State* tolua_S)
01086 {
01087 #ifndef TOLUA_RELEASE
01088  tolua_Error tolua_err;
01089  if (
01090      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
01091      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
01092      !tolua_isnoobj(tolua_S,3,&tolua_err)
01093  )
01094   goto tolua_lerror;
01095  else
01096 #endif
01097  {
01098   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
01099   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
01100 #ifndef TOLUA_RELEASE
01101   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
01102 #endif
01103   {
01104    self->msgq_remove(message);
01105   }
01106  }
01107  return 0;
01108 #ifndef TOLUA_RELEASE
01109  tolua_lerror:
01110  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
01111  return 0;
01112 #endif
01113 }
01114 #endif //#ifndef TOLUA_DISABLE
01115 
01116 /* method: msgq_remove of class  fawkes::TransformInterface */
01117 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_remove01
01118 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_remove01(lua_State* tolua_S)
01119 {
01120  tolua_Error tolua_err;
01121  if (
01122      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
01123      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01124      !tolua_isnoobj(tolua_S,3,&tolua_err)
01125  )
01126   goto tolua_lerror;
01127  else
01128  {
01129   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
01130   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
01131 #ifndef TOLUA_RELEASE
01132   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
01133 #endif
01134   {
01135    self->msgq_remove(message_id);
01136   }
01137  }
01138  return 0;
01139 tolua_lerror:
01140  return tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_remove00(tolua_S);
01141 }
01142 #endif //#ifndef TOLUA_DISABLE
01143 
01144 /* method: msgq_size of class  fawkes::TransformInterface */
01145 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_size00
01146 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_size00(lua_State* tolua_S)
01147 {
01148 #ifndef TOLUA_RELEASE
01149  tolua_Error tolua_err;
01150  if (
01151      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
01152      !tolua_isnoobj(tolua_S,2,&tolua_err)
01153  )
01154   goto tolua_lerror;
01155  else
01156 #endif
01157  {
01158   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
01159 #ifndef TOLUA_RELEASE
01160   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL);
01161 #endif
01162   {
01163    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
01164    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01165   }
01166  }
01167  return 1;
01168 #ifndef TOLUA_RELEASE
01169  tolua_lerror:
01170  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
01171  return 0;
01172 #endif
01173 }
01174 #endif //#ifndef TOLUA_DISABLE
01175 
01176 /* method: msgq_flush of class  fawkes::TransformInterface */
01177 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_flush00
01178 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_flush00(lua_State* tolua_S)
01179 {
01180 #ifndef TOLUA_RELEASE
01181  tolua_Error tolua_err;
01182  if (
01183      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
01184      !tolua_isnoobj(tolua_S,2,&tolua_err)
01185  )
01186   goto tolua_lerror;
01187  else
01188 #endif
01189  {
01190   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
01191 #ifndef TOLUA_RELEASE
01192   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL);
01193 #endif
01194   {
01195    self->msgq_flush();
01196   }
01197  }
01198  return 0;
01199 #ifndef TOLUA_RELEASE
01200  tolua_lerror:
01201  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
01202  return 0;
01203 #endif
01204 }
01205 #endif //#ifndef TOLUA_DISABLE
01206 
01207 /* method: msgq_lock of class  fawkes::TransformInterface */
01208 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_lock00
01209 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_lock00(lua_State* tolua_S)
01210 {
01211 #ifndef TOLUA_RELEASE
01212  tolua_Error tolua_err;
01213  if (
01214      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
01215      !tolua_isnoobj(tolua_S,2,&tolua_err)
01216  )
01217   goto tolua_lerror;
01218  else
01219 #endif
01220  {
01221   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
01222 #ifndef TOLUA_RELEASE
01223   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL);
01224 #endif
01225   {
01226    self->msgq_lock();
01227   }
01228  }
01229  return 0;
01230 #ifndef TOLUA_RELEASE
01231  tolua_lerror:
01232  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
01233  return 0;
01234 #endif
01235 }
01236 #endif //#ifndef TOLUA_DISABLE
01237 
01238 /* method: msgq_try_lock of class  fawkes::TransformInterface */
01239 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_try_lock00
01240 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_try_lock00(lua_State* tolua_S)
01241 {
01242 #ifndef TOLUA_RELEASE
01243  tolua_Error tolua_err;
01244  if (
01245      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
01246      !tolua_isnoobj(tolua_S,2,&tolua_err)
01247  )
01248   goto tolua_lerror;
01249  else
01250 #endif
01251  {
01252   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
01253 #ifndef TOLUA_RELEASE
01254   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL);
01255 #endif
01256   {
01257    bool tolua_ret = (bool)  self->msgq_try_lock();
01258    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01259   }
01260  }
01261  return 1;
01262 #ifndef TOLUA_RELEASE
01263  tolua_lerror:
01264  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
01265  return 0;
01266 #endif
01267 }
01268 #endif //#ifndef TOLUA_DISABLE
01269 
01270 /* method: msgq_unlock of class  fawkes::TransformInterface */
01271 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_unlock00
01272 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_unlock00(lua_State* tolua_S)
01273 {
01274 #ifndef TOLUA_RELEASE
01275  tolua_Error tolua_err;
01276  if (
01277      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
01278      !tolua_isnoobj(tolua_S,2,&tolua_err)
01279  )
01280   goto tolua_lerror;
01281  else
01282 #endif
01283  {
01284   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
01285 #ifndef TOLUA_RELEASE
01286   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL);
01287 #endif
01288   {
01289    self->msgq_unlock();
01290   }
01291  }
01292  return 0;
01293 #ifndef TOLUA_RELEASE
01294  tolua_lerror:
01295  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
01296  return 0;
01297 #endif
01298 }
01299 #endif //#ifndef TOLUA_DISABLE
01300 
01301 /* method: msgq_pop of class  fawkes::TransformInterface */
01302 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_pop00
01303 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_pop00(lua_State* tolua_S)
01304 {
01305 #ifndef TOLUA_RELEASE
01306  tolua_Error tolua_err;
01307  if (
01308      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
01309      !tolua_isnoobj(tolua_S,2,&tolua_err)
01310  )
01311   goto tolua_lerror;
01312  else
01313 #endif
01314  {
01315   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
01316 #ifndef TOLUA_RELEASE
01317   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL);
01318 #endif
01319   {
01320    self->msgq_pop();
01321   }
01322  }
01323  return 0;
01324 #ifndef TOLUA_RELEASE
01325  tolua_lerror:
01326  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
01327  return 0;
01328 #endif
01329 }
01330 #endif //#ifndef TOLUA_DISABLE
01331 
01332 /* method: msgq_first of class  fawkes::TransformInterface */
01333 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_first00
01334 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_first00(lua_State* tolua_S)
01335 {
01336 #ifndef TOLUA_RELEASE
01337  tolua_Error tolua_err;
01338  if (
01339      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
01340      !tolua_isnoobj(tolua_S,2,&tolua_err)
01341  )
01342   goto tolua_lerror;
01343  else
01344 #endif
01345  {
01346   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
01347 #ifndef TOLUA_RELEASE
01348   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL);
01349 #endif
01350   {
01351    Message* tolua_ret = (Message*)  self->msgq_first();
01352     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
01353   }
01354  }
01355  return 1;
01356 #ifndef TOLUA_RELEASE
01357  tolua_lerror:
01358  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
01359  return 0;
01360 #endif
01361 }
01362 #endif //#ifndef TOLUA_DISABLE
01363 
01364 /* method: msgq_empty of class  fawkes::TransformInterface */
01365 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_empty00
01366 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_empty00(lua_State* tolua_S)
01367 {
01368 #ifndef TOLUA_RELEASE
01369  tolua_Error tolua_err;
01370  if (
01371      !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) ||
01372      !tolua_isnoobj(tolua_S,2,&tolua_err)
01373  )
01374   goto tolua_lerror;
01375  else
01376 #endif
01377  {
01378   fawkes::TransformInterface* self = (fawkes::TransformInterface*)  tolua_tousertype(tolua_S,1,0);
01379 #ifndef TOLUA_RELEASE
01380   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL);
01381 #endif
01382   {
01383    bool tolua_ret = (bool)  self->msgq_empty();
01384    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01385   }
01386  }
01387  return 1;
01388 #ifndef TOLUA_RELEASE
01389  tolua_lerror:
01390  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
01391  return 0;
01392 #endif
01393 }
01394 #endif //#ifndef TOLUA_DISABLE
01395 
01396 /* Open function */
01397 TOLUA_API int tolua_interfaces_TransformInterface_open (lua_State* tolua_S)
01398 {
01399  tolua_open(tolua_S);
01400  tolua_reg_types(tolua_S);
01401  tolua_module(tolua_S,NULL,0);
01402  tolua_beginmodule(tolua_S,NULL);
01403   tolua_module(tolua_S,"fawkes",0);
01404   tolua_beginmodule(tolua_S,"fawkes");
01405    tolua_cclass(tolua_S,"TransformInterface","fawkes::TransformInterface","Interface",NULL);
01406    tolua_beginmodule(tolua_S,"TransformInterface");
01407     tolua_function(tolua_S,"frame",tolua_interfaces_TransformInterface_fawkes_TransformInterface_frame00);
01408     tolua_function(tolua_S,"set_frame",tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_frame00);
01409     tolua_function(tolua_S,"maxlenof_frame",tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_frame00);
01410     tolua_function(tolua_S,"child_frame",tolua_interfaces_TransformInterface_fawkes_TransformInterface_child_frame00);
01411     tolua_function(tolua_S,"set_child_frame",tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_child_frame00);
01412     tolua_function(tolua_S,"maxlenof_child_frame",tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_child_frame00);
01413     tolua_function(tolua_S,"translation",tolua_interfaces_TransformInterface_fawkes_TransformInterface_translation00);
01414     tolua_function(tolua_S,"set_translation",tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_translation00);
01415     tolua_function(tolua_S,"maxlenof_translation",tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_translation00);
01416     tolua_function(tolua_S,"rotation",tolua_interfaces_TransformInterface_fawkes_TransformInterface_rotation00);
01417     tolua_function(tolua_S,"set_rotation",tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_rotation00);
01418     tolua_function(tolua_S,"maxlenof_rotation",tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_rotation00);
01419     tolua_function(tolua_S,"oftype",tolua_interfaces_TransformInterface_fawkes_TransformInterface_oftype00);
01420     tolua_function(tolua_S,"datachunk",tolua_interfaces_TransformInterface_fawkes_TransformInterface_datachunk00);
01421     tolua_function(tolua_S,"datasize",tolua_interfaces_TransformInterface_fawkes_TransformInterface_datasize00);
01422     tolua_function(tolua_S,"type",tolua_interfaces_TransformInterface_fawkes_TransformInterface_type00);
01423     tolua_function(tolua_S,"id",tolua_interfaces_TransformInterface_fawkes_TransformInterface_id00);
01424     tolua_function(tolua_S,"uid",tolua_interfaces_TransformInterface_fawkes_TransformInterface_uid00);
01425     tolua_function(tolua_S,"serial",tolua_interfaces_TransformInterface_fawkes_TransformInterface_serial00);
01426     tolua_function(tolua_S,"mem_serial",tolua_interfaces_TransformInterface_fawkes_TransformInterface_mem_serial00);
01427     tolua_function(tolua_S,".eq",tolua_interfaces_TransformInterface_fawkes_TransformInterface__eq00);
01428     tolua_function(tolua_S,"hash",tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash00);
01429     tolua_function(tolua_S,"hash_size",tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash_size00);
01430     tolua_function(tolua_S,"hash_printable",tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash_printable00);
01431     tolua_function(tolua_S,"is_writer",tolua_interfaces_TransformInterface_fawkes_TransformInterface_is_writer00);
01432     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_from_chunk00);
01433     tolua_function(tolua_S,"create_message",tolua_interfaces_TransformInterface_fawkes_TransformInterface_create_message00);
01434     tolua_function(tolua_S,"read",tolua_interfaces_TransformInterface_fawkes_TransformInterface_read00);
01435     tolua_function(tolua_S,"write",tolua_interfaces_TransformInterface_fawkes_TransformInterface_write00);
01436     tolua_function(tolua_S,"has_writer",tolua_interfaces_TransformInterface_fawkes_TransformInterface_has_writer00);
01437     tolua_function(tolua_S,"num_readers",tolua_interfaces_TransformInterface_fawkes_TransformInterface_num_readers00);
01438     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_enqueue_copy00);
01439     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_remove00);
01440     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_remove01);
01441     tolua_function(tolua_S,"msgq_size",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_size00);
01442     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_flush00);
01443     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_lock00);
01444     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_try_lock00);
01445     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_unlock00);
01446     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_pop00);
01447     tolua_function(tolua_S,"msgq_first",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_first00);
01448     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_empty00);
01449    tolua_endmodule(tolua_S);
01450   tolua_endmodule(tolua_S);
01451  tolua_endmodule(tolua_S);
01452  return 1;
01453 }
01454 
01455 
01456 extern "C" {
01457 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
01458  TOLUA_API int luaopen_interfaces_TransformInterface (lua_State* tolua_S) {
01459  return tolua_interfaces_TransformInterface_open(tolua_S);
01460 };
01461 #endif
01462 }
01463 
01464