00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #ifndef __cplusplus
00020 #include "stdlib.h"
00021 #endif
00022 #include "string.h"
00023
00024 #include "tolua++.h"
00025
00026
00027 TOLUA_API int tolua_interfaces_SpeechRecognitionInterface_open (lua_State* tolua_S);
00028
00029 #include <interfaces/SpeechRecognitionInterface.h>
00030 using namespace fawkes;
00031
00032
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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