00001 /*
00002 ** Lua binding: fawkesinterface
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_fawkesinterface_open (lua_State* tolua_S);
00028
00029 #include <interface/interface.h>
00030 #include <interface/message_queue.h>
00031 #include <interface/message.h>
00032
00033 /* function to release collected object via destructor */
00034 #ifdef __cplusplus
00035 
00036 static int tolua_collect_fawkes__MessageQueue__MessageIterator (lua_State* tolua_S)
00037 {
00038  fawkes::MessageQueue::MessageIterator* self = (fawkes::MessageQueue::MessageIterator*) tolua_tousertype(tolua_S,1,0);
00039         delete self;
00040         return 0;
00041 }
00042
00043 static int tolua_collect_fawkes__Message (lua_State* tolua_S)
00044 {
00045  fawkes::Message* self = (fawkes::Message*) tolua_tousertype(tolua_S,1,0);
00046         delete self;
00047         return 0;
00048 }
00049
00050 static int tolua_collect_fawkes__MessageQueue (lua_State* tolua_S)
00051 {
00052  fawkes::MessageQueue* self = (fawkes::MessageQueue*) tolua_tousertype(tolua_S,1,0);
00053         delete self;
00054         return 0;
00055 }
00056
00057 static int tolua_collect_size_t (lua_State* tolua_S)
00058 {
00059  size_t* self = (size_t*) tolua_tousertype(tolua_S,1,0);
00060         delete self;
00061         return 0;
00062 }
00063 #endif
00064 
00065
00066 /* function to register type */
00067 static void tolua_reg_types (lua_State* tolua_S)
00068 {
00069  tolua_usertype(tolua_S,"fawkes::MessageQueue::MessageIterator");
00070  tolua_usertype(tolua_S,"fawkes::Message");
00071  tolua_usertype(tolua_S,"fawkes::Interface");
00072  tolua_usertype(tolua_S,"fawkes::MessageQueue");
00073  tolua_usertype(tolua_S,"RefCount");
00074  tolua_usertype(tolua_S,"size_t");
00075 }
00076
00077 /* method: oftype of class  fawkes::Interface */
00078 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_oftype00
00079 static int tolua_fawkesinterface_fawkes_Interface_oftype00(lua_State* tolua_S)
00080 {
00081 #ifndef TOLUA_RELEASE
00082  tolua_Error tolua_err;
00083  if (
00084      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00085      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00086      !tolua_isnoobj(tolua_S,3,&tolua_err)
00087  )
00088   goto tolua_lerror;
00089  else
00090 #endif
00091  {
00092   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00093   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
00094 #ifndef TOLUA_RELEASE
00095   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'",NULL);
00096 #endif
00097   {
00098    bool tolua_ret = (bool)  self->oftype(interface_type);
00099    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00100   }
00101  }
00102  return 1;
00103 #ifndef TOLUA_RELEASE
00104  tolua_lerror:
00105  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
00106  return 0;
00107 #endif
00108 }
00109 #endif //#ifndef TOLUA_DISABLE
00110 
00111 /* method: datachunk of class  fawkes::Interface */
00112 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_datachunk00
00113 static int tolua_fawkesinterface_fawkes_Interface_datachunk00(lua_State* tolua_S)
00114 {
00115 #ifndef TOLUA_RELEASE
00116  tolua_Error tolua_err;
00117  if (
00118      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00119      !tolua_isnoobj(tolua_S,2,&tolua_err)
00120  )
00121   goto tolua_lerror;
00122  else
00123 #endif
00124  {
00125   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00126 #ifndef TOLUA_RELEASE
00127   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'",NULL);
00128 #endif
00129   {
00130    const void* tolua_ret = (const void*)  self->datachunk();
00131    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
00132   }
00133  }
00134  return 1;
00135 #ifndef TOLUA_RELEASE
00136  tolua_lerror:
00137  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
00138  return 0;
00139 #endif
00140 }
00141 #endif //#ifndef TOLUA_DISABLE
00142 
00143 /* method: datasize of class  fawkes::Interface */
00144 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_datasize00
00145 static int tolua_fawkesinterface_fawkes_Interface_datasize00(lua_State* tolua_S)
00146 {
00147 #ifndef TOLUA_RELEASE
00148  tolua_Error tolua_err;
00149  if (
00150      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00151      !tolua_isnoobj(tolua_S,2,&tolua_err)
00152  )
00153   goto tolua_lerror;
00154  else
00155 #endif
00156  {
00157   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00158 #ifndef TOLUA_RELEASE
00159   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'",NULL);
00160 #endif
00161   {
00162    unsigned int tolua_ret = (unsigned int)  self->datasize();
00163    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00164   }
00165  }
00166  return 1;
00167 #ifndef TOLUA_RELEASE
00168  tolua_lerror:
00169  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
00170  return 0;
00171 #endif
00172 }
00173 #endif //#ifndef TOLUA_DISABLE
00174 
00175 /* method: type of class  fawkes::Interface */
00176 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_type00
00177 static int tolua_fawkesinterface_fawkes_Interface_type00(lua_State* tolua_S)
00178 {
00179 #ifndef TOLUA_RELEASE
00180  tolua_Error tolua_err;
00181  if (
00182      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00183      !tolua_isnoobj(tolua_S,2,&tolua_err)
00184  )
00185   goto tolua_lerror;
00186  else
00187 #endif
00188  {
00189   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00190 #ifndef TOLUA_RELEASE
00191   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'",NULL);
00192 #endif
00193   {
00194    const char* tolua_ret = (const char*)  self->type();
00195    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00196   }
00197  }
00198  return 1;
00199 #ifndef TOLUA_RELEASE
00200  tolua_lerror:
00201  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
00202  return 0;
00203 #endif
00204 }
00205 #endif //#ifndef TOLUA_DISABLE
00206 
00207 /* method: id of class  fawkes::Interface */
00208 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_id00
00209 static int tolua_fawkesinterface_fawkes_Interface_id00(lua_State* tolua_S)
00210 {
00211 #ifndef TOLUA_RELEASE
00212  tolua_Error tolua_err;
00213  if (
00214      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00215      !tolua_isnoobj(tolua_S,2,&tolua_err)
00216  )
00217   goto tolua_lerror;
00218  else
00219 #endif
00220  {
00221   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00222 #ifndef TOLUA_RELEASE
00223   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'",NULL);
00224 #endif
00225   {
00226    const char* tolua_ret = (const char*)  self->id();
00227    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00228   }
00229  }
00230  return 1;
00231 #ifndef TOLUA_RELEASE
00232  tolua_lerror:
00233  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
00234  return 0;
00235 #endif
00236 }
00237 #endif //#ifndef TOLUA_DISABLE
00238 
00239 /* method: uid of class  fawkes::Interface */
00240 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_uid00
00241 static int tolua_fawkesinterface_fawkes_Interface_uid00(lua_State* tolua_S)
00242 {
00243 #ifndef TOLUA_RELEASE
00244  tolua_Error tolua_err;
00245  if (
00246      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00247      !tolua_isnoobj(tolua_S,2,&tolua_err)
00248  )
00249   goto tolua_lerror;
00250  else
00251 #endif
00252  {
00253   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00254 #ifndef TOLUA_RELEASE
00255   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'",NULL);
00256 #endif
00257   {
00258    const char* tolua_ret = (const char*)  self->uid();
00259    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00260   }
00261  }
00262  return 1;
00263 #ifndef TOLUA_RELEASE
00264  tolua_lerror:
00265  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
00266  return 0;
00267 #endif
00268 }
00269 #endif //#ifndef TOLUA_DISABLE
00270 
00271 /* method: serial of class  fawkes::Interface */
00272 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_serial00
00273 static int tolua_fawkesinterface_fawkes_Interface_serial00(lua_State* tolua_S)
00274 {
00275 #ifndef TOLUA_RELEASE
00276  tolua_Error tolua_err;
00277  if (
00278      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00279      !tolua_isnoobj(tolua_S,2,&tolua_err)
00280  )
00281   goto tolua_lerror;
00282  else
00283 #endif
00284  {
00285   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00286 #ifndef TOLUA_RELEASE
00287   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'",NULL);
00288 #endif
00289   {
00290    unsigned int tolua_ret = (unsigned int)  self->serial();
00291    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00292   }
00293  }
00294  return 1;
00295 #ifndef TOLUA_RELEASE
00296  tolua_lerror:
00297  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
00298  return 0;
00299 #endif
00300 }
00301 #endif //#ifndef TOLUA_DISABLE
00302 
00303 /* method: mem_serial of class  fawkes::Interface */
00304 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_mem_serial00
00305 static int tolua_fawkesinterface_fawkes_Interface_mem_serial00(lua_State* tolua_S)
00306 {
00307 #ifndef TOLUA_RELEASE
00308  tolua_Error tolua_err;
00309  if (
00310      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00311      !tolua_isnoobj(tolua_S,2,&tolua_err)
00312  )
00313   goto tolua_lerror;
00314  else
00315 #endif
00316  {
00317   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00318 #ifndef TOLUA_RELEASE
00319   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'",NULL);
00320 #endif
00321   {
00322    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
00323    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00324   }
00325  }
00326  return 1;
00327 #ifndef TOLUA_RELEASE
00328  tolua_lerror:
00329  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
00330  return 0;
00331 #endif
00332 }
00333 #endif //#ifndef TOLUA_DISABLE
00334 
00335 /* method: operator== of class  fawkes::Interface */
00336 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface__eq00
00337 static int tolua_fawkesinterface_fawkes_Interface__eq00(lua_State* tolua_S)
00338 {
00339 #ifndef TOLUA_RELEASE
00340  tolua_Error tolua_err;
00341  if (
00342      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00343      !tolua_isusertype(tolua_S,2,"fawkes::Interface",0,&tolua_err) ||
00344      !tolua_isnoobj(tolua_S,3,&tolua_err)
00345  )
00346   goto tolua_lerror;
00347  else
00348 #endif
00349  {
00350   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00351   fawkes::Interface* comp = ((fawkes::Interface*)  tolua_tousertype(tolua_S,2,0));
00352 #ifndef TOLUA_RELEASE
00353   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
00354 #endif
00355   {
00356    bool tolua_ret = (bool)  self->operator==(*comp);
00357    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00358   }
00359  }
00360  return 1;
00361 #ifndef TOLUA_RELEASE
00362  tolua_lerror:
00363  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
00364  return 0;
00365 #endif
00366 }
00367 #endif //#ifndef TOLUA_DISABLE
00368 
00369 /* method: hash of class  fawkes::Interface */
00370 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_hash00
00371 static int tolua_fawkesinterface_fawkes_Interface_hash00(lua_State* tolua_S)
00372 {
00373 #ifndef TOLUA_RELEASE
00374  tolua_Error tolua_err;
00375  if (
00376      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00377      !tolua_isnoobj(tolua_S,2,&tolua_err)
00378  )
00379   goto tolua_lerror;
00380  else
00381 #endif
00382  {
00383   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00384 #ifndef TOLUA_RELEASE
00385   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'",NULL);
00386 #endif
00387   {
00388    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
00389    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00390   }
00391  }
00392  return 1;
00393 #ifndef TOLUA_RELEASE
00394  tolua_lerror:
00395  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
00396  return 0;
00397 #endif
00398 }
00399 #endif //#ifndef TOLUA_DISABLE
00400 
00401 /* method: hash_size of class  fawkes::Interface */
00402 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_hash_size00
00403 static int tolua_fawkesinterface_fawkes_Interface_hash_size00(lua_State* tolua_S)
00404 {
00405 #ifndef TOLUA_RELEASE
00406  tolua_Error tolua_err;
00407  if (
00408      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00409      !tolua_isnoobj(tolua_S,2,&tolua_err)
00410  )
00411   goto tolua_lerror;
00412  else
00413 #endif
00414  {
00415   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00416 #ifndef TOLUA_RELEASE
00417   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'",NULL);
00418 #endif
00419   {
00420    size_t tolua_ret = (size_t)  self->hash_size();
00421    {
00422 #ifdef __cplusplus
00423     void* tolua_obj = new size_t(tolua_ret);
00424     tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"size_t");
00425 #else
00426     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(size_t));
00427     tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"size_t");
00428 #endif
00429    }
00430   }
00431  }
00432  return 1;
00433 #ifndef TOLUA_RELEASE
00434  tolua_lerror:
00435  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
00436  return 0;
00437 #endif
00438 }
00439 #endif //#ifndef TOLUA_DISABLE
00440 
00441 /* method: hash_printable of class  fawkes::Interface */
00442 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_hash_printable00
00443 static int tolua_fawkesinterface_fawkes_Interface_hash_printable00(lua_State* tolua_S)
00444 {
00445 #ifndef TOLUA_RELEASE
00446  tolua_Error tolua_err;
00447  if (
00448      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00449      !tolua_isnoobj(tolua_S,2,&tolua_err)
00450  )
00451   goto tolua_lerror;
00452  else
00453 #endif
00454  {
00455   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00456 #ifndef TOLUA_RELEASE
00457   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'",NULL);
00458 #endif
00459   {
00460    const char* tolua_ret = (const char*)  self->hash_printable();
00461    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00462   }
00463  }
00464  return 1;
00465 #ifndef TOLUA_RELEASE
00466  tolua_lerror:
00467  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
00468  return 0;
00469 #endif
00470 }
00471 #endif //#ifndef TOLUA_DISABLE
00472 
00473 /* method: is_writer of class  fawkes::Interface */
00474 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_is_writer00
00475 static int tolua_fawkesinterface_fawkes_Interface_is_writer00(lua_State* tolua_S)
00476 {
00477 #ifndef TOLUA_RELEASE
00478  tolua_Error tolua_err;
00479  if (
00480      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00481      !tolua_isnoobj(tolua_S,2,&tolua_err)
00482  )
00483   goto tolua_lerror;
00484  else
00485 #endif
00486  {
00487   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00488 #ifndef TOLUA_RELEASE
00489   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'",NULL);
00490 #endif
00491   {
00492    bool tolua_ret = (bool)  self->is_writer();
00493    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00494   }
00495  }
00496  return 1;
00497 #ifndef TOLUA_RELEASE
00498  tolua_lerror:
00499  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
00500  return 0;
00501 #endif
00502 }
00503 #endif //#ifndef TOLUA_DISABLE
00504 
00505 /* method: set_from_chunk of class  fawkes::Interface */
00506 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_set_from_chunk00
00507 static int tolua_fawkesinterface_fawkes_Interface_set_from_chunk00(lua_State* tolua_S)
00508 {
00509 #ifndef TOLUA_RELEASE
00510  tolua_Error tolua_err;
00511  if (
00512      !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
00513      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
00514      !tolua_isnoobj(tolua_S,3,&tolua_err)
00515  )
00516   goto tolua_lerror;
00517  else
00518 #endif
00519  {
00520   fawkes::Interface* self = (fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00521   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
00522 #ifndef TOLUA_RELEASE
00523   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'",NULL);
00524 #endif
00525   {
00526    self->set_from_chunk(chunk);
00527   }
00528  }
00529  return 0;
00530 #ifndef TOLUA_RELEASE
00531  tolua_lerror:
00532  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
00533  return 0;
00534 #endif
00535 }
00536 #endif //#ifndef TOLUA_DISABLE
00537 
00538 /* method: create_message of class  fawkes::Interface */
00539 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_create_message00
00540 static int tolua_fawkesinterface_fawkes_Interface_create_message00(lua_State* tolua_S)
00541 {
00542 #ifndef TOLUA_RELEASE
00543  tolua_Error tolua_err;
00544  if (
00545      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00546      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00547      !tolua_isnoobj(tolua_S,3,&tolua_err)
00548  )
00549   goto tolua_lerror;
00550  else
00551 #endif
00552  {
00553   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00554   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
00555 #ifndef TOLUA_RELEASE
00556   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'",NULL);
00557 #endif
00558   {
00559    fawkes::Message* tolua_ret = (fawkes::Message*)  self->create_message(type);
00560    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
00561   }
00562  }
00563  return 1;
00564 #ifndef TOLUA_RELEASE
00565  tolua_lerror:
00566  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
00567  return 0;
00568 #endif
00569 }
00570 #endif //#ifndef TOLUA_DISABLE
00571 
00572 /* method: read of class  fawkes::Interface */
00573 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_read00
00574 static int tolua_fawkesinterface_fawkes_Interface_read00(lua_State* tolua_S)
00575 {
00576 #ifndef TOLUA_RELEASE
00577  tolua_Error tolua_err;
00578  if (
00579      !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
00580      !tolua_isnoobj(tolua_S,2,&tolua_err)
00581  )
00582   goto tolua_lerror;
00583  else
00584 #endif
00585  {
00586   fawkes::Interface* self = (fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00587 #ifndef TOLUA_RELEASE
00588   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'",NULL);
00589 #endif
00590   {
00591    self->read();
00592   }
00593  }
00594  return 0;
00595 #ifndef TOLUA_RELEASE
00596  tolua_lerror:
00597  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
00598  return 0;
00599 #endif
00600 }
00601 #endif //#ifndef TOLUA_DISABLE
00602 
00603 /* method: write of class  fawkes::Interface */
00604 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_write00
00605 static int tolua_fawkesinterface_fawkes_Interface_write00(lua_State* tolua_S)
00606 {
00607 #ifndef TOLUA_RELEASE
00608  tolua_Error tolua_err;
00609  if (
00610      !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
00611      !tolua_isnoobj(tolua_S,2,&tolua_err)
00612  )
00613   goto tolua_lerror;
00614  else
00615 #endif
00616  {
00617   fawkes::Interface* self = (fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00618 #ifndef TOLUA_RELEASE
00619   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'",NULL);
00620 #endif
00621   {
00622    self->write();
00623   }
00624  }
00625  return 0;
00626 #ifndef TOLUA_RELEASE
00627  tolua_lerror:
00628  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
00629  return 0;
00630 #endif
00631 }
00632 #endif //#ifndef TOLUA_DISABLE
00633 
00634 /* method: has_writer of class  fawkes::Interface */
00635 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_has_writer00
00636 static int tolua_fawkesinterface_fawkes_Interface_has_writer00(lua_State* tolua_S)
00637 {
00638 #ifndef TOLUA_RELEASE
00639  tolua_Error tolua_err;
00640  if (
00641      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00642      !tolua_isnoobj(tolua_S,2,&tolua_err)
00643  )
00644   goto tolua_lerror;
00645  else
00646 #endif
00647  {
00648   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00649 #ifndef TOLUA_RELEASE
00650   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'",NULL);
00651 #endif
00652   {
00653    bool tolua_ret = (bool)  self->has_writer();
00654    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00655   }
00656  }
00657  return 1;
00658 #ifndef TOLUA_RELEASE
00659  tolua_lerror:
00660  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
00661  return 0;
00662 #endif
00663 }
00664 #endif //#ifndef TOLUA_DISABLE
00665 
00666 /* method: num_readers of class  fawkes::Interface */
00667 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_num_readers00
00668 static int tolua_fawkesinterface_fawkes_Interface_num_readers00(lua_State* tolua_S)
00669 {
00670 #ifndef TOLUA_RELEASE
00671  tolua_Error tolua_err;
00672  if (
00673      !tolua_isusertype(tolua_S,1,"const fawkes::Interface",0,&tolua_err) ||
00674      !tolua_isnoobj(tolua_S,2,&tolua_err)
00675  )
00676   goto tolua_lerror;
00677  else
00678 #endif
00679  {
00680   const fawkes::Interface* self = (const fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00681 #ifndef TOLUA_RELEASE
00682   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'",NULL);
00683 #endif
00684   {
00685    unsigned int tolua_ret = (unsigned int)  self->num_readers();
00686    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00687   }
00688  }
00689  return 1;
00690 #ifndef TOLUA_RELEASE
00691  tolua_lerror:
00692  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
00693  return 0;
00694 #endif
00695 }
00696 #endif //#ifndef TOLUA_DISABLE
00697 
00698 /* method: msgq_enqueue_copy of class  fawkes::Interface */
00699 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_enqueue_copy00
00700 static int tolua_fawkesinterface_fawkes_Interface_msgq_enqueue_copy00(lua_State* tolua_S)
00701 {
00702 #ifndef TOLUA_RELEASE
00703  tolua_Error tolua_err;
00704  if (
00705      !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
00706      !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) ||
00707      !tolua_isnoobj(tolua_S,3,&tolua_err)
00708  )
00709   goto tolua_lerror;
00710  else
00711 #endif
00712  {
00713   fawkes::Interface* self = (fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00714   fawkes::Message* message = ((fawkes::Message*)  tolua_tousertype(tolua_S,2,0));
00715 #ifndef TOLUA_RELEASE
00716   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'",NULL);
00717 #endif
00718   {
00719    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
00720    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00721   }
00722  }
00723  return 1;
00724 #ifndef TOLUA_RELEASE
00725  tolua_lerror:
00726  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
00727  return 0;
00728 #endif
00729 }
00730 #endif //#ifndef TOLUA_DISABLE
00731 
00732 /* method: msgq_remove of class  fawkes::Interface */
00733 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_remove00
00734 static int tolua_fawkesinterface_fawkes_Interface_msgq_remove00(lua_State* tolua_S)
00735 {
00736 #ifndef TOLUA_RELEASE
00737  tolua_Error tolua_err;
00738  if (
00739      !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
00740      !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) ||
00741      !tolua_isnoobj(tolua_S,3,&tolua_err)
00742  )
00743   goto tolua_lerror;
00744  else
00745 #endif
00746  {
00747   fawkes::Interface* self = (fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00748   fawkes::Message* message = ((fawkes::Message*)  tolua_tousertype(tolua_S,2,0));
00749 #ifndef TOLUA_RELEASE
00750   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
00751 #endif
00752   {
00753    self->msgq_remove(message);
00754   }
00755  }
00756  return 0;
00757 #ifndef TOLUA_RELEASE
00758  tolua_lerror:
00759  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
00760  return 0;
00761 #endif
00762 }
00763 #endif //#ifndef TOLUA_DISABLE
00764 
00765 /* method: msgq_remove of class  fawkes::Interface */
00766 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_remove01
00767 static int tolua_fawkesinterface_fawkes_Interface_msgq_remove01(lua_State* tolua_S)
00768 {
00769  tolua_Error tolua_err;
00770  if (
00771      !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
00772      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00773      !tolua_isnoobj(tolua_S,3,&tolua_err)
00774  )
00775   goto tolua_lerror;
00776  else
00777  {
00778   fawkes::Interface* self = (fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00779   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
00780 #ifndef TOLUA_RELEASE
00781   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
00782 #endif
00783   {
00784    self->msgq_remove(message_id);
00785   }
00786  }
00787  return 0;
00788 tolua_lerror:
00789  return tolua_fawkesinterface_fawkes_Interface_msgq_remove00(tolua_S);
00790 }
00791 #endif //#ifndef TOLUA_DISABLE
00792 
00793 /* method: msgq_size of class  fawkes::Interface */
00794 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_size00
00795 static int tolua_fawkesinterface_fawkes_Interface_msgq_size00(lua_State* tolua_S)
00796 {
00797 #ifndef TOLUA_RELEASE
00798  tolua_Error tolua_err;
00799  if (
00800      !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
00801      !tolua_isnoobj(tolua_S,2,&tolua_err)
00802  )
00803   goto tolua_lerror;
00804  else
00805 #endif
00806  {
00807   fawkes::Interface* self = (fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00808 #ifndef TOLUA_RELEASE
00809   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'",NULL);
00810 #endif
00811   {
00812    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
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 'msgq_size'.",&tolua_err);
00820  return 0;
00821 #endif
00822 }
00823 #endif //#ifndef TOLUA_DISABLE
00824 
00825 /* method: msgq_flush of class  fawkes::Interface */
00826 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_flush00
00827 static int tolua_fawkesinterface_fawkes_Interface_msgq_flush00(lua_State* tolua_S)
00828 {
00829 #ifndef TOLUA_RELEASE
00830  tolua_Error tolua_err;
00831  if (
00832      !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
00833      !tolua_isnoobj(tolua_S,2,&tolua_err)
00834  )
00835   goto tolua_lerror;
00836  else
00837 #endif
00838  {
00839   fawkes::Interface* self = (fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00840 #ifndef TOLUA_RELEASE
00841   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'",NULL);
00842 #endif
00843   {
00844    self->msgq_flush();
00845   }
00846  }
00847  return 0;
00848 #ifndef TOLUA_RELEASE
00849  tolua_lerror:
00850  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
00851  return 0;
00852 #endif
00853 }
00854 #endif //#ifndef TOLUA_DISABLE
00855 
00856 /* method: msgq_lock of class  fawkes::Interface */
00857 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_lock00
00858 static int tolua_fawkesinterface_fawkes_Interface_msgq_lock00(lua_State* tolua_S)
00859 {
00860 #ifndef TOLUA_RELEASE
00861  tolua_Error tolua_err;
00862  if (
00863      !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
00864      !tolua_isnoobj(tolua_S,2,&tolua_err)
00865  )
00866   goto tolua_lerror;
00867  else
00868 #endif
00869  {
00870   fawkes::Interface* self = (fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00871 #ifndef TOLUA_RELEASE
00872   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'",NULL);
00873 #endif
00874   {
00875    self->msgq_lock();
00876   }
00877  }
00878  return 0;
00879 #ifndef TOLUA_RELEASE
00880  tolua_lerror:
00881  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
00882  return 0;
00883 #endif
00884 }
00885 #endif //#ifndef TOLUA_DISABLE
00886 
00887 /* method: msgq_try_lock of class  fawkes::Interface */
00888 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_try_lock00
00889 static int tolua_fawkesinterface_fawkes_Interface_msgq_try_lock00(lua_State* tolua_S)
00890 {
00891 #ifndef TOLUA_RELEASE
00892  tolua_Error tolua_err;
00893  if (
00894      !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
00895      !tolua_isnoobj(tolua_S,2,&tolua_err)
00896  )
00897   goto tolua_lerror;
00898  else
00899 #endif
00900  {
00901   fawkes::Interface* self = (fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00902 #ifndef TOLUA_RELEASE
00903   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'",NULL);
00904 #endif
00905   {
00906    bool tolua_ret = (bool)  self->msgq_try_lock();
00907    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00908   }
00909  }
00910  return 1;
00911 #ifndef TOLUA_RELEASE
00912  tolua_lerror:
00913  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
00914  return 0;
00915 #endif
00916 }
00917 #endif //#ifndef TOLUA_DISABLE
00918 
00919 /* method: msgq_unlock of class  fawkes::Interface */
00920 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_unlock00
00921 static int tolua_fawkesinterface_fawkes_Interface_msgq_unlock00(lua_State* tolua_S)
00922 {
00923 #ifndef TOLUA_RELEASE
00924  tolua_Error tolua_err;
00925  if (
00926      !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
00927      !tolua_isnoobj(tolua_S,2,&tolua_err)
00928  )
00929   goto tolua_lerror;
00930  else
00931 #endif
00932  {
00933   fawkes::Interface* self = (fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00934 #ifndef TOLUA_RELEASE
00935   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'",NULL);
00936 #endif
00937   {
00938    self->msgq_unlock();
00939   }
00940  }
00941  return 0;
00942 #ifndef TOLUA_RELEASE
00943  tolua_lerror:
00944  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
00945  return 0;
00946 #endif
00947 }
00948 #endif //#ifndef TOLUA_DISABLE
00949 
00950 /* method: msgq_pop of class  fawkes::Interface */
00951 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_pop00
00952 static int tolua_fawkesinterface_fawkes_Interface_msgq_pop00(lua_State* tolua_S)
00953 {
00954 #ifndef TOLUA_RELEASE
00955  tolua_Error tolua_err;
00956  if (
00957      !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
00958      !tolua_isnoobj(tolua_S,2,&tolua_err)
00959  )
00960   goto tolua_lerror;
00961  else
00962 #endif
00963  {
00964   fawkes::Interface* self = (fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00965 #ifndef TOLUA_RELEASE
00966   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'",NULL);
00967 #endif
00968   {
00969    self->msgq_pop();
00970   }
00971  }
00972  return 0;
00973 #ifndef TOLUA_RELEASE
00974  tolua_lerror:
00975  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
00976  return 0;
00977 #endif
00978 }
00979 #endif //#ifndef TOLUA_DISABLE
00980 
00981 /* method: msgq_first of class  fawkes::Interface */
00982 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_first00
00983 static int tolua_fawkesinterface_fawkes_Interface_msgq_first00(lua_State* tolua_S)
00984 {
00985 #ifndef TOLUA_RELEASE
00986  tolua_Error tolua_err;
00987  if (
00988      !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
00989      !tolua_isnoobj(tolua_S,2,&tolua_err)
00990  )
00991   goto tolua_lerror;
00992  else
00993 #endif
00994  {
00995   fawkes::Interface* self = (fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
00996 #ifndef TOLUA_RELEASE
00997   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'",NULL);
00998 #endif
00999   {
01000    fawkes::Message* tolua_ret = (fawkes::Message*)  self->msgq_first();
01001    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
01002   }
01003  }
01004  return 1;
01005 #ifndef TOLUA_RELEASE
01006  tolua_lerror:
01007  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
01008  return 0;
01009 #endif
01010 }
01011 #endif //#ifndef TOLUA_DISABLE
01012 
01013 /* method: msgq_empty of class  fawkes::Interface */
01014 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Interface_msgq_empty00
01015 static int tolua_fawkesinterface_fawkes_Interface_msgq_empty00(lua_State* tolua_S)
01016 {
01017 #ifndef TOLUA_RELEASE
01018  tolua_Error tolua_err;
01019  if (
01020      !tolua_isusertype(tolua_S,1,"fawkes::Interface",0,&tolua_err) ||
01021      !tolua_isnoobj(tolua_S,2,&tolua_err)
01022  )
01023   goto tolua_lerror;
01024  else
01025 #endif
01026  {
01027   fawkes::Interface* self = (fawkes::Interface*)  tolua_tousertype(tolua_S,1,0);
01028 #ifndef TOLUA_RELEASE
01029   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'",NULL);
01030 #endif
01031   {
01032    bool tolua_ret = (bool)  self->msgq_empty();
01033    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01034   }
01035  }
01036  return 1;
01037 #ifndef TOLUA_RELEASE
01038  tolua_lerror:
01039  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
01040  return 0;
01041 #endif
01042 }
01043 #endif //#ifndef TOLUA_DISABLE
01044 
01045 /* method: new of class  fawkes::MessageQueue */
01046 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_new00
01047 static int tolua_fawkesinterface_fawkes_MessageQueue_new00(lua_State* tolua_S)
01048 {
01049 #ifndef TOLUA_RELEASE
01050  tolua_Error tolua_err;
01051  if (
01052      !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01053      !tolua_isnoobj(tolua_S,2,&tolua_err)
01054  )
01055   goto tolua_lerror;
01056  else
01057 #endif
01058  {
01059   {
01060    fawkes::MessageQueue* tolua_ret = (fawkes::MessageQueue*)  new fawkes::MessageQueue();
01061    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue");
01062   }
01063  }
01064  return 1;
01065 #ifndef TOLUA_RELEASE
01066  tolua_lerror:
01067  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01068  return 0;
01069 #endif
01070 }
01071 #endif //#ifndef TOLUA_DISABLE
01072 
01073 /* method: new_local of class  fawkes::MessageQueue */
01074 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_new00_local
01075 static int tolua_fawkesinterface_fawkes_MessageQueue_new00_local(lua_State* tolua_S)
01076 {
01077 #ifndef TOLUA_RELEASE
01078  tolua_Error tolua_err;
01079  if (
01080      !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01081      !tolua_isnoobj(tolua_S,2,&tolua_err)
01082  )
01083   goto tolua_lerror;
01084  else
01085 #endif
01086  {
01087   {
01088    fawkes::MessageQueue* tolua_ret = (fawkes::MessageQueue*)  new fawkes::MessageQueue();
01089    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MessageQueue");
01090   }
01091  }
01092  return 1;
01093 #ifndef TOLUA_RELEASE
01094  tolua_lerror:
01095  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01096  return 0;
01097 #endif
01098 }
01099 #endif //#ifndef TOLUA_DISABLE
01100 
01101 /* method: delete of class  fawkes::MessageQueue */
01102 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_delete00
01103 static int tolua_fawkesinterface_fawkes_MessageQueue_delete00(lua_State* tolua_S)
01104 {
01105 #ifndef TOLUA_RELEASE
01106  tolua_Error tolua_err;
01107  if (
01108      !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01109      !tolua_isnoobj(tolua_S,2,&tolua_err)
01110  )
01111   goto tolua_lerror;
01112  else
01113 #endif
01114  {
01115   fawkes::MessageQueue* self = (fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01116 #ifndef TOLUA_RELEASE
01117   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
01118 #endif
01119   delete self;
01120  }
01121  return 0;
01122 #ifndef TOLUA_RELEASE
01123  tolua_lerror:
01124  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01125  return 0;
01126 #endif
01127 }
01128 #endif //#ifndef TOLUA_DISABLE
01129 
01130 /* method: new of class  MessageIterator */
01131 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00
01132 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00(lua_State* tolua_S)
01133 {
01134 #ifndef TOLUA_RELEASE
01135  tolua_Error tolua_err;
01136  if (
01137      !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
01138      !tolua_isnoobj(tolua_S,2,&tolua_err)
01139  )
01140   goto tolua_lerror;
01141  else
01142 #endif
01143  {
01144   {
01145    fawkes::MessageQueue::MessageIterator* tolua_ret = (fawkes::MessageQueue::MessageIterator*)  new fawkes::MessageQueue::MessageIterator();
01146    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue::MessageIterator");
01147   }
01148  }
01149  return 1;
01150 #ifndef TOLUA_RELEASE
01151  tolua_lerror:
01152  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01153  return 0;
01154 #endif
01155 }
01156 #endif //#ifndef TOLUA_DISABLE
01157 
01158 /* method: new_local of class  MessageIterator */
01159 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local
01160 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local(lua_State* tolua_S)
01161 {
01162 #ifndef TOLUA_RELEASE
01163  tolua_Error tolua_err;
01164  if (
01165      !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
01166      !tolua_isnoobj(tolua_S,2,&tolua_err)
01167  )
01168   goto tolua_lerror;
01169  else
01170 #endif
01171  {
01172   {
01173    fawkes::MessageQueue::MessageIterator* tolua_ret = (fawkes::MessageQueue::MessageIterator*)  new fawkes::MessageQueue::MessageIterator();
01174    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MessageQueue::MessageIterator");
01175   }
01176  }
01177  return 1;
01178 #ifndef TOLUA_RELEASE
01179  tolua_lerror:
01180  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01181  return 0;
01182 #endif
01183 }
01184 #endif //#ifndef TOLUA_DISABLE
01185 
01186 /* method: new of class  MessageIterator */
01187 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01
01188 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01(lua_State* tolua_S)
01189 {
01190  tolua_Error tolua_err;
01191  if (
01192      !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
01193      !tolua_isusertype(tolua_S,2,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
01194      !tolua_isnoobj(tolua_S,3,&tolua_err)
01195  )
01196   goto tolua_lerror;
01197  else
01198  {
01199   const fawkes::MessageQueue::MessageIterator* it = ((const fawkes::MessageQueue::MessageIterator*)  tolua_tousertype(tolua_S,2,0));
01200   {
01201    fawkes::MessageQueue::MessageIterator* tolua_ret = (fawkes::MessageQueue::MessageIterator*)  new fawkes::MessageQueue::MessageIterator(*it);
01202    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MessageQueue::MessageIterator");
01203   }
01204  }
01205  return 1;
01206 tolua_lerror:
01207  return tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00(tolua_S);
01208 }
01209 #endif //#ifndef TOLUA_DISABLE
01210 
01211 /* method: new_local of class  MessageIterator */
01212 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local
01213 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local(lua_State* tolua_S)
01214 {
01215  tolua_Error tolua_err;
01216  if (
01217      !tolua_isusertable(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
01218      !tolua_isusertype(tolua_S,2,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
01219      !tolua_isnoobj(tolua_S,3,&tolua_err)
01220  )
01221   goto tolua_lerror;
01222  else
01223  {
01224   const fawkes::MessageQueue::MessageIterator* it = ((const fawkes::MessageQueue::MessageIterator*)  tolua_tousertype(tolua_S,2,0));
01225   {
01226    fawkes::MessageQueue::MessageIterator* tolua_ret = (fawkes::MessageQueue::MessageIterator*)  new fawkes::MessageQueue::MessageIterator(*it);
01227    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MessageQueue::MessageIterator");
01228   }
01229  }
01230  return 1;
01231 tolua_lerror:
01232  return tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local(tolua_S);
01233 }
01234 #endif //#ifndef TOLUA_DISABLE
01235 
01236 /* method: operator+ of class  MessageIterator */
01237 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__add00
01238 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__add00(lua_State* tolua_S)
01239 {
01240 #ifndef TOLUA_RELEASE
01241  tolua_Error tolua_err;
01242  if (
01243      !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
01244      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01245      !tolua_isnoobj(tolua_S,3,&tolua_err)
01246  )
01247   goto tolua_lerror;
01248  else
01249 #endif
01250  {
01251   fawkes::MessageQueue::MessageIterator* self = (fawkes::MessageQueue::MessageIterator*)  tolua_tousertype(tolua_S,1,0);
01252   unsigned int i = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
01253 #ifndef TOLUA_RELEASE
01254   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'",NULL);
01255 #endif
01256   {
01257    fawkes::MessageQueue::MessageIterator& tolua_ret = (fawkes::MessageQueue::MessageIterator&)  self->operator+(i);
01258    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::MessageQueue::MessageIterator");
01259   }
01260  }
01261  return 1;
01262 #ifndef TOLUA_RELEASE
01263  tolua_lerror:
01264  tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
01265  return 0;
01266 #endif
01267 }
01268 #endif //#ifndef TOLUA_DISABLE
01269 
01270 /* method: operator== of class  MessageIterator */
01271 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__eq00
01272 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__eq00(lua_State* tolua_S)
01273 {
01274 #ifndef TOLUA_RELEASE
01275  tolua_Error tolua_err;
01276  if (
01277      !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
01278      !tolua_isusertype(tolua_S,2,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
01279      !tolua_isnoobj(tolua_S,3,&tolua_err)
01280  )
01281   goto tolua_lerror;
01282  else
01283 #endif
01284  {
01285   const fawkes::MessageQueue::MessageIterator* self = (const fawkes::MessageQueue::MessageIterator*)  tolua_tousertype(tolua_S,1,0);
01286   const fawkes::MessageQueue::MessageIterator* c = ((const fawkes::MessageQueue::MessageIterator*)  tolua_tousertype(tolua_S,2,0));
01287 #ifndef TOLUA_RELEASE
01288   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
01289 #endif
01290   {
01291    bool tolua_ret = (bool)  self->operator==(*c);
01292    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01293   }
01294  }
01295  return 1;
01296 #ifndef TOLUA_RELEASE
01297  tolua_lerror:
01298  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
01299  return 0;
01300 #endif
01301 }
01302 #endif //#ifndef TOLUA_DISABLE
01303 
01304 /* method: operator* of class  MessageIterator */
01305 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__mul00
01306 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__mul00(lua_State* tolua_S)
01307 {
01308 #ifndef TOLUA_RELEASE
01309  tolua_Error tolua_err;
01310  if (
01311      !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
01312      !tolua_isnoobj(tolua_S,2,&tolua_err)
01313  )
01314   goto tolua_lerror;
01315  else
01316 #endif
01317  {
01318   const fawkes::MessageQueue::MessageIterator* self = (const fawkes::MessageQueue::MessageIterator*)  tolua_tousertype(tolua_S,1,0);
01319 #ifndef TOLUA_RELEASE
01320   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
01321 #endif
01322   {
01323    fawkes::Message* tolua_ret = (fawkes::Message*)  self->operator*();
01324    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
01325   }
01326  }
01327  return 1;
01328 #ifndef TOLUA_RELEASE
01329  tolua_lerror:
01330  tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
01331  return 0;
01332 #endif
01333 }
01334 #endif //#ifndef TOLUA_DISABLE
01335 
01336 /* method: id of class  MessageIterator */
01337 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_id00
01338 static int tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_id00(lua_State* tolua_S)
01339 {
01340 #ifndef TOLUA_RELEASE
01341  tolua_Error tolua_err;
01342  if (
01343      !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
01344      !tolua_isnoobj(tolua_S,2,&tolua_err)
01345  )
01346   goto tolua_lerror;
01347  else
01348 #endif
01349  {
01350   const fawkes::MessageQueue::MessageIterator* self = (const fawkes::MessageQueue::MessageIterator*)  tolua_tousertype(tolua_S,1,0);
01351 #ifndef TOLUA_RELEASE
01352   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'",NULL);
01353 #endif
01354   {
01355    unsigned int tolua_ret = (unsigned int)  self->id();
01356    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01357   }
01358  }
01359  return 1;
01360 #ifndef TOLUA_RELEASE
01361  tolua_lerror:
01362  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
01363  return 0;
01364 #endif
01365 }
01366 #endif //#ifndef TOLUA_DISABLE
01367 
01368 /* method: append of class  fawkes::MessageQueue */
01369 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_append00
01370 static int tolua_fawkesinterface_fawkes_MessageQueue_append00(lua_State* tolua_S)
01371 {
01372 #ifndef TOLUA_RELEASE
01373  tolua_Error tolua_err;
01374  if (
01375      !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01376      !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) ||
01377      !tolua_isnoobj(tolua_S,3,&tolua_err)
01378  )
01379   goto tolua_lerror;
01380  else
01381 #endif
01382  {
01383   fawkes::MessageQueue* self = (fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01384   fawkes::Message* msg = ((fawkes::Message*)  tolua_tousertype(tolua_S,2,0));
01385 #ifndef TOLUA_RELEASE
01386   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'append'",NULL);
01387 #endif
01388   {
01389    self->append(msg);
01390   }
01391  }
01392  return 0;
01393 #ifndef TOLUA_RELEASE
01394  tolua_lerror:
01395  tolua_error(tolua_S,"#ferror in function 'append'.",&tolua_err);
01396  return 0;
01397 #endif
01398 }
01399 #endif //#ifndef TOLUA_DISABLE
01400 
01401 /* method: remove of class  fawkes::MessageQueue */
01402 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_remove00
01403 static int tolua_fawkesinterface_fawkes_MessageQueue_remove00(lua_State* tolua_S)
01404 {
01405 #ifndef TOLUA_RELEASE
01406  tolua_Error tolua_err;
01407  if (
01408      !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01409      !tolua_isusertype(tolua_S,2,"const fawkes::Message",0,&tolua_err) ||
01410      !tolua_isnoobj(tolua_S,3,&tolua_err)
01411  )
01412   goto tolua_lerror;
01413  else
01414 #endif
01415  {
01416   fawkes::MessageQueue* self = (fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01417   const fawkes::Message* msg = ((const fawkes::Message*)  tolua_tousertype(tolua_S,2,0));
01418 #ifndef TOLUA_RELEASE
01419   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'",NULL);
01420 #endif
01421   {
01422    self->remove(msg);
01423   }
01424  }
01425  return 0;
01426 #ifndef TOLUA_RELEASE
01427  tolua_lerror:
01428  tolua_error(tolua_S,"#ferror in function 'remove'.",&tolua_err);
01429  return 0;
01430 #endif
01431 }
01432 #endif //#ifndef TOLUA_DISABLE
01433 
01434 /* method: remove of class  fawkes::MessageQueue */
01435 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_remove01
01436 static int tolua_fawkesinterface_fawkes_MessageQueue_remove01(lua_State* tolua_S)
01437 {
01438  tolua_Error tolua_err;
01439  if (
01440      !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01441      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01442      !tolua_isnoobj(tolua_S,3,&tolua_err)
01443  )
01444   goto tolua_lerror;
01445  else
01446  {
01447   fawkes::MessageQueue* self = (fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01448   unsigned const int msg_id = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
01449 #ifndef TOLUA_RELEASE
01450   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'",NULL);
01451 #endif
01452   {
01453    self->remove(msg_id);
01454   }
01455  }
01456  return 0;
01457 tolua_lerror:
01458  return tolua_fawkesinterface_fawkes_MessageQueue_remove00(tolua_S);
01459 }
01460 #endif //#ifndef TOLUA_DISABLE
01461 
01462 /* method: insert_after of class  fawkes::MessageQueue */
01463 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_insert_after00
01464 static int tolua_fawkesinterface_fawkes_MessageQueue_insert_after00(lua_State* tolua_S)
01465 {
01466 #ifndef TOLUA_RELEASE
01467  tolua_Error tolua_err;
01468  if (
01469      !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01470      !tolua_isusertype(tolua_S,2,"const fawkes::MessageQueue::MessageIterator",0,&tolua_err) ||
01471      !tolua_isusertype(tolua_S,3,"fawkes::Message",0,&tolua_err) ||
01472      !tolua_isnoobj(tolua_S,4,&tolua_err)
01473  )
01474   goto tolua_lerror;
01475  else
01476 #endif
01477  {
01478   fawkes::MessageQueue* self = (fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01479   const fawkes::MessageQueue::MessageIterator* it = ((const fawkes::MessageQueue::MessageIterator*)  tolua_tousertype(tolua_S,2,0));
01480   fawkes::Message* msg = ((fawkes::Message*)  tolua_tousertype(tolua_S,3,0));
01481 #ifndef TOLUA_RELEASE
01482   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insert_after'",NULL);
01483 #endif
01484   {
01485    self->insert_after(*it,msg);
01486   }
01487  }
01488  return 0;
01489 #ifndef TOLUA_RELEASE
01490  tolua_lerror:
01491  tolua_error(tolua_S,"#ferror in function 'insert_after'.",&tolua_err);
01492  return 0;
01493 #endif
01494 }
01495 #endif //#ifndef TOLUA_DISABLE
01496 
01497 /* method: size of class  fawkes::MessageQueue */
01498 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_size00
01499 static int tolua_fawkesinterface_fawkes_MessageQueue_size00(lua_State* tolua_S)
01500 {
01501 #ifndef TOLUA_RELEASE
01502  tolua_Error tolua_err;
01503  if (
01504      !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue",0,&tolua_err) ||
01505      !tolua_isnoobj(tolua_S,2,&tolua_err)
01506  )
01507   goto tolua_lerror;
01508  else
01509 #endif
01510  {
01511   const fawkes::MessageQueue* self = (const fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01512 #ifndef TOLUA_RELEASE
01513   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'",NULL);
01514 #endif
01515   {
01516    unsigned int tolua_ret = (unsigned int)  self->size();
01517    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01518   }
01519  }
01520  return 1;
01521 #ifndef TOLUA_RELEASE
01522  tolua_lerror:
01523  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
01524  return 0;
01525 #endif
01526 }
01527 #endif //#ifndef TOLUA_DISABLE
01528 
01529 /* method: flush of class  fawkes::MessageQueue */
01530 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_flush00
01531 static int tolua_fawkesinterface_fawkes_MessageQueue_flush00(lua_State* tolua_S)
01532 {
01533 #ifndef TOLUA_RELEASE
01534  tolua_Error tolua_err;
01535  if (
01536      !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01537      !tolua_isnoobj(tolua_S,2,&tolua_err)
01538  )
01539   goto tolua_lerror;
01540  else
01541 #endif
01542  {
01543   fawkes::MessageQueue* self = (fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01544 #ifndef TOLUA_RELEASE
01545   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'flush'",NULL);
01546 #endif
01547   {
01548    self->flush();
01549   }
01550  }
01551  return 0;
01552 #ifndef TOLUA_RELEASE
01553  tolua_lerror:
01554  tolua_error(tolua_S,"#ferror in function 'flush'.",&tolua_err);
01555  return 0;
01556 #endif
01557 }
01558 #endif //#ifndef TOLUA_DISABLE
01559 
01560 /* method: empty of class  fawkes::MessageQueue */
01561 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_empty00
01562 static int tolua_fawkesinterface_fawkes_MessageQueue_empty00(lua_State* tolua_S)
01563 {
01564 #ifndef TOLUA_RELEASE
01565  tolua_Error tolua_err;
01566  if (
01567      !tolua_isusertype(tolua_S,1,"const fawkes::MessageQueue",0,&tolua_err) ||
01568      !tolua_isnoobj(tolua_S,2,&tolua_err)
01569  )
01570   goto tolua_lerror;
01571  else
01572 #endif
01573  {
01574   const fawkes::MessageQueue* self = (const fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01575 #ifndef TOLUA_RELEASE
01576   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'empty'",NULL);
01577 #endif
01578   {
01579    bool tolua_ret = (bool)  self->empty();
01580    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01581   }
01582  }
01583  return 1;
01584 #ifndef TOLUA_RELEASE
01585  tolua_lerror:
01586  tolua_error(tolua_S,"#ferror in function 'empty'.",&tolua_err);
01587  return 0;
01588 #endif
01589 }
01590 #endif //#ifndef TOLUA_DISABLE
01591 
01592 /* method: lock of class  fawkes::MessageQueue */
01593 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_lock00
01594 static int tolua_fawkesinterface_fawkes_MessageQueue_lock00(lua_State* tolua_S)
01595 {
01596 #ifndef TOLUA_RELEASE
01597  tolua_Error tolua_err;
01598  if (
01599      !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01600      !tolua_isnoobj(tolua_S,2,&tolua_err)
01601  )
01602   goto tolua_lerror;
01603  else
01604 #endif
01605  {
01606   fawkes::MessageQueue* self = (fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01607 #ifndef TOLUA_RELEASE
01608   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lock'",NULL);
01609 #endif
01610   {
01611    self->lock();
01612   }
01613  }
01614  return 0;
01615 #ifndef TOLUA_RELEASE
01616  tolua_lerror:
01617  tolua_error(tolua_S,"#ferror in function 'lock'.",&tolua_err);
01618  return 0;
01619 #endif
01620 }
01621 #endif //#ifndef TOLUA_DISABLE
01622 
01623 /* method: try_lock of class  fawkes::MessageQueue */
01624 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_try_lock00
01625 static int tolua_fawkesinterface_fawkes_MessageQueue_try_lock00(lua_State* tolua_S)
01626 {
01627 #ifndef TOLUA_RELEASE
01628  tolua_Error tolua_err;
01629  if (
01630      !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01631      !tolua_isnoobj(tolua_S,2,&tolua_err)
01632  )
01633   goto tolua_lerror;
01634  else
01635 #endif
01636  {
01637   fawkes::MessageQueue* self = (fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01638 #ifndef TOLUA_RELEASE
01639   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'try_lock'",NULL);
01640 #endif
01641   {
01642    bool tolua_ret = (bool)  self->try_lock();
01643    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01644   }
01645  }
01646  return 1;
01647 #ifndef TOLUA_RELEASE
01648  tolua_lerror:
01649  tolua_error(tolua_S,"#ferror in function 'try_lock'.",&tolua_err);
01650  return 0;
01651 #endif
01652 }
01653 #endif //#ifndef TOLUA_DISABLE
01654 
01655 /* method: unlock of class  fawkes::MessageQueue */
01656 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_unlock00
01657 static int tolua_fawkesinterface_fawkes_MessageQueue_unlock00(lua_State* tolua_S)
01658 {
01659 #ifndef TOLUA_RELEASE
01660  tolua_Error tolua_err;
01661  if (
01662      !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01663      !tolua_isnoobj(tolua_S,2,&tolua_err)
01664  )
01665   goto tolua_lerror;
01666  else
01667 #endif
01668  {
01669   fawkes::MessageQueue* self = (fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01670 #ifndef TOLUA_RELEASE
01671   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unlock'",NULL);
01672 #endif
01673   {
01674    self->unlock();
01675   }
01676  }
01677  return 0;
01678 #ifndef TOLUA_RELEASE
01679  tolua_lerror:
01680  tolua_error(tolua_S,"#ferror in function 'unlock'.",&tolua_err);
01681  return 0;
01682 #endif
01683 }
01684 #endif //#ifndef TOLUA_DISABLE
01685 
01686 /* method: first of class  fawkes::MessageQueue */
01687 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_first00
01688 static int tolua_fawkesinterface_fawkes_MessageQueue_first00(lua_State* tolua_S)
01689 {
01690 #ifndef TOLUA_RELEASE
01691  tolua_Error tolua_err;
01692  if (
01693      !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01694      !tolua_isnoobj(tolua_S,2,&tolua_err)
01695  )
01696   goto tolua_lerror;
01697  else
01698 #endif
01699  {
01700   fawkes::MessageQueue* self = (fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01701 #ifndef TOLUA_RELEASE
01702   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'first'",NULL);
01703 #endif
01704   {
01705    fawkes::Message* tolua_ret = (fawkes::Message*)  self->first();
01706    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
01707   }
01708  }
01709  return 1;
01710 #ifndef TOLUA_RELEASE
01711  tolua_lerror:
01712  tolua_error(tolua_S,"#ferror in function 'first'.",&tolua_err);
01713  return 0;
01714 #endif
01715 }
01716 #endif //#ifndef TOLUA_DISABLE
01717 
01718 /* method: pop of class  fawkes::MessageQueue */
01719 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_pop00
01720 static int tolua_fawkesinterface_fawkes_MessageQueue_pop00(lua_State* tolua_S)
01721 {
01722 #ifndef TOLUA_RELEASE
01723  tolua_Error tolua_err;
01724  if (
01725      !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01726      !tolua_isnoobj(tolua_S,2,&tolua_err)
01727  )
01728   goto tolua_lerror;
01729  else
01730 #endif
01731  {
01732   fawkes::MessageQueue* self = (fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01733 #ifndef TOLUA_RELEASE
01734   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pop'",NULL);
01735 #endif
01736   {
01737    self->pop();
01738   }
01739  }
01740  return 0;
01741 #ifndef TOLUA_RELEASE
01742  tolua_lerror:
01743  tolua_error(tolua_S,"#ferror in function 'pop'.",&tolua_err);
01744  return 0;
01745 #endif
01746 }
01747 #endif //#ifndef TOLUA_DISABLE
01748 
01749 /* method: begin of class  fawkes::MessageQueue */
01750 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_begin00
01751 static int tolua_fawkesinterface_fawkes_MessageQueue_begin00(lua_State* tolua_S)
01752 {
01753 #ifndef TOLUA_RELEASE
01754  tolua_Error tolua_err;
01755  if (
01756      !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01757      !tolua_isnoobj(tolua_S,2,&tolua_err)
01758  )
01759   goto tolua_lerror;
01760  else
01761 #endif
01762  {
01763   fawkes::MessageQueue* self = (fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01764 #ifndef TOLUA_RELEASE
01765   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'begin'",NULL);
01766 #endif
01767   {
01768    fawkes::MessageQueue::MessageIterator tolua_ret = (fawkes::MessageQueue::MessageIterator)  self->begin();
01769    {
01770 #ifdef __cplusplus
01771     void* tolua_obj = new fawkes::MessageQueue::MessageIterator(tolua_ret);
01772     tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"fawkes::MessageQueue::MessageIterator");
01773 #else
01774     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::MessageQueue::MessageIterator));
01775     tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"fawkes::MessageQueue::MessageIterator");
01776 #endif
01777    }
01778   }
01779  }
01780  return 1;
01781 #ifndef TOLUA_RELEASE
01782  tolua_lerror:
01783  tolua_error(tolua_S,"#ferror in function 'begin'.",&tolua_err);
01784  return 0;
01785 #endif
01786 }
01787 #endif //#ifndef TOLUA_DISABLE
01788 
01789 /* method: end of class  fawkes::MessageQueue */
01790 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_MessageQueue_end00
01791 static int tolua_fawkesinterface_fawkes_MessageQueue_end00(lua_State* tolua_S)
01792 {
01793 #ifndef TOLUA_RELEASE
01794  tolua_Error tolua_err;
01795  if (
01796      !tolua_isusertype(tolua_S,1,"fawkes::MessageQueue",0,&tolua_err) ||
01797      !tolua_isnoobj(tolua_S,2,&tolua_err)
01798  )
01799   goto tolua_lerror;
01800  else
01801 #endif
01802  {
01803   fawkes::MessageQueue* self = (fawkes::MessageQueue*)  tolua_tousertype(tolua_S,1,0);
01804 #ifndef TOLUA_RELEASE
01805   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'end'",NULL);
01806 #endif
01807   {
01808    fawkes::MessageQueue::MessageIterator tolua_ret = (fawkes::MessageQueue::MessageIterator)  self->end();
01809    {
01810 #ifdef __cplusplus
01811     void* tolua_obj = new fawkes::MessageQueue::MessageIterator(tolua_ret);
01812     tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"fawkes::MessageQueue::MessageIterator");
01813 #else
01814     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::MessageQueue::MessageIterator));
01815     tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"fawkes::MessageQueue::MessageIterator");
01816 #endif
01817    }
01818   }
01819  }
01820  return 1;
01821 #ifndef TOLUA_RELEASE
01822  tolua_lerror:
01823  tolua_error(tolua_S,"#ferror in function 'end'.",&tolua_err);
01824  return 0;
01825 #endif
01826 }
01827 #endif //#ifndef TOLUA_DISABLE
01828 
01829 /* method: new of class  fawkes::Message */
01830 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new00
01831 static int tolua_fawkesinterface_fawkes_Message_new00(lua_State* tolua_S)
01832 {
01833 #ifndef TOLUA_RELEASE
01834  tolua_Error tolua_err;
01835  if (
01836      !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
01837      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01838      !tolua_isnoobj(tolua_S,3,&tolua_err)
01839  )
01840   goto tolua_lerror;
01841  else
01842 #endif
01843  {
01844   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
01845   {
01846    fawkes::Message* tolua_ret = (fawkes::Message*)  new fawkes::Message(type);
01847    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
01848   }
01849  }
01850  return 1;
01851 #ifndef TOLUA_RELEASE
01852  tolua_lerror:
01853  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01854  return 0;
01855 #endif
01856 }
01857 #endif //#ifndef TOLUA_DISABLE
01858 
01859 /* method: new_local of class  fawkes::Message */
01860 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new00_local
01861 static int tolua_fawkesinterface_fawkes_Message_new00_local(lua_State* tolua_S)
01862 {
01863 #ifndef TOLUA_RELEASE
01864  tolua_Error tolua_err;
01865  if (
01866      !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
01867      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01868      !tolua_isnoobj(tolua_S,3,&tolua_err)
01869  )
01870   goto tolua_lerror;
01871  else
01872 #endif
01873  {
01874   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
01875   {
01876    fawkes::Message* tolua_ret = (fawkes::Message*)  new fawkes::Message(type);
01877    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::Message");
01878   }
01879  }
01880  return 1;
01881 #ifndef TOLUA_RELEASE
01882  tolua_lerror:
01883  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01884  return 0;
01885 #endif
01886 }
01887 #endif //#ifndef TOLUA_DISABLE
01888 
01889 /* method: new of class  fawkes::Message */
01890 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new01
01891 static int tolua_fawkesinterface_fawkes_Message_new01(lua_State* tolua_S)
01892 {
01893  tolua_Error tolua_err;
01894  if (
01895      !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
01896      !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) ||
01897      !tolua_isnoobj(tolua_S,3,&tolua_err)
01898  )
01899   goto tolua_lerror;
01900  else
01901  {
01902   fawkes::Message* mesg = ((fawkes::Message*)  tolua_tousertype(tolua_S,2,0));
01903   {
01904    fawkes::Message* tolua_ret = (fawkes::Message*)  new fawkes::Message(mesg);
01905    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
01906   }
01907  }
01908  return 1;
01909 tolua_lerror:
01910  return tolua_fawkesinterface_fawkes_Message_new00(tolua_S);
01911 }
01912 #endif //#ifndef TOLUA_DISABLE
01913 
01914 /* method: new_local of class  fawkes::Message */
01915 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new01_local
01916 static int tolua_fawkesinterface_fawkes_Message_new01_local(lua_State* tolua_S)
01917 {
01918  tolua_Error tolua_err;
01919  if (
01920      !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
01921      !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) ||
01922      !tolua_isnoobj(tolua_S,3,&tolua_err)
01923  )
01924   goto tolua_lerror;
01925  else
01926  {
01927   fawkes::Message* mesg = ((fawkes::Message*)  tolua_tousertype(tolua_S,2,0));
01928   {
01929    fawkes::Message* tolua_ret = (fawkes::Message*)  new fawkes::Message(mesg);
01930    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::Message");
01931   }
01932  }
01933  return 1;
01934 tolua_lerror:
01935  return tolua_fawkesinterface_fawkes_Message_new00_local(tolua_S);
01936 }
01937 #endif //#ifndef TOLUA_DISABLE
01938 
01939 /* method: new of class  fawkes::Message */
01940 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new02
01941 static int tolua_fawkesinterface_fawkes_Message_new02(lua_State* tolua_S)
01942 {
01943  tolua_Error tolua_err;
01944  if (
01945      !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
01946      !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) ||
01947      !tolua_isnoobj(tolua_S,3,&tolua_err)
01948  )
01949   goto tolua_lerror;
01950  else
01951  {
01952   fawkes::Message* mesg = ((fawkes::Message*)  tolua_tousertype(tolua_S,2,0));
01953   {
01954    fawkes::Message* tolua_ret = (fawkes::Message*)  new fawkes::Message(*mesg);
01955    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Message");
01956   }
01957  }
01958  return 1;
01959 tolua_lerror:
01960  return tolua_fawkesinterface_fawkes_Message_new01(tolua_S);
01961 }
01962 #endif //#ifndef TOLUA_DISABLE
01963 
01964 /* method: new_local of class  fawkes::Message */
01965 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_new02_local
01966 static int tolua_fawkesinterface_fawkes_Message_new02_local(lua_State* tolua_S)
01967 {
01968  tolua_Error tolua_err;
01969  if (
01970      !tolua_isusertable(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
01971      !tolua_isusertype(tolua_S,2,"fawkes::Message",0,&tolua_err) ||
01972      !tolua_isnoobj(tolua_S,3,&tolua_err)
01973  )
01974   goto tolua_lerror;
01975  else
01976  {
01977   fawkes::Message* mesg = ((fawkes::Message*)  tolua_tousertype(tolua_S,2,0));
01978   {
01979    fawkes::Message* tolua_ret = (fawkes::Message*)  new fawkes::Message(*mesg);
01980    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::Message");
01981   }
01982  }
01983  return 1;
01984 tolua_lerror:
01985  return tolua_fawkesinterface_fawkes_Message_new01_local(tolua_S);
01986 }
01987 #endif //#ifndef TOLUA_DISABLE
01988 
01989 /* method: sender_id of class  fawkes::Message */
01990 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_sender_id00
01991 static int tolua_fawkesinterface_fawkes_Message_sender_id00(lua_State* tolua_S)
01992 {
01993 #ifndef TOLUA_RELEASE
01994  tolua_Error tolua_err;
01995  if (
01996      !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) ||
01997      !tolua_isnoobj(tolua_S,2,&tolua_err)
01998  )
01999   goto tolua_lerror;
02000  else
02001 #endif
02002  {
02003   const fawkes::Message* self = (const fawkes::Message*)  tolua_tousertype(tolua_S,1,0);
02004 #ifndef TOLUA_RELEASE
02005   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sender_id'",NULL);
02006 #endif
02007   {
02008    unsigned int tolua_ret = (unsigned int)  self->sender_id();
02009    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02010   }
02011  }
02012  return 1;
02013 #ifndef TOLUA_RELEASE
02014  tolua_lerror:
02015  tolua_error(tolua_S,"#ferror in function 'sender_id'.",&tolua_err);
02016  return 0;
02017 #endif
02018 }
02019 #endif //#ifndef TOLUA_DISABLE
02020 
02021 /* method: sender_thread_name of class  fawkes::Message */
02022 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_sender_thread_name00
02023 static int tolua_fawkesinterface_fawkes_Message_sender_thread_name00(lua_State* tolua_S)
02024 {
02025 #ifndef TOLUA_RELEASE
02026  tolua_Error tolua_err;
02027  if (
02028      !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) ||
02029      !tolua_isnoobj(tolua_S,2,&tolua_err)
02030  )
02031   goto tolua_lerror;
02032  else
02033 #endif
02034  {
02035   const fawkes::Message* self = (const fawkes::Message*)  tolua_tousertype(tolua_S,1,0);
02036 #ifndef TOLUA_RELEASE
02037   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sender_thread_name'",NULL);
02038 #endif
02039   {
02040    const char* tolua_ret = (const char*)  self->sender_thread_name();
02041    tolua_pushstring(tolua_S,(const char*)tolua_ret);
02042   }
02043  }
02044  return 1;
02045 #ifndef TOLUA_RELEASE
02046  tolua_lerror:
02047  tolua_error(tolua_S,"#ferror in function 'sender_thread_name'.",&tolua_err);
02048  return 0;
02049 #endif
02050 }
02051 #endif //#ifndef TOLUA_DISABLE
02052 
02053 /* method: interface of class  fawkes::Message */
02054 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_interface00
02055 static int tolua_fawkesinterface_fawkes_Message_interface00(lua_State* tolua_S)
02056 {
02057 #ifndef TOLUA_RELEASE
02058  tolua_Error tolua_err;
02059  if (
02060      !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) ||
02061      !tolua_isnoobj(tolua_S,2,&tolua_err)
02062  )
02063   goto tolua_lerror;
02064  else
02065 #endif
02066  {
02067   const fawkes::Message* self = (const fawkes::Message*)  tolua_tousertype(tolua_S,1,0);
02068 #ifndef TOLUA_RELEASE
02069   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'interface'",NULL);
02070 #endif
02071   {
02072    fawkes::Interface* tolua_ret = (fawkes::Interface*)  self->interface();
02073    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Interface");
02074   }
02075  }
02076  return 1;
02077 #ifndef TOLUA_RELEASE
02078  tolua_lerror:
02079  tolua_error(tolua_S,"#ferror in function 'interface'.",&tolua_err);
02080  return 0;
02081 #endif
02082 }
02083 #endif //#ifndef TOLUA_DISABLE
02084 
02085 /* method: type of class  fawkes::Message */
02086 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_type00
02087 static int tolua_fawkesinterface_fawkes_Message_type00(lua_State* tolua_S)
02088 {
02089 #ifndef TOLUA_RELEASE
02090  tolua_Error tolua_err;
02091  if (
02092      !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) ||
02093      !tolua_isnoobj(tolua_S,2,&tolua_err)
02094  )
02095   goto tolua_lerror;
02096  else
02097 #endif
02098  {
02099   const fawkes::Message* self = (const fawkes::Message*)  tolua_tousertype(tolua_S,1,0);
02100 #ifndef TOLUA_RELEASE
02101   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'",NULL);
02102 #endif
02103   {
02104    const char* tolua_ret = (const char*)  self->type();
02105    tolua_pushstring(tolua_S,(const char*)tolua_ret);
02106   }
02107  }
02108  return 1;
02109 #ifndef TOLUA_RELEASE
02110  tolua_lerror:
02111  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
02112  return 0;
02113 #endif
02114 }
02115 #endif //#ifndef TOLUA_DISABLE
02116 
02117 /* method: datachunk of class  fawkes::Message */
02118 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_datachunk00
02119 static int tolua_fawkesinterface_fawkes_Message_datachunk00(lua_State* tolua_S)
02120 {
02121 #ifndef TOLUA_RELEASE
02122  tolua_Error tolua_err;
02123  if (
02124      !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) ||
02125      !tolua_isnoobj(tolua_S,2,&tolua_err)
02126  )
02127   goto tolua_lerror;
02128  else
02129 #endif
02130  {
02131   const fawkes::Message* self = (const fawkes::Message*)  tolua_tousertype(tolua_S,1,0);
02132 #ifndef TOLUA_RELEASE
02133   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'",NULL);
02134 #endif
02135   {
02136    const void* tolua_ret = (const void*)  self->datachunk();
02137    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
02138   }
02139  }
02140  return 1;
02141 #ifndef TOLUA_RELEASE
02142  tolua_lerror:
02143  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
02144  return 0;
02145 #endif
02146 }
02147 #endif //#ifndef TOLUA_DISABLE
02148 
02149 /* method: datasize of class  fawkes::Message */
02150 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_datasize00
02151 static int tolua_fawkesinterface_fawkes_Message_datasize00(lua_State* tolua_S)
02152 {
02153 #ifndef TOLUA_RELEASE
02154  tolua_Error tolua_err;
02155  if (
02156      !tolua_isusertype(tolua_S,1,"const fawkes::Message",0,&tolua_err) ||
02157      !tolua_isnoobj(tolua_S,2,&tolua_err)
02158  )
02159   goto tolua_lerror;
02160  else
02161 #endif
02162  {
02163   const fawkes::Message* self = (const fawkes::Message*)  tolua_tousertype(tolua_S,1,0);
02164 #ifndef TOLUA_RELEASE
02165   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'",NULL);
02166 #endif
02167   {
02168    unsigned int tolua_ret = (unsigned int)  self->datasize();
02169    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02170   }
02171  }
02172  return 1;
02173 #ifndef TOLUA_RELEASE
02174  tolua_lerror:
02175  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
02176  return 0;
02177 #endif
02178 }
02179 #endif //#ifndef TOLUA_DISABLE
02180 
02181 /* method: set_from_chunk of class  fawkes::Message */
02182 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_set_from_chunk00
02183 static int tolua_fawkesinterface_fawkes_Message_set_from_chunk00(lua_State* tolua_S)
02184 {
02185 #ifndef TOLUA_RELEASE
02186  tolua_Error tolua_err;
02187  if (
02188      !tolua_isusertype(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
02189      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
02190      !tolua_isnoobj(tolua_S,3,&tolua_err)
02191  )
02192   goto tolua_lerror;
02193  else
02194 #endif
02195  {
02196   fawkes::Message* self = (fawkes::Message*)  tolua_tousertype(tolua_S,1,0);
02197   const void* chunk = ((const void*)  tolua_touserdata(tolua_S,2,0));
02198 #ifndef TOLUA_RELEASE
02199   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'",NULL);
02200 #endif
02201   {
02202    self->set_from_chunk(chunk);
02203   }
02204  }
02205  return 0;
02206 #ifndef TOLUA_RELEASE
02207  tolua_lerror:
02208  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
02209  return 0;
02210 #endif
02211 }
02212 #endif //#ifndef TOLUA_DISABLE
02213 
02214 /* method: ref of class  fawkes::Message */
02215 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_ref00
02216 static int tolua_fawkesinterface_fawkes_Message_ref00(lua_State* tolua_S)
02217 {
02218 #ifndef TOLUA_RELEASE
02219  tolua_Error tolua_err;
02220  if (
02221      !tolua_isusertype(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
02222      !tolua_isnoobj(tolua_S,2,&tolua_err)
02223  )
02224   goto tolua_lerror;
02225  else
02226 #endif
02227  {
02228   fawkes::Message* self = (fawkes::Message*)  tolua_tousertype(tolua_S,1,0);
02229 #ifndef TOLUA_RELEASE
02230   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ref'",NULL);
02231 #endif
02232   {
02233    self->ref();
02234   }
02235  }
02236  return 0;
02237 #ifndef TOLUA_RELEASE
02238  tolua_lerror:
02239  tolua_error(tolua_S,"#ferror in function 'ref'.",&tolua_err);
02240  return 0;
02241 #endif
02242 }
02243 #endif //#ifndef TOLUA_DISABLE
02244 
02245 /* method: unref of class  fawkes::Message */
02246 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_unref00
02247 static int tolua_fawkesinterface_fawkes_Message_unref00(lua_State* tolua_S)
02248 {
02249 #ifndef TOLUA_RELEASE
02250  tolua_Error tolua_err;
02251  if (
02252      !tolua_isusertype(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
02253      !tolua_isnoobj(tolua_S,2,&tolua_err)
02254  )
02255   goto tolua_lerror;
02256  else
02257 #endif
02258  {
02259   fawkes::Message* self = (fawkes::Message*)  tolua_tousertype(tolua_S,1,0);
02260 #ifndef TOLUA_RELEASE
02261   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unref'",NULL);
02262 #endif
02263   {
02264    self->unref();
02265   }
02266  }
02267  return 0;
02268 #ifndef TOLUA_RELEASE
02269  tolua_lerror:
02270  tolua_error(tolua_S,"#ferror in function 'unref'.",&tolua_err);
02271  return 0;
02272 #endif
02273 }
02274 #endif //#ifndef TOLUA_DISABLE
02275 
02276 /* method: refcount of class  fawkes::Message */
02277 #ifndef TOLUA_DISABLE_tolua_fawkesinterface_fawkes_Message_refcount00
02278 static int tolua_fawkesinterface_fawkes_Message_refcount00(lua_State* tolua_S)
02279 {
02280 #ifndef TOLUA_RELEASE
02281  tolua_Error tolua_err;
02282  if (
02283      !tolua_isusertype(tolua_S,1,"fawkes::Message",0,&tolua_err) ||
02284      !tolua_isnoobj(tolua_S,2,&tolua_err)
02285  )
02286   goto tolua_lerror;
02287  else
02288 #endif
02289  {
02290   fawkes::Message* self = (fawkes::Message*)  tolua_tousertype(tolua_S,1,0);
02291 #ifndef TOLUA_RELEASE
02292   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'refcount'",NULL);
02293 #endif
02294   {
02295    unsigned int tolua_ret = (unsigned int)  self->refcount();
02296    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02297   }
02298  }
02299  return 1;
02300 #ifndef TOLUA_RELEASE
02301  tolua_lerror:
02302  tolua_error(tolua_S,"#ferror in function 'refcount'.",&tolua_err);
02303  return 0;
02304 #endif
02305 }
02306 #endif //#ifndef TOLUA_DISABLE
02307 
02308 /* Open function */
02309 TOLUA_API int tolua_fawkesinterface_open (lua_State* tolua_S)
02310 {
02311  tolua_open(tolua_S);
02312  tolua_reg_types(tolua_S);
02313  tolua_module(tolua_S,NULL,0);
02314  tolua_beginmodule(tolua_S,NULL);
02315   tolua_module(tolua_S,"fawkes",0);
02316   tolua_beginmodule(tolua_S,"fawkes");
02317    tolua_cclass(tolua_S,"Interface","fawkes::Interface","",NULL);
02318    tolua_beginmodule(tolua_S,"Interface");
02319     tolua_function(tolua_S,"oftype",tolua_fawkesinterface_fawkes_Interface_oftype00);
02320     tolua_function(tolua_S,"datachunk",tolua_fawkesinterface_fawkes_Interface_datachunk00);
02321     tolua_function(tolua_S,"datasize",tolua_fawkesinterface_fawkes_Interface_datasize00);
02322     tolua_function(tolua_S,"type",tolua_fawkesinterface_fawkes_Interface_type00);
02323     tolua_function(tolua_S,"id",tolua_fawkesinterface_fawkes_Interface_id00);
02324     tolua_function(tolua_S,"uid",tolua_fawkesinterface_fawkes_Interface_uid00);
02325     tolua_function(tolua_S,"serial",tolua_fawkesinterface_fawkes_Interface_serial00);
02326     tolua_function(tolua_S,"mem_serial",tolua_fawkesinterface_fawkes_Interface_mem_serial00);
02327     tolua_function(tolua_S,".eq",tolua_fawkesinterface_fawkes_Interface__eq00);
02328     tolua_function(tolua_S,"hash",tolua_fawkesinterface_fawkes_Interface_hash00);
02329     tolua_function(tolua_S,"hash_size",tolua_fawkesinterface_fawkes_Interface_hash_size00);
02330     tolua_function(tolua_S,"hash_printable",tolua_fawkesinterface_fawkes_Interface_hash_printable00);
02331     tolua_function(tolua_S,"is_writer",tolua_fawkesinterface_fawkes_Interface_is_writer00);
02332     tolua_function(tolua_S,"set_from_chunk",tolua_fawkesinterface_fawkes_Interface_set_from_chunk00);
02333     tolua_function(tolua_S,"create_message",tolua_fawkesinterface_fawkes_Interface_create_message00);
02334     tolua_function(tolua_S,"read",tolua_fawkesinterface_fawkes_Interface_read00);
02335     tolua_function(tolua_S,"write",tolua_fawkesinterface_fawkes_Interface_write00);
02336     tolua_function(tolua_S,"has_writer",tolua_fawkesinterface_fawkes_Interface_has_writer00);
02337     tolua_function(tolua_S,"num_readers",tolua_fawkesinterface_fawkes_Interface_num_readers00);
02338     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_fawkesinterface_fawkes_Interface_msgq_enqueue_copy00);
02339     tolua_function(tolua_S,"msgq_remove",tolua_fawkesinterface_fawkes_Interface_msgq_remove00);
02340     tolua_function(tolua_S,"msgq_remove",tolua_fawkesinterface_fawkes_Interface_msgq_remove01);
02341     tolua_function(tolua_S,"msgq_size",tolua_fawkesinterface_fawkes_Interface_msgq_size00);
02342     tolua_function(tolua_S,"msgq_flush",tolua_fawkesinterface_fawkes_Interface_msgq_flush00);
02343     tolua_function(tolua_S,"msgq_lock",tolua_fawkesinterface_fawkes_Interface_msgq_lock00);
02344     tolua_function(tolua_S,"msgq_try_lock",tolua_fawkesinterface_fawkes_Interface_msgq_try_lock00);
02345     tolua_function(tolua_S,"msgq_unlock",tolua_fawkesinterface_fawkes_Interface_msgq_unlock00);
02346     tolua_function(tolua_S,"msgq_pop",tolua_fawkesinterface_fawkes_Interface_msgq_pop00);
02347     tolua_function(tolua_S,"msgq_first",tolua_fawkesinterface_fawkes_Interface_msgq_first00);
02348     tolua_function(tolua_S,"msgq_empty",tolua_fawkesinterface_fawkes_Interface_msgq_empty00);
02349    tolua_endmodule(tolua_S);
02350   tolua_endmodule(tolua_S);
02351   tolua_module(tolua_S,"fawkes",0);
02352   tolua_beginmodule(tolua_S,"fawkes");
02353    #ifdef __cplusplus
02354    tolua_cclass(tolua_S,"MessageQueue","fawkes::MessageQueue","",tolua_collect_fawkes__MessageQueue);
02355    #else
02356    tolua_cclass(tolua_S,"MessageQueue","fawkes::MessageQueue","",NULL);
02357    #endif
02358    tolua_beginmodule(tolua_S,"MessageQueue");
02359     tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_MessageQueue_new00);
02360     tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_MessageQueue_new00_local);
02361     tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_MessageQueue_new00_local);
02362     tolua_function(tolua_S,"delete",tolua_fawkesinterface_fawkes_MessageQueue_delete00);
02363     #ifdef __cplusplus
02364     tolua_cclass(tolua_S,"MessageIterator","fawkes::MessageQueue::MessageIterator","",tolua_collect_fawkes__MessageQueue__MessageIterator);
02365     #else
02366     tolua_cclass(tolua_S,"MessageIterator","fawkes::MessageQueue::MessageIterator","",NULL);
02367     #endif
02368     tolua_beginmodule(tolua_S,"MessageIterator");
02369      tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00);
02370      tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local);
02371      tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new00_local);
02372      tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01);
02373      tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local);
02374      tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_new01_local);
02375      tolua_function(tolua_S,".add",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__add00);
02376      tolua_function(tolua_S,".eq",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__eq00);
02377      tolua_function(tolua_S,".mul",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator__mul00);
02378      tolua_function(tolua_S,"id",tolua_fawkesinterface_fawkes_MessageQueue_MessageIterator_id00);
02379     tolua_endmodule(tolua_S);
02380     tolua_function(tolua_S,"append",tolua_fawkesinterface_fawkes_MessageQueue_append00);
02381     tolua_function(tolua_S,"remove",tolua_fawkesinterface_fawkes_MessageQueue_remove00);
02382     tolua_function(tolua_S,"remove",tolua_fawkesinterface_fawkes_MessageQueue_remove01);
02383     tolua_function(tolua_S,"insert_after",tolua_fawkesinterface_fawkes_MessageQueue_insert_after00);
02384     tolua_function(tolua_S,"size",tolua_fawkesinterface_fawkes_MessageQueue_size00);
02385     tolua_function(tolua_S,"flush",tolua_fawkesinterface_fawkes_MessageQueue_flush00);
02386     tolua_function(tolua_S,"empty",tolua_fawkesinterface_fawkes_MessageQueue_empty00);
02387     tolua_function(tolua_S,"lock",tolua_fawkesinterface_fawkes_MessageQueue_lock00);
02388     tolua_function(tolua_S,"try_lock",tolua_fawkesinterface_fawkes_MessageQueue_try_lock00);
02389     tolua_function(tolua_S,"unlock",tolua_fawkesinterface_fawkes_MessageQueue_unlock00);
02390     tolua_function(tolua_S,"first",tolua_fawkesinterface_fawkes_MessageQueue_first00);
02391     tolua_function(tolua_S,"pop",tolua_fawkesinterface_fawkes_MessageQueue_pop00);
02392     tolua_function(tolua_S,"begin",tolua_fawkesinterface_fawkes_MessageQueue_begin00);
02393     tolua_function(tolua_S,"end",tolua_fawkesinterface_fawkes_MessageQueue_end00);
02394    tolua_endmodule(tolua_S);
02395   tolua_endmodule(tolua_S);
02396   tolua_module(tolua_S,"fawkes",0);
02397   tolua_beginmodule(tolua_S,"fawkes");
02398    #ifdef __cplusplus
02399    tolua_cclass(tolua_S,"Message","fawkes::Message","RefCount",tolua_collect_fawkes__Message);
02400    #else
02401    tolua_cclass(tolua_S,"Message","fawkes::Message","RefCount",NULL);
02402    #endif
02403    tolua_beginmodule(tolua_S,"Message");
02404     tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_Message_new00);
02405     tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_Message_new00_local);
02406     tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_Message_new00_local);
02407     tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_Message_new01);
02408     tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_Message_new01_local);
02409     tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_Message_new01_local);
02410     tolua_function(tolua_S,"new",tolua_fawkesinterface_fawkes_Message_new02);
02411     tolua_function(tolua_S,"new_local",tolua_fawkesinterface_fawkes_Message_new02_local);
02412     tolua_function(tolua_S,".call",tolua_fawkesinterface_fawkes_Message_new02_local);
02413     tolua_function(tolua_S,"sender_id",tolua_fawkesinterface_fawkes_Message_sender_id00);
02414     tolua_function(tolua_S,"sender_thread_name",tolua_fawkesinterface_fawkes_Message_sender_thread_name00);
02415     tolua_function(tolua_S,"interface",tolua_fawkesinterface_fawkes_Message_interface00);
02416     tolua_function(tolua_S,"type",tolua_fawkesinterface_fawkes_Message_type00);
02417     tolua_function(tolua_S,"datachunk",tolua_fawkesinterface_fawkes_Message_datachunk00);
02418     tolua_function(tolua_S,"datasize",tolua_fawkesinterface_fawkes_Message_datasize00);
02419     tolua_function(tolua_S,"set_from_chunk",tolua_fawkesinterface_fawkes_Message_set_from_chunk00);
02420     tolua_function(tolua_S,"ref",tolua_fawkesinterface_fawkes_Message_ref00);
02421     tolua_function(tolua_S,"unref",tolua_fawkesinterface_fawkes_Message_unref00);
02422     tolua_function(tolua_S,"refcount",tolua_fawkesinterface_fawkes_Message_refcount00);
02423    tolua_endmodule(tolua_S);
02424   tolua_endmodule(tolua_S);
02425  tolua_endmodule(tolua_S);
02426  return 1;
02427 }
02428
02429
02430 extern "C" {
02431 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
02432  TOLUA_API int luaopen_fawkesinterface (lua_State* tolua_S) {
02433  return tolua_fawkesinterface_open(tolua_S);
02434 };
02435 #endif
02436 }
02437
02438