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

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