Fawkes API  Fawkes Development Version
TestInterface_tolua.cpp
00001 /*
00002 ** Lua binding: interfaces_TestInterface
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_TestInterface_open (lua_State* tolua_S);
00028 
00029 #include <interfaces/TestInterface.h>
00030 using namespace fawkes;
00031 
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__TestInterface__SetTestIntMessage (lua_State* tolua_S)
00036 {
00037  fawkes::TestInterface::SetTestIntMessage* self = (fawkes::TestInterface::SetTestIntMessage*) tolua_tousertype(tolua_S,1,0);
00038         Mtolua_delete(self);
00039         return 0;
00040 }
00041 
00042 static int tolua_collect_fawkes__TestInterface__CalculateMessage (lua_State* tolua_S)
00043 {
00044  fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*) tolua_tousertype(tolua_S,1,0);
00045         Mtolua_delete(self);
00046         return 0;
00047 }
00048 
00049 static int tolua_collect_fawkes__TestInterface__SetTestStringMessage (lua_State* tolua_S)
00050 {
00051  fawkes::TestInterface::SetTestStringMessage* self = (fawkes::TestInterface::SetTestStringMessage*) tolua_tousertype(tolua_S,1,0);
00052         Mtolua_delete(self);
00053         return 0;
00054 }
00055 #endif
00056 
00057 
00058 /* function to register type */
00059 static void tolua_reg_types (lua_State* tolua_S)
00060 {
00061  tolua_usertype(tolua_S,"Message");
00062  tolua_usertype(tolua_S,"fawkes::TestInterface::SetTestIntMessage");
00063  tolua_usertype(tolua_S,"fawkes::TestInterface");
00064  tolua_usertype(tolua_S,"fawkes::TestInterface::CalculateMessage");
00065  tolua_usertype(tolua_S,"fawkes::TestInterface::SetTestStringMessage");
00066  tolua_usertype(tolua_S,"Interface");
00067 }
00068 
00069 /* get function: TEST_CONSTANT of class  fawkes::TestInterface */
00070 #ifndef TOLUA_DISABLE_tolua_get_fawkes__TestInterface_TEST_CONSTANT
00071 static int tolua_get_fawkes__TestInterface_TEST_CONSTANT(lua_State* tolua_S)
00072 {
00073   tolua_pushnumber(tolua_S,(lua_Number)fawkes::TestInterface::TEST_CONSTANT);
00074  return 1;
00075 }
00076 #endif //#ifndef TOLUA_DISABLE
00077 
00078 /* get function: TEST_FLOAT_CONSTANT of class  fawkes::TestInterface */
00079 #ifndef TOLUA_DISABLE_tolua_get_fawkes__TestInterface_TEST_FLOAT_CONSTANT
00080 static int tolua_get_fawkes__TestInterface_TEST_FLOAT_CONSTANT(lua_State* tolua_S)
00081 {
00082   tolua_pushnumber(tolua_S,(lua_Number)fawkes::TestInterface::TEST_FLOAT_CONSTANT);
00083  return 1;
00084 }
00085 #endif //#ifndef TOLUA_DISABLE
00086 
00087 /* method: new of class  SetTestIntMessage */
00088 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00
00089 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00(lua_State* tolua_S)
00090 {
00091 #ifndef TOLUA_RELEASE
00092  tolua_Error tolua_err;
00093  if (
00094      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00095      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00096      !tolua_isnoobj(tolua_S,3,&tolua_err)
00097  )
00098   goto tolua_lerror;
00099  else
00100 #endif
00101  {
00102   int ini_test_int = ((int)  tolua_tonumber(tolua_S,2,0));
00103   {
00104    fawkes::TestInterface::SetTestIntMessage* tolua_ret = (fawkes::TestInterface::SetTestIntMessage*)  Mtolua_new((fawkes::TestInterface::SetTestIntMessage)(ini_test_int));
00105     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestIntMessage");
00106   }
00107  }
00108  return 1;
00109 #ifndef TOLUA_RELEASE
00110  tolua_lerror:
00111  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00112  return 0;
00113 #endif
00114 }
00115 #endif //#ifndef TOLUA_DISABLE
00116 
00117 /* method: new_local of class  SetTestIntMessage */
00118 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local
00119 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local(lua_State* tolua_S)
00120 {
00121 #ifndef TOLUA_RELEASE
00122  tolua_Error tolua_err;
00123  if (
00124      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00125      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00126      !tolua_isnoobj(tolua_S,3,&tolua_err)
00127  )
00128   goto tolua_lerror;
00129  else
00130 #endif
00131  {
00132   int ini_test_int = ((int)  tolua_tonumber(tolua_S,2,0));
00133   {
00134    fawkes::TestInterface::SetTestIntMessage* tolua_ret = (fawkes::TestInterface::SetTestIntMessage*)  Mtolua_new((fawkes::TestInterface::SetTestIntMessage)(ini_test_int));
00135     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestIntMessage");
00136     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00137   }
00138  }
00139  return 1;
00140 #ifndef TOLUA_RELEASE
00141  tolua_lerror:
00142  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00143  return 0;
00144 #endif
00145 }
00146 #endif //#ifndef TOLUA_DISABLE
00147 
00148 /* method: new of class  SetTestIntMessage */
00149 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01
00150 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01(lua_State* tolua_S)
00151 {
00152  tolua_Error tolua_err;
00153  if (
00154      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00155      !tolua_isnoobj(tolua_S,2,&tolua_err)
00156  )
00157   goto tolua_lerror;
00158  else
00159  {
00160   {
00161    fawkes::TestInterface::SetTestIntMessage* tolua_ret = (fawkes::TestInterface::SetTestIntMessage*)  Mtolua_new((fawkes::TestInterface::SetTestIntMessage)());
00162     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestIntMessage");
00163   }
00164  }
00165  return 1;
00166 tolua_lerror:
00167  return tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00(tolua_S);
00168 }
00169 #endif //#ifndef TOLUA_DISABLE
00170 
00171 /* method: new_local of class  SetTestIntMessage */
00172 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local
00173 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local(lua_State* tolua_S)
00174 {
00175  tolua_Error tolua_err;
00176  if (
00177      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00178      !tolua_isnoobj(tolua_S,2,&tolua_err)
00179  )
00180   goto tolua_lerror;
00181  else
00182  {
00183   {
00184    fawkes::TestInterface::SetTestIntMessage* tolua_ret = (fawkes::TestInterface::SetTestIntMessage*)  Mtolua_new((fawkes::TestInterface::SetTestIntMessage)());
00185     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestIntMessage");
00186     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00187   }
00188  }
00189  return 1;
00190 tolua_lerror:
00191  return tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local(tolua_S);
00192 }
00193 #endif //#ifndef TOLUA_DISABLE
00194 
00195 /* method: delete of class  SetTestIntMessage */
00196 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_delete00
00197 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_delete00(lua_State* tolua_S)
00198 {
00199 #ifndef TOLUA_RELEASE
00200  tolua_Error tolua_err;
00201  if (
00202      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00203      !tolua_isnoobj(tolua_S,2,&tolua_err)
00204  )
00205   goto tolua_lerror;
00206  else
00207 #endif
00208  {
00209   fawkes::TestInterface::SetTestIntMessage* self = (fawkes::TestInterface::SetTestIntMessage*)  tolua_tousertype(tolua_S,1,0);
00210 #ifndef TOLUA_RELEASE
00211   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00212 #endif
00213   Mtolua_delete(self);
00214  }
00215  return 0;
00216 #ifndef TOLUA_RELEASE
00217  tolua_lerror:
00218  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00219  return 0;
00220 #endif
00221 }
00222 #endif //#ifndef TOLUA_DISABLE
00223 
00224 /* method: test_int of class  SetTestIntMessage */
00225 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_test_int00
00226 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_test_int00(lua_State* tolua_S)
00227 {
00228 #ifndef TOLUA_RELEASE
00229  tolua_Error tolua_err;
00230  if (
00231      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00232      !tolua_isnoobj(tolua_S,2,&tolua_err)
00233  )
00234   goto tolua_lerror;
00235  else
00236 #endif
00237  {
00238   fawkes::TestInterface::SetTestIntMessage* self = (fawkes::TestInterface::SetTestIntMessage*)  tolua_tousertype(tolua_S,1,0);
00239 #ifndef TOLUA_RELEASE
00240   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_int'", NULL);
00241 #endif
00242   {
00243    int tolua_ret = (int)  self->test_int();
00244    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00245   }
00246  }
00247  return 1;
00248 #ifndef TOLUA_RELEASE
00249  tolua_lerror:
00250  tolua_error(tolua_S,"#ferror in function 'test_int'.",&tolua_err);
00251  return 0;
00252 #endif
00253 }
00254 #endif //#ifndef TOLUA_DISABLE
00255 
00256 /* method: set_test_int of class  SetTestIntMessage */
00257 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_set_test_int00
00258 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_set_test_int00(lua_State* tolua_S)
00259 {
00260 #ifndef TOLUA_RELEASE
00261  tolua_Error tolua_err;
00262  if (
00263      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00264      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00265      !tolua_isnoobj(tolua_S,3,&tolua_err)
00266  )
00267   goto tolua_lerror;
00268  else
00269 #endif
00270  {
00271   fawkes::TestInterface::SetTestIntMessage* self = (fawkes::TestInterface::SetTestIntMessage*)  tolua_tousertype(tolua_S,1,0);
00272   const int new_test_int = ((const int)  tolua_tonumber(tolua_S,2,0));
00273 #ifndef TOLUA_RELEASE
00274   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_int'", NULL);
00275 #endif
00276   {
00277    self->set_test_int(new_test_int);
00278   }
00279  }
00280  return 0;
00281 #ifndef TOLUA_RELEASE
00282  tolua_lerror:
00283  tolua_error(tolua_S,"#ferror in function 'set_test_int'.",&tolua_err);
00284  return 0;
00285 #endif
00286 }
00287 #endif //#ifndef TOLUA_DISABLE
00288 
00289 /* method: maxlenof_test_int of class  SetTestIntMessage */
00290 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_maxlenof_test_int00
00291 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_maxlenof_test_int00(lua_State* tolua_S)
00292 {
00293 #ifndef TOLUA_RELEASE
00294  tolua_Error tolua_err;
00295  if (
00296      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00297      !tolua_isnoobj(tolua_S,2,&tolua_err)
00298  )
00299   goto tolua_lerror;
00300  else
00301 #endif
00302  {
00303   const fawkes::TestInterface::SetTestIntMessage* self = (const fawkes::TestInterface::SetTestIntMessage*)  tolua_tousertype(tolua_S,1,0);
00304 #ifndef TOLUA_RELEASE
00305   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_int'", NULL);
00306 #endif
00307   {
00308    int tolua_ret = (int)  self->maxlenof_test_int();
00309    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00310   }
00311  }
00312  return 1;
00313 #ifndef TOLUA_RELEASE
00314  tolua_lerror:
00315  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_int'.",&tolua_err);
00316  return 0;
00317 #endif
00318 }
00319 #endif //#ifndef TOLUA_DISABLE
00320 
00321 /* method: new of class  SetTestStringMessage */
00322 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00
00323 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00(lua_State* tolua_S)
00324 {
00325 #ifndef TOLUA_RELEASE
00326  tolua_Error tolua_err;
00327  if (
00328      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00329      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00330      !tolua_isnoobj(tolua_S,3,&tolua_err)
00331  )
00332   goto tolua_lerror;
00333  else
00334 #endif
00335  {
00336   char* ini_test_string = ((char*)  tolua_tostring(tolua_S,2,0));
00337   {
00338    fawkes::TestInterface::SetTestStringMessage* tolua_ret = (fawkes::TestInterface::SetTestStringMessage*)  Mtolua_new((fawkes::TestInterface::SetTestStringMessage)(ini_test_string));
00339     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestStringMessage");
00340   }
00341  }
00342  return 1;
00343 #ifndef TOLUA_RELEASE
00344  tolua_lerror:
00345  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00346  return 0;
00347 #endif
00348 }
00349 #endif //#ifndef TOLUA_DISABLE
00350 
00351 /* method: new_local of class  SetTestStringMessage */
00352 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local
00353 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local(lua_State* tolua_S)
00354 {
00355 #ifndef TOLUA_RELEASE
00356  tolua_Error tolua_err;
00357  if (
00358      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00359      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00360      !tolua_isnoobj(tolua_S,3,&tolua_err)
00361  )
00362   goto tolua_lerror;
00363  else
00364 #endif
00365  {
00366   char* ini_test_string = ((char*)  tolua_tostring(tolua_S,2,0));
00367   {
00368    fawkes::TestInterface::SetTestStringMessage* tolua_ret = (fawkes::TestInterface::SetTestStringMessage*)  Mtolua_new((fawkes::TestInterface::SetTestStringMessage)(ini_test_string));
00369     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestStringMessage");
00370     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00371   }
00372  }
00373  return 1;
00374 #ifndef TOLUA_RELEASE
00375  tolua_lerror:
00376  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00377  return 0;
00378 #endif
00379 }
00380 #endif //#ifndef TOLUA_DISABLE
00381 
00382 /* method: new of class  SetTestStringMessage */
00383 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01
00384 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01(lua_State* tolua_S)
00385 {
00386  tolua_Error tolua_err;
00387  if (
00388      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00389      !tolua_isnoobj(tolua_S,2,&tolua_err)
00390  )
00391   goto tolua_lerror;
00392  else
00393  {
00394   {
00395    fawkes::TestInterface::SetTestStringMessage* tolua_ret = (fawkes::TestInterface::SetTestStringMessage*)  Mtolua_new((fawkes::TestInterface::SetTestStringMessage)());
00396     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestStringMessage");
00397   }
00398  }
00399  return 1;
00400 tolua_lerror:
00401  return tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00(tolua_S);
00402 }
00403 #endif //#ifndef TOLUA_DISABLE
00404 
00405 /* method: new_local of class  SetTestStringMessage */
00406 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local
00407 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local(lua_State* tolua_S)
00408 {
00409  tolua_Error tolua_err;
00410  if (
00411      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00412      !tolua_isnoobj(tolua_S,2,&tolua_err)
00413  )
00414   goto tolua_lerror;
00415  else
00416  {
00417   {
00418    fawkes::TestInterface::SetTestStringMessage* tolua_ret = (fawkes::TestInterface::SetTestStringMessage*)  Mtolua_new((fawkes::TestInterface::SetTestStringMessage)());
00419     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestStringMessage");
00420     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00421   }
00422  }
00423  return 1;
00424 tolua_lerror:
00425  return tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local(tolua_S);
00426 }
00427 #endif //#ifndef TOLUA_DISABLE
00428 
00429 /* method: delete of class  SetTestStringMessage */
00430 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_delete00
00431 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_delete00(lua_State* tolua_S)
00432 {
00433 #ifndef TOLUA_RELEASE
00434  tolua_Error tolua_err;
00435  if (
00436      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00437      !tolua_isnoobj(tolua_S,2,&tolua_err)
00438  )
00439   goto tolua_lerror;
00440  else
00441 #endif
00442  {
00443   fawkes::TestInterface::SetTestStringMessage* self = (fawkes::TestInterface::SetTestStringMessage*)  tolua_tousertype(tolua_S,1,0);
00444 #ifndef TOLUA_RELEASE
00445   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00446 #endif
00447   Mtolua_delete(self);
00448  }
00449  return 0;
00450 #ifndef TOLUA_RELEASE
00451  tolua_lerror:
00452  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00453  return 0;
00454 #endif
00455 }
00456 #endif //#ifndef TOLUA_DISABLE
00457 
00458 /* method: test_string of class  SetTestStringMessage */
00459 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_test_string00
00460 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_test_string00(lua_State* tolua_S)
00461 {
00462 #ifndef TOLUA_RELEASE
00463  tolua_Error tolua_err;
00464  if (
00465      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00466      !tolua_isnoobj(tolua_S,2,&tolua_err)
00467  )
00468   goto tolua_lerror;
00469  else
00470 #endif
00471  {
00472   fawkes::TestInterface::SetTestStringMessage* self = (fawkes::TestInterface::SetTestStringMessage*)  tolua_tousertype(tolua_S,1,0);
00473 #ifndef TOLUA_RELEASE
00474   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_string'", NULL);
00475 #endif
00476   {
00477    char* tolua_ret = (char*)  self->test_string();
00478    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00479   }
00480  }
00481  return 1;
00482 #ifndef TOLUA_RELEASE
00483  tolua_lerror:
00484  tolua_error(tolua_S,"#ferror in function 'test_string'.",&tolua_err);
00485  return 0;
00486 #endif
00487 }
00488 #endif //#ifndef TOLUA_DISABLE
00489 
00490 /* method: set_test_string of class  SetTestStringMessage */
00491 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_set_test_string00
00492 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_set_test_string00(lua_State* tolua_S)
00493 {
00494 #ifndef TOLUA_RELEASE
00495  tolua_Error tolua_err;
00496  if (
00497      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00498      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00499      !tolua_isnoobj(tolua_S,3,&tolua_err)
00500  )
00501   goto tolua_lerror;
00502  else
00503 #endif
00504  {
00505   fawkes::TestInterface::SetTestStringMessage* self = (fawkes::TestInterface::SetTestStringMessage*)  tolua_tousertype(tolua_S,1,0);
00506   const char* new_test_string = ((const char*)  tolua_tostring(tolua_S,2,0));
00507 #ifndef TOLUA_RELEASE
00508   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_string'", NULL);
00509 #endif
00510   {
00511    self->set_test_string(new_test_string);
00512   }
00513  }
00514  return 0;
00515 #ifndef TOLUA_RELEASE
00516  tolua_lerror:
00517  tolua_error(tolua_S,"#ferror in function 'set_test_string'.",&tolua_err);
00518  return 0;
00519 #endif
00520 }
00521 #endif //#ifndef TOLUA_DISABLE
00522 
00523 /* method: maxlenof_test_string of class  SetTestStringMessage */
00524 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_maxlenof_test_string00
00525 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_maxlenof_test_string00(lua_State* tolua_S)
00526 {
00527 #ifndef TOLUA_RELEASE
00528  tolua_Error tolua_err;
00529  if (
00530      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00531      !tolua_isnoobj(tolua_S,2,&tolua_err)
00532  )
00533   goto tolua_lerror;
00534  else
00535 #endif
00536  {
00537   const fawkes::TestInterface::SetTestStringMessage* self = (const fawkes::TestInterface::SetTestStringMessage*)  tolua_tousertype(tolua_S,1,0);
00538 #ifndef TOLUA_RELEASE
00539   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_string'", NULL);
00540 #endif
00541   {
00542    int tolua_ret = (int)  self->maxlenof_test_string();
00543    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00544   }
00545  }
00546  return 1;
00547 #ifndef TOLUA_RELEASE
00548  tolua_lerror:
00549  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_string'.",&tolua_err);
00550  return 0;
00551 #endif
00552 }
00553 #endif //#ifndef TOLUA_DISABLE
00554 
00555 /* method: new of class  CalculateMessage */
00556 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00
00557 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00(lua_State* tolua_S)
00558 {
00559 #ifndef TOLUA_RELEASE
00560  tolua_Error tolua_err;
00561  if (
00562      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00563      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00564      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00565      !tolua_isnoobj(tolua_S,4,&tolua_err)
00566  )
00567   goto tolua_lerror;
00568  else
00569 #endif
00570  {
00571   int ini_summand = ((int)  tolua_tonumber(tolua_S,2,0));
00572   int ini_addend = ((int)  tolua_tonumber(tolua_S,3,0));
00573   {
00574    fawkes::TestInterface::CalculateMessage* tolua_ret = (fawkes::TestInterface::CalculateMessage*)  Mtolua_new((fawkes::TestInterface::CalculateMessage)(ini_summand,ini_addend));
00575     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::CalculateMessage");
00576   }
00577  }
00578  return 1;
00579 #ifndef TOLUA_RELEASE
00580  tolua_lerror:
00581  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00582  return 0;
00583 #endif
00584 }
00585 #endif //#ifndef TOLUA_DISABLE
00586 
00587 /* method: new_local of class  CalculateMessage */
00588 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local
00589 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local(lua_State* tolua_S)
00590 {
00591 #ifndef TOLUA_RELEASE
00592  tolua_Error tolua_err;
00593  if (
00594      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00595      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00596      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00597      !tolua_isnoobj(tolua_S,4,&tolua_err)
00598  )
00599   goto tolua_lerror;
00600  else
00601 #endif
00602  {
00603   int ini_summand = ((int)  tolua_tonumber(tolua_S,2,0));
00604   int ini_addend = ((int)  tolua_tonumber(tolua_S,3,0));
00605   {
00606    fawkes::TestInterface::CalculateMessage* tolua_ret = (fawkes::TestInterface::CalculateMessage*)  Mtolua_new((fawkes::TestInterface::CalculateMessage)(ini_summand,ini_addend));
00607     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::CalculateMessage");
00608     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00609   }
00610  }
00611  return 1;
00612 #ifndef TOLUA_RELEASE
00613  tolua_lerror:
00614  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00615  return 0;
00616 #endif
00617 }
00618 #endif //#ifndef TOLUA_DISABLE
00619 
00620 /* method: new of class  CalculateMessage */
00621 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01
00622 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01(lua_State* tolua_S)
00623 {
00624  tolua_Error tolua_err;
00625  if (
00626      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00627      !tolua_isnoobj(tolua_S,2,&tolua_err)
00628  )
00629   goto tolua_lerror;
00630  else
00631  {
00632   {
00633    fawkes::TestInterface::CalculateMessage* tolua_ret = (fawkes::TestInterface::CalculateMessage*)  Mtolua_new((fawkes::TestInterface::CalculateMessage)());
00634     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::CalculateMessage");
00635   }
00636  }
00637  return 1;
00638 tolua_lerror:
00639  return tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00(tolua_S);
00640 }
00641 #endif //#ifndef TOLUA_DISABLE
00642 
00643 /* method: new_local of class  CalculateMessage */
00644 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local
00645 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local(lua_State* tolua_S)
00646 {
00647  tolua_Error tolua_err;
00648  if (
00649      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00650      !tolua_isnoobj(tolua_S,2,&tolua_err)
00651  )
00652   goto tolua_lerror;
00653  else
00654  {
00655   {
00656    fawkes::TestInterface::CalculateMessage* tolua_ret = (fawkes::TestInterface::CalculateMessage*)  Mtolua_new((fawkes::TestInterface::CalculateMessage)());
00657     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::CalculateMessage");
00658     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00659   }
00660  }
00661  return 1;
00662 tolua_lerror:
00663  return tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local(tolua_S);
00664 }
00665 #endif //#ifndef TOLUA_DISABLE
00666 
00667 /* method: delete of class  CalculateMessage */
00668 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_delete00
00669 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_delete00(lua_State* tolua_S)
00670 {
00671 #ifndef TOLUA_RELEASE
00672  tolua_Error tolua_err;
00673  if (
00674      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00675      !tolua_isnoobj(tolua_S,2,&tolua_err)
00676  )
00677   goto tolua_lerror;
00678  else
00679 #endif
00680  {
00681   fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*)  tolua_tousertype(tolua_S,1,0);
00682 #ifndef TOLUA_RELEASE
00683   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00684 #endif
00685   Mtolua_delete(self);
00686  }
00687  return 0;
00688 #ifndef TOLUA_RELEASE
00689  tolua_lerror:
00690  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00691  return 0;
00692 #endif
00693 }
00694 #endif //#ifndef TOLUA_DISABLE
00695 
00696 /* method: summand of class  CalculateMessage */
00697 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_summand00
00698 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_summand00(lua_State* tolua_S)
00699 {
00700 #ifndef TOLUA_RELEASE
00701  tolua_Error tolua_err;
00702  if (
00703      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00704      !tolua_isnoobj(tolua_S,2,&tolua_err)
00705  )
00706   goto tolua_lerror;
00707  else
00708 #endif
00709  {
00710   fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*)  tolua_tousertype(tolua_S,1,0);
00711 #ifndef TOLUA_RELEASE
00712   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'summand'", NULL);
00713 #endif
00714   {
00715    int tolua_ret = (int)  self->summand();
00716    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00717   }
00718  }
00719  return 1;
00720 #ifndef TOLUA_RELEASE
00721  tolua_lerror:
00722  tolua_error(tolua_S,"#ferror in function 'summand'.",&tolua_err);
00723  return 0;
00724 #endif
00725 }
00726 #endif //#ifndef TOLUA_DISABLE
00727 
00728 /* method: set_summand of class  CalculateMessage */
00729 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_summand00
00730 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_summand00(lua_State* tolua_S)
00731 {
00732 #ifndef TOLUA_RELEASE
00733  tolua_Error tolua_err;
00734  if (
00735      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00736      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00737      !tolua_isnoobj(tolua_S,3,&tolua_err)
00738  )
00739   goto tolua_lerror;
00740  else
00741 #endif
00742  {
00743   fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*)  tolua_tousertype(tolua_S,1,0);
00744   const int new_summand = ((const int)  tolua_tonumber(tolua_S,2,0));
00745 #ifndef TOLUA_RELEASE
00746   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_summand'", NULL);
00747 #endif
00748   {
00749    self->set_summand(new_summand);
00750   }
00751  }
00752  return 0;
00753 #ifndef TOLUA_RELEASE
00754  tolua_lerror:
00755  tolua_error(tolua_S,"#ferror in function 'set_summand'.",&tolua_err);
00756  return 0;
00757 #endif
00758 }
00759 #endif //#ifndef TOLUA_DISABLE
00760 
00761 /* method: maxlenof_summand of class  CalculateMessage */
00762 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_summand00
00763 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_summand00(lua_State* tolua_S)
00764 {
00765 #ifndef TOLUA_RELEASE
00766  tolua_Error tolua_err;
00767  if (
00768      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00769      !tolua_isnoobj(tolua_S,2,&tolua_err)
00770  )
00771   goto tolua_lerror;
00772  else
00773 #endif
00774  {
00775   const fawkes::TestInterface::CalculateMessage* self = (const fawkes::TestInterface::CalculateMessage*)  tolua_tousertype(tolua_S,1,0);
00776 #ifndef TOLUA_RELEASE
00777   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_summand'", NULL);
00778 #endif
00779   {
00780    int tolua_ret = (int)  self->maxlenof_summand();
00781    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00782   }
00783  }
00784  return 1;
00785 #ifndef TOLUA_RELEASE
00786  tolua_lerror:
00787  tolua_error(tolua_S,"#ferror in function 'maxlenof_summand'.",&tolua_err);
00788  return 0;
00789 #endif
00790 }
00791 #endif //#ifndef TOLUA_DISABLE
00792 
00793 /* method: addend of class  CalculateMessage */
00794 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_addend00
00795 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_addend00(lua_State* tolua_S)
00796 {
00797 #ifndef TOLUA_RELEASE
00798  tolua_Error tolua_err;
00799  if (
00800      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00801      !tolua_isnoobj(tolua_S,2,&tolua_err)
00802  )
00803   goto tolua_lerror;
00804  else
00805 #endif
00806  {
00807   fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*)  tolua_tousertype(tolua_S,1,0);
00808 #ifndef TOLUA_RELEASE
00809   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addend'", NULL);
00810 #endif
00811   {
00812    int tolua_ret = (int)  self->addend();
00813    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00814   }
00815  }
00816  return 1;
00817 #ifndef TOLUA_RELEASE
00818  tolua_lerror:
00819  tolua_error(tolua_S,"#ferror in function 'addend'.",&tolua_err);
00820  return 0;
00821 #endif
00822 }
00823 #endif //#ifndef TOLUA_DISABLE
00824 
00825 /* method: set_addend of class  CalculateMessage */
00826 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_addend00
00827 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_addend00(lua_State* tolua_S)
00828 {
00829 #ifndef TOLUA_RELEASE
00830  tolua_Error tolua_err;
00831  if (
00832      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00833      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00834      !tolua_isnoobj(tolua_S,3,&tolua_err)
00835  )
00836   goto tolua_lerror;
00837  else
00838 #endif
00839  {
00840   fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*)  tolua_tousertype(tolua_S,1,0);
00841   const int new_addend = ((const int)  tolua_tonumber(tolua_S,2,0));
00842 #ifndef TOLUA_RELEASE
00843   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_addend'", NULL);
00844 #endif
00845   {
00846    self->set_addend(new_addend);
00847   }
00848  }
00849  return 0;
00850 #ifndef TOLUA_RELEASE
00851  tolua_lerror:
00852  tolua_error(tolua_S,"#ferror in function 'set_addend'.",&tolua_err);
00853  return 0;
00854 #endif
00855 }
00856 #endif //#ifndef TOLUA_DISABLE
00857 
00858 /* method: maxlenof_addend of class  CalculateMessage */
00859 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_addend00
00860 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_addend00(lua_State* tolua_S)
00861 {
00862 #ifndef TOLUA_RELEASE
00863  tolua_Error tolua_err;
00864  if (
00865      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00866      !tolua_isnoobj(tolua_S,2,&tolua_err)
00867  )
00868   goto tolua_lerror;
00869  else
00870 #endif
00871  {
00872   const fawkes::TestInterface::CalculateMessage* self = (const fawkes::TestInterface::CalculateMessage*)  tolua_tousertype(tolua_S,1,0);
00873 #ifndef TOLUA_RELEASE
00874   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_addend'", NULL);
00875 #endif
00876   {
00877    int tolua_ret = (int)  self->maxlenof_addend();
00878    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00879   }
00880  }
00881  return 1;
00882 #ifndef TOLUA_RELEASE
00883  tolua_lerror:
00884  tolua_error(tolua_S,"#ferror in function 'maxlenof_addend'.",&tolua_err);
00885  return 0;
00886 #endif
00887 }
00888 #endif //#ifndef TOLUA_DISABLE
00889 
00890 /* method: is_test_bool of class  fawkes::TestInterface */
00891 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_is_test_bool00
00892 static int tolua_interfaces_TestInterface_fawkes_TestInterface_is_test_bool00(lua_State* tolua_S)
00893 {
00894 #ifndef TOLUA_RELEASE
00895  tolua_Error tolua_err;
00896  if (
00897      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
00898      !tolua_isnoobj(tolua_S,2,&tolua_err)
00899  )
00900   goto tolua_lerror;
00901  else
00902 #endif
00903  {
00904   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
00905 #ifndef TOLUA_RELEASE
00906   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_test_bool'", NULL);
00907 #endif
00908   {
00909    bool tolua_ret = (bool)  self->is_test_bool();
00910    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00911   }
00912  }
00913  return 1;
00914 #ifndef TOLUA_RELEASE
00915  tolua_lerror:
00916  tolua_error(tolua_S,"#ferror in function 'is_test_bool'.",&tolua_err);
00917  return 0;
00918 #endif
00919 }
00920 #endif //#ifndef TOLUA_DISABLE
00921 
00922 /* method: set_test_bool of class  fawkes::TestInterface */
00923 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_bool00
00924 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_bool00(lua_State* tolua_S)
00925 {
00926 #ifndef TOLUA_RELEASE
00927  tolua_Error tolua_err;
00928  if (
00929      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
00930      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
00931      !tolua_isnoobj(tolua_S,3,&tolua_err)
00932  )
00933   goto tolua_lerror;
00934  else
00935 #endif
00936  {
00937   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
00938   const bool new_test_bool = ((const bool)  tolua_toboolean(tolua_S,2,0));
00939 #ifndef TOLUA_RELEASE
00940   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_bool'", NULL);
00941 #endif
00942   {
00943    self->set_test_bool(new_test_bool);
00944   }
00945  }
00946  return 0;
00947 #ifndef TOLUA_RELEASE
00948  tolua_lerror:
00949  tolua_error(tolua_S,"#ferror in function 'set_test_bool'.",&tolua_err);
00950  return 0;
00951 #endif
00952 }
00953 #endif //#ifndef TOLUA_DISABLE
00954 
00955 /* method: maxlenof_test_bool of class  fawkes::TestInterface */
00956 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_bool00
00957 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_bool00(lua_State* tolua_S)
00958 {
00959 #ifndef TOLUA_RELEASE
00960  tolua_Error tolua_err;
00961  if (
00962      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
00963      !tolua_isnoobj(tolua_S,2,&tolua_err)
00964  )
00965   goto tolua_lerror;
00966  else
00967 #endif
00968  {
00969   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
00970 #ifndef TOLUA_RELEASE
00971   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_bool'", NULL);
00972 #endif
00973   {
00974    int tolua_ret = (int)  self->maxlenof_test_bool();
00975    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00976   }
00977  }
00978  return 1;
00979 #ifndef TOLUA_RELEASE
00980  tolua_lerror:
00981  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_bool'.",&tolua_err);
00982  return 0;
00983 #endif
00984 }
00985 #endif //#ifndef TOLUA_DISABLE
00986 
00987 /* method: test_int of class  fawkes::TestInterface */
00988 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_int00
00989 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_int00(lua_State* tolua_S)
00990 {
00991 #ifndef TOLUA_RELEASE
00992  tolua_Error tolua_err;
00993  if (
00994      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
00995      !tolua_isnoobj(tolua_S,2,&tolua_err)
00996  )
00997   goto tolua_lerror;
00998  else
00999 #endif
01000  {
01001   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01002 #ifndef TOLUA_RELEASE
01003   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_int'", NULL);
01004 #endif
01005   {
01006    int tolua_ret = (int)  self->test_int();
01007    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01008   }
01009  }
01010  return 1;
01011 #ifndef TOLUA_RELEASE
01012  tolua_lerror:
01013  tolua_error(tolua_S,"#ferror in function 'test_int'.",&tolua_err);
01014  return 0;
01015 #endif
01016 }
01017 #endif //#ifndef TOLUA_DISABLE
01018 
01019 /* method: set_test_int of class  fawkes::TestInterface */
01020 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_int00
01021 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_int00(lua_State* tolua_S)
01022 {
01023 #ifndef TOLUA_RELEASE
01024  tolua_Error tolua_err;
01025  if (
01026      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01027      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01028      !tolua_isnoobj(tolua_S,3,&tolua_err)
01029  )
01030   goto tolua_lerror;
01031  else
01032 #endif
01033  {
01034   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01035   const int new_test_int = ((const int)  tolua_tonumber(tolua_S,2,0));
01036 #ifndef TOLUA_RELEASE
01037   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_int'", NULL);
01038 #endif
01039   {
01040    self->set_test_int(new_test_int);
01041   }
01042  }
01043  return 0;
01044 #ifndef TOLUA_RELEASE
01045  tolua_lerror:
01046  tolua_error(tolua_S,"#ferror in function 'set_test_int'.",&tolua_err);
01047  return 0;
01048 #endif
01049 }
01050 #endif //#ifndef TOLUA_DISABLE
01051 
01052 /* method: maxlenof_test_int of class  fawkes::TestInterface */
01053 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_int00
01054 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_int00(lua_State* tolua_S)
01055 {
01056 #ifndef TOLUA_RELEASE
01057  tolua_Error tolua_err;
01058  if (
01059      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01060      !tolua_isnoobj(tolua_S,2,&tolua_err)
01061  )
01062   goto tolua_lerror;
01063  else
01064 #endif
01065  {
01066   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01067 #ifndef TOLUA_RELEASE
01068   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_int'", NULL);
01069 #endif
01070   {
01071    int tolua_ret = (int)  self->maxlenof_test_int();
01072    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01073   }
01074  }
01075  return 1;
01076 #ifndef TOLUA_RELEASE
01077  tolua_lerror:
01078  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_int'.",&tolua_err);
01079  return 0;
01080 #endif
01081 }
01082 #endif //#ifndef TOLUA_DISABLE
01083 
01084 /* method: flags of class  fawkes::TestInterface */
01085 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_flags00
01086 static int tolua_interfaces_TestInterface_fawkes_TestInterface_flags00(lua_State* tolua_S)
01087 {
01088 #ifndef TOLUA_RELEASE
01089  tolua_Error tolua_err;
01090  if (
01091      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01092      !tolua_isnoobj(tolua_S,2,&tolua_err)
01093  )
01094   goto tolua_lerror;
01095  else
01096 #endif
01097  {
01098   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01099 #ifndef TOLUA_RELEASE
01100   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'flags'", NULL);
01101 #endif
01102   {
01103    unsigned char tolua_ret = (unsigned char)  self->flags();
01104    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01105   }
01106  }
01107  return 1;
01108 #ifndef TOLUA_RELEASE
01109  tolua_lerror:
01110  tolua_error(tolua_S,"#ferror in function 'flags'.",&tolua_err);
01111  return 0;
01112 #endif
01113 }
01114 #endif //#ifndef TOLUA_DISABLE
01115 
01116 /* method: set_flags of class  fawkes::TestInterface */
01117 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_flags00
01118 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_flags00(lua_State* tolua_S)
01119 {
01120 #ifndef TOLUA_RELEASE
01121  tolua_Error tolua_err;
01122  if (
01123      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01124      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01125      !tolua_isnoobj(tolua_S,3,&tolua_err)
01126  )
01127   goto tolua_lerror;
01128  else
01129 #endif
01130  {
01131   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01132   unsigned const char new_flags = ((unsigned const char)  tolua_tonumber(tolua_S,2,0));
01133 #ifndef TOLUA_RELEASE
01134   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_flags'", NULL);
01135 #endif
01136   {
01137    self->set_flags(new_flags);
01138   }
01139  }
01140  return 0;
01141 #ifndef TOLUA_RELEASE
01142  tolua_lerror:
01143  tolua_error(tolua_S,"#ferror in function 'set_flags'.",&tolua_err);
01144  return 0;
01145 #endif
01146 }
01147 #endif //#ifndef TOLUA_DISABLE
01148 
01149 /* method: maxlenof_flags of class  fawkes::TestInterface */
01150 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_flags00
01151 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_flags00(lua_State* tolua_S)
01152 {
01153 #ifndef TOLUA_RELEASE
01154  tolua_Error tolua_err;
01155  if (
01156      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01157      !tolua_isnoobj(tolua_S,2,&tolua_err)
01158  )
01159   goto tolua_lerror;
01160  else
01161 #endif
01162  {
01163   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01164 #ifndef TOLUA_RELEASE
01165   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_flags'", NULL);
01166 #endif
01167   {
01168    int tolua_ret = (int)  self->maxlenof_flags();
01169    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01170   }
01171  }
01172  return 1;
01173 #ifndef TOLUA_RELEASE
01174  tolua_lerror:
01175  tolua_error(tolua_S,"#ferror in function 'maxlenof_flags'.",&tolua_err);
01176  return 0;
01177 #endif
01178 }
01179 #endif //#ifndef TOLUA_DISABLE
01180 
01181 /* method: test_string of class  fawkes::TestInterface */
01182 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_string00
01183 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_string00(lua_State* tolua_S)
01184 {
01185 #ifndef TOLUA_RELEASE
01186  tolua_Error tolua_err;
01187  if (
01188      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01189      !tolua_isnoobj(tolua_S,2,&tolua_err)
01190  )
01191   goto tolua_lerror;
01192  else
01193 #endif
01194  {
01195   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01196 #ifndef TOLUA_RELEASE
01197   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_string'", NULL);
01198 #endif
01199   {
01200    char* tolua_ret = (char*)  self->test_string();
01201    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01202   }
01203  }
01204  return 1;
01205 #ifndef TOLUA_RELEASE
01206  tolua_lerror:
01207  tolua_error(tolua_S,"#ferror in function 'test_string'.",&tolua_err);
01208  return 0;
01209 #endif
01210 }
01211 #endif //#ifndef TOLUA_DISABLE
01212 
01213 /* method: set_test_string of class  fawkes::TestInterface */
01214 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_string00
01215 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_string00(lua_State* tolua_S)
01216 {
01217 #ifndef TOLUA_RELEASE
01218  tolua_Error tolua_err;
01219  if (
01220      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01221      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01222      !tolua_isnoobj(tolua_S,3,&tolua_err)
01223  )
01224   goto tolua_lerror;
01225  else
01226 #endif
01227  {
01228   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01229   const char* new_test_string = ((const char*)  tolua_tostring(tolua_S,2,0));
01230 #ifndef TOLUA_RELEASE
01231   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_string'", NULL);
01232 #endif
01233   {
01234    self->set_test_string(new_test_string);
01235   }
01236  }
01237  return 0;
01238 #ifndef TOLUA_RELEASE
01239  tolua_lerror:
01240  tolua_error(tolua_S,"#ferror in function 'set_test_string'.",&tolua_err);
01241  return 0;
01242 #endif
01243 }
01244 #endif //#ifndef TOLUA_DISABLE
01245 
01246 /* method: maxlenof_test_string of class  fawkes::TestInterface */
01247 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_string00
01248 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_string00(lua_State* tolua_S)
01249 {
01250 #ifndef TOLUA_RELEASE
01251  tolua_Error tolua_err;
01252  if (
01253      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01254      !tolua_isnoobj(tolua_S,2,&tolua_err)
01255  )
01256   goto tolua_lerror;
01257  else
01258 #endif
01259  {
01260   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01261 #ifndef TOLUA_RELEASE
01262   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_string'", NULL);
01263 #endif
01264   {
01265    int tolua_ret = (int)  self->maxlenof_test_string();
01266    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01267   }
01268  }
01269  return 1;
01270 #ifndef TOLUA_RELEASE
01271  tolua_lerror:
01272  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_string'.",&tolua_err);
01273  return 0;
01274 #endif
01275 }
01276 #endif //#ifndef TOLUA_DISABLE
01277 
01278 /* method: result of class  fawkes::TestInterface */
01279 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_result00
01280 static int tolua_interfaces_TestInterface_fawkes_TestInterface_result00(lua_State* tolua_S)
01281 {
01282 #ifndef TOLUA_RELEASE
01283  tolua_Error tolua_err;
01284  if (
01285      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01286      !tolua_isnoobj(tolua_S,2,&tolua_err)
01287  )
01288   goto tolua_lerror;
01289  else
01290 #endif
01291  {
01292   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01293 #ifndef TOLUA_RELEASE
01294   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'result'", NULL);
01295 #endif
01296   {
01297    int tolua_ret = (int)  self->result();
01298    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01299   }
01300  }
01301  return 1;
01302 #ifndef TOLUA_RELEASE
01303  tolua_lerror:
01304  tolua_error(tolua_S,"#ferror in function 'result'.",&tolua_err);
01305  return 0;
01306 #endif
01307 }
01308 #endif //#ifndef TOLUA_DISABLE
01309 
01310 /* method: set_result of class  fawkes::TestInterface */
01311 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_result00
01312 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_result00(lua_State* tolua_S)
01313 {
01314 #ifndef TOLUA_RELEASE
01315  tolua_Error tolua_err;
01316  if (
01317      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01318      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01319      !tolua_isnoobj(tolua_S,3,&tolua_err)
01320  )
01321   goto tolua_lerror;
01322  else
01323 #endif
01324  {
01325   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01326   const int new_result = ((const int)  tolua_tonumber(tolua_S,2,0));
01327 #ifndef TOLUA_RELEASE
01328   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_result'", NULL);
01329 #endif
01330   {
01331    self->set_result(new_result);
01332   }
01333  }
01334  return 0;
01335 #ifndef TOLUA_RELEASE
01336  tolua_lerror:
01337  tolua_error(tolua_S,"#ferror in function 'set_result'.",&tolua_err);
01338  return 0;
01339 #endif
01340 }
01341 #endif //#ifndef TOLUA_DISABLE
01342 
01343 /* method: maxlenof_result of class  fawkes::TestInterface */
01344 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_result00
01345 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_result00(lua_State* tolua_S)
01346 {
01347 #ifndef TOLUA_RELEASE
01348  tolua_Error tolua_err;
01349  if (
01350      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01351      !tolua_isnoobj(tolua_S,2,&tolua_err)
01352  )
01353   goto tolua_lerror;
01354  else
01355 #endif
01356  {
01357   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01358 #ifndef TOLUA_RELEASE
01359   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_result'", NULL);
01360 #endif
01361   {
01362    int tolua_ret = (int)  self->maxlenof_result();
01363    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01364   }
01365  }
01366  return 1;
01367 #ifndef TOLUA_RELEASE
01368  tolua_lerror:
01369  tolua_error(tolua_S,"#ferror in function 'maxlenof_result'.",&tolua_err);
01370  return 0;
01371 #endif
01372 }
01373 #endif //#ifndef TOLUA_DISABLE
01374 
01375 /* method: test_uint of class  fawkes::TestInterface */
01376 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_uint00
01377 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_uint00(lua_State* tolua_S)
01378 {
01379 #ifndef TOLUA_RELEASE
01380  tolua_Error tolua_err;
01381  if (
01382      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01383      !tolua_isnoobj(tolua_S,2,&tolua_err)
01384  )
01385   goto tolua_lerror;
01386  else
01387 #endif
01388  {
01389   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01390 #ifndef TOLUA_RELEASE
01391   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_uint'", NULL);
01392 #endif
01393   {
01394    unsigned int tolua_ret = (unsigned int)  self->test_uint();
01395    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01396   }
01397  }
01398  return 1;
01399 #ifndef TOLUA_RELEASE
01400  tolua_lerror:
01401  tolua_error(tolua_S,"#ferror in function 'test_uint'.",&tolua_err);
01402  return 0;
01403 #endif
01404 }
01405 #endif //#ifndef TOLUA_DISABLE
01406 
01407 /* method: set_test_uint of class  fawkes::TestInterface */
01408 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_uint00
01409 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_uint00(lua_State* tolua_S)
01410 {
01411 #ifndef TOLUA_RELEASE
01412  tolua_Error tolua_err;
01413  if (
01414      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01415      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01416      !tolua_isnoobj(tolua_S,3,&tolua_err)
01417  )
01418   goto tolua_lerror;
01419  else
01420 #endif
01421  {
01422   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01423   unsigned const int new_test_uint = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
01424 #ifndef TOLUA_RELEASE
01425   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_uint'", NULL);
01426 #endif
01427   {
01428    self->set_test_uint(new_test_uint);
01429   }
01430  }
01431  return 0;
01432 #ifndef TOLUA_RELEASE
01433  tolua_lerror:
01434  tolua_error(tolua_S,"#ferror in function 'set_test_uint'.",&tolua_err);
01435  return 0;
01436 #endif
01437 }
01438 #endif //#ifndef TOLUA_DISABLE
01439 
01440 /* method: maxlenof_test_uint of class  fawkes::TestInterface */
01441 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_uint00
01442 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_uint00(lua_State* tolua_S)
01443 {
01444 #ifndef TOLUA_RELEASE
01445  tolua_Error tolua_err;
01446  if (
01447      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01448      !tolua_isnoobj(tolua_S,2,&tolua_err)
01449  )
01450   goto tolua_lerror;
01451  else
01452 #endif
01453  {
01454   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01455 #ifndef TOLUA_RELEASE
01456   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_uint'", NULL);
01457 #endif
01458   {
01459    int tolua_ret = (int)  self->maxlenof_test_uint();
01460    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01461   }
01462  }
01463  return 1;
01464 #ifndef TOLUA_RELEASE
01465  tolua_lerror:
01466  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_uint'.",&tolua_err);
01467  return 0;
01468 #endif
01469 }
01470 #endif //#ifndef TOLUA_DISABLE
01471 
01472 /* method: test_ulint of class  fawkes::TestInterface */
01473 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_ulint00
01474 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_ulint00(lua_State* tolua_S)
01475 {
01476 #ifndef TOLUA_RELEASE
01477  tolua_Error tolua_err;
01478  if (
01479      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01480      !tolua_isnoobj(tolua_S,2,&tolua_err)
01481  )
01482   goto tolua_lerror;
01483  else
01484 #endif
01485  {
01486   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01487 #ifndef TOLUA_RELEASE
01488   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_ulint'", NULL);
01489 #endif
01490   {
01491    unsigned long tolua_ret = (unsigned long)  self->test_ulint();
01492    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01493   }
01494  }
01495  return 1;
01496 #ifndef TOLUA_RELEASE
01497  tolua_lerror:
01498  tolua_error(tolua_S,"#ferror in function 'test_ulint'.",&tolua_err);
01499  return 0;
01500 #endif
01501 }
01502 #endif //#ifndef TOLUA_DISABLE
01503 
01504 /* method: set_test_ulint of class  fawkes::TestInterface */
01505 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_ulint00
01506 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_ulint00(lua_State* tolua_S)
01507 {
01508 #ifndef TOLUA_RELEASE
01509  tolua_Error tolua_err;
01510  if (
01511      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01512      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01513      !tolua_isnoobj(tolua_S,3,&tolua_err)
01514  )
01515   goto tolua_lerror;
01516  else
01517 #endif
01518  {
01519   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01520   unsigned const long new_test_ulint = ((unsigned const long)  tolua_tonumber(tolua_S,2,0));
01521 #ifndef TOLUA_RELEASE
01522   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_ulint'", NULL);
01523 #endif
01524   {
01525    self->set_test_ulint(new_test_ulint);
01526   }
01527  }
01528  return 0;
01529 #ifndef TOLUA_RELEASE
01530  tolua_lerror:
01531  tolua_error(tolua_S,"#ferror in function 'set_test_ulint'.",&tolua_err);
01532  return 0;
01533 #endif
01534 }
01535 #endif //#ifndef TOLUA_DISABLE
01536 
01537 /* method: maxlenof_test_ulint of class  fawkes::TestInterface */
01538 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_ulint00
01539 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_ulint00(lua_State* tolua_S)
01540 {
01541 #ifndef TOLUA_RELEASE
01542  tolua_Error tolua_err;
01543  if (
01544      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01545      !tolua_isnoobj(tolua_S,2,&tolua_err)
01546  )
01547   goto tolua_lerror;
01548  else
01549 #endif
01550  {
01551   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01552 #ifndef TOLUA_RELEASE
01553   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_ulint'", NULL);
01554 #endif
01555   {
01556    int tolua_ret = (int)  self->maxlenof_test_ulint();
01557    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01558   }
01559  }
01560  return 1;
01561 #ifndef TOLUA_RELEASE
01562  tolua_lerror:
01563  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_ulint'.",&tolua_err);
01564  return 0;
01565 #endif
01566 }
01567 #endif //#ifndef TOLUA_DISABLE
01568 
01569 /* method: test_lint of class  fawkes::TestInterface */
01570 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_lint00
01571 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_lint00(lua_State* tolua_S)
01572 {
01573 #ifndef TOLUA_RELEASE
01574  tolua_Error tolua_err;
01575  if (
01576      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01577      !tolua_isnoobj(tolua_S,2,&tolua_err)
01578  )
01579   goto tolua_lerror;
01580  else
01581 #endif
01582  {
01583   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01584 #ifndef TOLUA_RELEASE
01585   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_lint'", NULL);
01586 #endif
01587   {
01588    long tolua_ret = (long)  self->test_lint();
01589    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01590   }
01591  }
01592  return 1;
01593 #ifndef TOLUA_RELEASE
01594  tolua_lerror:
01595  tolua_error(tolua_S,"#ferror in function 'test_lint'.",&tolua_err);
01596  return 0;
01597 #endif
01598 }
01599 #endif //#ifndef TOLUA_DISABLE
01600 
01601 /* method: set_test_lint of class  fawkes::TestInterface */
01602 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_lint00
01603 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_lint00(lua_State* tolua_S)
01604 {
01605 #ifndef TOLUA_RELEASE
01606  tolua_Error tolua_err;
01607  if (
01608      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01609      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01610      !tolua_isnoobj(tolua_S,3,&tolua_err)
01611  )
01612   goto tolua_lerror;
01613  else
01614 #endif
01615  {
01616   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01617   const long new_test_lint = ((const long)  tolua_tonumber(tolua_S,2,0));
01618 #ifndef TOLUA_RELEASE
01619   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_lint'", NULL);
01620 #endif
01621   {
01622    self->set_test_lint(new_test_lint);
01623   }
01624  }
01625  return 0;
01626 #ifndef TOLUA_RELEASE
01627  tolua_lerror:
01628  tolua_error(tolua_S,"#ferror in function 'set_test_lint'.",&tolua_err);
01629  return 0;
01630 #endif
01631 }
01632 #endif //#ifndef TOLUA_DISABLE
01633 
01634 /* method: maxlenof_test_lint of class  fawkes::TestInterface */
01635 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_lint00
01636 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_lint00(lua_State* tolua_S)
01637 {
01638 #ifndef TOLUA_RELEASE
01639  tolua_Error tolua_err;
01640  if (
01641      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01642      !tolua_isnoobj(tolua_S,2,&tolua_err)
01643  )
01644   goto tolua_lerror;
01645  else
01646 #endif
01647  {
01648   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01649 #ifndef TOLUA_RELEASE
01650   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_lint'", NULL);
01651 #endif
01652   {
01653    int tolua_ret = (int)  self->maxlenof_test_lint();
01654    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01655   }
01656  }
01657  return 1;
01658 #ifndef TOLUA_RELEASE
01659  tolua_lerror:
01660  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_lint'.",&tolua_err);
01661  return 0;
01662 #endif
01663 }
01664 #endif //#ifndef TOLUA_DISABLE
01665 
01666 /* method: oftype of class  fawkes::TestInterface */
01667 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00
01668 static int tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00(lua_State* tolua_S)
01669 {
01670 #ifndef TOLUA_RELEASE
01671  tolua_Error tolua_err;
01672  if (
01673      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01674      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01675      !tolua_isnoobj(tolua_S,3,&tolua_err)
01676  )
01677   goto tolua_lerror;
01678  else
01679 #endif
01680  {
01681   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01682   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
01683 #ifndef TOLUA_RELEASE
01684   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL);
01685 #endif
01686   {
01687    bool tolua_ret = (bool)  self->oftype(interface_type);
01688    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01689   }
01690  }
01691  return 1;
01692 #ifndef TOLUA_RELEASE
01693  tolua_lerror:
01694  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
01695  return 0;
01696 #endif
01697 }
01698 #endif //#ifndef TOLUA_DISABLE
01699 
01700 /* method: datachunk of class  fawkes::TestInterface */
01701 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00
01702 static int tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00(lua_State* tolua_S)
01703 {
01704 #ifndef TOLUA_RELEASE
01705  tolua_Error tolua_err;
01706  if (
01707      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01708      !tolua_isnoobj(tolua_S,2,&tolua_err)
01709  )
01710   goto tolua_lerror;
01711  else
01712 #endif
01713  {
01714   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01715 #ifndef TOLUA_RELEASE
01716   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL);
01717 #endif
01718   {
01719    const void* tolua_ret = (const void*)  self->datachunk();
01720    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
01721   }
01722  }
01723  return 1;
01724 #ifndef TOLUA_RELEASE
01725  tolua_lerror:
01726  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
01727  return 0;
01728 #endif
01729 }
01730 #endif //#ifndef TOLUA_DISABLE
01731 
01732 /* method: datasize of class  fawkes::TestInterface */
01733 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00
01734 static int tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00(lua_State* tolua_S)
01735 {
01736 #ifndef TOLUA_RELEASE
01737  tolua_Error tolua_err;
01738  if (
01739      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01740      !tolua_isnoobj(tolua_S,2,&tolua_err)
01741  )
01742   goto tolua_lerror;
01743  else
01744 #endif
01745  {
01746   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01747 #ifndef TOLUA_RELEASE
01748   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL);
01749 #endif
01750   {
01751    unsigned int tolua_ret = (unsigned int)  self->datasize();
01752    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01753   }
01754  }
01755  return 1;
01756 #ifndef TOLUA_RELEASE
01757  tolua_lerror:
01758  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
01759  return 0;
01760 #endif
01761 }
01762 #endif //#ifndef TOLUA_DISABLE
01763 
01764 /* method: type of class  fawkes::TestInterface */
01765 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_type00
01766 static int tolua_interfaces_TestInterface_fawkes_TestInterface_type00(lua_State* tolua_S)
01767 {
01768 #ifndef TOLUA_RELEASE
01769  tolua_Error tolua_err;
01770  if (
01771      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01772      !tolua_isnoobj(tolua_S,2,&tolua_err)
01773  )
01774   goto tolua_lerror;
01775  else
01776 #endif
01777  {
01778   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01779 #ifndef TOLUA_RELEASE
01780   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
01781 #endif
01782   {
01783    const char* tolua_ret = (const char*)  self->type();
01784    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01785   }
01786  }
01787  return 1;
01788 #ifndef TOLUA_RELEASE
01789  tolua_lerror:
01790  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
01791  return 0;
01792 #endif
01793 }
01794 #endif //#ifndef TOLUA_DISABLE
01795 
01796 /* method: id of class  fawkes::TestInterface */
01797 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_id00
01798 static int tolua_interfaces_TestInterface_fawkes_TestInterface_id00(lua_State* tolua_S)
01799 {
01800 #ifndef TOLUA_RELEASE
01801  tolua_Error tolua_err;
01802  if (
01803      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01804      !tolua_isnoobj(tolua_S,2,&tolua_err)
01805  )
01806   goto tolua_lerror;
01807  else
01808 #endif
01809  {
01810   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01811 #ifndef TOLUA_RELEASE
01812   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL);
01813 #endif
01814   {
01815    const char* tolua_ret = (const char*)  self->id();
01816    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01817   }
01818  }
01819  return 1;
01820 #ifndef TOLUA_RELEASE
01821  tolua_lerror:
01822  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
01823  return 0;
01824 #endif
01825 }
01826 #endif //#ifndef TOLUA_DISABLE
01827 
01828 /* method: uid of class  fawkes::TestInterface */
01829 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_uid00
01830 static int tolua_interfaces_TestInterface_fawkes_TestInterface_uid00(lua_State* tolua_S)
01831 {
01832 #ifndef TOLUA_RELEASE
01833  tolua_Error tolua_err;
01834  if (
01835      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01836      !tolua_isnoobj(tolua_S,2,&tolua_err)
01837  )
01838   goto tolua_lerror;
01839  else
01840 #endif
01841  {
01842   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01843 #ifndef TOLUA_RELEASE
01844   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL);
01845 #endif
01846   {
01847    const char* tolua_ret = (const char*)  self->uid();
01848    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01849   }
01850  }
01851  return 1;
01852 #ifndef TOLUA_RELEASE
01853  tolua_lerror:
01854  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
01855  return 0;
01856 #endif
01857 }
01858 #endif //#ifndef TOLUA_DISABLE
01859 
01860 /* method: serial of class  fawkes::TestInterface */
01861 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_serial00
01862 static int tolua_interfaces_TestInterface_fawkes_TestInterface_serial00(lua_State* tolua_S)
01863 {
01864 #ifndef TOLUA_RELEASE
01865  tolua_Error tolua_err;
01866  if (
01867      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01868      !tolua_isnoobj(tolua_S,2,&tolua_err)
01869  )
01870   goto tolua_lerror;
01871  else
01872 #endif
01873  {
01874   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01875 #ifndef TOLUA_RELEASE
01876   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL);
01877 #endif
01878   {
01879    unsigned int tolua_ret = (unsigned int)  self->serial();
01880    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01881   }
01882  }
01883  return 1;
01884 #ifndef TOLUA_RELEASE
01885  tolua_lerror:
01886  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
01887  return 0;
01888 #endif
01889 }
01890 #endif //#ifndef TOLUA_DISABLE
01891 
01892 /* method: mem_serial of class  fawkes::TestInterface */
01893 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00
01894 static int tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00(lua_State* tolua_S)
01895 {
01896 #ifndef TOLUA_RELEASE
01897  tolua_Error tolua_err;
01898  if (
01899      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01900      !tolua_isnoobj(tolua_S,2,&tolua_err)
01901  )
01902   goto tolua_lerror;
01903  else
01904 #endif
01905  {
01906   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01907 #ifndef TOLUA_RELEASE
01908   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL);
01909 #endif
01910   {
01911    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
01912    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01913   }
01914  }
01915  return 1;
01916 #ifndef TOLUA_RELEASE
01917  tolua_lerror:
01918  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
01919  return 0;
01920 #endif
01921 }
01922 #endif //#ifndef TOLUA_DISABLE
01923 
01924 /* method: operator== of class  fawkes::TestInterface */
01925 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface__eq00
01926 static int tolua_interfaces_TestInterface_fawkes_TestInterface__eq00(lua_State* tolua_S)
01927 {
01928 #ifndef TOLUA_RELEASE
01929  tolua_Error tolua_err;
01930  if (
01931      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01932      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) ||
01933      !tolua_isnoobj(tolua_S,3,&tolua_err)
01934  )
01935   goto tolua_lerror;
01936  else
01937 #endif
01938  {
01939   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01940   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
01941 #ifndef TOLUA_RELEASE
01942   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
01943 #endif
01944   {
01945    bool tolua_ret = (bool)  self->operator==(*comp);
01946    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01947   }
01948  }
01949  return 1;
01950 #ifndef TOLUA_RELEASE
01951  tolua_lerror:
01952  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
01953  return 0;
01954 #endif
01955 }
01956 #endif //#ifndef TOLUA_DISABLE
01957 
01958 /* method: hash of class  fawkes::TestInterface */
01959 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash00
01960 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash00(lua_State* tolua_S)
01961 {
01962 #ifndef TOLUA_RELEASE
01963  tolua_Error tolua_err;
01964  if (
01965      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01966      !tolua_isnoobj(tolua_S,2,&tolua_err)
01967  )
01968   goto tolua_lerror;
01969  else
01970 #endif
01971  {
01972   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01973 #ifndef TOLUA_RELEASE
01974   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL);
01975 #endif
01976   {
01977    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
01978    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01979   }
01980  }
01981  return 1;
01982 #ifndef TOLUA_RELEASE
01983  tolua_lerror:
01984  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
01985  return 0;
01986 #endif
01987 }
01988 #endif //#ifndef TOLUA_DISABLE
01989 
01990 /* method: hash_size of class  fawkes::TestInterface */
01991 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00
01992 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00(lua_State* tolua_S)
01993 {
01994 #ifndef TOLUA_RELEASE
01995  tolua_Error tolua_err;
01996  if (
01997      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01998      !tolua_isnoobj(tolua_S,2,&tolua_err)
01999  )
02000   goto tolua_lerror;
02001  else
02002 #endif
02003  {
02004   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02005 #ifndef TOLUA_RELEASE
02006   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL);
02007 #endif
02008   {
02009    int tolua_ret = (int)  self->hash_size();
02010    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02011   }
02012  }
02013  return 1;
02014 #ifndef TOLUA_RELEASE
02015  tolua_lerror:
02016  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
02017  return 0;
02018 #endif
02019 }
02020 #endif //#ifndef TOLUA_DISABLE
02021 
02022 /* method: hash_printable of class  fawkes::TestInterface */
02023 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00
02024 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00(lua_State* tolua_S)
02025 {
02026 #ifndef TOLUA_RELEASE
02027  tolua_Error tolua_err;
02028  if (
02029      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02030      !tolua_isnoobj(tolua_S,2,&tolua_err)
02031  )
02032   goto tolua_lerror;
02033  else
02034 #endif
02035  {
02036   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02037 #ifndef TOLUA_RELEASE
02038   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL);
02039 #endif
02040   {
02041    const char* tolua_ret = (const char*)  self->hash_printable();
02042    tolua_pushstring(tolua_S,(const char*)tolua_ret);
02043   }
02044  }
02045  return 1;
02046 #ifndef TOLUA_RELEASE
02047  tolua_lerror:
02048  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
02049  return 0;
02050 #endif
02051 }
02052 #endif //#ifndef TOLUA_DISABLE
02053 
02054 /* method: is_writer of class  fawkes::TestInterface */
02055 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00
02056 static int tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00(lua_State* tolua_S)
02057 {
02058 #ifndef TOLUA_RELEASE
02059  tolua_Error tolua_err;
02060  if (
02061      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02062      !tolua_isnoobj(tolua_S,2,&tolua_err)
02063  )
02064   goto tolua_lerror;
02065  else
02066 #endif
02067  {
02068   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02069 #ifndef TOLUA_RELEASE
02070   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL);
02071 #endif
02072   {
02073    bool tolua_ret = (bool)  self->is_writer();
02074    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02075   }
02076  }
02077  return 1;
02078 #ifndef TOLUA_RELEASE
02079  tolua_lerror:
02080  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
02081  return 0;
02082 #endif
02083 }
02084 #endif //#ifndef TOLUA_DISABLE
02085 
02086 /* method: set_from_chunk of class  fawkes::TestInterface */
02087 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00
02088 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00(lua_State* tolua_S)
02089 {
02090 #ifndef TOLUA_RELEASE
02091  tolua_Error tolua_err;
02092  if (
02093      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02094      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
02095      !tolua_isnoobj(tolua_S,3,&tolua_err)
02096  )
02097   goto tolua_lerror;
02098  else
02099 #endif
02100  {
02101   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02102   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
02103 #ifndef TOLUA_RELEASE
02104   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL);
02105 #endif
02106   {
02107    self->set_from_chunk(chunk);
02108   }
02109  }
02110  return 0;
02111 #ifndef TOLUA_RELEASE
02112  tolua_lerror:
02113  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
02114  return 0;
02115 #endif
02116 }
02117 #endif //#ifndef TOLUA_DISABLE
02118 
02119 /* method: create_message of class  fawkes::TestInterface */
02120 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00
02121 static int tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00(lua_State* tolua_S)
02122 {
02123 #ifndef TOLUA_RELEASE
02124  tolua_Error tolua_err;
02125  if (
02126      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02127      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
02128      !tolua_isnoobj(tolua_S,3,&tolua_err)
02129  )
02130   goto tolua_lerror;
02131  else
02132 #endif
02133  {
02134   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02135   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
02136 #ifndef TOLUA_RELEASE
02137   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL);
02138 #endif
02139   {
02140    Message* tolua_ret = (Message*)  self->create_message(type);
02141     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
02142   }
02143  }
02144  return 1;
02145 #ifndef TOLUA_RELEASE
02146  tolua_lerror:
02147  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
02148  return 0;
02149 #endif
02150 }
02151 #endif //#ifndef TOLUA_DISABLE
02152 
02153 /* method: read of class  fawkes::TestInterface */
02154 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_read00
02155 static int tolua_interfaces_TestInterface_fawkes_TestInterface_read00(lua_State* tolua_S)
02156 {
02157 #ifndef TOLUA_RELEASE
02158  tolua_Error tolua_err;
02159  if (
02160      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02161      !tolua_isnoobj(tolua_S,2,&tolua_err)
02162  )
02163   goto tolua_lerror;
02164  else
02165 #endif
02166  {
02167   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02168 #ifndef TOLUA_RELEASE
02169   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
02170 #endif
02171   {
02172    self->read();
02173   }
02174  }
02175  return 0;
02176 #ifndef TOLUA_RELEASE
02177  tolua_lerror:
02178  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
02179  return 0;
02180 #endif
02181 }
02182 #endif //#ifndef TOLUA_DISABLE
02183 
02184 /* method: write of class  fawkes::TestInterface */
02185 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_write00
02186 static int tolua_interfaces_TestInterface_fawkes_TestInterface_write00(lua_State* tolua_S)
02187 {
02188 #ifndef TOLUA_RELEASE
02189  tolua_Error tolua_err;
02190  if (
02191      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02192      !tolua_isnoobj(tolua_S,2,&tolua_err)
02193  )
02194   goto tolua_lerror;
02195  else
02196 #endif
02197  {
02198   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02199 #ifndef TOLUA_RELEASE
02200   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
02201 #endif
02202   {
02203    self->write();
02204   }
02205  }
02206  return 0;
02207 #ifndef TOLUA_RELEASE
02208  tolua_lerror:
02209  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
02210  return 0;
02211 #endif
02212 }
02213 #endif //#ifndef TOLUA_DISABLE
02214 
02215 /* method: has_writer of class  fawkes::TestInterface */
02216 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00
02217 static int tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00(lua_State* tolua_S)
02218 {
02219 #ifndef TOLUA_RELEASE
02220  tolua_Error tolua_err;
02221  if (
02222      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02223      !tolua_isnoobj(tolua_S,2,&tolua_err)
02224  )
02225   goto tolua_lerror;
02226  else
02227 #endif
02228  {
02229   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02230 #ifndef TOLUA_RELEASE
02231   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL);
02232 #endif
02233   {
02234    bool tolua_ret = (bool)  self->has_writer();
02235    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02236   }
02237  }
02238  return 1;
02239 #ifndef TOLUA_RELEASE
02240  tolua_lerror:
02241  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
02242  return 0;
02243 #endif
02244 }
02245 #endif //#ifndef TOLUA_DISABLE
02246 
02247 /* method: num_readers of class  fawkes::TestInterface */
02248 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00
02249 static int tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00(lua_State* tolua_S)
02250 {
02251 #ifndef TOLUA_RELEASE
02252  tolua_Error tolua_err;
02253  if (
02254      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02255      !tolua_isnoobj(tolua_S,2,&tolua_err)
02256  )
02257   goto tolua_lerror;
02258  else
02259 #endif
02260  {
02261   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02262 #ifndef TOLUA_RELEASE
02263   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL);
02264 #endif
02265   {
02266    unsigned int tolua_ret = (unsigned int)  self->num_readers();
02267    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02268   }
02269  }
02270  return 1;
02271 #ifndef TOLUA_RELEASE
02272  tolua_lerror:
02273  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
02274  return 0;
02275 #endif
02276 }
02277 #endif //#ifndef TOLUA_DISABLE
02278 
02279 /* method: msgq_enqueue_copy of class  fawkes::TestInterface */
02280 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00
02281 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00(lua_State* tolua_S)
02282 {
02283 #ifndef TOLUA_RELEASE
02284  tolua_Error tolua_err;
02285  if (
02286      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02287      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
02288      !tolua_isnoobj(tolua_S,3,&tolua_err)
02289  )
02290   goto tolua_lerror;
02291  else
02292 #endif
02293  {
02294   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02295   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
02296 #ifndef TOLUA_RELEASE
02297   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL);
02298 #endif
02299   {
02300    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
02301    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02302   }
02303  }
02304  return 1;
02305 #ifndef TOLUA_RELEASE
02306  tolua_lerror:
02307  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
02308  return 0;
02309 #endif
02310 }
02311 #endif //#ifndef TOLUA_DISABLE
02312 
02313 /* method: msgq_remove of class  fawkes::TestInterface */
02314 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00
02315 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00(lua_State* tolua_S)
02316 {
02317 #ifndef TOLUA_RELEASE
02318  tolua_Error tolua_err;
02319  if (
02320      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02321      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
02322      !tolua_isnoobj(tolua_S,3,&tolua_err)
02323  )
02324   goto tolua_lerror;
02325  else
02326 #endif
02327  {
02328   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02329   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
02330 #ifndef TOLUA_RELEASE
02331   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
02332 #endif
02333   {
02334    self->msgq_remove(message);
02335   }
02336  }
02337  return 0;
02338 #ifndef TOLUA_RELEASE
02339  tolua_lerror:
02340  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
02341  return 0;
02342 #endif
02343 }
02344 #endif //#ifndef TOLUA_DISABLE
02345 
02346 /* method: msgq_remove of class  fawkes::TestInterface */
02347 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01
02348 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01(lua_State* tolua_S)
02349 {
02350  tolua_Error tolua_err;
02351  if (
02352      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02353      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02354      !tolua_isnoobj(tolua_S,3,&tolua_err)
02355  )
02356   goto tolua_lerror;
02357  else
02358  {
02359   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02360   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
02361 #ifndef TOLUA_RELEASE
02362   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
02363 #endif
02364   {
02365    self->msgq_remove(message_id);
02366   }
02367  }
02368  return 0;
02369 tolua_lerror:
02370  return tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00(tolua_S);
02371 }
02372 #endif //#ifndef TOLUA_DISABLE
02373 
02374 /* method: msgq_size of class  fawkes::TestInterface */
02375 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00
02376 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00(lua_State* tolua_S)
02377 {
02378 #ifndef TOLUA_RELEASE
02379  tolua_Error tolua_err;
02380  if (
02381      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02382      !tolua_isnoobj(tolua_S,2,&tolua_err)
02383  )
02384   goto tolua_lerror;
02385  else
02386 #endif
02387  {
02388   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02389 #ifndef TOLUA_RELEASE
02390   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL);
02391 #endif
02392   {
02393    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
02394    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02395   }
02396  }
02397  return 1;
02398 #ifndef TOLUA_RELEASE
02399  tolua_lerror:
02400  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
02401  return 0;
02402 #endif
02403 }
02404 #endif //#ifndef TOLUA_DISABLE
02405 
02406 /* method: msgq_flush of class  fawkes::TestInterface */
02407 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00
02408 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00(lua_State* tolua_S)
02409 {
02410 #ifndef TOLUA_RELEASE
02411  tolua_Error tolua_err;
02412  if (
02413      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02414      !tolua_isnoobj(tolua_S,2,&tolua_err)
02415  )
02416   goto tolua_lerror;
02417  else
02418 #endif
02419  {
02420   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02421 #ifndef TOLUA_RELEASE
02422   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL);
02423 #endif
02424   {
02425    self->msgq_flush();
02426   }
02427  }
02428  return 0;
02429 #ifndef TOLUA_RELEASE
02430  tolua_lerror:
02431  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
02432  return 0;
02433 #endif
02434 }
02435 #endif //#ifndef TOLUA_DISABLE
02436 
02437 /* method: msgq_lock of class  fawkes::TestInterface */
02438 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00
02439 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00(lua_State* tolua_S)
02440 {
02441 #ifndef TOLUA_RELEASE
02442  tolua_Error tolua_err;
02443  if (
02444      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02445      !tolua_isnoobj(tolua_S,2,&tolua_err)
02446  )
02447   goto tolua_lerror;
02448  else
02449 #endif
02450  {
02451   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02452 #ifndef TOLUA_RELEASE
02453   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL);
02454 #endif
02455   {
02456    self->msgq_lock();
02457   }
02458  }
02459  return 0;
02460 #ifndef TOLUA_RELEASE
02461  tolua_lerror:
02462  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
02463  return 0;
02464 #endif
02465 }
02466 #endif //#ifndef TOLUA_DISABLE
02467 
02468 /* method: msgq_try_lock of class  fawkes::TestInterface */
02469 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00
02470 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00(lua_State* tolua_S)
02471 {
02472 #ifndef TOLUA_RELEASE
02473  tolua_Error tolua_err;
02474  if (
02475      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02476      !tolua_isnoobj(tolua_S,2,&tolua_err)
02477  )
02478   goto tolua_lerror;
02479  else
02480 #endif
02481  {
02482   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02483 #ifndef TOLUA_RELEASE
02484   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL);
02485 #endif
02486   {
02487    bool tolua_ret = (bool)  self->msgq_try_lock();
02488    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02489   }
02490  }
02491  return 1;
02492 #ifndef TOLUA_RELEASE
02493  tolua_lerror:
02494  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
02495  return 0;
02496 #endif
02497 }
02498 #endif //#ifndef TOLUA_DISABLE
02499 
02500 /* method: msgq_unlock of class  fawkes::TestInterface */
02501 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00
02502 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00(lua_State* tolua_S)
02503 {
02504 #ifndef TOLUA_RELEASE
02505  tolua_Error tolua_err;
02506  if (
02507      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02508      !tolua_isnoobj(tolua_S,2,&tolua_err)
02509  )
02510   goto tolua_lerror;
02511  else
02512 #endif
02513  {
02514   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02515 #ifndef TOLUA_RELEASE
02516   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL);
02517 #endif
02518   {
02519    self->msgq_unlock();
02520   }
02521  }
02522  return 0;
02523 #ifndef TOLUA_RELEASE
02524  tolua_lerror:
02525  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
02526  return 0;
02527 #endif
02528 }
02529 #endif //#ifndef TOLUA_DISABLE
02530 
02531 /* method: msgq_pop of class  fawkes::TestInterface */
02532 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00
02533 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00(lua_State* tolua_S)
02534 {
02535 #ifndef TOLUA_RELEASE
02536  tolua_Error tolua_err;
02537  if (
02538      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02539      !tolua_isnoobj(tolua_S,2,&tolua_err)
02540  )
02541   goto tolua_lerror;
02542  else
02543 #endif
02544  {
02545   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02546 #ifndef TOLUA_RELEASE
02547   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL);
02548 #endif
02549   {
02550    self->msgq_pop();
02551   }
02552  }
02553  return 0;
02554 #ifndef TOLUA_RELEASE
02555  tolua_lerror:
02556  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
02557  return 0;
02558 #endif
02559 }
02560 #endif //#ifndef TOLUA_DISABLE
02561 
02562 /* method: msgq_first of class  fawkes::TestInterface */
02563 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00
02564 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00(lua_State* tolua_S)
02565 {
02566 #ifndef TOLUA_RELEASE
02567  tolua_Error tolua_err;
02568  if (
02569      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02570      !tolua_isnoobj(tolua_S,2,&tolua_err)
02571  )
02572   goto tolua_lerror;
02573  else
02574 #endif
02575  {
02576   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02577 #ifndef TOLUA_RELEASE
02578   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL);
02579 #endif
02580   {
02581    Message* tolua_ret = (Message*)  self->msgq_first();
02582     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
02583   }
02584  }
02585  return 1;
02586 #ifndef TOLUA_RELEASE
02587  tolua_lerror:
02588  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
02589  return 0;
02590 #endif
02591 }
02592 #endif //#ifndef TOLUA_DISABLE
02593 
02594 /* method: msgq_empty of class  fawkes::TestInterface */
02595 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00
02596 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00(lua_State* tolua_S)
02597 {
02598 #ifndef TOLUA_RELEASE
02599  tolua_Error tolua_err;
02600  if (
02601      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02602      !tolua_isnoobj(tolua_S,2,&tolua_err)
02603  )
02604   goto tolua_lerror;
02605  else
02606 #endif
02607  {
02608   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02609 #ifndef TOLUA_RELEASE
02610   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL);
02611 #endif
02612   {
02613    bool tolua_ret = (bool)  self->msgq_empty();
02614    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02615   }
02616  }
02617  return 1;
02618 #ifndef TOLUA_RELEASE
02619  tolua_lerror:
02620  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
02621  return 0;
02622 #endif
02623 }
02624 #endif //#ifndef TOLUA_DISABLE
02625 
02626 /* Open function */
02627 TOLUA_API int tolua_interfaces_TestInterface_open (lua_State* tolua_S)
02628 {
02629  tolua_open(tolua_S);
02630  tolua_reg_types(tolua_S);
02631  tolua_module(tolua_S,NULL,0);
02632  tolua_beginmodule(tolua_S,NULL);
02633   tolua_module(tolua_S,"fawkes",0);
02634   tolua_beginmodule(tolua_S,"fawkes");
02635    tolua_cclass(tolua_S,"TestInterface","fawkes::TestInterface","Interface",NULL);
02636    tolua_beginmodule(tolua_S,"TestInterface");
02637     tolua_variable(tolua_S,"TEST_CONSTANT",tolua_get_fawkes__TestInterface_TEST_CONSTANT,NULL);
02638     tolua_variable(tolua_S,"TEST_FLOAT_CONSTANT",tolua_get_fawkes__TestInterface_TEST_FLOAT_CONSTANT,NULL);
02639     tolua_constant(tolua_S,"TEST_ENUM_1",fawkes::TestInterface::TEST_ENUM_1);
02640     tolua_constant(tolua_S,"TEST_ENUM_2",fawkes::TestInterface::TEST_ENUM_2);
02641     #ifdef __cplusplus
02642     tolua_cclass(tolua_S,"SetTestIntMessage","fawkes::TestInterface::SetTestIntMessage","Message",tolua_collect_fawkes__TestInterface__SetTestIntMessage);
02643     #else
02644     tolua_cclass(tolua_S,"SetTestIntMessage","fawkes::TestInterface::SetTestIntMessage","Message",NULL);
02645     #endif
02646     tolua_beginmodule(tolua_S,"SetTestIntMessage");
02647      tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00);
02648      tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local);
02649      tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local);
02650      tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01);
02651      tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local);
02652      tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local);
02653      tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_delete00);
02654      tolua_function(tolua_S,"test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_test_int00);
02655      tolua_function(tolua_S,"set_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_set_test_int00);
02656      tolua_function(tolua_S,"maxlenof_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_maxlenof_test_int00);
02657     tolua_endmodule(tolua_S);
02658     #ifdef __cplusplus
02659     tolua_cclass(tolua_S,"SetTestStringMessage","fawkes::TestInterface::SetTestStringMessage","Message",tolua_collect_fawkes__TestInterface__SetTestStringMessage);
02660     #else
02661     tolua_cclass(tolua_S,"SetTestStringMessage","fawkes::TestInterface::SetTestStringMessage","Message",NULL);
02662     #endif
02663     tolua_beginmodule(tolua_S,"SetTestStringMessage");
02664      tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00);
02665      tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local);
02666      tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local);
02667      tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01);
02668      tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local);
02669      tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local);
02670      tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_delete00);
02671      tolua_function(tolua_S,"test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_test_string00);
02672      tolua_function(tolua_S,"set_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_set_test_string00);
02673      tolua_function(tolua_S,"maxlenof_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_maxlenof_test_string00);
02674     tolua_endmodule(tolua_S);
02675     #ifdef __cplusplus
02676     tolua_cclass(tolua_S,"CalculateMessage","fawkes::TestInterface::CalculateMessage","Message",tolua_collect_fawkes__TestInterface__CalculateMessage);
02677     #else
02678     tolua_cclass(tolua_S,"CalculateMessage","fawkes::TestInterface::CalculateMessage","Message",NULL);
02679     #endif
02680     tolua_beginmodule(tolua_S,"CalculateMessage");
02681      tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00);
02682      tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local);
02683      tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local);
02684      tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01);
02685      tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local);
02686      tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local);
02687      tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_delete00);
02688      tolua_function(tolua_S,"summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_summand00);
02689      tolua_function(tolua_S,"set_summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_summand00);
02690      tolua_function(tolua_S,"maxlenof_summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_summand00);
02691      tolua_function(tolua_S,"addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_addend00);
02692      tolua_function(tolua_S,"set_addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_addend00);
02693      tolua_function(tolua_S,"maxlenof_addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_addend00);
02694     tolua_endmodule(tolua_S);
02695     tolua_function(tolua_S,"is_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_is_test_bool00);
02696     tolua_function(tolua_S,"set_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_bool00);
02697     tolua_function(tolua_S,"maxlenof_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_bool00);
02698     tolua_function(tolua_S,"test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_test_int00);
02699     tolua_function(tolua_S,"set_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_int00);
02700     tolua_function(tolua_S,"maxlenof_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_int00);
02701     tolua_function(tolua_S,"flags",tolua_interfaces_TestInterface_fawkes_TestInterface_flags00);
02702     tolua_function(tolua_S,"set_flags",tolua_interfaces_TestInterface_fawkes_TestInterface_set_flags00);
02703     tolua_function(tolua_S,"maxlenof_flags",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_flags00);
02704     tolua_function(tolua_S,"test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_test_string00);
02705     tolua_function(tolua_S,"set_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_string00);
02706     tolua_function(tolua_S,"maxlenof_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_string00);
02707     tolua_function(tolua_S,"result",tolua_interfaces_TestInterface_fawkes_TestInterface_result00);
02708     tolua_function(tolua_S,"set_result",tolua_interfaces_TestInterface_fawkes_TestInterface_set_result00);
02709     tolua_function(tolua_S,"maxlenof_result",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_result00);
02710     tolua_function(tolua_S,"test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_test_uint00);
02711     tolua_function(tolua_S,"set_test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_uint00);
02712     tolua_function(tolua_S,"maxlenof_test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_uint00);
02713     tolua_function(tolua_S,"test_ulint",tolua_interfaces_TestInterface_fawkes_TestInterface_test_ulint00);
02714     tolua_function(tolua_S,"set_test_ulint",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_ulint00);
02715     tolua_function(tolua_S,"maxlenof_test_ulint",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_ulint00);
02716     tolua_function(tolua_S,"test_lint",tolua_interfaces_TestInterface_fawkes_TestInterface_test_lint00);
02717     tolua_function(tolua_S,"set_test_lint",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_lint00);
02718     tolua_function(tolua_S,"maxlenof_test_lint",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_lint00);
02719     tolua_function(tolua_S,"oftype",tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00);
02720     tolua_function(tolua_S,"datachunk",tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00);
02721     tolua_function(tolua_S,"datasize",tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00);
02722     tolua_function(tolua_S,"type",tolua_interfaces_TestInterface_fawkes_TestInterface_type00);
02723     tolua_function(tolua_S,"id",tolua_interfaces_TestInterface_fawkes_TestInterface_id00);
02724     tolua_function(tolua_S,"uid",tolua_interfaces_TestInterface_fawkes_TestInterface_uid00);
02725     tolua_function(tolua_S,"serial",tolua_interfaces_TestInterface_fawkes_TestInterface_serial00);
02726     tolua_function(tolua_S,"mem_serial",tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00);
02727     tolua_function(tolua_S,".eq",tolua_interfaces_TestInterface_fawkes_TestInterface__eq00);
02728     tolua_function(tolua_S,"hash",tolua_interfaces_TestInterface_fawkes_TestInterface_hash00);
02729     tolua_function(tolua_S,"hash_size",tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00);
02730     tolua_function(tolua_S,"hash_printable",tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00);
02731     tolua_function(tolua_S,"is_writer",tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00);
02732     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00);
02733     tolua_function(tolua_S,"create_message",tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00);
02734     tolua_function(tolua_S,"read",tolua_interfaces_TestInterface_fawkes_TestInterface_read00);
02735     tolua_function(tolua_S,"write",tolua_interfaces_TestInterface_fawkes_TestInterface_write00);
02736     tolua_function(tolua_S,"has_writer",tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00);
02737     tolua_function(tolua_S,"num_readers",tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00);
02738     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00);
02739     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00);
02740     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01);
02741     tolua_function(tolua_S,"msgq_size",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00);
02742     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00);
02743     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00);
02744     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00);
02745     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00);
02746     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00);
02747     tolua_function(tolua_S,"msgq_first",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00);
02748     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00);
02749    tolua_endmodule(tolua_S);
02750   tolua_endmodule(tolua_S);
02751  tolua_endmodule(tolua_S);
02752  return 1;
02753 }
02754 
02755 
02756 extern "C" {
02757 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
02758  TOLUA_API int luaopen_interfaces_TestInterface (lua_State* tolua_S) {
02759  return tolua_interfaces_TestInterface_open(tolua_S);
02760 };
02761 #endif
02762 }
02763 
02764