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

Generated on Tue Feb 22 13:31:23 2011 for Fawkes API by  doxygen 1.4.7