fawkesinterface_tolua.cpp

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

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