SpeechSynthInterface_tolua.cpp

00001 /*
00002 ** Lua binding: interfaces_SpeechSynthInterface
00003 ** Generated automatically by tolua++-1.0.92
00004 */
00005 /*  This program is free software; you can redistribute it and/or modify
00006  *  it under the terms of the GNU General Public License as published by
00007  *  the Free Software Foundation; either version 2 of the License, or
00008  *  (at your option) any later version. A runtime exception applies to
00009  *  this software (see LICENSE.GPL_WRE file mentioned below for details).
00010  *
00011  *  This program is distributed in the hope that it will be useful,
00012  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  *  GNU Library General Public License for more details.
00015  *
00016  *  Read the full text in the LICENSE.GPL_WRE file in the doc directory.
00017  */
00018
00019 #ifndef __cplusplus
00020 #include "stdlib.h"
00021 #endif
00022 #include "string.h"
00023
00024 #include "tolua++.h"
00025
00026 /* Exported function */
00027 TOLUA_API int  tolua_interfaces_SpeechSynthInterface_open (lua_State* tolua_S);
00028
00029 #include <interfaces/SpeechSynthInterface.h>
00030 using namespace fawkes;
00031
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__SpeechSynthInterface__SayMessage (lua_State* tolua_S)
00036 {
00037  fawkes::SpeechSynthInterface::SayMessage* self = (fawkes::SpeechSynthInterface::SayMessage*) tolua_tousertype(tolua_S,1,0);
00038         delete self;
00039         return 0;
00040 }
00041 #endif
00042 
00043
00044 /* function to register type */
00045 static void tolua_reg_types (lua_State* tolua_S)
00046 {
00047  tolua_usertype(tolua_S,"Message");
00048  tolua_usertype(tolua_S,"fawkes::SpeechSynthInterface");
00049  tolua_usertype(tolua_S,"fawkes::SpeechSynthInterface::SayMessage");
00050  tolua_usertype(tolua_S,"Interface");
00051 }
00052
00053 /* method: new of class  SayMessage */
00054 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new00
00055 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new00(lua_State* tolua_S)
00056 {
00057 #ifndef TOLUA_RELEASE
00058  tolua_Error tolua_err;
00059  if (
00060      !tolua_isusertable(tolua_S,1,"fawkes::SpeechSynthInterface::SayMessage",0,&tolua_err) ||
00061      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00062      !tolua_isnoobj(tolua_S,3,&tolua_err)
00063  )
00064   goto tolua_lerror;
00065  else
00066 #endif
00067  {
00068   char* ini_text = ((char*)  tolua_tostring(tolua_S,2,0));
00069   {
00070    fawkes::SpeechSynthInterface::SayMessage* tolua_ret = (fawkes::SpeechSynthInterface::SayMessage*)  new fawkes::SpeechSynthInterface::SayMessage(ini_text);
00071    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SpeechSynthInterface::SayMessage");
00072   }
00073  }
00074  return 1;
00075 #ifndef TOLUA_RELEASE
00076  tolua_lerror:
00077  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00078  return 0;
00079 #endif
00080 }
00081 #endif //#ifndef TOLUA_DISABLE
00082 
00083 /* method: new_local of class  SayMessage */
00084 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new00_local
00085 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new00_local(lua_State* tolua_S)
00086 {
00087 #ifndef TOLUA_RELEASE
00088  tolua_Error tolua_err;
00089  if (
00090      !tolua_isusertable(tolua_S,1,"fawkes::SpeechSynthInterface::SayMessage",0,&tolua_err) ||
00091      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00092      !tolua_isnoobj(tolua_S,3,&tolua_err)
00093  )
00094   goto tolua_lerror;
00095  else
00096 #endif
00097  {
00098   char* ini_text = ((char*)  tolua_tostring(tolua_S,2,0));
00099   {
00100    fawkes::SpeechSynthInterface::SayMessage* tolua_ret = (fawkes::SpeechSynthInterface::SayMessage*)  new fawkes::SpeechSynthInterface::SayMessage(ini_text);
00101    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::SpeechSynthInterface::SayMessage");
00102   }
00103  }
00104  return 1;
00105 #ifndef TOLUA_RELEASE
00106  tolua_lerror:
00107  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00108  return 0;
00109 #endif
00110 }
00111 #endif //#ifndef TOLUA_DISABLE
00112 
00113 /* method: new of class  SayMessage */
00114 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new01
00115 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new01(lua_State* tolua_S)
00116 {
00117  tolua_Error tolua_err;
00118  if (
00119      !tolua_isusertable(tolua_S,1,"fawkes::SpeechSynthInterface::SayMessage",0,&tolua_err) ||
00120      !tolua_isnoobj(tolua_S,2,&tolua_err)
00121  )
00122   goto tolua_lerror;
00123  else
00124  {
00125   {
00126    fawkes::SpeechSynthInterface::SayMessage* tolua_ret = (fawkes::SpeechSynthInterface::SayMessage*)  new fawkes::SpeechSynthInterface::SayMessage();
00127    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SpeechSynthInterface::SayMessage");
00128   }
00129  }
00130  return 1;
00131 tolua_lerror:
00132  return tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new00(tolua_S);
00133 }
00134 #endif //#ifndef TOLUA_DISABLE
00135 
00136 /* method: new_local of class  SayMessage */
00137 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new01_local
00138 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new01_local(lua_State* tolua_S)
00139 {
00140  tolua_Error tolua_err;
00141  if (
00142      !tolua_isusertable(tolua_S,1,"fawkes::SpeechSynthInterface::SayMessage",0,&tolua_err) ||
00143      !tolua_isnoobj(tolua_S,2,&tolua_err)
00144  )
00145   goto tolua_lerror;
00146  else
00147  {
00148   {
00149    fawkes::SpeechSynthInterface::SayMessage* tolua_ret = (fawkes::SpeechSynthInterface::SayMessage*)  new fawkes::SpeechSynthInterface::SayMessage();
00150    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::SpeechSynthInterface::SayMessage");
00151   }
00152  }
00153  return 1;
00154 tolua_lerror:
00155  return tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new00_local(tolua_S);
00156 }
00157 #endif //#ifndef TOLUA_DISABLE
00158 
00159 /* method: delete of class  SayMessage */
00160 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_delete00
00161 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_delete00(lua_State* tolua_S)
00162 {
00163 #ifndef TOLUA_RELEASE
00164  tolua_Error tolua_err;
00165  if (
00166      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface::SayMessage",0,&tolua_err) ||
00167      !tolua_isnoobj(tolua_S,2,&tolua_err)
00168  )
00169   goto tolua_lerror;
00170  else
00171 #endif
00172  {
00173   fawkes::SpeechSynthInterface::SayMessage* self = (fawkes::SpeechSynthInterface::SayMessage*)  tolua_tousertype(tolua_S,1,0);
00174 #ifndef TOLUA_RELEASE
00175   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00176 #endif
00177   delete self;
00178  }
00179  return 0;
00180 #ifndef TOLUA_RELEASE
00181  tolua_lerror:
00182  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00183  return 0;
00184 #endif
00185 }
00186 #endif //#ifndef TOLUA_DISABLE
00187 
00188 /* method: text of class  SayMessage */
00189 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_text00
00190 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_text00(lua_State* tolua_S)
00191 {
00192 #ifndef TOLUA_RELEASE
00193  tolua_Error tolua_err;
00194  if (
00195      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface::SayMessage",0,&tolua_err) ||
00196      !tolua_isnoobj(tolua_S,2,&tolua_err)
00197  )
00198   goto tolua_lerror;
00199  else
00200 #endif
00201  {
00202   fawkes::SpeechSynthInterface::SayMessage* self = (fawkes::SpeechSynthInterface::SayMessage*)  tolua_tousertype(tolua_S,1,0);
00203 #ifndef TOLUA_RELEASE
00204   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'text'",NULL);
00205 #endif
00206   {
00207    char* tolua_ret = (char*)  self->text();
00208    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00209   }
00210  }
00211  return 1;
00212 #ifndef TOLUA_RELEASE
00213  tolua_lerror:
00214  tolua_error(tolua_S,"#ferror in function 'text'.",&tolua_err);
00215  return 0;
00216 #endif
00217 }
00218 #endif //#ifndef TOLUA_DISABLE
00219 
00220 /* method: set_text of class  SayMessage */
00221 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_set_text00
00222 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_set_text00(lua_State* tolua_S)
00223 {
00224 #ifndef TOLUA_RELEASE
00225  tolua_Error tolua_err;
00226  if (
00227      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface::SayMessage",0,&tolua_err) ||
00228      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00229      !tolua_isnoobj(tolua_S,3,&tolua_err)
00230  )
00231   goto tolua_lerror;
00232  else
00233 #endif
00234  {
00235   fawkes::SpeechSynthInterface::SayMessage* self = (fawkes::SpeechSynthInterface::SayMessage*)  tolua_tousertype(tolua_S,1,0);
00236   const char* new_text = ((const char*)  tolua_tostring(tolua_S,2,0));
00237 #ifndef TOLUA_RELEASE
00238   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_text'",NULL);
00239 #endif
00240   {
00241    self->set_text(new_text);
00242   }
00243  }
00244  return 0;
00245 #ifndef TOLUA_RELEASE
00246  tolua_lerror:
00247  tolua_error(tolua_S,"#ferror in function 'set_text'.",&tolua_err);
00248  return 0;
00249 #endif
00250 }
00251 #endif //#ifndef TOLUA_DISABLE
00252 
00253 /* method: maxlenof_text of class  SayMessage */
00254 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_maxlenof_text00
00255 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_maxlenof_text00(lua_State* tolua_S)
00256 {
00257 #ifndef TOLUA_RELEASE
00258  tolua_Error tolua_err;
00259  if (
00260      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface::SayMessage",0,&tolua_err) ||
00261      !tolua_isnoobj(tolua_S,2,&tolua_err)
00262  )
00263   goto tolua_lerror;
00264  else
00265 #endif
00266  {
00267   const fawkes::SpeechSynthInterface::SayMessage* self = (const fawkes::SpeechSynthInterface::SayMessage*)  tolua_tousertype(tolua_S,1,0);
00268 #ifndef TOLUA_RELEASE
00269   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_text'",NULL);
00270 #endif
00271   {
00272    int tolua_ret = (int)  self->maxlenof_text();
00273    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00274   }
00275  }
00276  return 1;
00277 #ifndef TOLUA_RELEASE
00278  tolua_lerror:
00279  tolua_error(tolua_S,"#ferror in function 'maxlenof_text'.",&tolua_err);
00280  return 0;
00281 #endif
00282 }
00283 #endif //#ifndef TOLUA_DISABLE
00284 
00285 /* method: text of class  fawkes::SpeechSynthInterface */
00286 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_text00
00287 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_text00(lua_State* tolua_S)
00288 {
00289 #ifndef TOLUA_RELEASE
00290  tolua_Error tolua_err;
00291  if (
00292      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
00293      !tolua_isnoobj(tolua_S,2,&tolua_err)
00294  )
00295   goto tolua_lerror;
00296  else
00297 #endif
00298  {
00299   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00300 #ifndef TOLUA_RELEASE
00301   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'text'",NULL);
00302 #endif
00303   {
00304    char* tolua_ret = (char*)  self->text();
00305    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00306   }
00307  }
00308  return 1;
00309 #ifndef TOLUA_RELEASE
00310  tolua_lerror:
00311  tolua_error(tolua_S,"#ferror in function 'text'.",&tolua_err);
00312  return 0;
00313 #endif
00314 }
00315 #endif //#ifndef TOLUA_DISABLE
00316 
00317 /* method: set_text of class  fawkes::SpeechSynthInterface */
00318 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_text00
00319 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_text00(lua_State* tolua_S)
00320 {
00321 #ifndef TOLUA_RELEASE
00322  tolua_Error tolua_err;
00323  if (
00324      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
00325      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00326      !tolua_isnoobj(tolua_S,3,&tolua_err)
00327  )
00328   goto tolua_lerror;
00329  else
00330 #endif
00331  {
00332   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00333   const char* new_text = ((const char*)  tolua_tostring(tolua_S,2,0));
00334 #ifndef TOLUA_RELEASE
00335   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_text'",NULL);
00336 #endif
00337   {
00338    self->set_text(new_text);
00339   }
00340  }
00341  return 0;
00342 #ifndef TOLUA_RELEASE
00343  tolua_lerror:
00344  tolua_error(tolua_S,"#ferror in function 'set_text'.",&tolua_err);
00345  return 0;
00346 #endif
00347 }
00348 #endif //#ifndef TOLUA_DISABLE
00349 
00350 /* method: maxlenof_text of class  fawkes::SpeechSynthInterface */
00351 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_maxlenof_text00
00352 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_maxlenof_text00(lua_State* tolua_S)
00353 {
00354 #ifndef TOLUA_RELEASE
00355  tolua_Error tolua_err;
00356  if (
00357      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
00358      !tolua_isnoobj(tolua_S,2,&tolua_err)
00359  )
00360   goto tolua_lerror;
00361  else
00362 #endif
00363  {
00364   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00365 #ifndef TOLUA_RELEASE
00366   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_text'",NULL);
00367 #endif
00368   {
00369    int tolua_ret = (int)  self->maxlenof_text();
00370    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00371   }
00372  }
00373  return 1;
00374 #ifndef TOLUA_RELEASE
00375  tolua_lerror:
00376  tolua_error(tolua_S,"#ferror in function 'maxlenof_text'.",&tolua_err);
00377  return 0;
00378 #endif
00379 }
00380 #endif //#ifndef TOLUA_DISABLE
00381 
00382 /* method: msgid of class  fawkes::SpeechSynthInterface */
00383 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgid00
00384 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgid00(lua_State* tolua_S)
00385 {
00386 #ifndef TOLUA_RELEASE
00387  tolua_Error tolua_err;
00388  if (
00389      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
00390      !tolua_isnoobj(tolua_S,2,&tolua_err)
00391  )
00392   goto tolua_lerror;
00393  else
00394 #endif
00395  {
00396   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00397 #ifndef TOLUA_RELEASE
00398   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgid'",NULL);
00399 #endif
00400   {
00401    unsigned int tolua_ret = (unsigned int)  self->msgid();
00402    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00403   }
00404  }
00405  return 1;
00406 #ifndef TOLUA_RELEASE
00407  tolua_lerror:
00408  tolua_error(tolua_S,"#ferror in function 'msgid'.",&tolua_err);
00409  return 0;
00410 #endif
00411 }
00412 #endif //#ifndef TOLUA_DISABLE
00413 
00414 /* method: set_msgid of class  fawkes::SpeechSynthInterface */
00415 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_msgid00
00416 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_msgid00(lua_State* tolua_S)
00417 {
00418 #ifndef TOLUA_RELEASE
00419  tolua_Error tolua_err;
00420  if (
00421      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
00422      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00423      !tolua_isnoobj(tolua_S,3,&tolua_err)
00424  )
00425   goto tolua_lerror;
00426  else
00427 #endif
00428  {
00429   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00430   unsigned const int new_msgid = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
00431 #ifndef TOLUA_RELEASE
00432   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_msgid'",NULL);
00433 #endif
00434   {
00435    self->set_msgid(new_msgid);
00436   }
00437  }
00438  return 0;
00439 #ifndef TOLUA_RELEASE
00440  tolua_lerror:
00441  tolua_error(tolua_S,"#ferror in function 'set_msgid'.",&tolua_err);
00442  return 0;
00443 #endif
00444 }
00445 #endif //#ifndef TOLUA_DISABLE
00446 
00447 /* method: maxlenof_msgid of class  fawkes::SpeechSynthInterface */
00448 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_maxlenof_msgid00
00449 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_maxlenof_msgid00(lua_State* tolua_S)
00450 {
00451 #ifndef TOLUA_RELEASE
00452  tolua_Error tolua_err;
00453  if (
00454      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
00455      !tolua_isnoobj(tolua_S,2,&tolua_err)
00456  )
00457   goto tolua_lerror;
00458  else
00459 #endif
00460  {
00461   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00462 #ifndef TOLUA_RELEASE
00463   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_msgid'",NULL);
00464 #endif
00465   {
00466    int tolua_ret = (int)  self->maxlenof_msgid();
00467    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00468   }
00469  }
00470  return 1;
00471 #ifndef TOLUA_RELEASE
00472  tolua_lerror:
00473  tolua_error(tolua_S,"#ferror in function 'maxlenof_msgid'.",&tolua_err);
00474  return 0;
00475 #endif
00476 }
00477 #endif //#ifndef TOLUA_DISABLE
00478 
00479 /* method: is_final of class  fawkes::SpeechSynthInterface */
00480 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_is_final00
00481 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_is_final00(lua_State* tolua_S)
00482 {
00483 #ifndef TOLUA_RELEASE
00484  tolua_Error tolua_err;
00485  if (
00486      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
00487      !tolua_isnoobj(tolua_S,2,&tolua_err)
00488  )
00489   goto tolua_lerror;
00490  else
00491 #endif
00492  {
00493   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00494 #ifndef TOLUA_RELEASE
00495   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_final'",NULL);
00496 #endif
00497   {
00498    bool tolua_ret = (bool)  self->is_final();
00499    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00500   }
00501  }
00502  return 1;
00503 #ifndef TOLUA_RELEASE
00504  tolua_lerror:
00505  tolua_error(tolua_S,"#ferror in function 'is_final'.",&tolua_err);
00506  return 0;
00507 #endif
00508 }
00509 #endif //#ifndef TOLUA_DISABLE
00510 
00511 /* method: set_final of class  fawkes::SpeechSynthInterface */
00512 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_final00
00513 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_final00(lua_State* tolua_S)
00514 {
00515 #ifndef TOLUA_RELEASE
00516  tolua_Error tolua_err;
00517  if (
00518      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
00519      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
00520      !tolua_isnoobj(tolua_S,3,&tolua_err)
00521  )
00522   goto tolua_lerror;
00523  else
00524 #endif
00525  {
00526   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00527   const bool new_final = ((const bool)  tolua_toboolean(tolua_S,2,0));
00528 #ifndef TOLUA_RELEASE
00529   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_final'",NULL);
00530 #endif
00531   {
00532    self->set_final(new_final);
00533   }
00534  }
00535  return 0;
00536 #ifndef TOLUA_RELEASE
00537  tolua_lerror:
00538  tolua_error(tolua_S,"#ferror in function 'set_final'.",&tolua_err);
00539  return 0;
00540 #endif
00541 }
00542 #endif //#ifndef TOLUA_DISABLE
00543 
00544 /* method: maxlenof_final of class  fawkes::SpeechSynthInterface */
00545 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_maxlenof_final00
00546 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_maxlenof_final00(lua_State* tolua_S)
00547 {
00548 #ifndef TOLUA_RELEASE
00549  tolua_Error tolua_err;
00550  if (
00551      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
00552      !tolua_isnoobj(tolua_S,2,&tolua_err)
00553  )
00554   goto tolua_lerror;
00555  else
00556 #endif
00557  {
00558   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00559 #ifndef TOLUA_RELEASE
00560   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_final'",NULL);
00561 #endif
00562   {
00563    int tolua_ret = (int)  self->maxlenof_final();
00564    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00565   }
00566  }
00567  return 1;
00568 #ifndef TOLUA_RELEASE
00569  tolua_lerror:
00570  tolua_error(tolua_S,"#ferror in function 'maxlenof_final'.",&tolua_err);
00571  return 0;
00572 #endif
00573 }
00574 #endif //#ifndef TOLUA_DISABLE
00575 
00576 /* method: duration of class  fawkes::SpeechSynthInterface */
00577 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_duration00
00578 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_duration00(lua_State* tolua_S)
00579 {
00580 #ifndef TOLUA_RELEASE
00581  tolua_Error tolua_err;
00582  if (
00583      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
00584      !tolua_isnoobj(tolua_S,2,&tolua_err)
00585  )
00586   goto tolua_lerror;
00587  else
00588 #endif
00589  {
00590   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00591 #ifndef TOLUA_RELEASE
00592   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'duration'",NULL);
00593 #endif
00594   {
00595    float tolua_ret = (float)  self->duration();
00596    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00597   }
00598  }
00599  return 1;
00600 #ifndef TOLUA_RELEASE
00601  tolua_lerror:
00602  tolua_error(tolua_S,"#ferror in function 'duration'.",&tolua_err);
00603  return 0;
00604 #endif
00605 }
00606 #endif //#ifndef TOLUA_DISABLE
00607 
00608 /* method: set_duration of class  fawkes::SpeechSynthInterface */
00609 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_duration00
00610 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_duration00(lua_State* tolua_S)
00611 {
00612 #ifndef TOLUA_RELEASE
00613  tolua_Error tolua_err;
00614  if (
00615      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
00616      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00617      !tolua_isnoobj(tolua_S,3,&tolua_err)
00618  )
00619   goto tolua_lerror;
00620  else
00621 #endif
00622  {
00623   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00624   const float new_duration = ((const float)  tolua_tonumber(tolua_S,2,0));
00625 #ifndef TOLUA_RELEASE
00626   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_duration'",NULL);
00627 #endif
00628   {
00629    self->set_duration(new_duration);
00630   }
00631  }
00632  return 0;
00633 #ifndef TOLUA_RELEASE
00634  tolua_lerror:
00635  tolua_error(tolua_S,"#ferror in function 'set_duration'.",&tolua_err);
00636  return 0;
00637 #endif
00638 }
00639 #endif //#ifndef TOLUA_DISABLE
00640 
00641 /* method: maxlenof_duration of class  fawkes::SpeechSynthInterface */
00642 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_maxlenof_duration00
00643 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_maxlenof_duration00(lua_State* tolua_S)
00644 {
00645 #ifndef TOLUA_RELEASE
00646  tolua_Error tolua_err;
00647  if (
00648      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
00649      !tolua_isnoobj(tolua_S,2,&tolua_err)
00650  )
00651   goto tolua_lerror;
00652  else
00653 #endif
00654  {
00655   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00656 #ifndef TOLUA_RELEASE
00657   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_duration'",NULL);
00658 #endif
00659   {
00660    int tolua_ret = (int)  self->maxlenof_duration();
00661    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00662   }
00663  }
00664  return 1;
00665 #ifndef TOLUA_RELEASE
00666  tolua_lerror:
00667  tolua_error(tolua_S,"#ferror in function 'maxlenof_duration'.",&tolua_err);
00668  return 0;
00669 #endif
00670 }
00671 #endif //#ifndef TOLUA_DISABLE
00672 
00673 /* method: oftype of class  fawkes::SpeechSynthInterface */
00674 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_oftype00
00675 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_oftype00(lua_State* tolua_S)
00676 {
00677 #ifndef TOLUA_RELEASE
00678  tolua_Error tolua_err;
00679  if (
00680      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
00681      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00682      !tolua_isnoobj(tolua_S,3,&tolua_err)
00683  )
00684   goto tolua_lerror;
00685  else
00686 #endif
00687  {
00688   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00689   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
00690 #ifndef TOLUA_RELEASE
00691   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'",NULL);
00692 #endif
00693   {
00694    bool tolua_ret = (bool)  self->oftype(interface_type);
00695    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00696   }
00697  }
00698  return 1;
00699 #ifndef TOLUA_RELEASE
00700  tolua_lerror:
00701  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
00702  return 0;
00703 #endif
00704 }
00705 #endif //#ifndef TOLUA_DISABLE
00706 
00707 /* method: datachunk of class  fawkes::SpeechSynthInterface */
00708 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_datachunk00
00709 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_datachunk00(lua_State* tolua_S)
00710 {
00711 #ifndef TOLUA_RELEASE
00712  tolua_Error tolua_err;
00713  if (
00714      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
00715      !tolua_isnoobj(tolua_S,2,&tolua_err)
00716  )
00717   goto tolua_lerror;
00718  else
00719 #endif
00720  {
00721   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00722 #ifndef TOLUA_RELEASE
00723   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'",NULL);
00724 #endif
00725   {
00726    const void* tolua_ret = (const void*)  self->datachunk();
00727    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
00728   }
00729  }
00730  return 1;
00731 #ifndef TOLUA_RELEASE
00732  tolua_lerror:
00733  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
00734  return 0;
00735 #endif
00736 }
00737 #endif //#ifndef TOLUA_DISABLE
00738 
00739 /* method: datasize of class  fawkes::SpeechSynthInterface */
00740 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_datasize00
00741 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_datasize00(lua_State* tolua_S)
00742 {
00743 #ifndef TOLUA_RELEASE
00744  tolua_Error tolua_err;
00745  if (
00746      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
00747      !tolua_isnoobj(tolua_S,2,&tolua_err)
00748  )
00749   goto tolua_lerror;
00750  else
00751 #endif
00752  {
00753   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00754 #ifndef TOLUA_RELEASE
00755   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'",NULL);
00756 #endif
00757   {
00758    unsigned int tolua_ret = (unsigned int)  self->datasize();
00759    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00760   }
00761  }
00762  return 1;
00763 #ifndef TOLUA_RELEASE
00764  tolua_lerror:
00765  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
00766  return 0;
00767 #endif
00768 }
00769 #endif //#ifndef TOLUA_DISABLE
00770 
00771 /* method: type of class  fawkes::SpeechSynthInterface */
00772 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_type00
00773 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_type00(lua_State* tolua_S)
00774 {
00775 #ifndef TOLUA_RELEASE
00776  tolua_Error tolua_err;
00777  if (
00778      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
00779      !tolua_isnoobj(tolua_S,2,&tolua_err)
00780  )
00781   goto tolua_lerror;
00782  else
00783 #endif
00784  {
00785   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00786 #ifndef TOLUA_RELEASE
00787   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'",NULL);
00788 #endif
00789   {
00790    const char* tolua_ret = (const char*)  self->type();
00791    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00792   }
00793  }
00794  return 1;
00795 #ifndef TOLUA_RELEASE
00796  tolua_lerror:
00797  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
00798  return 0;
00799 #endif
00800 }
00801 #endif //#ifndef TOLUA_DISABLE
00802 
00803 /* method: id of class  fawkes::SpeechSynthInterface */
00804 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_id00
00805 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_id00(lua_State* tolua_S)
00806 {
00807 #ifndef TOLUA_RELEASE
00808  tolua_Error tolua_err;
00809  if (
00810      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
00811      !tolua_isnoobj(tolua_S,2,&tolua_err)
00812  )
00813   goto tolua_lerror;
00814  else
00815 #endif
00816  {
00817   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00818 #ifndef TOLUA_RELEASE
00819   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'",NULL);
00820 #endif
00821   {
00822    const char* tolua_ret = (const char*)  self->id();
00823    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00824   }
00825  }
00826  return 1;
00827 #ifndef TOLUA_RELEASE
00828  tolua_lerror:
00829  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
00830  return 0;
00831 #endif
00832 }
00833 #endif //#ifndef TOLUA_DISABLE
00834 
00835 /* method: uid of class  fawkes::SpeechSynthInterface */
00836 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_uid00
00837 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_uid00(lua_State* tolua_S)
00838 {
00839 #ifndef TOLUA_RELEASE
00840  tolua_Error tolua_err;
00841  if (
00842      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
00843      !tolua_isnoobj(tolua_S,2,&tolua_err)
00844  )
00845   goto tolua_lerror;
00846  else
00847 #endif
00848  {
00849   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00850 #ifndef TOLUA_RELEASE
00851   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'",NULL);
00852 #endif
00853   {
00854    const char* tolua_ret = (const char*)  self->uid();
00855    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00856   }
00857  }
00858  return 1;
00859 #ifndef TOLUA_RELEASE
00860  tolua_lerror:
00861  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
00862  return 0;
00863 #endif
00864 }
00865 #endif //#ifndef TOLUA_DISABLE
00866 
00867 /* method: serial of class  fawkes::SpeechSynthInterface */
00868 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_serial00
00869 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_serial00(lua_State* tolua_S)
00870 {
00871 #ifndef TOLUA_RELEASE
00872  tolua_Error tolua_err;
00873  if (
00874      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
00875      !tolua_isnoobj(tolua_S,2,&tolua_err)
00876  )
00877   goto tolua_lerror;
00878  else
00879 #endif
00880  {
00881   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00882 #ifndef TOLUA_RELEASE
00883   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'",NULL);
00884 #endif
00885   {
00886    unsigned int tolua_ret = (unsigned int)  self->serial();
00887    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00888   }
00889  }
00890  return 1;
00891 #ifndef TOLUA_RELEASE
00892  tolua_lerror:
00893  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
00894  return 0;
00895 #endif
00896 }
00897 #endif //#ifndef TOLUA_DISABLE
00898 
00899 /* method: mem_serial of class  fawkes::SpeechSynthInterface */
00900 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_mem_serial00
00901 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_mem_serial00(lua_State* tolua_S)
00902 {
00903 #ifndef TOLUA_RELEASE
00904  tolua_Error tolua_err;
00905  if (
00906      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
00907      !tolua_isnoobj(tolua_S,2,&tolua_err)
00908  )
00909   goto tolua_lerror;
00910  else
00911 #endif
00912  {
00913   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00914 #ifndef TOLUA_RELEASE
00915   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'",NULL);
00916 #endif
00917   {
00918    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
00919    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00920   }
00921  }
00922  return 1;
00923 #ifndef TOLUA_RELEASE
00924  tolua_lerror:
00925  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
00926  return 0;
00927 #endif
00928 }
00929 #endif //#ifndef TOLUA_DISABLE
00930 
00931 /* method: operator== of class  fawkes::SpeechSynthInterface */
00932 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface__eq00
00933 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface__eq00(lua_State* tolua_S)
00934 {
00935 #ifndef TOLUA_RELEASE
00936  tolua_Error tolua_err;
00937  if (
00938      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
00939      !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err) ||
00940      !tolua_isnoobj(tolua_S,3,&tolua_err)
00941  )
00942   goto tolua_lerror;
00943  else
00944 #endif
00945  {
00946   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00947   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
00948 #ifndef TOLUA_RELEASE
00949   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
00950 #endif
00951   {
00952    bool tolua_ret = (bool)  self->operator==(*comp);
00953    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00954   }
00955  }
00956  return 1;
00957 #ifndef TOLUA_RELEASE
00958  tolua_lerror:
00959  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
00960  return 0;
00961 #endif
00962 }
00963 #endif //#ifndef TOLUA_DISABLE
00964 
00965 /* method: hash of class  fawkes::SpeechSynthInterface */
00966 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_hash00
00967 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_hash00(lua_State* tolua_S)
00968 {
00969 #ifndef TOLUA_RELEASE
00970  tolua_Error tolua_err;
00971  if (
00972      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
00973      !tolua_isnoobj(tolua_S,2,&tolua_err)
00974  )
00975   goto tolua_lerror;
00976  else
00977 #endif
00978  {
00979   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
00980 #ifndef TOLUA_RELEASE
00981   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'",NULL);
00982 #endif
00983   {
00984    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
00985    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00986   }
00987  }
00988  return 1;
00989 #ifndef TOLUA_RELEASE
00990  tolua_lerror:
00991  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
00992  return 0;
00993 #endif
00994 }
00995 #endif //#ifndef TOLUA_DISABLE
00996 
00997 /* method: hash_size of class  fawkes::SpeechSynthInterface */
00998 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_hash_size00
00999 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_hash_size00(lua_State* tolua_S)
01000 {
01001 #ifndef TOLUA_RELEASE
01002  tolua_Error tolua_err;
01003  if (
01004      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
01005      !tolua_isnoobj(tolua_S,2,&tolua_err)
01006  )
01007   goto tolua_lerror;
01008  else
01009 #endif
01010  {
01011   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01012 #ifndef TOLUA_RELEASE
01013   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'",NULL);
01014 #endif
01015   {
01016    int tolua_ret = (int)  self->hash_size();
01017    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01018   }
01019  }
01020  return 1;
01021 #ifndef TOLUA_RELEASE
01022  tolua_lerror:
01023  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
01024  return 0;
01025 #endif
01026 }
01027 #endif //#ifndef TOLUA_DISABLE
01028 
01029 /* method: hash_printable of class  fawkes::SpeechSynthInterface */
01030 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_hash_printable00
01031 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_hash_printable00(lua_State* tolua_S)
01032 {
01033 #ifndef TOLUA_RELEASE
01034  tolua_Error tolua_err;
01035  if (
01036      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
01037      !tolua_isnoobj(tolua_S,2,&tolua_err)
01038  )
01039   goto tolua_lerror;
01040  else
01041 #endif
01042  {
01043   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01044 #ifndef TOLUA_RELEASE
01045   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'",NULL);
01046 #endif
01047   {
01048    const char* tolua_ret = (const char*)  self->hash_printable();
01049    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01050   }
01051  }
01052  return 1;
01053 #ifndef TOLUA_RELEASE
01054  tolua_lerror:
01055  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
01056  return 0;
01057 #endif
01058 }
01059 #endif //#ifndef TOLUA_DISABLE
01060 
01061 /* method: is_writer of class  fawkes::SpeechSynthInterface */
01062 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_is_writer00
01063 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_is_writer00(lua_State* tolua_S)
01064 {
01065 #ifndef TOLUA_RELEASE
01066  tolua_Error tolua_err;
01067  if (
01068      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
01069      !tolua_isnoobj(tolua_S,2,&tolua_err)
01070  )
01071   goto tolua_lerror;
01072  else
01073 #endif
01074  {
01075   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01076 #ifndef TOLUA_RELEASE
01077   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'",NULL);
01078 #endif
01079   {
01080    bool tolua_ret = (bool)  self->is_writer();
01081    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01082   }
01083  }
01084  return 1;
01085 #ifndef TOLUA_RELEASE
01086  tolua_lerror:
01087  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
01088  return 0;
01089 #endif
01090 }
01091 #endif //#ifndef TOLUA_DISABLE
01092 
01093 /* method: set_from_chunk of class  fawkes::SpeechSynthInterface */
01094 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_from_chunk00
01095 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_from_chunk00(lua_State* tolua_S)
01096 {
01097 #ifndef TOLUA_RELEASE
01098  tolua_Error tolua_err;
01099  if (
01100      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
01101      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
01102      !tolua_isnoobj(tolua_S,3,&tolua_err)
01103  )
01104   goto tolua_lerror;
01105  else
01106 #endif
01107  {
01108   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01109   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
01110 #ifndef TOLUA_RELEASE
01111   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'",NULL);
01112 #endif
01113   {
01114    self->set_from_chunk(chunk);
01115   }
01116  }
01117  return 0;
01118 #ifndef TOLUA_RELEASE
01119  tolua_lerror:
01120  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
01121  return 0;
01122 #endif
01123 }
01124 #endif //#ifndef TOLUA_DISABLE
01125 
01126 /* method: create_message of class  fawkes::SpeechSynthInterface */
01127 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_create_message00
01128 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_create_message00(lua_State* tolua_S)
01129 {
01130 #ifndef TOLUA_RELEASE
01131  tolua_Error tolua_err;
01132  if (
01133      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
01134      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01135      !tolua_isnoobj(tolua_S,3,&tolua_err)
01136  )
01137   goto tolua_lerror;
01138  else
01139 #endif
01140  {
01141   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01142   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
01143 #ifndef TOLUA_RELEASE
01144   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'",NULL);
01145 #endif
01146   {
01147    Message* tolua_ret = (Message*)  self->create_message(type);
01148    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
01149   }
01150  }
01151  return 1;
01152 #ifndef TOLUA_RELEASE
01153  tolua_lerror:
01154  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
01155  return 0;
01156 #endif
01157 }
01158 #endif //#ifndef TOLUA_DISABLE
01159 
01160 /* method: read of class  fawkes::SpeechSynthInterface */
01161 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_read00
01162 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_read00(lua_State* tolua_S)
01163 {
01164 #ifndef TOLUA_RELEASE
01165  tolua_Error tolua_err;
01166  if (
01167      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
01168      !tolua_isnoobj(tolua_S,2,&tolua_err)
01169  )
01170   goto tolua_lerror;
01171  else
01172 #endif
01173  {
01174   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01175 #ifndef TOLUA_RELEASE
01176   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'",NULL);
01177 #endif
01178   {
01179    self->read();
01180   }
01181  }
01182  return 0;
01183 #ifndef TOLUA_RELEASE
01184  tolua_lerror:
01185  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
01186  return 0;
01187 #endif
01188 }
01189 #endif //#ifndef TOLUA_DISABLE
01190 
01191 /* method: write of class  fawkes::SpeechSynthInterface */
01192 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_write00
01193 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_write00(lua_State* tolua_S)
01194 {
01195 #ifndef TOLUA_RELEASE
01196  tolua_Error tolua_err;
01197  if (
01198      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
01199      !tolua_isnoobj(tolua_S,2,&tolua_err)
01200  )
01201   goto tolua_lerror;
01202  else
01203 #endif
01204  {
01205   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01206 #ifndef TOLUA_RELEASE
01207   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'",NULL);
01208 #endif
01209   {
01210    self->write();
01211   }
01212  }
01213  return 0;
01214 #ifndef TOLUA_RELEASE
01215  tolua_lerror:
01216  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
01217  return 0;
01218 #endif
01219 }
01220 #endif //#ifndef TOLUA_DISABLE
01221 
01222 /* method: has_writer of class  fawkes::SpeechSynthInterface */
01223 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_has_writer00
01224 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_has_writer00(lua_State* tolua_S)
01225 {
01226 #ifndef TOLUA_RELEASE
01227  tolua_Error tolua_err;
01228  if (
01229      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
01230      !tolua_isnoobj(tolua_S,2,&tolua_err)
01231  )
01232   goto tolua_lerror;
01233  else
01234 #endif
01235  {
01236   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01237 #ifndef TOLUA_RELEASE
01238   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'",NULL);
01239 #endif
01240   {
01241    bool tolua_ret = (bool)  self->has_writer();
01242    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01243   }
01244  }
01245  return 1;
01246 #ifndef TOLUA_RELEASE
01247  tolua_lerror:
01248  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
01249  return 0;
01250 #endif
01251 }
01252 #endif //#ifndef TOLUA_DISABLE
01253 
01254 /* method: num_readers of class  fawkes::SpeechSynthInterface */
01255 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_num_readers00
01256 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_num_readers00(lua_State* tolua_S)
01257 {
01258 #ifndef TOLUA_RELEASE
01259  tolua_Error tolua_err;
01260  if (
01261      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechSynthInterface",0,&tolua_err) ||
01262      !tolua_isnoobj(tolua_S,2,&tolua_err)
01263  )
01264   goto tolua_lerror;
01265  else
01266 #endif
01267  {
01268   const fawkes::SpeechSynthInterface* self = (const fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01269 #ifndef TOLUA_RELEASE
01270   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'",NULL);
01271 #endif
01272   {
01273    unsigned int tolua_ret = (unsigned int)  self->num_readers();
01274    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01275   }
01276  }
01277  return 1;
01278 #ifndef TOLUA_RELEASE
01279  tolua_lerror:
01280  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
01281  return 0;
01282 #endif
01283 }
01284 #endif //#ifndef TOLUA_DISABLE
01285 
01286 /* method: msgq_enqueue_copy of class  fawkes::SpeechSynthInterface */
01287 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_enqueue_copy00
01288 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_enqueue_copy00(lua_State* tolua_S)
01289 {
01290 #ifndef TOLUA_RELEASE
01291  tolua_Error tolua_err;
01292  if (
01293      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
01294      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
01295      !tolua_isnoobj(tolua_S,3,&tolua_err)
01296  )
01297   goto tolua_lerror;
01298  else
01299 #endif
01300  {
01301   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01302   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
01303 #ifndef TOLUA_RELEASE
01304   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'",NULL);
01305 #endif
01306   {
01307    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
01308    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01309   }
01310  }
01311  return 1;
01312 #ifndef TOLUA_RELEASE
01313  tolua_lerror:
01314  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
01315  return 0;
01316 #endif
01317 }
01318 #endif //#ifndef TOLUA_DISABLE
01319 
01320 /* method: msgq_remove of class  fawkes::SpeechSynthInterface */
01321 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_remove00
01322 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_remove00(lua_State* tolua_S)
01323 {
01324 #ifndef TOLUA_RELEASE
01325  tolua_Error tolua_err;
01326  if (
01327      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
01328      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
01329      !tolua_isnoobj(tolua_S,3,&tolua_err)
01330  )
01331   goto tolua_lerror;
01332  else
01333 #endif
01334  {
01335   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01336   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
01337 #ifndef TOLUA_RELEASE
01338   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
01339 #endif
01340   {
01341    self->msgq_remove(message);
01342   }
01343  }
01344  return 0;
01345 #ifndef TOLUA_RELEASE
01346  tolua_lerror:
01347  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
01348  return 0;
01349 #endif
01350 }
01351 #endif //#ifndef TOLUA_DISABLE
01352 
01353 /* method: msgq_remove of class  fawkes::SpeechSynthInterface */
01354 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_remove01
01355 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_remove01(lua_State* tolua_S)
01356 {
01357  tolua_Error tolua_err;
01358  if (
01359      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
01360      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01361      !tolua_isnoobj(tolua_S,3,&tolua_err)
01362  )
01363   goto tolua_lerror;
01364  else
01365  {
01366   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01367   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
01368 #ifndef TOLUA_RELEASE
01369   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
01370 #endif
01371   {
01372    self->msgq_remove(message_id);
01373   }
01374  }
01375  return 0;
01376 tolua_lerror:
01377  return tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_remove00(tolua_S);
01378 }
01379 #endif //#ifndef TOLUA_DISABLE
01380 
01381 /* method: msgq_size of class  fawkes::SpeechSynthInterface */
01382 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_size00
01383 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_size00(lua_State* tolua_S)
01384 {
01385 #ifndef TOLUA_RELEASE
01386  tolua_Error tolua_err;
01387  if (
01388      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
01389      !tolua_isnoobj(tolua_S,2,&tolua_err)
01390  )
01391   goto tolua_lerror;
01392  else
01393 #endif
01394  {
01395   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01396 #ifndef TOLUA_RELEASE
01397   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'",NULL);
01398 #endif
01399   {
01400    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
01401    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01402   }
01403  }
01404  return 1;
01405 #ifndef TOLUA_RELEASE
01406  tolua_lerror:
01407  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
01408  return 0;
01409 #endif
01410 }
01411 #endif //#ifndef TOLUA_DISABLE
01412 
01413 /* method: msgq_flush of class  fawkes::SpeechSynthInterface */
01414 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_flush00
01415 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_flush00(lua_State* tolua_S)
01416 {
01417 #ifndef TOLUA_RELEASE
01418  tolua_Error tolua_err;
01419  if (
01420      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
01421      !tolua_isnoobj(tolua_S,2,&tolua_err)
01422  )
01423   goto tolua_lerror;
01424  else
01425 #endif
01426  {
01427   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01428 #ifndef TOLUA_RELEASE
01429   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'",NULL);
01430 #endif
01431   {
01432    self->msgq_flush();
01433   }
01434  }
01435  return 0;
01436 #ifndef TOLUA_RELEASE
01437  tolua_lerror:
01438  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
01439  return 0;
01440 #endif
01441 }
01442 #endif //#ifndef TOLUA_DISABLE
01443 
01444 /* method: msgq_lock of class  fawkes::SpeechSynthInterface */
01445 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_lock00
01446 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_lock00(lua_State* tolua_S)
01447 {
01448 #ifndef TOLUA_RELEASE
01449  tolua_Error tolua_err;
01450  if (
01451      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
01452      !tolua_isnoobj(tolua_S,2,&tolua_err)
01453  )
01454   goto tolua_lerror;
01455  else
01456 #endif
01457  {
01458   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01459 #ifndef TOLUA_RELEASE
01460   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'",NULL);
01461 #endif
01462   {
01463    self->msgq_lock();
01464   }
01465  }
01466  return 0;
01467 #ifndef TOLUA_RELEASE
01468  tolua_lerror:
01469  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
01470  return 0;
01471 #endif
01472 }
01473 #endif //#ifndef TOLUA_DISABLE
01474 
01475 /* method: msgq_try_lock of class  fawkes::SpeechSynthInterface */
01476 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_try_lock00
01477 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_try_lock00(lua_State* tolua_S)
01478 {
01479 #ifndef TOLUA_RELEASE
01480  tolua_Error tolua_err;
01481  if (
01482      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
01483      !tolua_isnoobj(tolua_S,2,&tolua_err)
01484  )
01485   goto tolua_lerror;
01486  else
01487 #endif
01488  {
01489   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01490 #ifndef TOLUA_RELEASE
01491   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'",NULL);
01492 #endif
01493   {
01494    bool tolua_ret = (bool)  self->msgq_try_lock();
01495    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01496   }
01497  }
01498  return 1;
01499 #ifndef TOLUA_RELEASE
01500  tolua_lerror:
01501  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
01502  return 0;
01503 #endif
01504 }
01505 #endif //#ifndef TOLUA_DISABLE
01506 
01507 /* method: msgq_unlock of class  fawkes::SpeechSynthInterface */
01508 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_unlock00
01509 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_unlock00(lua_State* tolua_S)
01510 {
01511 #ifndef TOLUA_RELEASE
01512  tolua_Error tolua_err;
01513  if (
01514      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
01515      !tolua_isnoobj(tolua_S,2,&tolua_err)
01516  )
01517   goto tolua_lerror;
01518  else
01519 #endif
01520  {
01521   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01522 #ifndef TOLUA_RELEASE
01523   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'",NULL);
01524 #endif
01525   {
01526    self->msgq_unlock();
01527   }
01528  }
01529  return 0;
01530 #ifndef TOLUA_RELEASE
01531  tolua_lerror:
01532  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
01533  return 0;
01534 #endif
01535 }
01536 #endif //#ifndef TOLUA_DISABLE
01537 
01538 /* method: msgq_pop of class  fawkes::SpeechSynthInterface */
01539 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_pop00
01540 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_pop00(lua_State* tolua_S)
01541 {
01542 #ifndef TOLUA_RELEASE
01543  tolua_Error tolua_err;
01544  if (
01545      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
01546      !tolua_isnoobj(tolua_S,2,&tolua_err)
01547  )
01548   goto tolua_lerror;
01549  else
01550 #endif
01551  {
01552   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01553 #ifndef TOLUA_RELEASE
01554   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'",NULL);
01555 #endif
01556   {
01557    self->msgq_pop();
01558   }
01559  }
01560  return 0;
01561 #ifndef TOLUA_RELEASE
01562  tolua_lerror:
01563  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
01564  return 0;
01565 #endif
01566 }
01567 #endif //#ifndef TOLUA_DISABLE
01568 
01569 /* method: msgq_first of class  fawkes::SpeechSynthInterface */
01570 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_first00
01571 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_first00(lua_State* tolua_S)
01572 {
01573 #ifndef TOLUA_RELEASE
01574  tolua_Error tolua_err;
01575  if (
01576      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
01577      !tolua_isnoobj(tolua_S,2,&tolua_err)
01578  )
01579   goto tolua_lerror;
01580  else
01581 #endif
01582  {
01583   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01584 #ifndef TOLUA_RELEASE
01585   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'",NULL);
01586 #endif
01587   {
01588    Message* tolua_ret = (Message*)  self->msgq_first();
01589    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
01590   }
01591  }
01592  return 1;
01593 #ifndef TOLUA_RELEASE
01594  tolua_lerror:
01595  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
01596  return 0;
01597 #endif
01598 }
01599 #endif //#ifndef TOLUA_DISABLE
01600 
01601 /* method: msgq_empty of class  fawkes::SpeechSynthInterface */
01602 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_empty00
01603 static int tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_empty00(lua_State* tolua_S)
01604 {
01605 #ifndef TOLUA_RELEASE
01606  tolua_Error tolua_err;
01607  if (
01608      !tolua_isusertype(tolua_S,1,"fawkes::SpeechSynthInterface",0,&tolua_err) ||
01609      !tolua_isnoobj(tolua_S,2,&tolua_err)
01610  )
01611   goto tolua_lerror;
01612  else
01613 #endif
01614  {
01615   fawkes::SpeechSynthInterface* self = (fawkes::SpeechSynthInterface*)  tolua_tousertype(tolua_S,1,0);
01616 #ifndef TOLUA_RELEASE
01617   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'",NULL);
01618 #endif
01619   {
01620    bool tolua_ret = (bool)  self->msgq_empty();
01621    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01622   }
01623  }
01624  return 1;
01625 #ifndef TOLUA_RELEASE
01626  tolua_lerror:
01627  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
01628  return 0;
01629 #endif
01630 }
01631 #endif //#ifndef TOLUA_DISABLE
01632 
01633 /* Open function */
01634 TOLUA_API int tolua_interfaces_SpeechSynthInterface_open (lua_State* tolua_S)
01635 {
01636  tolua_open(tolua_S);
01637  tolua_reg_types(tolua_S);
01638  tolua_module(tolua_S,NULL,0);
01639  tolua_beginmodule(tolua_S,NULL);
01640   tolua_module(tolua_S,"fawkes",0);
01641   tolua_beginmodule(tolua_S,"fawkes");
01642    tolua_cclass(tolua_S,"SpeechSynthInterface","fawkes::SpeechSynthInterface","Interface",NULL);
01643    tolua_beginmodule(tolua_S,"SpeechSynthInterface");
01644     #ifdef __cplusplus
01645     tolua_cclass(tolua_S,"SayMessage","fawkes::SpeechSynthInterface::SayMessage","Message",tolua_collect_fawkes__SpeechSynthInterface__SayMessage);
01646     #else
01647     tolua_cclass(tolua_S,"SayMessage","fawkes::SpeechSynthInterface::SayMessage","Message",NULL);
01648     #endif
01649     tolua_beginmodule(tolua_S,"SayMessage");
01650      tolua_function(tolua_S,"new",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new00);
01651      tolua_function(tolua_S,"new_local",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new00_local);
01652      tolua_function(tolua_S,".call",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new00_local);
01653      tolua_function(tolua_S,"new",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new01);
01654      tolua_function(tolua_S,"new_local",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new01_local);
01655      tolua_function(tolua_S,".call",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_new01_local);
01656      tolua_function(tolua_S,"delete",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_delete00);
01657      tolua_function(tolua_S,"text",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_text00);
01658      tolua_function(tolua_S,"set_text",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_set_text00);
01659      tolua_function(tolua_S,"maxlenof_text",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_SayMessage_maxlenof_text00);
01660     tolua_endmodule(tolua_S);
01661     tolua_function(tolua_S,"text",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_text00);
01662     tolua_function(tolua_S,"set_text",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_text00);
01663     tolua_function(tolua_S,"maxlenof_text",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_maxlenof_text00);
01664     tolua_function(tolua_S,"msgid",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgid00);
01665     tolua_function(tolua_S,"set_msgid",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_msgid00);
01666     tolua_function(tolua_S,"maxlenof_msgid",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_maxlenof_msgid00);
01667     tolua_function(tolua_S,"is_final",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_is_final00);
01668     tolua_function(tolua_S,"set_final",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_final00);
01669     tolua_function(tolua_S,"maxlenof_final",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_maxlenof_final00);
01670     tolua_function(tolua_S,"duration",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_duration00);
01671     tolua_function(tolua_S,"set_duration",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_duration00);
01672     tolua_function(tolua_S,"maxlenof_duration",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_maxlenof_duration00);
01673     tolua_function(tolua_S,"oftype",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_oftype00);
01674     tolua_function(tolua_S,"datachunk",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_datachunk00);
01675     tolua_function(tolua_S,"datasize",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_datasize00);
01676     tolua_function(tolua_S,"type",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_type00);
01677     tolua_function(tolua_S,"id",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_id00);
01678     tolua_function(tolua_S,"uid",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_uid00);
01679     tolua_function(tolua_S,"serial",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_serial00);
01680     tolua_function(tolua_S,"mem_serial",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_mem_serial00);
01681     tolua_function(tolua_S,".eq",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface__eq00);
01682     tolua_function(tolua_S,"hash",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_hash00);
01683     tolua_function(tolua_S,"hash_size",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_hash_size00);
01684     tolua_function(tolua_S,"hash_printable",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_hash_printable00);
01685     tolua_function(tolua_S,"is_writer",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_is_writer00);
01686     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_set_from_chunk00);
01687     tolua_function(tolua_S,"create_message",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_create_message00);
01688     tolua_function(tolua_S,"read",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_read00);
01689     tolua_function(tolua_S,"write",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_write00);
01690     tolua_function(tolua_S,"has_writer",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_has_writer00);
01691     tolua_function(tolua_S,"num_readers",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_num_readers00);
01692     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_enqueue_copy00);
01693     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_remove00);
01694     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_remove01);
01695     tolua_function(tolua_S,"msgq_size",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_size00);
01696     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_flush00);
01697     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_lock00);
01698     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_try_lock00);
01699     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_unlock00);
01700     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_pop00);
01701     tolua_function(tolua_S,"msgq_first",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_first00);
01702     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_SpeechSynthInterface_fawkes_SpeechSynthInterface_msgq_empty00);
01703    tolua_endmodule(tolua_S);
01704   tolua_endmodule(tolua_S);
01705  tolua_endmodule(tolua_S);
01706  return 1;
01707 }
01708
01709
01710 extern "C" {
01711 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
01712  TOLUA_API int luaopen_interfaces_SpeechSynthInterface (lua_State* tolua_S) {
01713  return tolua_interfaces_SpeechSynthInterface_open(tolua_S);
01714 };
01715 #endif
01716 }
01717
01718