SpeechRecognitionInterface_tolua.cpp

00001 /*
00002 ** Lua binding: interfaces_SpeechRecognitionInterface
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_SpeechRecognitionInterface_open (lua_State* tolua_S);
00028
00029 #include <interfaces/SpeechRecognitionInterface.h>
00030 using namespace fawkes;
00031
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__SpeechRecognitionInterface__SetEnabledMessage (lua_State* tolua_S)
00036 {
00037  fawkes::SpeechRecognitionInterface::SetEnabledMessage* self = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*) tolua_tousertype(tolua_S,1,0);
00038         delete self;
00039         return 0;
00040 }
00041
00042 static int tolua_collect_fawkes__SpeechRecognitionInterface__ResetMessage (lua_State* tolua_S)
00043 {
00044  fawkes::SpeechRecognitionInterface::ResetMessage* self = (fawkes::SpeechRecognitionInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0);
00045         delete self;
00046         return 0;
00047 }
00048 #endif
00049 
00050
00051 /* function to register type */
00052 static void tolua_reg_types (lua_State* tolua_S)
00053 {
00054  tolua_usertype(tolua_S,"Message");
00055  tolua_usertype(tolua_S,"fawkes::SpeechRecognitionInterface");
00056  tolua_usertype(tolua_S,"fawkes::SpeechRecognitionInterface::ResetMessage");
00057  tolua_usertype(tolua_S,"fawkes::SpeechRecognitionInterface::SetEnabledMessage");
00058  tolua_usertype(tolua_S,"Interface");
00059 }
00060
00061 /* method: new of class  ResetMessage */
00062 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_new00
00063 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_new00(lua_State* tolua_S)
00064 {
00065 #ifndef TOLUA_RELEASE
00066  tolua_Error tolua_err;
00067  if (
00068      !tolua_isusertable(tolua_S,1,"fawkes::SpeechRecognitionInterface::ResetMessage",0,&tolua_err) ||
00069      !tolua_isnoobj(tolua_S,2,&tolua_err)
00070  )
00071   goto tolua_lerror;
00072  else
00073 #endif
00074  {
00075   {
00076    fawkes::SpeechRecognitionInterface::ResetMessage* tolua_ret = (fawkes::SpeechRecognitionInterface::ResetMessage*)  new fawkes::SpeechRecognitionInterface::ResetMessage();
00077    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SpeechRecognitionInterface::ResetMessage");
00078   }
00079  }
00080  return 1;
00081 #ifndef TOLUA_RELEASE
00082  tolua_lerror:
00083  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00084  return 0;
00085 #endif
00086 }
00087 #endif //#ifndef TOLUA_DISABLE
00088 
00089 /* method: new_local of class  ResetMessage */
00090 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_new00_local
00091 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_new00_local(lua_State* tolua_S)
00092 {
00093 #ifndef TOLUA_RELEASE
00094  tolua_Error tolua_err;
00095  if (
00096      !tolua_isusertable(tolua_S,1,"fawkes::SpeechRecognitionInterface::ResetMessage",0,&tolua_err) ||
00097      !tolua_isnoobj(tolua_S,2,&tolua_err)
00098  )
00099   goto tolua_lerror;
00100  else
00101 #endif
00102  {
00103   {
00104    fawkes::SpeechRecognitionInterface::ResetMessage* tolua_ret = (fawkes::SpeechRecognitionInterface::ResetMessage*)  new fawkes::SpeechRecognitionInterface::ResetMessage();
00105    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::SpeechRecognitionInterface::ResetMessage");
00106   }
00107  }
00108  return 1;
00109 #ifndef TOLUA_RELEASE
00110  tolua_lerror:
00111  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00112  return 0;
00113 #endif
00114 }
00115 #endif //#ifndef TOLUA_DISABLE
00116 
00117 /* method: delete of class  ResetMessage */
00118 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_delete00
00119 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_delete00(lua_State* tolua_S)
00120 {
00121 #ifndef TOLUA_RELEASE
00122  tolua_Error tolua_err;
00123  if (
00124      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface::ResetMessage",0,&tolua_err) ||
00125      !tolua_isnoobj(tolua_S,2,&tolua_err)
00126  )
00127   goto tolua_lerror;
00128  else
00129 #endif
00130  {
00131   fawkes::SpeechRecognitionInterface::ResetMessage* self = (fawkes::SpeechRecognitionInterface::ResetMessage*)  tolua_tousertype(tolua_S,1,0);
00132 #ifndef TOLUA_RELEASE
00133   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00134 #endif
00135   delete self;
00136  }
00137  return 0;
00138 #ifndef TOLUA_RELEASE
00139  tolua_lerror:
00140  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00141  return 0;
00142 #endif
00143 }
00144 #endif //#ifndef TOLUA_DISABLE
00145 
00146 /* method: new of class  SetEnabledMessage */
00147 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00
00148 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00(lua_State* tolua_S)
00149 {
00150 #ifndef TOLUA_RELEASE
00151  tolua_Error tolua_err;
00152  if (
00153      !tolua_isusertable(tolua_S,1,"fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) ||
00154      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
00155      !tolua_isnoobj(tolua_S,3,&tolua_err)
00156  )
00157   goto tolua_lerror;
00158  else
00159 #endif
00160  {
00161   bool ini_enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
00162   {
00163    fawkes::SpeechRecognitionInterface::SetEnabledMessage* tolua_ret = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*)  new fawkes::SpeechRecognitionInterface::SetEnabledMessage(ini_enabled);
00164    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SpeechRecognitionInterface::SetEnabledMessage");
00165   }
00166  }
00167  return 1;
00168 #ifndef TOLUA_RELEASE
00169  tolua_lerror:
00170  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00171  return 0;
00172 #endif
00173 }
00174 #endif //#ifndef TOLUA_DISABLE
00175 
00176 /* method: new_local of class  SetEnabledMessage */
00177 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00_local
00178 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00_local(lua_State* tolua_S)
00179 {
00180 #ifndef TOLUA_RELEASE
00181  tolua_Error tolua_err;
00182  if (
00183      !tolua_isusertable(tolua_S,1,"fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) ||
00184      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
00185      !tolua_isnoobj(tolua_S,3,&tolua_err)
00186  )
00187   goto tolua_lerror;
00188  else
00189 #endif
00190  {
00191   bool ini_enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
00192   {
00193    fawkes::SpeechRecognitionInterface::SetEnabledMessage* tolua_ret = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*)  new fawkes::SpeechRecognitionInterface::SetEnabledMessage(ini_enabled);
00194    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::SpeechRecognitionInterface::SetEnabledMessage");
00195   }
00196  }
00197  return 1;
00198 #ifndef TOLUA_RELEASE
00199  tolua_lerror:
00200  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00201  return 0;
00202 #endif
00203 }
00204 #endif //#ifndef TOLUA_DISABLE
00205 
00206 /* method: new of class  SetEnabledMessage */
00207 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new01
00208 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new01(lua_State* tolua_S)
00209 {
00210  tolua_Error tolua_err;
00211  if (
00212      !tolua_isusertable(tolua_S,1,"fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) ||
00213      !tolua_isnoobj(tolua_S,2,&tolua_err)
00214  )
00215   goto tolua_lerror;
00216  else
00217  {
00218   {
00219    fawkes::SpeechRecognitionInterface::SetEnabledMessage* tolua_ret = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*)  new fawkes::SpeechRecognitionInterface::SetEnabledMessage();
00220    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SpeechRecognitionInterface::SetEnabledMessage");
00221   }
00222  }
00223  return 1;
00224 tolua_lerror:
00225  return tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00(tolua_S);
00226 }
00227 #endif //#ifndef TOLUA_DISABLE
00228 
00229 /* method: new_local of class  SetEnabledMessage */
00230 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new01_local
00231 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new01_local(lua_State* tolua_S)
00232 {
00233  tolua_Error tolua_err;
00234  if (
00235      !tolua_isusertable(tolua_S,1,"fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) ||
00236      !tolua_isnoobj(tolua_S,2,&tolua_err)
00237  )
00238   goto tolua_lerror;
00239  else
00240  {
00241   {
00242    fawkes::SpeechRecognitionInterface::SetEnabledMessage* tolua_ret = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*)  new fawkes::SpeechRecognitionInterface::SetEnabledMessage();
00243    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::SpeechRecognitionInterface::SetEnabledMessage");
00244   }
00245  }
00246  return 1;
00247 tolua_lerror:
00248  return tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00_local(tolua_S);
00249 }
00250 #endif //#ifndef TOLUA_DISABLE
00251 
00252 /* method: delete of class  SetEnabledMessage */
00253 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_delete00
00254 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_delete00(lua_State* tolua_S)
00255 {
00256 #ifndef TOLUA_RELEASE
00257  tolua_Error tolua_err;
00258  if (
00259      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) ||
00260      !tolua_isnoobj(tolua_S,2,&tolua_err)
00261  )
00262   goto tolua_lerror;
00263  else
00264 #endif
00265  {
00266   fawkes::SpeechRecognitionInterface::SetEnabledMessage* self = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*)  tolua_tousertype(tolua_S,1,0);
00267 #ifndef TOLUA_RELEASE
00268   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00269 #endif
00270   delete self;
00271  }
00272  return 0;
00273 #ifndef TOLUA_RELEASE
00274  tolua_lerror:
00275  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00276  return 0;
00277 #endif
00278 }
00279 #endif //#ifndef TOLUA_DISABLE
00280 
00281 /* method: is_enabled of class  SetEnabledMessage */
00282 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_is_enabled00
00283 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_is_enabled00(lua_State* tolua_S)
00284 {
00285 #ifndef TOLUA_RELEASE
00286  tolua_Error tolua_err;
00287  if (
00288      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) ||
00289      !tolua_isnoobj(tolua_S,2,&tolua_err)
00290  )
00291   goto tolua_lerror;
00292  else
00293 #endif
00294  {
00295   fawkes::SpeechRecognitionInterface::SetEnabledMessage* self = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*)  tolua_tousertype(tolua_S,1,0);
00296 #ifndef TOLUA_RELEASE
00297   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_enabled'",NULL);
00298 #endif
00299   {
00300    bool tolua_ret = (bool)  self->is_enabled();
00301    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00302   }
00303  }
00304  return 1;
00305 #ifndef TOLUA_RELEASE
00306  tolua_lerror:
00307  tolua_error(tolua_S,"#ferror in function 'is_enabled'.",&tolua_err);
00308  return 0;
00309 #endif
00310 }
00311 #endif //#ifndef TOLUA_DISABLE
00312 
00313 /* method: set_enabled of class  SetEnabledMessage */
00314 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_set_enabled00
00315 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_set_enabled00(lua_State* tolua_S)
00316 {
00317 #ifndef TOLUA_RELEASE
00318  tolua_Error tolua_err;
00319  if (
00320      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) ||
00321      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
00322      !tolua_isnoobj(tolua_S,3,&tolua_err)
00323  )
00324   goto tolua_lerror;
00325  else
00326 #endif
00327  {
00328   fawkes::SpeechRecognitionInterface::SetEnabledMessage* self = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*)  tolua_tousertype(tolua_S,1,0);
00329   const bool new_enabled = ((const bool)  tolua_toboolean(tolua_S,2,0));
00330 #ifndef TOLUA_RELEASE
00331   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_enabled'",NULL);
00332 #endif
00333   {
00334    self->set_enabled(new_enabled);
00335   }
00336  }
00337  return 0;
00338 #ifndef TOLUA_RELEASE
00339  tolua_lerror:
00340  tolua_error(tolua_S,"#ferror in function 'set_enabled'.",&tolua_err);
00341  return 0;
00342 #endif
00343 }
00344 #endif //#ifndef TOLUA_DISABLE
00345 
00346 /* method: maxlenof_enabled of class  SetEnabledMessage */
00347 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_maxlenof_enabled00
00348 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_maxlenof_enabled00(lua_State* tolua_S)
00349 {
00350 #ifndef TOLUA_RELEASE
00351  tolua_Error tolua_err;
00352  if (
00353      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) ||
00354      !tolua_isnoobj(tolua_S,2,&tolua_err)
00355  )
00356   goto tolua_lerror;
00357  else
00358 #endif
00359  {
00360   const fawkes::SpeechRecognitionInterface::SetEnabledMessage* self = (const fawkes::SpeechRecognitionInterface::SetEnabledMessage*)  tolua_tousertype(tolua_S,1,0);
00361 #ifndef TOLUA_RELEASE
00362   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_enabled'",NULL);
00363 #endif
00364   {
00365    int tolua_ret = (int)  self->maxlenof_enabled();
00366    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00367   }
00368  }
00369  return 1;
00370 #ifndef TOLUA_RELEASE
00371  tolua_lerror:
00372  tolua_error(tolua_S,"#ferror in function 'maxlenof_enabled'.",&tolua_err);
00373  return 0;
00374 #endif
00375 }
00376 #endif //#ifndef TOLUA_DISABLE
00377 
00378 /* method: text of class  fawkes::SpeechRecognitionInterface */
00379 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_text00
00380 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_text00(lua_State* tolua_S)
00381 {
00382 #ifndef TOLUA_RELEASE
00383  tolua_Error tolua_err;
00384  if (
00385      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00386      !tolua_isnoobj(tolua_S,2,&tolua_err)
00387  )
00388   goto tolua_lerror;
00389  else
00390 #endif
00391  {
00392   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00393 #ifndef TOLUA_RELEASE
00394   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'text'",NULL);
00395 #endif
00396   {
00397    char* tolua_ret = (char*)  self->text();
00398    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00399   }
00400  }
00401  return 1;
00402 #ifndef TOLUA_RELEASE
00403  tolua_lerror:
00404  tolua_error(tolua_S,"#ferror in function 'text'.",&tolua_err);
00405  return 0;
00406 #endif
00407 }
00408 #endif //#ifndef TOLUA_DISABLE
00409 
00410 /* method: set_text of class  fawkes::SpeechRecognitionInterface */
00411 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_text00
00412 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_text00(lua_State* tolua_S)
00413 {
00414 #ifndef TOLUA_RELEASE
00415  tolua_Error tolua_err;
00416  if (
00417      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00418      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00419      !tolua_isnoobj(tolua_S,3,&tolua_err)
00420  )
00421   goto tolua_lerror;
00422  else
00423 #endif
00424  {
00425   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00426   const char* new_text = ((const char*)  tolua_tostring(tolua_S,2,0));
00427 #ifndef TOLUA_RELEASE
00428   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_text'",NULL);
00429 #endif
00430   {
00431    self->set_text(new_text);
00432   }
00433  }
00434  return 0;
00435 #ifndef TOLUA_RELEASE
00436  tolua_lerror:
00437  tolua_error(tolua_S,"#ferror in function 'set_text'.",&tolua_err);
00438  return 0;
00439 #endif
00440 }
00441 #endif //#ifndef TOLUA_DISABLE
00442 
00443 /* method: maxlenof_text of class  fawkes::SpeechRecognitionInterface */
00444 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_text00
00445 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_text00(lua_State* tolua_S)
00446 {
00447 #ifndef TOLUA_RELEASE
00448  tolua_Error tolua_err;
00449  if (
00450      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00451      !tolua_isnoobj(tolua_S,2,&tolua_err)
00452  )
00453   goto tolua_lerror;
00454  else
00455 #endif
00456  {
00457   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00458 #ifndef TOLUA_RELEASE
00459   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_text'",NULL);
00460 #endif
00461   {
00462    int tolua_ret = (int)  self->maxlenof_text();
00463    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00464   }
00465  }
00466  return 1;
00467 #ifndef TOLUA_RELEASE
00468  tolua_lerror:
00469  tolua_error(tolua_S,"#ferror in function 'maxlenof_text'.",&tolua_err);
00470  return 0;
00471 #endif
00472 }
00473 #endif //#ifndef TOLUA_DISABLE
00474 
00475 /* method: counter of class  fawkes::SpeechRecognitionInterface */
00476 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_counter00
00477 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_counter00(lua_State* tolua_S)
00478 {
00479 #ifndef TOLUA_RELEASE
00480  tolua_Error tolua_err;
00481  if (
00482      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00483      !tolua_isnoobj(tolua_S,2,&tolua_err)
00484  )
00485   goto tolua_lerror;
00486  else
00487 #endif
00488  {
00489   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00490 #ifndef TOLUA_RELEASE
00491   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'counter'",NULL);
00492 #endif
00493   {
00494    unsigned int tolua_ret = (unsigned int)  self->counter();
00495    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00496   }
00497  }
00498  return 1;
00499 #ifndef TOLUA_RELEASE
00500  tolua_lerror:
00501  tolua_error(tolua_S,"#ferror in function 'counter'.",&tolua_err);
00502  return 0;
00503 #endif
00504 }
00505 #endif //#ifndef TOLUA_DISABLE
00506 
00507 /* method: set_counter of class  fawkes::SpeechRecognitionInterface */
00508 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_counter00
00509 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_counter00(lua_State* tolua_S)
00510 {
00511 #ifndef TOLUA_RELEASE
00512  tolua_Error tolua_err;
00513  if (
00514      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00515      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00516      !tolua_isnoobj(tolua_S,3,&tolua_err)
00517  )
00518   goto tolua_lerror;
00519  else
00520 #endif
00521  {
00522   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00523   unsigned const int new_counter = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
00524 #ifndef TOLUA_RELEASE
00525   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_counter'",NULL);
00526 #endif
00527   {
00528    self->set_counter(new_counter);
00529   }
00530  }
00531  return 0;
00532 #ifndef TOLUA_RELEASE
00533  tolua_lerror:
00534  tolua_error(tolua_S,"#ferror in function 'set_counter'.",&tolua_err);
00535  return 0;
00536 #endif
00537 }
00538 #endif //#ifndef TOLUA_DISABLE
00539 
00540 /* method: maxlenof_counter of class  fawkes::SpeechRecognitionInterface */
00541 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_counter00
00542 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_counter00(lua_State* tolua_S)
00543 {
00544 #ifndef TOLUA_RELEASE
00545  tolua_Error tolua_err;
00546  if (
00547      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00548      !tolua_isnoobj(tolua_S,2,&tolua_err)
00549  )
00550   goto tolua_lerror;
00551  else
00552 #endif
00553  {
00554   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00555 #ifndef TOLUA_RELEASE
00556   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_counter'",NULL);
00557 #endif
00558   {
00559    int tolua_ret = (int)  self->maxlenof_counter();
00560    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00561   }
00562  }
00563  return 1;
00564 #ifndef TOLUA_RELEASE
00565  tolua_lerror:
00566  tolua_error(tolua_S,"#ferror in function 'maxlenof_counter'.",&tolua_err);
00567  return 0;
00568 #endif
00569 }
00570 #endif //#ifndef TOLUA_DISABLE
00571 
00572 /* method: is_processing of class  fawkes::SpeechRecognitionInterface */
00573 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_processing00
00574 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_processing00(lua_State* tolua_S)
00575 {
00576 #ifndef TOLUA_RELEASE
00577  tolua_Error tolua_err;
00578  if (
00579      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00580      !tolua_isnoobj(tolua_S,2,&tolua_err)
00581  )
00582   goto tolua_lerror;
00583  else
00584 #endif
00585  {
00586   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00587 #ifndef TOLUA_RELEASE
00588   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_processing'",NULL);
00589 #endif
00590   {
00591    bool tolua_ret = (bool)  self->is_processing();
00592    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00593   }
00594  }
00595  return 1;
00596 #ifndef TOLUA_RELEASE
00597  tolua_lerror:
00598  tolua_error(tolua_S,"#ferror in function 'is_processing'.",&tolua_err);
00599  return 0;
00600 #endif
00601 }
00602 #endif //#ifndef TOLUA_DISABLE
00603 
00604 /* method: set_processing of class  fawkes::SpeechRecognitionInterface */
00605 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_processing00
00606 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_processing00(lua_State* tolua_S)
00607 {
00608 #ifndef TOLUA_RELEASE
00609  tolua_Error tolua_err;
00610  if (
00611      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00612      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
00613      !tolua_isnoobj(tolua_S,3,&tolua_err)
00614  )
00615   goto tolua_lerror;
00616  else
00617 #endif
00618  {
00619   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00620   const bool new_processing = ((const bool)  tolua_toboolean(tolua_S,2,0));
00621 #ifndef TOLUA_RELEASE
00622   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_processing'",NULL);
00623 #endif
00624   {
00625    self->set_processing(new_processing);
00626   }
00627  }
00628  return 0;
00629 #ifndef TOLUA_RELEASE
00630  tolua_lerror:
00631  tolua_error(tolua_S,"#ferror in function 'set_processing'.",&tolua_err);
00632  return 0;
00633 #endif
00634 }
00635 #endif //#ifndef TOLUA_DISABLE
00636 
00637 /* method: maxlenof_processing of class  fawkes::SpeechRecognitionInterface */
00638 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_processing00
00639 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_processing00(lua_State* tolua_S)
00640 {
00641 #ifndef TOLUA_RELEASE
00642  tolua_Error tolua_err;
00643  if (
00644      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00645      !tolua_isnoobj(tolua_S,2,&tolua_err)
00646  )
00647   goto tolua_lerror;
00648  else
00649 #endif
00650  {
00651   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00652 #ifndef TOLUA_RELEASE
00653   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_processing'",NULL);
00654 #endif
00655   {
00656    int tolua_ret = (int)  self->maxlenof_processing();
00657    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00658   }
00659  }
00660  return 1;
00661 #ifndef TOLUA_RELEASE
00662  tolua_lerror:
00663  tolua_error(tolua_S,"#ferror in function 'maxlenof_processing'.",&tolua_err);
00664  return 0;
00665 #endif
00666 }
00667 #endif //#ifndef TOLUA_DISABLE
00668 
00669 /* method: is_enabled of class  fawkes::SpeechRecognitionInterface */
00670 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_enabled00
00671 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_enabled00(lua_State* tolua_S)
00672 {
00673 #ifndef TOLUA_RELEASE
00674  tolua_Error tolua_err;
00675  if (
00676      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00677      !tolua_isnoobj(tolua_S,2,&tolua_err)
00678  )
00679   goto tolua_lerror;
00680  else
00681 #endif
00682  {
00683   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00684 #ifndef TOLUA_RELEASE
00685   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_enabled'",NULL);
00686 #endif
00687   {
00688    bool tolua_ret = (bool)  self->is_enabled();
00689    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00690   }
00691  }
00692  return 1;
00693 #ifndef TOLUA_RELEASE
00694  tolua_lerror:
00695  tolua_error(tolua_S,"#ferror in function 'is_enabled'.",&tolua_err);
00696  return 0;
00697 #endif
00698 }
00699 #endif //#ifndef TOLUA_DISABLE
00700 
00701 /* method: set_enabled of class  fawkes::SpeechRecognitionInterface */
00702 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_enabled00
00703 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_enabled00(lua_State* tolua_S)
00704 {
00705 #ifndef TOLUA_RELEASE
00706  tolua_Error tolua_err;
00707  if (
00708      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00709      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
00710      !tolua_isnoobj(tolua_S,3,&tolua_err)
00711  )
00712   goto tolua_lerror;
00713  else
00714 #endif
00715  {
00716   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00717   const bool new_enabled = ((const bool)  tolua_toboolean(tolua_S,2,0));
00718 #ifndef TOLUA_RELEASE
00719   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_enabled'",NULL);
00720 #endif
00721   {
00722    self->set_enabled(new_enabled);
00723   }
00724  }
00725  return 0;
00726 #ifndef TOLUA_RELEASE
00727  tolua_lerror:
00728  tolua_error(tolua_S,"#ferror in function 'set_enabled'.",&tolua_err);
00729  return 0;
00730 #endif
00731 }
00732 #endif //#ifndef TOLUA_DISABLE
00733 
00734 /* method: maxlenof_enabled of class  fawkes::SpeechRecognitionInterface */
00735 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_enabled00
00736 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_enabled00(lua_State* tolua_S)
00737 {
00738 #ifndef TOLUA_RELEASE
00739  tolua_Error tolua_err;
00740  if (
00741      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00742      !tolua_isnoobj(tolua_S,2,&tolua_err)
00743  )
00744   goto tolua_lerror;
00745  else
00746 #endif
00747  {
00748   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00749 #ifndef TOLUA_RELEASE
00750   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_enabled'",NULL);
00751 #endif
00752   {
00753    int tolua_ret = (int)  self->maxlenof_enabled();
00754    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00755   }
00756  }
00757  return 1;
00758 #ifndef TOLUA_RELEASE
00759  tolua_lerror:
00760  tolua_error(tolua_S,"#ferror in function 'maxlenof_enabled'.",&tolua_err);
00761  return 0;
00762 #endif
00763 }
00764 #endif //#ifndef TOLUA_DISABLE
00765 
00766 /* method: oftype of class  fawkes::SpeechRecognitionInterface */
00767 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_oftype00
00768 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_oftype00(lua_State* tolua_S)
00769 {
00770 #ifndef TOLUA_RELEASE
00771  tolua_Error tolua_err;
00772  if (
00773      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00774      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00775      !tolua_isnoobj(tolua_S,3,&tolua_err)
00776  )
00777   goto tolua_lerror;
00778  else
00779 #endif
00780  {
00781   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00782   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
00783 #ifndef TOLUA_RELEASE
00784   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'",NULL);
00785 #endif
00786   {
00787    bool tolua_ret = (bool)  self->oftype(interface_type);
00788    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00789   }
00790  }
00791  return 1;
00792 #ifndef TOLUA_RELEASE
00793  tolua_lerror:
00794  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
00795  return 0;
00796 #endif
00797 }
00798 #endif //#ifndef TOLUA_DISABLE
00799 
00800 /* method: datachunk of class  fawkes::SpeechRecognitionInterface */
00801 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_datachunk00
00802 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_datachunk00(lua_State* tolua_S)
00803 {
00804 #ifndef TOLUA_RELEASE
00805  tolua_Error tolua_err;
00806  if (
00807      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00808      !tolua_isnoobj(tolua_S,2,&tolua_err)
00809  )
00810   goto tolua_lerror;
00811  else
00812 #endif
00813  {
00814   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00815 #ifndef TOLUA_RELEASE
00816   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'",NULL);
00817 #endif
00818   {
00819    const void* tolua_ret = (const void*)  self->datachunk();
00820    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
00821   }
00822  }
00823  return 1;
00824 #ifndef TOLUA_RELEASE
00825  tolua_lerror:
00826  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
00827  return 0;
00828 #endif
00829 }
00830 #endif //#ifndef TOLUA_DISABLE
00831 
00832 /* method: datasize of class  fawkes::SpeechRecognitionInterface */
00833 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_datasize00
00834 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_datasize00(lua_State* tolua_S)
00835 {
00836 #ifndef TOLUA_RELEASE
00837  tolua_Error tolua_err;
00838  if (
00839      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00840      !tolua_isnoobj(tolua_S,2,&tolua_err)
00841  )
00842   goto tolua_lerror;
00843  else
00844 #endif
00845  {
00846   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00847 #ifndef TOLUA_RELEASE
00848   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'",NULL);
00849 #endif
00850   {
00851    unsigned int tolua_ret = (unsigned int)  self->datasize();
00852    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00853   }
00854  }
00855  return 1;
00856 #ifndef TOLUA_RELEASE
00857  tolua_lerror:
00858  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
00859  return 0;
00860 #endif
00861 }
00862 #endif //#ifndef TOLUA_DISABLE
00863 
00864 /* method: type of class  fawkes::SpeechRecognitionInterface */
00865 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_type00
00866 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_type00(lua_State* tolua_S)
00867 {
00868 #ifndef TOLUA_RELEASE
00869  tolua_Error tolua_err;
00870  if (
00871      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00872      !tolua_isnoobj(tolua_S,2,&tolua_err)
00873  )
00874   goto tolua_lerror;
00875  else
00876 #endif
00877  {
00878   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00879 #ifndef TOLUA_RELEASE
00880   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'",NULL);
00881 #endif
00882   {
00883    const char* tolua_ret = (const char*)  self->type();
00884    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00885   }
00886  }
00887  return 1;
00888 #ifndef TOLUA_RELEASE
00889  tolua_lerror:
00890  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
00891  return 0;
00892 #endif
00893 }
00894 #endif //#ifndef TOLUA_DISABLE
00895 
00896 /* method: id of class  fawkes::SpeechRecognitionInterface */
00897 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_id00
00898 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_id00(lua_State* tolua_S)
00899 {
00900 #ifndef TOLUA_RELEASE
00901  tolua_Error tolua_err;
00902  if (
00903      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00904      !tolua_isnoobj(tolua_S,2,&tolua_err)
00905  )
00906   goto tolua_lerror;
00907  else
00908 #endif
00909  {
00910   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00911 #ifndef TOLUA_RELEASE
00912   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'",NULL);
00913 #endif
00914   {
00915    const char* tolua_ret = (const char*)  self->id();
00916    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00917   }
00918  }
00919  return 1;
00920 #ifndef TOLUA_RELEASE
00921  tolua_lerror:
00922  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
00923  return 0;
00924 #endif
00925 }
00926 #endif //#ifndef TOLUA_DISABLE
00927 
00928 /* method: uid of class  fawkes::SpeechRecognitionInterface */
00929 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_uid00
00930 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_uid00(lua_State* tolua_S)
00931 {
00932 #ifndef TOLUA_RELEASE
00933  tolua_Error tolua_err;
00934  if (
00935      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00936      !tolua_isnoobj(tolua_S,2,&tolua_err)
00937  )
00938   goto tolua_lerror;
00939  else
00940 #endif
00941  {
00942   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00943 #ifndef TOLUA_RELEASE
00944   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'",NULL);
00945 #endif
00946   {
00947    const char* tolua_ret = (const char*)  self->uid();
00948    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00949   }
00950  }
00951  return 1;
00952 #ifndef TOLUA_RELEASE
00953  tolua_lerror:
00954  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
00955  return 0;
00956 #endif
00957 }
00958 #endif //#ifndef TOLUA_DISABLE
00959 
00960 /* method: serial of class  fawkes::SpeechRecognitionInterface */
00961 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_serial00
00962 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_serial00(lua_State* tolua_S)
00963 {
00964 #ifndef TOLUA_RELEASE
00965  tolua_Error tolua_err;
00966  if (
00967      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
00968      !tolua_isnoobj(tolua_S,2,&tolua_err)
00969  )
00970   goto tolua_lerror;
00971  else
00972 #endif
00973  {
00974   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
00975 #ifndef TOLUA_RELEASE
00976   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'",NULL);
00977 #endif
00978   {
00979    unsigned int tolua_ret = (unsigned int)  self->serial();
00980    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00981   }
00982  }
00983  return 1;
00984 #ifndef TOLUA_RELEASE
00985  tolua_lerror:
00986  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
00987  return 0;
00988 #endif
00989 }
00990 #endif //#ifndef TOLUA_DISABLE
00991 
00992 /* method: mem_serial of class  fawkes::SpeechRecognitionInterface */
00993 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_mem_serial00
00994 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_mem_serial00(lua_State* tolua_S)
00995 {
00996 #ifndef TOLUA_RELEASE
00997  tolua_Error tolua_err;
00998  if (
00999      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01000      !tolua_isnoobj(tolua_S,2,&tolua_err)
01001  )
01002   goto tolua_lerror;
01003  else
01004 #endif
01005  {
01006   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01007 #ifndef TOLUA_RELEASE
01008   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'",NULL);
01009 #endif
01010   {
01011    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
01012    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01013   }
01014  }
01015  return 1;
01016 #ifndef TOLUA_RELEASE
01017  tolua_lerror:
01018  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
01019  return 0;
01020 #endif
01021 }
01022 #endif //#ifndef TOLUA_DISABLE
01023 
01024 /* method: operator== of class  fawkes::SpeechRecognitionInterface */
01025 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface__eq00
01026 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface__eq00(lua_State* tolua_S)
01027 {
01028 #ifndef TOLUA_RELEASE
01029  tolua_Error tolua_err;
01030  if (
01031      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01032      !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err) ||
01033      !tolua_isnoobj(tolua_S,3,&tolua_err)
01034  )
01035   goto tolua_lerror;
01036  else
01037 #endif
01038  {
01039   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01040   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
01041 #ifndef TOLUA_RELEASE
01042   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
01043 #endif
01044   {
01045    bool tolua_ret = (bool)  self->operator==(*comp);
01046    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01047   }
01048  }
01049  return 1;
01050 #ifndef TOLUA_RELEASE
01051  tolua_lerror:
01052  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
01053  return 0;
01054 #endif
01055 }
01056 #endif //#ifndef TOLUA_DISABLE
01057 
01058 /* method: hash of class  fawkes::SpeechRecognitionInterface */
01059 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash00
01060 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash00(lua_State* tolua_S)
01061 {
01062 #ifndef TOLUA_RELEASE
01063  tolua_Error tolua_err;
01064  if (
01065      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01066      !tolua_isnoobj(tolua_S,2,&tolua_err)
01067  )
01068   goto tolua_lerror;
01069  else
01070 #endif
01071  {
01072   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01073 #ifndef TOLUA_RELEASE
01074   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'",NULL);
01075 #endif
01076   {
01077    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
01078    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01079   }
01080  }
01081  return 1;
01082 #ifndef TOLUA_RELEASE
01083  tolua_lerror:
01084  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
01085  return 0;
01086 #endif
01087 }
01088 #endif //#ifndef TOLUA_DISABLE
01089 
01090 /* method: hash_size of class  fawkes::SpeechRecognitionInterface */
01091 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash_size00
01092 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash_size00(lua_State* tolua_S)
01093 {
01094 #ifndef TOLUA_RELEASE
01095  tolua_Error tolua_err;
01096  if (
01097      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01098      !tolua_isnoobj(tolua_S,2,&tolua_err)
01099  )
01100   goto tolua_lerror;
01101  else
01102 #endif
01103  {
01104   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01105 #ifndef TOLUA_RELEASE
01106   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'",NULL);
01107 #endif
01108   {
01109    int tolua_ret = (int)  self->hash_size();
01110    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01111   }
01112  }
01113  return 1;
01114 #ifndef TOLUA_RELEASE
01115  tolua_lerror:
01116  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
01117  return 0;
01118 #endif
01119 }
01120 #endif //#ifndef TOLUA_DISABLE
01121 
01122 /* method: hash_printable of class  fawkes::SpeechRecognitionInterface */
01123 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash_printable00
01124 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash_printable00(lua_State* tolua_S)
01125 {
01126 #ifndef TOLUA_RELEASE
01127  tolua_Error tolua_err;
01128  if (
01129      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01130      !tolua_isnoobj(tolua_S,2,&tolua_err)
01131  )
01132   goto tolua_lerror;
01133  else
01134 #endif
01135  {
01136   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01137 #ifndef TOLUA_RELEASE
01138   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'",NULL);
01139 #endif
01140   {
01141    const char* tolua_ret = (const char*)  self->hash_printable();
01142    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01143   }
01144  }
01145  return 1;
01146 #ifndef TOLUA_RELEASE
01147  tolua_lerror:
01148  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
01149  return 0;
01150 #endif
01151 }
01152 #endif //#ifndef TOLUA_DISABLE
01153 
01154 /* method: is_writer of class  fawkes::SpeechRecognitionInterface */
01155 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_writer00
01156 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_writer00(lua_State* tolua_S)
01157 {
01158 #ifndef TOLUA_RELEASE
01159  tolua_Error tolua_err;
01160  if (
01161      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01162      !tolua_isnoobj(tolua_S,2,&tolua_err)
01163  )
01164   goto tolua_lerror;
01165  else
01166 #endif
01167  {
01168   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01169 #ifndef TOLUA_RELEASE
01170   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'",NULL);
01171 #endif
01172   {
01173    bool tolua_ret = (bool)  self->is_writer();
01174    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01175   }
01176  }
01177  return 1;
01178 #ifndef TOLUA_RELEASE
01179  tolua_lerror:
01180  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
01181  return 0;
01182 #endif
01183 }
01184 #endif //#ifndef TOLUA_DISABLE
01185 
01186 /* method: set_from_chunk of class  fawkes::SpeechRecognitionInterface */
01187 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_from_chunk00
01188 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_from_chunk00(lua_State* tolua_S)
01189 {
01190 #ifndef TOLUA_RELEASE
01191  tolua_Error tolua_err;
01192  if (
01193      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01194      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
01195      !tolua_isnoobj(tolua_S,3,&tolua_err)
01196  )
01197   goto tolua_lerror;
01198  else
01199 #endif
01200  {
01201   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01202   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
01203 #ifndef TOLUA_RELEASE
01204   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'",NULL);
01205 #endif
01206   {
01207    self->set_from_chunk(chunk);
01208   }
01209  }
01210  return 0;
01211 #ifndef TOLUA_RELEASE
01212  tolua_lerror:
01213  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
01214  return 0;
01215 #endif
01216 }
01217 #endif //#ifndef TOLUA_DISABLE
01218 
01219 /* method: create_message of class  fawkes::SpeechRecognitionInterface */
01220 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_create_message00
01221 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_create_message00(lua_State* tolua_S)
01222 {
01223 #ifndef TOLUA_RELEASE
01224  tolua_Error tolua_err;
01225  if (
01226      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01227      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01228      !tolua_isnoobj(tolua_S,3,&tolua_err)
01229  )
01230   goto tolua_lerror;
01231  else
01232 #endif
01233  {
01234   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01235   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
01236 #ifndef TOLUA_RELEASE
01237   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'",NULL);
01238 #endif
01239   {
01240    Message* tolua_ret = (Message*)  self->create_message(type);
01241    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
01242   }
01243  }
01244  return 1;
01245 #ifndef TOLUA_RELEASE
01246  tolua_lerror:
01247  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
01248  return 0;
01249 #endif
01250 }
01251 #endif //#ifndef TOLUA_DISABLE
01252 
01253 /* method: read of class  fawkes::SpeechRecognitionInterface */
01254 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_read00
01255 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_read00(lua_State* tolua_S)
01256 {
01257 #ifndef TOLUA_RELEASE
01258  tolua_Error tolua_err;
01259  if (
01260      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01261      !tolua_isnoobj(tolua_S,2,&tolua_err)
01262  )
01263   goto tolua_lerror;
01264  else
01265 #endif
01266  {
01267   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01268 #ifndef TOLUA_RELEASE
01269   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'",NULL);
01270 #endif
01271   {
01272    self->read();
01273   }
01274  }
01275  return 0;
01276 #ifndef TOLUA_RELEASE
01277  tolua_lerror:
01278  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
01279  return 0;
01280 #endif
01281 }
01282 #endif //#ifndef TOLUA_DISABLE
01283 
01284 /* method: write of class  fawkes::SpeechRecognitionInterface */
01285 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_write00
01286 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_write00(lua_State* tolua_S)
01287 {
01288 #ifndef TOLUA_RELEASE
01289  tolua_Error tolua_err;
01290  if (
01291      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01292      !tolua_isnoobj(tolua_S,2,&tolua_err)
01293  )
01294   goto tolua_lerror;
01295  else
01296 #endif
01297  {
01298   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01299 #ifndef TOLUA_RELEASE
01300   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'",NULL);
01301 #endif
01302   {
01303    self->write();
01304   }
01305  }
01306  return 0;
01307 #ifndef TOLUA_RELEASE
01308  tolua_lerror:
01309  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
01310  return 0;
01311 #endif
01312 }
01313 #endif //#ifndef TOLUA_DISABLE
01314 
01315 /* method: has_writer of class  fawkes::SpeechRecognitionInterface */
01316 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_has_writer00
01317 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_has_writer00(lua_State* tolua_S)
01318 {
01319 #ifndef TOLUA_RELEASE
01320  tolua_Error tolua_err;
01321  if (
01322      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01323      !tolua_isnoobj(tolua_S,2,&tolua_err)
01324  )
01325   goto tolua_lerror;
01326  else
01327 #endif
01328  {
01329   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01330 #ifndef TOLUA_RELEASE
01331   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'",NULL);
01332 #endif
01333   {
01334    bool tolua_ret = (bool)  self->has_writer();
01335    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01336   }
01337  }
01338  return 1;
01339 #ifndef TOLUA_RELEASE
01340  tolua_lerror:
01341  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
01342  return 0;
01343 #endif
01344 }
01345 #endif //#ifndef TOLUA_DISABLE
01346 
01347 /* method: num_readers of class  fawkes::SpeechRecognitionInterface */
01348 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_num_readers00
01349 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_num_readers00(lua_State* tolua_S)
01350 {
01351 #ifndef TOLUA_RELEASE
01352  tolua_Error tolua_err;
01353  if (
01354      !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01355      !tolua_isnoobj(tolua_S,2,&tolua_err)
01356  )
01357   goto tolua_lerror;
01358  else
01359 #endif
01360  {
01361   const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01362 #ifndef TOLUA_RELEASE
01363   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'",NULL);
01364 #endif
01365   {
01366    unsigned int tolua_ret = (unsigned int)  self->num_readers();
01367    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01368   }
01369  }
01370  return 1;
01371 #ifndef TOLUA_RELEASE
01372  tolua_lerror:
01373  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
01374  return 0;
01375 #endif
01376 }
01377 #endif //#ifndef TOLUA_DISABLE
01378 
01379 /* method: msgq_enqueue_copy of class  fawkes::SpeechRecognitionInterface */
01380 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_enqueue_copy00
01381 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_enqueue_copy00(lua_State* tolua_S)
01382 {
01383 #ifndef TOLUA_RELEASE
01384  tolua_Error tolua_err;
01385  if (
01386      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01387      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
01388      !tolua_isnoobj(tolua_S,3,&tolua_err)
01389  )
01390   goto tolua_lerror;
01391  else
01392 #endif
01393  {
01394   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01395   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
01396 #ifndef TOLUA_RELEASE
01397   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'",NULL);
01398 #endif
01399   {
01400    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
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_enqueue_copy'.",&tolua_err);
01408  return 0;
01409 #endif
01410 }
01411 #endif //#ifndef TOLUA_DISABLE
01412 
01413 /* method: msgq_remove of class  fawkes::SpeechRecognitionInterface */
01414 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_remove00
01415 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_remove00(lua_State* tolua_S)
01416 {
01417 #ifndef TOLUA_RELEASE
01418  tolua_Error tolua_err;
01419  if (
01420      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01421      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
01422      !tolua_isnoobj(tolua_S,3,&tolua_err)
01423  )
01424   goto tolua_lerror;
01425  else
01426 #endif
01427  {
01428   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01429   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
01430 #ifndef TOLUA_RELEASE
01431   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
01432 #endif
01433   {
01434    self->msgq_remove(message);
01435   }
01436  }
01437  return 0;
01438 #ifndef TOLUA_RELEASE
01439  tolua_lerror:
01440  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
01441  return 0;
01442 #endif
01443 }
01444 #endif //#ifndef TOLUA_DISABLE
01445 
01446 /* method: msgq_remove of class  fawkes::SpeechRecognitionInterface */
01447 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_remove01
01448 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_remove01(lua_State* tolua_S)
01449 {
01450  tolua_Error tolua_err;
01451  if (
01452      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01453      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01454      !tolua_isnoobj(tolua_S,3,&tolua_err)
01455  )
01456   goto tolua_lerror;
01457  else
01458  {
01459   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01460   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
01461 #ifndef TOLUA_RELEASE
01462   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
01463 #endif
01464   {
01465    self->msgq_remove(message_id);
01466   }
01467  }
01468  return 0;
01469 tolua_lerror:
01470  return tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_remove00(tolua_S);
01471 }
01472 #endif //#ifndef TOLUA_DISABLE
01473 
01474 /* method: msgq_size of class  fawkes::SpeechRecognitionInterface */
01475 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_size00
01476 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_size00(lua_State* tolua_S)
01477 {
01478 #ifndef TOLUA_RELEASE
01479  tolua_Error tolua_err;
01480  if (
01481      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01482      !tolua_isnoobj(tolua_S,2,&tolua_err)
01483  )
01484   goto tolua_lerror;
01485  else
01486 #endif
01487  {
01488   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01489 #ifndef TOLUA_RELEASE
01490   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'",NULL);
01491 #endif
01492   {
01493    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
01494    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01495   }
01496  }
01497  return 1;
01498 #ifndef TOLUA_RELEASE
01499  tolua_lerror:
01500  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
01501  return 0;
01502 #endif
01503 }
01504 #endif //#ifndef TOLUA_DISABLE
01505 
01506 /* method: msgq_flush of class  fawkes::SpeechRecognitionInterface */
01507 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_flush00
01508 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_flush00(lua_State* tolua_S)
01509 {
01510 #ifndef TOLUA_RELEASE
01511  tolua_Error tolua_err;
01512  if (
01513      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01514      !tolua_isnoobj(tolua_S,2,&tolua_err)
01515  )
01516   goto tolua_lerror;
01517  else
01518 #endif
01519  {
01520   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01521 #ifndef TOLUA_RELEASE
01522   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'",NULL);
01523 #endif
01524   {
01525    self->msgq_flush();
01526   }
01527  }
01528  return 0;
01529 #ifndef TOLUA_RELEASE
01530  tolua_lerror:
01531  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
01532  return 0;
01533 #endif
01534 }
01535 #endif //#ifndef TOLUA_DISABLE
01536 
01537 /* method: msgq_lock of class  fawkes::SpeechRecognitionInterface */
01538 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_lock00
01539 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_lock00(lua_State* tolua_S)
01540 {
01541 #ifndef TOLUA_RELEASE
01542  tolua_Error tolua_err;
01543  if (
01544      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01545      !tolua_isnoobj(tolua_S,2,&tolua_err)
01546  )
01547   goto tolua_lerror;
01548  else
01549 #endif
01550  {
01551   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01552 #ifndef TOLUA_RELEASE
01553   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'",NULL);
01554 #endif
01555   {
01556    self->msgq_lock();
01557   }
01558  }
01559  return 0;
01560 #ifndef TOLUA_RELEASE
01561  tolua_lerror:
01562  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
01563  return 0;
01564 #endif
01565 }
01566 #endif //#ifndef TOLUA_DISABLE
01567 
01568 /* method: msgq_try_lock of class  fawkes::SpeechRecognitionInterface */
01569 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_try_lock00
01570 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_try_lock00(lua_State* tolua_S)
01571 {
01572 #ifndef TOLUA_RELEASE
01573  tolua_Error tolua_err;
01574  if (
01575      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01576      !tolua_isnoobj(tolua_S,2,&tolua_err)
01577  )
01578   goto tolua_lerror;
01579  else
01580 #endif
01581  {
01582   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01583 #ifndef TOLUA_RELEASE
01584   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'",NULL);
01585 #endif
01586   {
01587    bool tolua_ret = (bool)  self->msgq_try_lock();
01588    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01589   }
01590  }
01591  return 1;
01592 #ifndef TOLUA_RELEASE
01593  tolua_lerror:
01594  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
01595  return 0;
01596 #endif
01597 }
01598 #endif //#ifndef TOLUA_DISABLE
01599 
01600 /* method: msgq_unlock of class  fawkes::SpeechRecognitionInterface */
01601 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_unlock00
01602 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_unlock00(lua_State* tolua_S)
01603 {
01604 #ifndef TOLUA_RELEASE
01605  tolua_Error tolua_err;
01606  if (
01607      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01608      !tolua_isnoobj(tolua_S,2,&tolua_err)
01609  )
01610   goto tolua_lerror;
01611  else
01612 #endif
01613  {
01614   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01615 #ifndef TOLUA_RELEASE
01616   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'",NULL);
01617 #endif
01618   {
01619    self->msgq_unlock();
01620   }
01621  }
01622  return 0;
01623 #ifndef TOLUA_RELEASE
01624  tolua_lerror:
01625  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
01626  return 0;
01627 #endif
01628 }
01629 #endif //#ifndef TOLUA_DISABLE
01630 
01631 /* method: msgq_pop of class  fawkes::SpeechRecognitionInterface */
01632 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_pop00
01633 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_pop00(lua_State* tolua_S)
01634 {
01635 #ifndef TOLUA_RELEASE
01636  tolua_Error tolua_err;
01637  if (
01638      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01639      !tolua_isnoobj(tolua_S,2,&tolua_err)
01640  )
01641   goto tolua_lerror;
01642  else
01643 #endif
01644  {
01645   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01646 #ifndef TOLUA_RELEASE
01647   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'",NULL);
01648 #endif
01649   {
01650    self->msgq_pop();
01651   }
01652  }
01653  return 0;
01654 #ifndef TOLUA_RELEASE
01655  tolua_lerror:
01656  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
01657  return 0;
01658 #endif
01659 }
01660 #endif //#ifndef TOLUA_DISABLE
01661 
01662 /* method: msgq_first of class  fawkes::SpeechRecognitionInterface */
01663 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_first00
01664 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_first00(lua_State* tolua_S)
01665 {
01666 #ifndef TOLUA_RELEASE
01667  tolua_Error tolua_err;
01668  if (
01669      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01670      !tolua_isnoobj(tolua_S,2,&tolua_err)
01671  )
01672   goto tolua_lerror;
01673  else
01674 #endif
01675  {
01676   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01677 #ifndef TOLUA_RELEASE
01678   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'",NULL);
01679 #endif
01680   {
01681    Message* tolua_ret = (Message*)  self->msgq_first();
01682    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
01683   }
01684  }
01685  return 1;
01686 #ifndef TOLUA_RELEASE
01687  tolua_lerror:
01688  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
01689  return 0;
01690 #endif
01691 }
01692 #endif //#ifndef TOLUA_DISABLE
01693 
01694 /* method: msgq_empty of class  fawkes::SpeechRecognitionInterface */
01695 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_empty00
01696 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_empty00(lua_State* tolua_S)
01697 {
01698 #ifndef TOLUA_RELEASE
01699  tolua_Error tolua_err;
01700  if (
01701      !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) ||
01702      !tolua_isnoobj(tolua_S,2,&tolua_err)
01703  )
01704   goto tolua_lerror;
01705  else
01706 #endif
01707  {
01708   fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*)  tolua_tousertype(tolua_S,1,0);
01709 #ifndef TOLUA_RELEASE
01710   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'",NULL);
01711 #endif
01712   {
01713    bool tolua_ret = (bool)  self->msgq_empty();
01714    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01715   }
01716  }
01717  return 1;
01718 #ifndef TOLUA_RELEASE
01719  tolua_lerror:
01720  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
01721  return 0;
01722 #endif
01723 }
01724 #endif //#ifndef TOLUA_DISABLE
01725 
01726 /* Open function */
01727 TOLUA_API int tolua_interfaces_SpeechRecognitionInterface_open (lua_State* tolua_S)
01728 {
01729  tolua_open(tolua_S);
01730  tolua_reg_types(tolua_S);
01731  tolua_module(tolua_S,NULL,0);
01732  tolua_beginmodule(tolua_S,NULL);
01733   tolua_module(tolua_S,"fawkes",0);
01734   tolua_beginmodule(tolua_S,"fawkes");
01735    tolua_cclass(tolua_S,"SpeechRecognitionInterface","fawkes::SpeechRecognitionInterface","Interface",NULL);
01736    tolua_beginmodule(tolua_S,"SpeechRecognitionInterface");
01737     #ifdef __cplusplus
01738     tolua_cclass(tolua_S,"ResetMessage","fawkes::SpeechRecognitionInterface::ResetMessage","Message",tolua_collect_fawkes__SpeechRecognitionInterface__ResetMessage);
01739     #else
01740     tolua_cclass(tolua_S,"ResetMessage","fawkes::SpeechRecognitionInterface::ResetMessage","Message",NULL);
01741     #endif
01742     tolua_beginmodule(tolua_S,"ResetMessage");
01743      tolua_function(tolua_S,"new",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_new00);
01744      tolua_function(tolua_S,"new_local",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_new00_local);
01745      tolua_function(tolua_S,".call",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_new00_local);
01746      tolua_function(tolua_S,"delete",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_delete00);
01747     tolua_endmodule(tolua_S);
01748     #ifdef __cplusplus
01749     tolua_cclass(tolua_S,"SetEnabledMessage","fawkes::SpeechRecognitionInterface::SetEnabledMessage","Message",tolua_collect_fawkes__SpeechRecognitionInterface__SetEnabledMessage);
01750     #else
01751     tolua_cclass(tolua_S,"SetEnabledMessage","fawkes::SpeechRecognitionInterface::SetEnabledMessage","Message",NULL);
01752     #endif
01753     tolua_beginmodule(tolua_S,"SetEnabledMessage");
01754      tolua_function(tolua_S,"new",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00);
01755      tolua_function(tolua_S,"new_local",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00_local);
01756      tolua_function(tolua_S,".call",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00_local);
01757      tolua_function(tolua_S,"new",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new01);
01758      tolua_function(tolua_S,"new_local",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new01_local);
01759      tolua_function(tolua_S,".call",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new01_local);
01760      tolua_function(tolua_S,"delete",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_delete00);
01761      tolua_function(tolua_S,"is_enabled",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_is_enabled00);
01762      tolua_function(tolua_S,"set_enabled",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_set_enabled00);
01763      tolua_function(tolua_S,"maxlenof_enabled",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_maxlenof_enabled00);
01764     tolua_endmodule(tolua_S);
01765     tolua_function(tolua_S,"text",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_text00);
01766     tolua_function(tolua_S,"set_text",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_text00);
01767     tolua_function(tolua_S,"maxlenof_text",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_text00);
01768     tolua_function(tolua_S,"counter",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_counter00);
01769     tolua_function(tolua_S,"set_counter",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_counter00);
01770     tolua_function(tolua_S,"maxlenof_counter",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_counter00);
01771     tolua_function(tolua_S,"is_processing",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_processing00);
01772     tolua_function(tolua_S,"set_processing",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_processing00);
01773     tolua_function(tolua_S,"maxlenof_processing",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_processing00);
01774     tolua_function(tolua_S,"is_enabled",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_enabled00);
01775     tolua_function(tolua_S,"set_enabled",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_enabled00);
01776     tolua_function(tolua_S,"maxlenof_enabled",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_enabled00);
01777     tolua_function(tolua_S,"oftype",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_oftype00);
01778     tolua_function(tolua_S,"datachunk",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_datachunk00);
01779     tolua_function(tolua_S,"datasize",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_datasize00);
01780     tolua_function(tolua_S,"type",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_type00);
01781     tolua_function(tolua_S,"id",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_id00);
01782     tolua_function(tolua_S,"uid",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_uid00);
01783     tolua_function(tolua_S,"serial",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_serial00);
01784     tolua_function(tolua_S,"mem_serial",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_mem_serial00);
01785     tolua_function(tolua_S,".eq",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface__eq00);
01786     tolua_function(tolua_S,"hash",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash00);
01787     tolua_function(tolua_S,"hash_size",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash_size00);
01788     tolua_function(tolua_S,"hash_printable",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash_printable00);
01789     tolua_function(tolua_S,"is_writer",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_writer00);
01790     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_from_chunk00);
01791     tolua_function(tolua_S,"create_message",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_create_message00);
01792     tolua_function(tolua_S,"read",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_read00);
01793     tolua_function(tolua_S,"write",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_write00);
01794     tolua_function(tolua_S,"has_writer",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_has_writer00);
01795     tolua_function(tolua_S,"num_readers",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_num_readers00);
01796     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_enqueue_copy00);
01797     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_remove00);
01798     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_remove01);
01799     tolua_function(tolua_S,"msgq_size",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_size00);
01800     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_flush00);
01801     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_lock00);
01802     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_try_lock00);
01803     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_unlock00);
01804     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_pop00);
01805     tolua_function(tolua_S,"msgq_first",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_first00);
01806     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_empty00);
01807    tolua_endmodule(tolua_S);
01808   tolua_endmodule(tolua_S);
01809  tolua_endmodule(tolua_S);
01810  return 1;
01811 }
01812
01813
01814 extern "C" {
01815 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
01816  TOLUA_API int luaopen_interfaces_SpeechRecognitionInterface (lua_State* tolua_S) {
01817  return tolua_interfaces_SpeechRecognitionInterface_open(tolua_S);
01818 };
01819 #endif
01820 }
01821
01822