Fawkes API
Fawkes Development Version
|
00001 /* 00002 ** Lua binding: interfaces_SwitchInterface 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_SwitchInterface_open (lua_State* tolua_S); 00028 00029 #include <interfaces/SwitchInterface.h> 00030 using namespace fawkes; 00031 00032 /* function to release collected object via destructor */ 00033 #ifdef __cplusplus 00034 00035 static int tolua_collect_fawkes__SwitchInterface__SetMessage (lua_State* tolua_S) 00036 { 00037 fawkes::SwitchInterface::SetMessage* self = (fawkes::SwitchInterface::SetMessage*) tolua_tousertype(tolua_S,1,0); 00038 Mtolua_delete(self); 00039 return 0; 00040 } 00041 00042 static int tolua_collect_fawkes__SwitchInterface__EnableDurationMessage (lua_State* tolua_S) 00043 { 00044 fawkes::SwitchInterface::EnableDurationMessage* self = (fawkes::SwitchInterface::EnableDurationMessage*) tolua_tousertype(tolua_S,1,0); 00045 Mtolua_delete(self); 00046 return 0; 00047 } 00048 00049 static int tolua_collect_fawkes__SwitchInterface__EnableSwitchMessage (lua_State* tolua_S) 00050 { 00051 fawkes::SwitchInterface::EnableSwitchMessage* self = (fawkes::SwitchInterface::EnableSwitchMessage*) tolua_tousertype(tolua_S,1,0); 00052 Mtolua_delete(self); 00053 return 0; 00054 } 00055 00056 static int tolua_collect_fawkes__SwitchInterface__DisableSwitchMessage (lua_State* tolua_S) 00057 { 00058 fawkes::SwitchInterface::DisableSwitchMessage* self = (fawkes::SwitchInterface::DisableSwitchMessage*) tolua_tousertype(tolua_S,1,0); 00059 Mtolua_delete(self); 00060 return 0; 00061 } 00062 #endif 00063 00064 00065 /* function to register type */ 00066 static void tolua_reg_types (lua_State* tolua_S) 00067 { 00068 tolua_usertype(tolua_S,"fawkes::SwitchInterface::SetMessage"); 00069 tolua_usertype(tolua_S,"fawkes::SwitchInterface::EnableDurationMessage"); 00070 tolua_usertype(tolua_S,"fawkes::SwitchInterface::DisableSwitchMessage"); 00071 tolua_usertype(tolua_S,"fawkes::SwitchInterface"); 00072 tolua_usertype(tolua_S,"Message"); 00073 tolua_usertype(tolua_S,"fawkes::SwitchInterface::EnableSwitchMessage"); 00074 tolua_usertype(tolua_S,"Interface"); 00075 } 00076 00077 /* method: new of class SetMessage */ 00078 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new00 00079 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new00(lua_State* tolua_S) 00080 { 00081 #ifndef TOLUA_RELEASE 00082 tolua_Error tolua_err; 00083 if ( 00084 !tolua_isusertable(tolua_S,1,"fawkes::SwitchInterface::SetMessage",0,&tolua_err) || 00085 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 00086 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00087 !tolua_isnoobj(tolua_S,4,&tolua_err) 00088 ) 00089 goto tolua_lerror; 00090 else 00091 #endif 00092 { 00093 bool ini_enabled = ((bool) tolua_toboolean(tolua_S,2,0)); 00094 float ini_value = ((float) tolua_tonumber(tolua_S,3,0)); 00095 { 00096 fawkes::SwitchInterface::SetMessage* tolua_ret = (fawkes::SwitchInterface::SetMessage*) Mtolua_new((fawkes::SwitchInterface::SetMessage)(ini_enabled,ini_value)); 00097 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SwitchInterface::SetMessage"); 00098 } 00099 } 00100 return 1; 00101 #ifndef TOLUA_RELEASE 00102 tolua_lerror: 00103 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00104 return 0; 00105 #endif 00106 } 00107 #endif //#ifndef TOLUA_DISABLE 00108 00109 /* method: new_local of class SetMessage */ 00110 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new00_local 00111 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new00_local(lua_State* tolua_S) 00112 { 00113 #ifndef TOLUA_RELEASE 00114 tolua_Error tolua_err; 00115 if ( 00116 !tolua_isusertable(tolua_S,1,"fawkes::SwitchInterface::SetMessage",0,&tolua_err) || 00117 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 00118 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00119 !tolua_isnoobj(tolua_S,4,&tolua_err) 00120 ) 00121 goto tolua_lerror; 00122 else 00123 #endif 00124 { 00125 bool ini_enabled = ((bool) tolua_toboolean(tolua_S,2,0)); 00126 float ini_value = ((float) tolua_tonumber(tolua_S,3,0)); 00127 { 00128 fawkes::SwitchInterface::SetMessage* tolua_ret = (fawkes::SwitchInterface::SetMessage*) Mtolua_new((fawkes::SwitchInterface::SetMessage)(ini_enabled,ini_value)); 00129 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SwitchInterface::SetMessage"); 00130 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00131 } 00132 } 00133 return 1; 00134 #ifndef TOLUA_RELEASE 00135 tolua_lerror: 00136 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00137 return 0; 00138 #endif 00139 } 00140 #endif //#ifndef TOLUA_DISABLE 00141 00142 /* method: new of class SetMessage */ 00143 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new01 00144 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new01(lua_State* tolua_S) 00145 { 00146 tolua_Error tolua_err; 00147 if ( 00148 !tolua_isusertable(tolua_S,1,"fawkes::SwitchInterface::SetMessage",0,&tolua_err) || 00149 !tolua_isnoobj(tolua_S,2,&tolua_err) 00150 ) 00151 goto tolua_lerror; 00152 else 00153 { 00154 { 00155 fawkes::SwitchInterface::SetMessage* tolua_ret = (fawkes::SwitchInterface::SetMessage*) Mtolua_new((fawkes::SwitchInterface::SetMessage)()); 00156 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SwitchInterface::SetMessage"); 00157 } 00158 } 00159 return 1; 00160 tolua_lerror: 00161 return tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new00(tolua_S); 00162 } 00163 #endif //#ifndef TOLUA_DISABLE 00164 00165 /* method: new_local of class SetMessage */ 00166 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new01_local 00167 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new01_local(lua_State* tolua_S) 00168 { 00169 tolua_Error tolua_err; 00170 if ( 00171 !tolua_isusertable(tolua_S,1,"fawkes::SwitchInterface::SetMessage",0,&tolua_err) || 00172 !tolua_isnoobj(tolua_S,2,&tolua_err) 00173 ) 00174 goto tolua_lerror; 00175 else 00176 { 00177 { 00178 fawkes::SwitchInterface::SetMessage* tolua_ret = (fawkes::SwitchInterface::SetMessage*) Mtolua_new((fawkes::SwitchInterface::SetMessage)()); 00179 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SwitchInterface::SetMessage"); 00180 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00181 } 00182 } 00183 return 1; 00184 tolua_lerror: 00185 return tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new00_local(tolua_S); 00186 } 00187 #endif //#ifndef TOLUA_DISABLE 00188 00189 /* method: delete of class SetMessage */ 00190 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_delete00 00191 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_delete00(lua_State* tolua_S) 00192 { 00193 #ifndef TOLUA_RELEASE 00194 tolua_Error tolua_err; 00195 if ( 00196 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface::SetMessage",0,&tolua_err) || 00197 !tolua_isnoobj(tolua_S,2,&tolua_err) 00198 ) 00199 goto tolua_lerror; 00200 else 00201 #endif 00202 { 00203 fawkes::SwitchInterface::SetMessage* self = (fawkes::SwitchInterface::SetMessage*) tolua_tousertype(tolua_S,1,0); 00204 #ifndef TOLUA_RELEASE 00205 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00206 #endif 00207 Mtolua_delete(self); 00208 } 00209 return 0; 00210 #ifndef TOLUA_RELEASE 00211 tolua_lerror: 00212 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00213 return 0; 00214 #endif 00215 } 00216 #endif //#ifndef TOLUA_DISABLE 00217 00218 /* method: is_enabled of class SetMessage */ 00219 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_is_enabled00 00220 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_is_enabled00(lua_State* tolua_S) 00221 { 00222 #ifndef TOLUA_RELEASE 00223 tolua_Error tolua_err; 00224 if ( 00225 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface::SetMessage",0,&tolua_err) || 00226 !tolua_isnoobj(tolua_S,2,&tolua_err) 00227 ) 00228 goto tolua_lerror; 00229 else 00230 #endif 00231 { 00232 fawkes::SwitchInterface::SetMessage* self = (fawkes::SwitchInterface::SetMessage*) tolua_tousertype(tolua_S,1,0); 00233 #ifndef TOLUA_RELEASE 00234 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_enabled'", NULL); 00235 #endif 00236 { 00237 bool tolua_ret = (bool) self->is_enabled(); 00238 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00239 } 00240 } 00241 return 1; 00242 #ifndef TOLUA_RELEASE 00243 tolua_lerror: 00244 tolua_error(tolua_S,"#ferror in function 'is_enabled'.",&tolua_err); 00245 return 0; 00246 #endif 00247 } 00248 #endif //#ifndef TOLUA_DISABLE 00249 00250 /* method: set_enabled of class SetMessage */ 00251 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_set_enabled00 00252 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_set_enabled00(lua_State* tolua_S) 00253 { 00254 #ifndef TOLUA_RELEASE 00255 tolua_Error tolua_err; 00256 if ( 00257 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface::SetMessage",0,&tolua_err) || 00258 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 00259 !tolua_isnoobj(tolua_S,3,&tolua_err) 00260 ) 00261 goto tolua_lerror; 00262 else 00263 #endif 00264 { 00265 fawkes::SwitchInterface::SetMessage* self = (fawkes::SwitchInterface::SetMessage*) tolua_tousertype(tolua_S,1,0); 00266 const bool new_enabled = ((const bool) tolua_toboolean(tolua_S,2,0)); 00267 #ifndef TOLUA_RELEASE 00268 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_enabled'", NULL); 00269 #endif 00270 { 00271 self->set_enabled(new_enabled); 00272 } 00273 } 00274 return 0; 00275 #ifndef TOLUA_RELEASE 00276 tolua_lerror: 00277 tolua_error(tolua_S,"#ferror in function 'set_enabled'.",&tolua_err); 00278 return 0; 00279 #endif 00280 } 00281 #endif //#ifndef TOLUA_DISABLE 00282 00283 /* method: maxlenof_enabled of class SetMessage */ 00284 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_maxlenof_enabled00 00285 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_maxlenof_enabled00(lua_State* tolua_S) 00286 { 00287 #ifndef TOLUA_RELEASE 00288 tolua_Error tolua_err; 00289 if ( 00290 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface::SetMessage",0,&tolua_err) || 00291 !tolua_isnoobj(tolua_S,2,&tolua_err) 00292 ) 00293 goto tolua_lerror; 00294 else 00295 #endif 00296 { 00297 const fawkes::SwitchInterface::SetMessage* self = (const fawkes::SwitchInterface::SetMessage*) tolua_tousertype(tolua_S,1,0); 00298 #ifndef TOLUA_RELEASE 00299 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_enabled'", NULL); 00300 #endif 00301 { 00302 int tolua_ret = (int) self->maxlenof_enabled(); 00303 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00304 } 00305 } 00306 return 1; 00307 #ifndef TOLUA_RELEASE 00308 tolua_lerror: 00309 tolua_error(tolua_S,"#ferror in function 'maxlenof_enabled'.",&tolua_err); 00310 return 0; 00311 #endif 00312 } 00313 #endif //#ifndef TOLUA_DISABLE 00314 00315 /* method: value of class SetMessage */ 00316 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_value00 00317 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_value00(lua_State* tolua_S) 00318 { 00319 #ifndef TOLUA_RELEASE 00320 tolua_Error tolua_err; 00321 if ( 00322 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface::SetMessage",0,&tolua_err) || 00323 !tolua_isnoobj(tolua_S,2,&tolua_err) 00324 ) 00325 goto tolua_lerror; 00326 else 00327 #endif 00328 { 00329 fawkes::SwitchInterface::SetMessage* self = (fawkes::SwitchInterface::SetMessage*) tolua_tousertype(tolua_S,1,0); 00330 #ifndef TOLUA_RELEASE 00331 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'value'", NULL); 00332 #endif 00333 { 00334 float tolua_ret = (float) self->value(); 00335 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00336 } 00337 } 00338 return 1; 00339 #ifndef TOLUA_RELEASE 00340 tolua_lerror: 00341 tolua_error(tolua_S,"#ferror in function 'value'.",&tolua_err); 00342 return 0; 00343 #endif 00344 } 00345 #endif //#ifndef TOLUA_DISABLE 00346 00347 /* method: set_value of class SetMessage */ 00348 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_set_value00 00349 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_set_value00(lua_State* tolua_S) 00350 { 00351 #ifndef TOLUA_RELEASE 00352 tolua_Error tolua_err; 00353 if ( 00354 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface::SetMessage",0,&tolua_err) || 00355 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00356 !tolua_isnoobj(tolua_S,3,&tolua_err) 00357 ) 00358 goto tolua_lerror; 00359 else 00360 #endif 00361 { 00362 fawkes::SwitchInterface::SetMessage* self = (fawkes::SwitchInterface::SetMessage*) tolua_tousertype(tolua_S,1,0); 00363 const float new_value = ((const float) tolua_tonumber(tolua_S,2,0)); 00364 #ifndef TOLUA_RELEASE 00365 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_value'", NULL); 00366 #endif 00367 { 00368 self->set_value(new_value); 00369 } 00370 } 00371 return 0; 00372 #ifndef TOLUA_RELEASE 00373 tolua_lerror: 00374 tolua_error(tolua_S,"#ferror in function 'set_value'.",&tolua_err); 00375 return 0; 00376 #endif 00377 } 00378 #endif //#ifndef TOLUA_DISABLE 00379 00380 /* method: maxlenof_value of class SetMessage */ 00381 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_maxlenof_value00 00382 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_maxlenof_value00(lua_State* tolua_S) 00383 { 00384 #ifndef TOLUA_RELEASE 00385 tolua_Error tolua_err; 00386 if ( 00387 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface::SetMessage",0,&tolua_err) || 00388 !tolua_isnoobj(tolua_S,2,&tolua_err) 00389 ) 00390 goto tolua_lerror; 00391 else 00392 #endif 00393 { 00394 const fawkes::SwitchInterface::SetMessage* self = (const fawkes::SwitchInterface::SetMessage*) tolua_tousertype(tolua_S,1,0); 00395 #ifndef TOLUA_RELEASE 00396 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_value'", NULL); 00397 #endif 00398 { 00399 int tolua_ret = (int) self->maxlenof_value(); 00400 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00401 } 00402 } 00403 return 1; 00404 #ifndef TOLUA_RELEASE 00405 tolua_lerror: 00406 tolua_error(tolua_S,"#ferror in function 'maxlenof_value'.",&tolua_err); 00407 return 0; 00408 #endif 00409 } 00410 #endif //#ifndef TOLUA_DISABLE 00411 00412 /* method: new of class EnableSwitchMessage */ 00413 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableSwitchMessage_new00 00414 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableSwitchMessage_new00(lua_State* tolua_S) 00415 { 00416 #ifndef TOLUA_RELEASE 00417 tolua_Error tolua_err; 00418 if ( 00419 !tolua_isusertable(tolua_S,1,"fawkes::SwitchInterface::EnableSwitchMessage",0,&tolua_err) || 00420 !tolua_isnoobj(tolua_S,2,&tolua_err) 00421 ) 00422 goto tolua_lerror; 00423 else 00424 #endif 00425 { 00426 { 00427 fawkes::SwitchInterface::EnableSwitchMessage* tolua_ret = (fawkes::SwitchInterface::EnableSwitchMessage*) Mtolua_new((fawkes::SwitchInterface::EnableSwitchMessage)()); 00428 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SwitchInterface::EnableSwitchMessage"); 00429 } 00430 } 00431 return 1; 00432 #ifndef TOLUA_RELEASE 00433 tolua_lerror: 00434 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00435 return 0; 00436 #endif 00437 } 00438 #endif //#ifndef TOLUA_DISABLE 00439 00440 /* method: new_local of class EnableSwitchMessage */ 00441 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableSwitchMessage_new00_local 00442 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableSwitchMessage_new00_local(lua_State* tolua_S) 00443 { 00444 #ifndef TOLUA_RELEASE 00445 tolua_Error tolua_err; 00446 if ( 00447 !tolua_isusertable(tolua_S,1,"fawkes::SwitchInterface::EnableSwitchMessage",0,&tolua_err) || 00448 !tolua_isnoobj(tolua_S,2,&tolua_err) 00449 ) 00450 goto tolua_lerror; 00451 else 00452 #endif 00453 { 00454 { 00455 fawkes::SwitchInterface::EnableSwitchMessage* tolua_ret = (fawkes::SwitchInterface::EnableSwitchMessage*) Mtolua_new((fawkes::SwitchInterface::EnableSwitchMessage)()); 00456 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SwitchInterface::EnableSwitchMessage"); 00457 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00458 } 00459 } 00460 return 1; 00461 #ifndef TOLUA_RELEASE 00462 tolua_lerror: 00463 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00464 return 0; 00465 #endif 00466 } 00467 #endif //#ifndef TOLUA_DISABLE 00468 00469 /* method: delete of class EnableSwitchMessage */ 00470 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableSwitchMessage_delete00 00471 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableSwitchMessage_delete00(lua_State* tolua_S) 00472 { 00473 #ifndef TOLUA_RELEASE 00474 tolua_Error tolua_err; 00475 if ( 00476 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface::EnableSwitchMessage",0,&tolua_err) || 00477 !tolua_isnoobj(tolua_S,2,&tolua_err) 00478 ) 00479 goto tolua_lerror; 00480 else 00481 #endif 00482 { 00483 fawkes::SwitchInterface::EnableSwitchMessage* self = (fawkes::SwitchInterface::EnableSwitchMessage*) tolua_tousertype(tolua_S,1,0); 00484 #ifndef TOLUA_RELEASE 00485 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00486 #endif 00487 Mtolua_delete(self); 00488 } 00489 return 0; 00490 #ifndef TOLUA_RELEASE 00491 tolua_lerror: 00492 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00493 return 0; 00494 #endif 00495 } 00496 #endif //#ifndef TOLUA_DISABLE 00497 00498 /* method: new of class DisableSwitchMessage */ 00499 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_DisableSwitchMessage_new00 00500 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_DisableSwitchMessage_new00(lua_State* tolua_S) 00501 { 00502 #ifndef TOLUA_RELEASE 00503 tolua_Error tolua_err; 00504 if ( 00505 !tolua_isusertable(tolua_S,1,"fawkes::SwitchInterface::DisableSwitchMessage",0,&tolua_err) || 00506 !tolua_isnoobj(tolua_S,2,&tolua_err) 00507 ) 00508 goto tolua_lerror; 00509 else 00510 #endif 00511 { 00512 { 00513 fawkes::SwitchInterface::DisableSwitchMessage* tolua_ret = (fawkes::SwitchInterface::DisableSwitchMessage*) Mtolua_new((fawkes::SwitchInterface::DisableSwitchMessage)()); 00514 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SwitchInterface::DisableSwitchMessage"); 00515 } 00516 } 00517 return 1; 00518 #ifndef TOLUA_RELEASE 00519 tolua_lerror: 00520 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00521 return 0; 00522 #endif 00523 } 00524 #endif //#ifndef TOLUA_DISABLE 00525 00526 /* method: new_local of class DisableSwitchMessage */ 00527 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_DisableSwitchMessage_new00_local 00528 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_DisableSwitchMessage_new00_local(lua_State* tolua_S) 00529 { 00530 #ifndef TOLUA_RELEASE 00531 tolua_Error tolua_err; 00532 if ( 00533 !tolua_isusertable(tolua_S,1,"fawkes::SwitchInterface::DisableSwitchMessage",0,&tolua_err) || 00534 !tolua_isnoobj(tolua_S,2,&tolua_err) 00535 ) 00536 goto tolua_lerror; 00537 else 00538 #endif 00539 { 00540 { 00541 fawkes::SwitchInterface::DisableSwitchMessage* tolua_ret = (fawkes::SwitchInterface::DisableSwitchMessage*) Mtolua_new((fawkes::SwitchInterface::DisableSwitchMessage)()); 00542 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SwitchInterface::DisableSwitchMessage"); 00543 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00544 } 00545 } 00546 return 1; 00547 #ifndef TOLUA_RELEASE 00548 tolua_lerror: 00549 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00550 return 0; 00551 #endif 00552 } 00553 #endif //#ifndef TOLUA_DISABLE 00554 00555 /* method: delete of class DisableSwitchMessage */ 00556 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_DisableSwitchMessage_delete00 00557 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_DisableSwitchMessage_delete00(lua_State* tolua_S) 00558 { 00559 #ifndef TOLUA_RELEASE 00560 tolua_Error tolua_err; 00561 if ( 00562 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface::DisableSwitchMessage",0,&tolua_err) || 00563 !tolua_isnoobj(tolua_S,2,&tolua_err) 00564 ) 00565 goto tolua_lerror; 00566 else 00567 #endif 00568 { 00569 fawkes::SwitchInterface::DisableSwitchMessage* self = (fawkes::SwitchInterface::DisableSwitchMessage*) tolua_tousertype(tolua_S,1,0); 00570 #ifndef TOLUA_RELEASE 00571 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00572 #endif 00573 Mtolua_delete(self); 00574 } 00575 return 0; 00576 #ifndef TOLUA_RELEASE 00577 tolua_lerror: 00578 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00579 return 0; 00580 #endif 00581 } 00582 #endif //#ifndef TOLUA_DISABLE 00583 00584 /* method: new of class EnableDurationMessage */ 00585 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new00 00586 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new00(lua_State* tolua_S) 00587 { 00588 #ifndef TOLUA_RELEASE 00589 tolua_Error tolua_err; 00590 if ( 00591 !tolua_isusertable(tolua_S,1,"fawkes::SwitchInterface::EnableDurationMessage",0,&tolua_err) || 00592 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00593 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00594 !tolua_isnoobj(tolua_S,4,&tolua_err) 00595 ) 00596 goto tolua_lerror; 00597 else 00598 #endif 00599 { 00600 float ini_duration = ((float) tolua_tonumber(tolua_S,2,0)); 00601 float ini_value = ((float) tolua_tonumber(tolua_S,3,0)); 00602 { 00603 fawkes::SwitchInterface::EnableDurationMessage* tolua_ret = (fawkes::SwitchInterface::EnableDurationMessage*) Mtolua_new((fawkes::SwitchInterface::EnableDurationMessage)(ini_duration,ini_value)); 00604 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SwitchInterface::EnableDurationMessage"); 00605 } 00606 } 00607 return 1; 00608 #ifndef TOLUA_RELEASE 00609 tolua_lerror: 00610 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00611 return 0; 00612 #endif 00613 } 00614 #endif //#ifndef TOLUA_DISABLE 00615 00616 /* method: new_local of class EnableDurationMessage */ 00617 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new00_local 00618 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new00_local(lua_State* tolua_S) 00619 { 00620 #ifndef TOLUA_RELEASE 00621 tolua_Error tolua_err; 00622 if ( 00623 !tolua_isusertable(tolua_S,1,"fawkes::SwitchInterface::EnableDurationMessage",0,&tolua_err) || 00624 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00625 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00626 !tolua_isnoobj(tolua_S,4,&tolua_err) 00627 ) 00628 goto tolua_lerror; 00629 else 00630 #endif 00631 { 00632 float ini_duration = ((float) tolua_tonumber(tolua_S,2,0)); 00633 float ini_value = ((float) tolua_tonumber(tolua_S,3,0)); 00634 { 00635 fawkes::SwitchInterface::EnableDurationMessage* tolua_ret = (fawkes::SwitchInterface::EnableDurationMessage*) Mtolua_new((fawkes::SwitchInterface::EnableDurationMessage)(ini_duration,ini_value)); 00636 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SwitchInterface::EnableDurationMessage"); 00637 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00638 } 00639 } 00640 return 1; 00641 #ifndef TOLUA_RELEASE 00642 tolua_lerror: 00643 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00644 return 0; 00645 #endif 00646 } 00647 #endif //#ifndef TOLUA_DISABLE 00648 00649 /* method: new of class EnableDurationMessage */ 00650 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new01 00651 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new01(lua_State* tolua_S) 00652 { 00653 tolua_Error tolua_err; 00654 if ( 00655 !tolua_isusertable(tolua_S,1,"fawkes::SwitchInterface::EnableDurationMessage",0,&tolua_err) || 00656 !tolua_isnoobj(tolua_S,2,&tolua_err) 00657 ) 00658 goto tolua_lerror; 00659 else 00660 { 00661 { 00662 fawkes::SwitchInterface::EnableDurationMessage* tolua_ret = (fawkes::SwitchInterface::EnableDurationMessage*) Mtolua_new((fawkes::SwitchInterface::EnableDurationMessage)()); 00663 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SwitchInterface::EnableDurationMessage"); 00664 } 00665 } 00666 return 1; 00667 tolua_lerror: 00668 return tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new00(tolua_S); 00669 } 00670 #endif //#ifndef TOLUA_DISABLE 00671 00672 /* method: new_local of class EnableDurationMessage */ 00673 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new01_local 00674 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new01_local(lua_State* tolua_S) 00675 { 00676 tolua_Error tolua_err; 00677 if ( 00678 !tolua_isusertable(tolua_S,1,"fawkes::SwitchInterface::EnableDurationMessage",0,&tolua_err) || 00679 !tolua_isnoobj(tolua_S,2,&tolua_err) 00680 ) 00681 goto tolua_lerror; 00682 else 00683 { 00684 { 00685 fawkes::SwitchInterface::EnableDurationMessage* tolua_ret = (fawkes::SwitchInterface::EnableDurationMessage*) Mtolua_new((fawkes::SwitchInterface::EnableDurationMessage)()); 00686 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SwitchInterface::EnableDurationMessage"); 00687 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00688 } 00689 } 00690 return 1; 00691 tolua_lerror: 00692 return tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new00_local(tolua_S); 00693 } 00694 #endif //#ifndef TOLUA_DISABLE 00695 00696 /* method: delete of class EnableDurationMessage */ 00697 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_delete00 00698 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_delete00(lua_State* tolua_S) 00699 { 00700 #ifndef TOLUA_RELEASE 00701 tolua_Error tolua_err; 00702 if ( 00703 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface::EnableDurationMessage",0,&tolua_err) || 00704 !tolua_isnoobj(tolua_S,2,&tolua_err) 00705 ) 00706 goto tolua_lerror; 00707 else 00708 #endif 00709 { 00710 fawkes::SwitchInterface::EnableDurationMessage* self = (fawkes::SwitchInterface::EnableDurationMessage*) tolua_tousertype(tolua_S,1,0); 00711 #ifndef TOLUA_RELEASE 00712 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00713 #endif 00714 Mtolua_delete(self); 00715 } 00716 return 0; 00717 #ifndef TOLUA_RELEASE 00718 tolua_lerror: 00719 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00720 return 0; 00721 #endif 00722 } 00723 #endif //#ifndef TOLUA_DISABLE 00724 00725 /* method: duration of class EnableDurationMessage */ 00726 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_duration00 00727 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_duration00(lua_State* tolua_S) 00728 { 00729 #ifndef TOLUA_RELEASE 00730 tolua_Error tolua_err; 00731 if ( 00732 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface::EnableDurationMessage",0,&tolua_err) || 00733 !tolua_isnoobj(tolua_S,2,&tolua_err) 00734 ) 00735 goto tolua_lerror; 00736 else 00737 #endif 00738 { 00739 fawkes::SwitchInterface::EnableDurationMessage* self = (fawkes::SwitchInterface::EnableDurationMessage*) tolua_tousertype(tolua_S,1,0); 00740 #ifndef TOLUA_RELEASE 00741 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'duration'", NULL); 00742 #endif 00743 { 00744 float tolua_ret = (float) self->duration(); 00745 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00746 } 00747 } 00748 return 1; 00749 #ifndef TOLUA_RELEASE 00750 tolua_lerror: 00751 tolua_error(tolua_S,"#ferror in function 'duration'.",&tolua_err); 00752 return 0; 00753 #endif 00754 } 00755 #endif //#ifndef TOLUA_DISABLE 00756 00757 /* method: set_duration of class EnableDurationMessage */ 00758 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_set_duration00 00759 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_set_duration00(lua_State* tolua_S) 00760 { 00761 #ifndef TOLUA_RELEASE 00762 tolua_Error tolua_err; 00763 if ( 00764 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface::EnableDurationMessage",0,&tolua_err) || 00765 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00766 !tolua_isnoobj(tolua_S,3,&tolua_err) 00767 ) 00768 goto tolua_lerror; 00769 else 00770 #endif 00771 { 00772 fawkes::SwitchInterface::EnableDurationMessage* self = (fawkes::SwitchInterface::EnableDurationMessage*) tolua_tousertype(tolua_S,1,0); 00773 const float new_duration = ((const float) tolua_tonumber(tolua_S,2,0)); 00774 #ifndef TOLUA_RELEASE 00775 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_duration'", NULL); 00776 #endif 00777 { 00778 self->set_duration(new_duration); 00779 } 00780 } 00781 return 0; 00782 #ifndef TOLUA_RELEASE 00783 tolua_lerror: 00784 tolua_error(tolua_S,"#ferror in function 'set_duration'.",&tolua_err); 00785 return 0; 00786 #endif 00787 } 00788 #endif //#ifndef TOLUA_DISABLE 00789 00790 /* method: maxlenof_duration of class EnableDurationMessage */ 00791 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_maxlenof_duration00 00792 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_maxlenof_duration00(lua_State* tolua_S) 00793 { 00794 #ifndef TOLUA_RELEASE 00795 tolua_Error tolua_err; 00796 if ( 00797 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface::EnableDurationMessage",0,&tolua_err) || 00798 !tolua_isnoobj(tolua_S,2,&tolua_err) 00799 ) 00800 goto tolua_lerror; 00801 else 00802 #endif 00803 { 00804 const fawkes::SwitchInterface::EnableDurationMessage* self = (const fawkes::SwitchInterface::EnableDurationMessage*) tolua_tousertype(tolua_S,1,0); 00805 #ifndef TOLUA_RELEASE 00806 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_duration'", NULL); 00807 #endif 00808 { 00809 int tolua_ret = (int) self->maxlenof_duration(); 00810 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00811 } 00812 } 00813 return 1; 00814 #ifndef TOLUA_RELEASE 00815 tolua_lerror: 00816 tolua_error(tolua_S,"#ferror in function 'maxlenof_duration'.",&tolua_err); 00817 return 0; 00818 #endif 00819 } 00820 #endif //#ifndef TOLUA_DISABLE 00821 00822 /* method: value of class EnableDurationMessage */ 00823 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_value00 00824 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_value00(lua_State* tolua_S) 00825 { 00826 #ifndef TOLUA_RELEASE 00827 tolua_Error tolua_err; 00828 if ( 00829 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface::EnableDurationMessage",0,&tolua_err) || 00830 !tolua_isnoobj(tolua_S,2,&tolua_err) 00831 ) 00832 goto tolua_lerror; 00833 else 00834 #endif 00835 { 00836 fawkes::SwitchInterface::EnableDurationMessage* self = (fawkes::SwitchInterface::EnableDurationMessage*) tolua_tousertype(tolua_S,1,0); 00837 #ifndef TOLUA_RELEASE 00838 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'value'", NULL); 00839 #endif 00840 { 00841 float tolua_ret = (float) self->value(); 00842 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00843 } 00844 } 00845 return 1; 00846 #ifndef TOLUA_RELEASE 00847 tolua_lerror: 00848 tolua_error(tolua_S,"#ferror in function 'value'.",&tolua_err); 00849 return 0; 00850 #endif 00851 } 00852 #endif //#ifndef TOLUA_DISABLE 00853 00854 /* method: set_value of class EnableDurationMessage */ 00855 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_set_value00 00856 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_set_value00(lua_State* tolua_S) 00857 { 00858 #ifndef TOLUA_RELEASE 00859 tolua_Error tolua_err; 00860 if ( 00861 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface::EnableDurationMessage",0,&tolua_err) || 00862 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00863 !tolua_isnoobj(tolua_S,3,&tolua_err) 00864 ) 00865 goto tolua_lerror; 00866 else 00867 #endif 00868 { 00869 fawkes::SwitchInterface::EnableDurationMessage* self = (fawkes::SwitchInterface::EnableDurationMessage*) tolua_tousertype(tolua_S,1,0); 00870 const float new_value = ((const float) tolua_tonumber(tolua_S,2,0)); 00871 #ifndef TOLUA_RELEASE 00872 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_value'", NULL); 00873 #endif 00874 { 00875 self->set_value(new_value); 00876 } 00877 } 00878 return 0; 00879 #ifndef TOLUA_RELEASE 00880 tolua_lerror: 00881 tolua_error(tolua_S,"#ferror in function 'set_value'.",&tolua_err); 00882 return 0; 00883 #endif 00884 } 00885 #endif //#ifndef TOLUA_DISABLE 00886 00887 /* method: maxlenof_value of class EnableDurationMessage */ 00888 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_maxlenof_value00 00889 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_maxlenof_value00(lua_State* tolua_S) 00890 { 00891 #ifndef TOLUA_RELEASE 00892 tolua_Error tolua_err; 00893 if ( 00894 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface::EnableDurationMessage",0,&tolua_err) || 00895 !tolua_isnoobj(tolua_S,2,&tolua_err) 00896 ) 00897 goto tolua_lerror; 00898 else 00899 #endif 00900 { 00901 const fawkes::SwitchInterface::EnableDurationMessage* self = (const fawkes::SwitchInterface::EnableDurationMessage*) tolua_tousertype(tolua_S,1,0); 00902 #ifndef TOLUA_RELEASE 00903 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_value'", NULL); 00904 #endif 00905 { 00906 int tolua_ret = (int) self->maxlenof_value(); 00907 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00908 } 00909 } 00910 return 1; 00911 #ifndef TOLUA_RELEASE 00912 tolua_lerror: 00913 tolua_error(tolua_S,"#ferror in function 'maxlenof_value'.",&tolua_err); 00914 return 0; 00915 #endif 00916 } 00917 #endif //#ifndef TOLUA_DISABLE 00918 00919 /* method: is_enabled of class fawkes::SwitchInterface */ 00920 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_is_enabled00 00921 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_is_enabled00(lua_State* tolua_S) 00922 { 00923 #ifndef TOLUA_RELEASE 00924 tolua_Error tolua_err; 00925 if ( 00926 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 00927 !tolua_isnoobj(tolua_S,2,&tolua_err) 00928 ) 00929 goto tolua_lerror; 00930 else 00931 #endif 00932 { 00933 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 00934 #ifndef TOLUA_RELEASE 00935 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_enabled'", NULL); 00936 #endif 00937 { 00938 bool tolua_ret = (bool) self->is_enabled(); 00939 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00940 } 00941 } 00942 return 1; 00943 #ifndef TOLUA_RELEASE 00944 tolua_lerror: 00945 tolua_error(tolua_S,"#ferror in function 'is_enabled'.",&tolua_err); 00946 return 0; 00947 #endif 00948 } 00949 #endif //#ifndef TOLUA_DISABLE 00950 00951 /* method: set_enabled of class fawkes::SwitchInterface */ 00952 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_enabled00 00953 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_enabled00(lua_State* tolua_S) 00954 { 00955 #ifndef TOLUA_RELEASE 00956 tolua_Error tolua_err; 00957 if ( 00958 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 00959 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 00960 !tolua_isnoobj(tolua_S,3,&tolua_err) 00961 ) 00962 goto tolua_lerror; 00963 else 00964 #endif 00965 { 00966 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 00967 const bool new_enabled = ((const bool) tolua_toboolean(tolua_S,2,0)); 00968 #ifndef TOLUA_RELEASE 00969 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_enabled'", NULL); 00970 #endif 00971 { 00972 self->set_enabled(new_enabled); 00973 } 00974 } 00975 return 0; 00976 #ifndef TOLUA_RELEASE 00977 tolua_lerror: 00978 tolua_error(tolua_S,"#ferror in function 'set_enabled'.",&tolua_err); 00979 return 0; 00980 #endif 00981 } 00982 #endif //#ifndef TOLUA_DISABLE 00983 00984 /* method: maxlenof_enabled of class fawkes::SwitchInterface */ 00985 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_enabled00 00986 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_enabled00(lua_State* tolua_S) 00987 { 00988 #ifndef TOLUA_RELEASE 00989 tolua_Error tolua_err; 00990 if ( 00991 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 00992 !tolua_isnoobj(tolua_S,2,&tolua_err) 00993 ) 00994 goto tolua_lerror; 00995 else 00996 #endif 00997 { 00998 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 00999 #ifndef TOLUA_RELEASE 01000 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_enabled'", NULL); 01001 #endif 01002 { 01003 int tolua_ret = (int) self->maxlenof_enabled(); 01004 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01005 } 01006 } 01007 return 1; 01008 #ifndef TOLUA_RELEASE 01009 tolua_lerror: 01010 tolua_error(tolua_S,"#ferror in function 'maxlenof_enabled'.",&tolua_err); 01011 return 0; 01012 #endif 01013 } 01014 #endif //#ifndef TOLUA_DISABLE 01015 01016 /* method: value of class fawkes::SwitchInterface */ 01017 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_value00 01018 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_value00(lua_State* tolua_S) 01019 { 01020 #ifndef TOLUA_RELEASE 01021 tolua_Error tolua_err; 01022 if ( 01023 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 01024 !tolua_isnoobj(tolua_S,2,&tolua_err) 01025 ) 01026 goto tolua_lerror; 01027 else 01028 #endif 01029 { 01030 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01031 #ifndef TOLUA_RELEASE 01032 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'value'", NULL); 01033 #endif 01034 { 01035 float tolua_ret = (float) self->value(); 01036 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01037 } 01038 } 01039 return 1; 01040 #ifndef TOLUA_RELEASE 01041 tolua_lerror: 01042 tolua_error(tolua_S,"#ferror in function 'value'.",&tolua_err); 01043 return 0; 01044 #endif 01045 } 01046 #endif //#ifndef TOLUA_DISABLE 01047 01048 /* method: set_value of class fawkes::SwitchInterface */ 01049 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_value00 01050 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_value00(lua_State* tolua_S) 01051 { 01052 #ifndef TOLUA_RELEASE 01053 tolua_Error tolua_err; 01054 if ( 01055 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 01056 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01057 !tolua_isnoobj(tolua_S,3,&tolua_err) 01058 ) 01059 goto tolua_lerror; 01060 else 01061 #endif 01062 { 01063 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01064 const float new_value = ((const float) tolua_tonumber(tolua_S,2,0)); 01065 #ifndef TOLUA_RELEASE 01066 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_value'", NULL); 01067 #endif 01068 { 01069 self->set_value(new_value); 01070 } 01071 } 01072 return 0; 01073 #ifndef TOLUA_RELEASE 01074 tolua_lerror: 01075 tolua_error(tolua_S,"#ferror in function 'set_value'.",&tolua_err); 01076 return 0; 01077 #endif 01078 } 01079 #endif //#ifndef TOLUA_DISABLE 01080 01081 /* method: maxlenof_value of class fawkes::SwitchInterface */ 01082 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_value00 01083 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_value00(lua_State* tolua_S) 01084 { 01085 #ifndef TOLUA_RELEASE 01086 tolua_Error tolua_err; 01087 if ( 01088 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01089 !tolua_isnoobj(tolua_S,2,&tolua_err) 01090 ) 01091 goto tolua_lerror; 01092 else 01093 #endif 01094 { 01095 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01096 #ifndef TOLUA_RELEASE 01097 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_value'", NULL); 01098 #endif 01099 { 01100 int tolua_ret = (int) self->maxlenof_value(); 01101 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01102 } 01103 } 01104 return 1; 01105 #ifndef TOLUA_RELEASE 01106 tolua_lerror: 01107 tolua_error(tolua_S,"#ferror in function 'maxlenof_value'.",&tolua_err); 01108 return 0; 01109 #endif 01110 } 01111 #endif //#ifndef TOLUA_DISABLE 01112 01113 /* method: history of class fawkes::SwitchInterface */ 01114 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_history00 01115 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_history00(lua_State* tolua_S) 01116 { 01117 #ifndef TOLUA_RELEASE 01118 tolua_Error tolua_err; 01119 if ( 01120 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 01121 !tolua_isnoobj(tolua_S,2,&tolua_err) 01122 ) 01123 goto tolua_lerror; 01124 else 01125 #endif 01126 { 01127 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01128 #ifndef TOLUA_RELEASE 01129 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'history'", NULL); 01130 #endif 01131 { 01132 float tolua_ret = (float) self->history(); 01133 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01134 } 01135 } 01136 return 1; 01137 #ifndef TOLUA_RELEASE 01138 tolua_lerror: 01139 tolua_error(tolua_S,"#ferror in function 'history'.",&tolua_err); 01140 return 0; 01141 #endif 01142 } 01143 #endif //#ifndef TOLUA_DISABLE 01144 01145 /* method: set_history of class fawkes::SwitchInterface */ 01146 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_history00 01147 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_history00(lua_State* tolua_S) 01148 { 01149 #ifndef TOLUA_RELEASE 01150 tolua_Error tolua_err; 01151 if ( 01152 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 01153 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01154 !tolua_isnoobj(tolua_S,3,&tolua_err) 01155 ) 01156 goto tolua_lerror; 01157 else 01158 #endif 01159 { 01160 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01161 const float new_history = ((const float) tolua_tonumber(tolua_S,2,0)); 01162 #ifndef TOLUA_RELEASE 01163 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_history'", NULL); 01164 #endif 01165 { 01166 self->set_history(new_history); 01167 } 01168 } 01169 return 0; 01170 #ifndef TOLUA_RELEASE 01171 tolua_lerror: 01172 tolua_error(tolua_S,"#ferror in function 'set_history'.",&tolua_err); 01173 return 0; 01174 #endif 01175 } 01176 #endif //#ifndef TOLUA_DISABLE 01177 01178 /* method: maxlenof_history of class fawkes::SwitchInterface */ 01179 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_history00 01180 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_history00(lua_State* tolua_S) 01181 { 01182 #ifndef TOLUA_RELEASE 01183 tolua_Error tolua_err; 01184 if ( 01185 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01186 !tolua_isnoobj(tolua_S,2,&tolua_err) 01187 ) 01188 goto tolua_lerror; 01189 else 01190 #endif 01191 { 01192 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01193 #ifndef TOLUA_RELEASE 01194 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_history'", NULL); 01195 #endif 01196 { 01197 int tolua_ret = (int) self->maxlenof_history(); 01198 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01199 } 01200 } 01201 return 1; 01202 #ifndef TOLUA_RELEASE 01203 tolua_lerror: 01204 tolua_error(tolua_S,"#ferror in function 'maxlenof_history'.",&tolua_err); 01205 return 0; 01206 #endif 01207 } 01208 #endif //#ifndef TOLUA_DISABLE 01209 01210 /* method: short_activations of class fawkes::SwitchInterface */ 01211 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_short_activations00 01212 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_short_activations00(lua_State* tolua_S) 01213 { 01214 #ifndef TOLUA_RELEASE 01215 tolua_Error tolua_err; 01216 if ( 01217 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 01218 !tolua_isnoobj(tolua_S,2,&tolua_err) 01219 ) 01220 goto tolua_lerror; 01221 else 01222 #endif 01223 { 01224 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01225 #ifndef TOLUA_RELEASE 01226 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'short_activations'", NULL); 01227 #endif 01228 { 01229 unsigned int tolua_ret = (unsigned int) self->short_activations(); 01230 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01231 } 01232 } 01233 return 1; 01234 #ifndef TOLUA_RELEASE 01235 tolua_lerror: 01236 tolua_error(tolua_S,"#ferror in function 'short_activations'.",&tolua_err); 01237 return 0; 01238 #endif 01239 } 01240 #endif //#ifndef TOLUA_DISABLE 01241 01242 /* method: set_short_activations of class fawkes::SwitchInterface */ 01243 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_short_activations00 01244 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_short_activations00(lua_State* tolua_S) 01245 { 01246 #ifndef TOLUA_RELEASE 01247 tolua_Error tolua_err; 01248 if ( 01249 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 01250 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01251 !tolua_isnoobj(tolua_S,3,&tolua_err) 01252 ) 01253 goto tolua_lerror; 01254 else 01255 #endif 01256 { 01257 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01258 unsigned const int new_short_activations = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 01259 #ifndef TOLUA_RELEASE 01260 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_short_activations'", NULL); 01261 #endif 01262 { 01263 self->set_short_activations(new_short_activations); 01264 } 01265 } 01266 return 0; 01267 #ifndef TOLUA_RELEASE 01268 tolua_lerror: 01269 tolua_error(tolua_S,"#ferror in function 'set_short_activations'.",&tolua_err); 01270 return 0; 01271 #endif 01272 } 01273 #endif //#ifndef TOLUA_DISABLE 01274 01275 /* method: maxlenof_short_activations of class fawkes::SwitchInterface */ 01276 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_short_activations00 01277 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_short_activations00(lua_State* tolua_S) 01278 { 01279 #ifndef TOLUA_RELEASE 01280 tolua_Error tolua_err; 01281 if ( 01282 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01283 !tolua_isnoobj(tolua_S,2,&tolua_err) 01284 ) 01285 goto tolua_lerror; 01286 else 01287 #endif 01288 { 01289 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01290 #ifndef TOLUA_RELEASE 01291 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_short_activations'", NULL); 01292 #endif 01293 { 01294 int tolua_ret = (int) self->maxlenof_short_activations(); 01295 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01296 } 01297 } 01298 return 1; 01299 #ifndef TOLUA_RELEASE 01300 tolua_lerror: 01301 tolua_error(tolua_S,"#ferror in function 'maxlenof_short_activations'.",&tolua_err); 01302 return 0; 01303 #endif 01304 } 01305 #endif //#ifndef TOLUA_DISABLE 01306 01307 /* method: long_activations of class fawkes::SwitchInterface */ 01308 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_long_activations00 01309 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_long_activations00(lua_State* tolua_S) 01310 { 01311 #ifndef TOLUA_RELEASE 01312 tolua_Error tolua_err; 01313 if ( 01314 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 01315 !tolua_isnoobj(tolua_S,2,&tolua_err) 01316 ) 01317 goto tolua_lerror; 01318 else 01319 #endif 01320 { 01321 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01322 #ifndef TOLUA_RELEASE 01323 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'long_activations'", NULL); 01324 #endif 01325 { 01326 unsigned int tolua_ret = (unsigned int) self->long_activations(); 01327 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01328 } 01329 } 01330 return 1; 01331 #ifndef TOLUA_RELEASE 01332 tolua_lerror: 01333 tolua_error(tolua_S,"#ferror in function 'long_activations'.",&tolua_err); 01334 return 0; 01335 #endif 01336 } 01337 #endif //#ifndef TOLUA_DISABLE 01338 01339 /* method: set_long_activations of class fawkes::SwitchInterface */ 01340 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_long_activations00 01341 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_long_activations00(lua_State* tolua_S) 01342 { 01343 #ifndef TOLUA_RELEASE 01344 tolua_Error tolua_err; 01345 if ( 01346 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 01347 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01348 !tolua_isnoobj(tolua_S,3,&tolua_err) 01349 ) 01350 goto tolua_lerror; 01351 else 01352 #endif 01353 { 01354 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01355 unsigned const int new_long_activations = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 01356 #ifndef TOLUA_RELEASE 01357 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_long_activations'", NULL); 01358 #endif 01359 { 01360 self->set_long_activations(new_long_activations); 01361 } 01362 } 01363 return 0; 01364 #ifndef TOLUA_RELEASE 01365 tolua_lerror: 01366 tolua_error(tolua_S,"#ferror in function 'set_long_activations'.",&tolua_err); 01367 return 0; 01368 #endif 01369 } 01370 #endif //#ifndef TOLUA_DISABLE 01371 01372 /* method: maxlenof_long_activations of class fawkes::SwitchInterface */ 01373 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_long_activations00 01374 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_long_activations00(lua_State* tolua_S) 01375 { 01376 #ifndef TOLUA_RELEASE 01377 tolua_Error tolua_err; 01378 if ( 01379 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01380 !tolua_isnoobj(tolua_S,2,&tolua_err) 01381 ) 01382 goto tolua_lerror; 01383 else 01384 #endif 01385 { 01386 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01387 #ifndef TOLUA_RELEASE 01388 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_long_activations'", NULL); 01389 #endif 01390 { 01391 int tolua_ret = (int) self->maxlenof_long_activations(); 01392 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01393 } 01394 } 01395 return 1; 01396 #ifndef TOLUA_RELEASE 01397 tolua_lerror: 01398 tolua_error(tolua_S,"#ferror in function 'maxlenof_long_activations'.",&tolua_err); 01399 return 0; 01400 #endif 01401 } 01402 #endif //#ifndef TOLUA_DISABLE 01403 01404 /* method: activation_count of class fawkes::SwitchInterface */ 01405 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_activation_count00 01406 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_activation_count00(lua_State* tolua_S) 01407 { 01408 #ifndef TOLUA_RELEASE 01409 tolua_Error tolua_err; 01410 if ( 01411 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 01412 !tolua_isnoobj(tolua_S,2,&tolua_err) 01413 ) 01414 goto tolua_lerror; 01415 else 01416 #endif 01417 { 01418 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01419 #ifndef TOLUA_RELEASE 01420 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'activation_count'", NULL); 01421 #endif 01422 { 01423 unsigned int tolua_ret = (unsigned int) self->activation_count(); 01424 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01425 } 01426 } 01427 return 1; 01428 #ifndef TOLUA_RELEASE 01429 tolua_lerror: 01430 tolua_error(tolua_S,"#ferror in function 'activation_count'.",&tolua_err); 01431 return 0; 01432 #endif 01433 } 01434 #endif //#ifndef TOLUA_DISABLE 01435 01436 /* method: set_activation_count of class fawkes::SwitchInterface */ 01437 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_activation_count00 01438 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_activation_count00(lua_State* tolua_S) 01439 { 01440 #ifndef TOLUA_RELEASE 01441 tolua_Error tolua_err; 01442 if ( 01443 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 01444 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01445 !tolua_isnoobj(tolua_S,3,&tolua_err) 01446 ) 01447 goto tolua_lerror; 01448 else 01449 #endif 01450 { 01451 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01452 unsigned const int new_activation_count = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 01453 #ifndef TOLUA_RELEASE 01454 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_activation_count'", NULL); 01455 #endif 01456 { 01457 self->set_activation_count(new_activation_count); 01458 } 01459 } 01460 return 0; 01461 #ifndef TOLUA_RELEASE 01462 tolua_lerror: 01463 tolua_error(tolua_S,"#ferror in function 'set_activation_count'.",&tolua_err); 01464 return 0; 01465 #endif 01466 } 01467 #endif //#ifndef TOLUA_DISABLE 01468 01469 /* method: maxlenof_activation_count of class fawkes::SwitchInterface */ 01470 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_activation_count00 01471 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_activation_count00(lua_State* tolua_S) 01472 { 01473 #ifndef TOLUA_RELEASE 01474 tolua_Error tolua_err; 01475 if ( 01476 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01477 !tolua_isnoobj(tolua_S,2,&tolua_err) 01478 ) 01479 goto tolua_lerror; 01480 else 01481 #endif 01482 { 01483 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01484 #ifndef TOLUA_RELEASE 01485 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_activation_count'", NULL); 01486 #endif 01487 { 01488 int tolua_ret = (int) self->maxlenof_activation_count(); 01489 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01490 } 01491 } 01492 return 1; 01493 #ifndef TOLUA_RELEASE 01494 tolua_lerror: 01495 tolua_error(tolua_S,"#ferror in function 'maxlenof_activation_count'.",&tolua_err); 01496 return 0; 01497 #endif 01498 } 01499 #endif //#ifndef TOLUA_DISABLE 01500 01501 /* method: oftype of class fawkes::SwitchInterface */ 01502 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_oftype00 01503 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_oftype00(lua_State* tolua_S) 01504 { 01505 #ifndef TOLUA_RELEASE 01506 tolua_Error tolua_err; 01507 if ( 01508 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01509 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01510 !tolua_isnoobj(tolua_S,3,&tolua_err) 01511 ) 01512 goto tolua_lerror; 01513 else 01514 #endif 01515 { 01516 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01517 const char* interface_type = ((const char*) tolua_tostring(tolua_S,2,0)); 01518 #ifndef TOLUA_RELEASE 01519 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL); 01520 #endif 01521 { 01522 bool tolua_ret = (bool) self->oftype(interface_type); 01523 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01524 } 01525 } 01526 return 1; 01527 #ifndef TOLUA_RELEASE 01528 tolua_lerror: 01529 tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err); 01530 return 0; 01531 #endif 01532 } 01533 #endif //#ifndef TOLUA_DISABLE 01534 01535 /* method: datachunk of class fawkes::SwitchInterface */ 01536 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_datachunk00 01537 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_datachunk00(lua_State* tolua_S) 01538 { 01539 #ifndef TOLUA_RELEASE 01540 tolua_Error tolua_err; 01541 if ( 01542 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01543 !tolua_isnoobj(tolua_S,2,&tolua_err) 01544 ) 01545 goto tolua_lerror; 01546 else 01547 #endif 01548 { 01549 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01550 #ifndef TOLUA_RELEASE 01551 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL); 01552 #endif 01553 { 01554 const void* tolua_ret = (const void*) self->datachunk(); 01555 tolua_pushuserdata(tolua_S,(void*)tolua_ret); 01556 } 01557 } 01558 return 1; 01559 #ifndef TOLUA_RELEASE 01560 tolua_lerror: 01561 tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err); 01562 return 0; 01563 #endif 01564 } 01565 #endif //#ifndef TOLUA_DISABLE 01566 01567 /* method: datasize of class fawkes::SwitchInterface */ 01568 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_datasize00 01569 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_datasize00(lua_State* tolua_S) 01570 { 01571 #ifndef TOLUA_RELEASE 01572 tolua_Error tolua_err; 01573 if ( 01574 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01575 !tolua_isnoobj(tolua_S,2,&tolua_err) 01576 ) 01577 goto tolua_lerror; 01578 else 01579 #endif 01580 { 01581 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01582 #ifndef TOLUA_RELEASE 01583 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL); 01584 #endif 01585 { 01586 unsigned int tolua_ret = (unsigned int) self->datasize(); 01587 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01588 } 01589 } 01590 return 1; 01591 #ifndef TOLUA_RELEASE 01592 tolua_lerror: 01593 tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err); 01594 return 0; 01595 #endif 01596 } 01597 #endif //#ifndef TOLUA_DISABLE 01598 01599 /* method: type of class fawkes::SwitchInterface */ 01600 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_type00 01601 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_type00(lua_State* tolua_S) 01602 { 01603 #ifndef TOLUA_RELEASE 01604 tolua_Error tolua_err; 01605 if ( 01606 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01607 !tolua_isnoobj(tolua_S,2,&tolua_err) 01608 ) 01609 goto tolua_lerror; 01610 else 01611 #endif 01612 { 01613 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01614 #ifndef TOLUA_RELEASE 01615 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL); 01616 #endif 01617 { 01618 const char* tolua_ret = (const char*) self->type(); 01619 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01620 } 01621 } 01622 return 1; 01623 #ifndef TOLUA_RELEASE 01624 tolua_lerror: 01625 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err); 01626 return 0; 01627 #endif 01628 } 01629 #endif //#ifndef TOLUA_DISABLE 01630 01631 /* method: id of class fawkes::SwitchInterface */ 01632 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_id00 01633 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_id00(lua_State* tolua_S) 01634 { 01635 #ifndef TOLUA_RELEASE 01636 tolua_Error tolua_err; 01637 if ( 01638 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01639 !tolua_isnoobj(tolua_S,2,&tolua_err) 01640 ) 01641 goto tolua_lerror; 01642 else 01643 #endif 01644 { 01645 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01646 #ifndef TOLUA_RELEASE 01647 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL); 01648 #endif 01649 { 01650 const char* tolua_ret = (const char*) self->id(); 01651 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01652 } 01653 } 01654 return 1; 01655 #ifndef TOLUA_RELEASE 01656 tolua_lerror: 01657 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err); 01658 return 0; 01659 #endif 01660 } 01661 #endif //#ifndef TOLUA_DISABLE 01662 01663 /* method: uid of class fawkes::SwitchInterface */ 01664 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_uid00 01665 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_uid00(lua_State* tolua_S) 01666 { 01667 #ifndef TOLUA_RELEASE 01668 tolua_Error tolua_err; 01669 if ( 01670 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01671 !tolua_isnoobj(tolua_S,2,&tolua_err) 01672 ) 01673 goto tolua_lerror; 01674 else 01675 #endif 01676 { 01677 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01678 #ifndef TOLUA_RELEASE 01679 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL); 01680 #endif 01681 { 01682 const char* tolua_ret = (const char*) self->uid(); 01683 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01684 } 01685 } 01686 return 1; 01687 #ifndef TOLUA_RELEASE 01688 tolua_lerror: 01689 tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err); 01690 return 0; 01691 #endif 01692 } 01693 #endif //#ifndef TOLUA_DISABLE 01694 01695 /* method: serial of class fawkes::SwitchInterface */ 01696 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_serial00 01697 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_serial00(lua_State* tolua_S) 01698 { 01699 #ifndef TOLUA_RELEASE 01700 tolua_Error tolua_err; 01701 if ( 01702 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01703 !tolua_isnoobj(tolua_S,2,&tolua_err) 01704 ) 01705 goto tolua_lerror; 01706 else 01707 #endif 01708 { 01709 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01710 #ifndef TOLUA_RELEASE 01711 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL); 01712 #endif 01713 { 01714 unsigned int tolua_ret = (unsigned int) self->serial(); 01715 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01716 } 01717 } 01718 return 1; 01719 #ifndef TOLUA_RELEASE 01720 tolua_lerror: 01721 tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err); 01722 return 0; 01723 #endif 01724 } 01725 #endif //#ifndef TOLUA_DISABLE 01726 01727 /* method: mem_serial of class fawkes::SwitchInterface */ 01728 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_mem_serial00 01729 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_mem_serial00(lua_State* tolua_S) 01730 { 01731 #ifndef TOLUA_RELEASE 01732 tolua_Error tolua_err; 01733 if ( 01734 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01735 !tolua_isnoobj(tolua_S,2,&tolua_err) 01736 ) 01737 goto tolua_lerror; 01738 else 01739 #endif 01740 { 01741 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01742 #ifndef TOLUA_RELEASE 01743 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL); 01744 #endif 01745 { 01746 unsigned int tolua_ret = (unsigned int) self->mem_serial(); 01747 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01748 } 01749 } 01750 return 1; 01751 #ifndef TOLUA_RELEASE 01752 tolua_lerror: 01753 tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err); 01754 return 0; 01755 #endif 01756 } 01757 #endif //#ifndef TOLUA_DISABLE 01758 01759 /* method: operator== of class fawkes::SwitchInterface */ 01760 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface__eq00 01761 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface__eq00(lua_State* tolua_S) 01762 { 01763 #ifndef TOLUA_RELEASE 01764 tolua_Error tolua_err; 01765 if ( 01766 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01767 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) || 01768 !tolua_isnoobj(tolua_S,3,&tolua_err) 01769 ) 01770 goto tolua_lerror; 01771 else 01772 #endif 01773 { 01774 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01775 Interface* comp = ((Interface*) tolua_tousertype(tolua_S,2,0)); 01776 #ifndef TOLUA_RELEASE 01777 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL); 01778 #endif 01779 { 01780 bool tolua_ret = (bool) self->operator==(*comp); 01781 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01782 } 01783 } 01784 return 1; 01785 #ifndef TOLUA_RELEASE 01786 tolua_lerror: 01787 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err); 01788 return 0; 01789 #endif 01790 } 01791 #endif //#ifndef TOLUA_DISABLE 01792 01793 /* method: hash of class fawkes::SwitchInterface */ 01794 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_hash00 01795 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_hash00(lua_State* tolua_S) 01796 { 01797 #ifndef TOLUA_RELEASE 01798 tolua_Error tolua_err; 01799 if ( 01800 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01801 !tolua_isnoobj(tolua_S,2,&tolua_err) 01802 ) 01803 goto tolua_lerror; 01804 else 01805 #endif 01806 { 01807 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01808 #ifndef TOLUA_RELEASE 01809 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL); 01810 #endif 01811 { 01812 unsigned const char* tolua_ret = ( unsigned const char*) self->hash(); 01813 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01814 } 01815 } 01816 return 1; 01817 #ifndef TOLUA_RELEASE 01818 tolua_lerror: 01819 tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err); 01820 return 0; 01821 #endif 01822 } 01823 #endif //#ifndef TOLUA_DISABLE 01824 01825 /* method: hash_size of class fawkes::SwitchInterface */ 01826 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_hash_size00 01827 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_hash_size00(lua_State* tolua_S) 01828 { 01829 #ifndef TOLUA_RELEASE 01830 tolua_Error tolua_err; 01831 if ( 01832 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01833 !tolua_isnoobj(tolua_S,2,&tolua_err) 01834 ) 01835 goto tolua_lerror; 01836 else 01837 #endif 01838 { 01839 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01840 #ifndef TOLUA_RELEASE 01841 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL); 01842 #endif 01843 { 01844 int tolua_ret = (int) self->hash_size(); 01845 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01846 } 01847 } 01848 return 1; 01849 #ifndef TOLUA_RELEASE 01850 tolua_lerror: 01851 tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err); 01852 return 0; 01853 #endif 01854 } 01855 #endif //#ifndef TOLUA_DISABLE 01856 01857 /* method: hash_printable of class fawkes::SwitchInterface */ 01858 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_hash_printable00 01859 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_hash_printable00(lua_State* tolua_S) 01860 { 01861 #ifndef TOLUA_RELEASE 01862 tolua_Error tolua_err; 01863 if ( 01864 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01865 !tolua_isnoobj(tolua_S,2,&tolua_err) 01866 ) 01867 goto tolua_lerror; 01868 else 01869 #endif 01870 { 01871 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01872 #ifndef TOLUA_RELEASE 01873 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL); 01874 #endif 01875 { 01876 const char* tolua_ret = (const char*) self->hash_printable(); 01877 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01878 } 01879 } 01880 return 1; 01881 #ifndef TOLUA_RELEASE 01882 tolua_lerror: 01883 tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err); 01884 return 0; 01885 #endif 01886 } 01887 #endif //#ifndef TOLUA_DISABLE 01888 01889 /* method: is_writer of class fawkes::SwitchInterface */ 01890 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_is_writer00 01891 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_is_writer00(lua_State* tolua_S) 01892 { 01893 #ifndef TOLUA_RELEASE 01894 tolua_Error tolua_err; 01895 if ( 01896 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01897 !tolua_isnoobj(tolua_S,2,&tolua_err) 01898 ) 01899 goto tolua_lerror; 01900 else 01901 #endif 01902 { 01903 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01904 #ifndef TOLUA_RELEASE 01905 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL); 01906 #endif 01907 { 01908 bool tolua_ret = (bool) self->is_writer(); 01909 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01910 } 01911 } 01912 return 1; 01913 #ifndef TOLUA_RELEASE 01914 tolua_lerror: 01915 tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err); 01916 return 0; 01917 #endif 01918 } 01919 #endif //#ifndef TOLUA_DISABLE 01920 01921 /* method: set_from_chunk of class fawkes::SwitchInterface */ 01922 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_from_chunk00 01923 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_from_chunk00(lua_State* tolua_S) 01924 { 01925 #ifndef TOLUA_RELEASE 01926 tolua_Error tolua_err; 01927 if ( 01928 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 01929 !tolua_isuserdata(tolua_S,2,0,&tolua_err) || 01930 !tolua_isnoobj(tolua_S,3,&tolua_err) 01931 ) 01932 goto tolua_lerror; 01933 else 01934 #endif 01935 { 01936 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01937 void* chunk = ((void*) tolua_touserdata(tolua_S,2,0)); 01938 #ifndef TOLUA_RELEASE 01939 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL); 01940 #endif 01941 { 01942 self->set_from_chunk(chunk); 01943 } 01944 } 01945 return 0; 01946 #ifndef TOLUA_RELEASE 01947 tolua_lerror: 01948 tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err); 01949 return 0; 01950 #endif 01951 } 01952 #endif //#ifndef TOLUA_DISABLE 01953 01954 /* method: create_message of class fawkes::SwitchInterface */ 01955 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_create_message00 01956 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_create_message00(lua_State* tolua_S) 01957 { 01958 #ifndef TOLUA_RELEASE 01959 tolua_Error tolua_err; 01960 if ( 01961 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 01962 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01963 !tolua_isnoobj(tolua_S,3,&tolua_err) 01964 ) 01965 goto tolua_lerror; 01966 else 01967 #endif 01968 { 01969 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 01970 const char* type = ((const char*) tolua_tostring(tolua_S,2,0)); 01971 #ifndef TOLUA_RELEASE 01972 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL); 01973 #endif 01974 { 01975 Message* tolua_ret = (Message*) self->create_message(type); 01976 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 01977 } 01978 } 01979 return 1; 01980 #ifndef TOLUA_RELEASE 01981 tolua_lerror: 01982 tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err); 01983 return 0; 01984 #endif 01985 } 01986 #endif //#ifndef TOLUA_DISABLE 01987 01988 /* method: read of class fawkes::SwitchInterface */ 01989 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_read00 01990 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_read00(lua_State* tolua_S) 01991 { 01992 #ifndef TOLUA_RELEASE 01993 tolua_Error tolua_err; 01994 if ( 01995 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 01996 !tolua_isnoobj(tolua_S,2,&tolua_err) 01997 ) 01998 goto tolua_lerror; 01999 else 02000 #endif 02001 { 02002 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02003 #ifndef TOLUA_RELEASE 02004 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL); 02005 #endif 02006 { 02007 self->read(); 02008 } 02009 } 02010 return 0; 02011 #ifndef TOLUA_RELEASE 02012 tolua_lerror: 02013 tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err); 02014 return 0; 02015 #endif 02016 } 02017 #endif //#ifndef TOLUA_DISABLE 02018 02019 /* method: write of class fawkes::SwitchInterface */ 02020 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_write00 02021 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_write00(lua_State* tolua_S) 02022 { 02023 #ifndef TOLUA_RELEASE 02024 tolua_Error tolua_err; 02025 if ( 02026 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 02027 !tolua_isnoobj(tolua_S,2,&tolua_err) 02028 ) 02029 goto tolua_lerror; 02030 else 02031 #endif 02032 { 02033 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02034 #ifndef TOLUA_RELEASE 02035 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL); 02036 #endif 02037 { 02038 self->write(); 02039 } 02040 } 02041 return 0; 02042 #ifndef TOLUA_RELEASE 02043 tolua_lerror: 02044 tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err); 02045 return 0; 02046 #endif 02047 } 02048 #endif //#ifndef TOLUA_DISABLE 02049 02050 /* method: has_writer of class fawkes::SwitchInterface */ 02051 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_has_writer00 02052 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_has_writer00(lua_State* tolua_S) 02053 { 02054 #ifndef TOLUA_RELEASE 02055 tolua_Error tolua_err; 02056 if ( 02057 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 02058 !tolua_isnoobj(tolua_S,2,&tolua_err) 02059 ) 02060 goto tolua_lerror; 02061 else 02062 #endif 02063 { 02064 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02065 #ifndef TOLUA_RELEASE 02066 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL); 02067 #endif 02068 { 02069 bool tolua_ret = (bool) self->has_writer(); 02070 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02071 } 02072 } 02073 return 1; 02074 #ifndef TOLUA_RELEASE 02075 tolua_lerror: 02076 tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err); 02077 return 0; 02078 #endif 02079 } 02080 #endif //#ifndef TOLUA_DISABLE 02081 02082 /* method: num_readers of class fawkes::SwitchInterface */ 02083 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_num_readers00 02084 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_num_readers00(lua_State* tolua_S) 02085 { 02086 #ifndef TOLUA_RELEASE 02087 tolua_Error tolua_err; 02088 if ( 02089 !tolua_isusertype(tolua_S,1,"const fawkes::SwitchInterface",0,&tolua_err) || 02090 !tolua_isnoobj(tolua_S,2,&tolua_err) 02091 ) 02092 goto tolua_lerror; 02093 else 02094 #endif 02095 { 02096 const fawkes::SwitchInterface* self = (const fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02097 #ifndef TOLUA_RELEASE 02098 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL); 02099 #endif 02100 { 02101 unsigned int tolua_ret = (unsigned int) self->num_readers(); 02102 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02103 } 02104 } 02105 return 1; 02106 #ifndef TOLUA_RELEASE 02107 tolua_lerror: 02108 tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err); 02109 return 0; 02110 #endif 02111 } 02112 #endif //#ifndef TOLUA_DISABLE 02113 02114 /* method: msgq_enqueue_copy of class fawkes::SwitchInterface */ 02115 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_enqueue_copy00 02116 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_enqueue_copy00(lua_State* tolua_S) 02117 { 02118 #ifndef TOLUA_RELEASE 02119 tolua_Error tolua_err; 02120 if ( 02121 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 02122 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 02123 !tolua_isnoobj(tolua_S,3,&tolua_err) 02124 ) 02125 goto tolua_lerror; 02126 else 02127 #endif 02128 { 02129 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02130 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 02131 #ifndef TOLUA_RELEASE 02132 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL); 02133 #endif 02134 { 02135 unsigned int tolua_ret = (unsigned int) self->msgq_enqueue_copy(message); 02136 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02137 } 02138 } 02139 return 1; 02140 #ifndef TOLUA_RELEASE 02141 tolua_lerror: 02142 tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err); 02143 return 0; 02144 #endif 02145 } 02146 #endif //#ifndef TOLUA_DISABLE 02147 02148 /* method: msgq_remove of class fawkes::SwitchInterface */ 02149 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_remove00 02150 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_remove00(lua_State* tolua_S) 02151 { 02152 #ifndef TOLUA_RELEASE 02153 tolua_Error tolua_err; 02154 if ( 02155 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 02156 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 02157 !tolua_isnoobj(tolua_S,3,&tolua_err) 02158 ) 02159 goto tolua_lerror; 02160 else 02161 #endif 02162 { 02163 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02164 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 02165 #ifndef TOLUA_RELEASE 02166 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 02167 #endif 02168 { 02169 self->msgq_remove(message); 02170 } 02171 } 02172 return 0; 02173 #ifndef TOLUA_RELEASE 02174 tolua_lerror: 02175 tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err); 02176 return 0; 02177 #endif 02178 } 02179 #endif //#ifndef TOLUA_DISABLE 02180 02181 /* method: msgq_remove of class fawkes::SwitchInterface */ 02182 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_remove01 02183 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_remove01(lua_State* tolua_S) 02184 { 02185 tolua_Error tolua_err; 02186 if ( 02187 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 02188 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02189 !tolua_isnoobj(tolua_S,3,&tolua_err) 02190 ) 02191 goto tolua_lerror; 02192 else 02193 { 02194 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02195 unsigned int message_id = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 02196 #ifndef TOLUA_RELEASE 02197 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 02198 #endif 02199 { 02200 self->msgq_remove(message_id); 02201 } 02202 } 02203 return 0; 02204 tolua_lerror: 02205 return tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_remove00(tolua_S); 02206 } 02207 #endif //#ifndef TOLUA_DISABLE 02208 02209 /* method: msgq_size of class fawkes::SwitchInterface */ 02210 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_size00 02211 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_size00(lua_State* tolua_S) 02212 { 02213 #ifndef TOLUA_RELEASE 02214 tolua_Error tolua_err; 02215 if ( 02216 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 02217 !tolua_isnoobj(tolua_S,2,&tolua_err) 02218 ) 02219 goto tolua_lerror; 02220 else 02221 #endif 02222 { 02223 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02224 #ifndef TOLUA_RELEASE 02225 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL); 02226 #endif 02227 { 02228 unsigned int tolua_ret = (unsigned int) self->msgq_size(); 02229 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02230 } 02231 } 02232 return 1; 02233 #ifndef TOLUA_RELEASE 02234 tolua_lerror: 02235 tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err); 02236 return 0; 02237 #endif 02238 } 02239 #endif //#ifndef TOLUA_DISABLE 02240 02241 /* method: msgq_flush of class fawkes::SwitchInterface */ 02242 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_flush00 02243 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_flush00(lua_State* tolua_S) 02244 { 02245 #ifndef TOLUA_RELEASE 02246 tolua_Error tolua_err; 02247 if ( 02248 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 02249 !tolua_isnoobj(tolua_S,2,&tolua_err) 02250 ) 02251 goto tolua_lerror; 02252 else 02253 #endif 02254 { 02255 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02256 #ifndef TOLUA_RELEASE 02257 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL); 02258 #endif 02259 { 02260 self->msgq_flush(); 02261 } 02262 } 02263 return 0; 02264 #ifndef TOLUA_RELEASE 02265 tolua_lerror: 02266 tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err); 02267 return 0; 02268 #endif 02269 } 02270 #endif //#ifndef TOLUA_DISABLE 02271 02272 /* method: msgq_lock of class fawkes::SwitchInterface */ 02273 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_lock00 02274 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_lock00(lua_State* tolua_S) 02275 { 02276 #ifndef TOLUA_RELEASE 02277 tolua_Error tolua_err; 02278 if ( 02279 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 02280 !tolua_isnoobj(tolua_S,2,&tolua_err) 02281 ) 02282 goto tolua_lerror; 02283 else 02284 #endif 02285 { 02286 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02287 #ifndef TOLUA_RELEASE 02288 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL); 02289 #endif 02290 { 02291 self->msgq_lock(); 02292 } 02293 } 02294 return 0; 02295 #ifndef TOLUA_RELEASE 02296 tolua_lerror: 02297 tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err); 02298 return 0; 02299 #endif 02300 } 02301 #endif //#ifndef TOLUA_DISABLE 02302 02303 /* method: msgq_try_lock of class fawkes::SwitchInterface */ 02304 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_try_lock00 02305 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_try_lock00(lua_State* tolua_S) 02306 { 02307 #ifndef TOLUA_RELEASE 02308 tolua_Error tolua_err; 02309 if ( 02310 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 02311 !tolua_isnoobj(tolua_S,2,&tolua_err) 02312 ) 02313 goto tolua_lerror; 02314 else 02315 #endif 02316 { 02317 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02318 #ifndef TOLUA_RELEASE 02319 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL); 02320 #endif 02321 { 02322 bool tolua_ret = (bool) self->msgq_try_lock(); 02323 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02324 } 02325 } 02326 return 1; 02327 #ifndef TOLUA_RELEASE 02328 tolua_lerror: 02329 tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err); 02330 return 0; 02331 #endif 02332 } 02333 #endif //#ifndef TOLUA_DISABLE 02334 02335 /* method: msgq_unlock of class fawkes::SwitchInterface */ 02336 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_unlock00 02337 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_unlock00(lua_State* tolua_S) 02338 { 02339 #ifndef TOLUA_RELEASE 02340 tolua_Error tolua_err; 02341 if ( 02342 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 02343 !tolua_isnoobj(tolua_S,2,&tolua_err) 02344 ) 02345 goto tolua_lerror; 02346 else 02347 #endif 02348 { 02349 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02350 #ifndef TOLUA_RELEASE 02351 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL); 02352 #endif 02353 { 02354 self->msgq_unlock(); 02355 } 02356 } 02357 return 0; 02358 #ifndef TOLUA_RELEASE 02359 tolua_lerror: 02360 tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err); 02361 return 0; 02362 #endif 02363 } 02364 #endif //#ifndef TOLUA_DISABLE 02365 02366 /* method: msgq_pop of class fawkes::SwitchInterface */ 02367 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_pop00 02368 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_pop00(lua_State* tolua_S) 02369 { 02370 #ifndef TOLUA_RELEASE 02371 tolua_Error tolua_err; 02372 if ( 02373 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 02374 !tolua_isnoobj(tolua_S,2,&tolua_err) 02375 ) 02376 goto tolua_lerror; 02377 else 02378 #endif 02379 { 02380 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02381 #ifndef TOLUA_RELEASE 02382 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL); 02383 #endif 02384 { 02385 self->msgq_pop(); 02386 } 02387 } 02388 return 0; 02389 #ifndef TOLUA_RELEASE 02390 tolua_lerror: 02391 tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err); 02392 return 0; 02393 #endif 02394 } 02395 #endif //#ifndef TOLUA_DISABLE 02396 02397 /* method: msgq_first of class fawkes::SwitchInterface */ 02398 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_first00 02399 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_first00(lua_State* tolua_S) 02400 { 02401 #ifndef TOLUA_RELEASE 02402 tolua_Error tolua_err; 02403 if ( 02404 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 02405 !tolua_isnoobj(tolua_S,2,&tolua_err) 02406 ) 02407 goto tolua_lerror; 02408 else 02409 #endif 02410 { 02411 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02412 #ifndef TOLUA_RELEASE 02413 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL); 02414 #endif 02415 { 02416 Message* tolua_ret = (Message*) self->msgq_first(); 02417 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 02418 } 02419 } 02420 return 1; 02421 #ifndef TOLUA_RELEASE 02422 tolua_lerror: 02423 tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err); 02424 return 0; 02425 #endif 02426 } 02427 #endif //#ifndef TOLUA_DISABLE 02428 02429 /* method: msgq_empty of class fawkes::SwitchInterface */ 02430 #ifndef TOLUA_DISABLE_tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_empty00 02431 static int tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_empty00(lua_State* tolua_S) 02432 { 02433 #ifndef TOLUA_RELEASE 02434 tolua_Error tolua_err; 02435 if ( 02436 !tolua_isusertype(tolua_S,1,"fawkes::SwitchInterface",0,&tolua_err) || 02437 !tolua_isnoobj(tolua_S,2,&tolua_err) 02438 ) 02439 goto tolua_lerror; 02440 else 02441 #endif 02442 { 02443 fawkes::SwitchInterface* self = (fawkes::SwitchInterface*) tolua_tousertype(tolua_S,1,0); 02444 #ifndef TOLUA_RELEASE 02445 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL); 02446 #endif 02447 { 02448 bool tolua_ret = (bool) self->msgq_empty(); 02449 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02450 } 02451 } 02452 return 1; 02453 #ifndef TOLUA_RELEASE 02454 tolua_lerror: 02455 tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err); 02456 return 0; 02457 #endif 02458 } 02459 #endif //#ifndef TOLUA_DISABLE 02460 02461 /* Open function */ 02462 TOLUA_API int tolua_interfaces_SwitchInterface_open (lua_State* tolua_S) 02463 { 02464 tolua_open(tolua_S); 02465 tolua_reg_types(tolua_S); 02466 tolua_module(tolua_S,NULL,0); 02467 tolua_beginmodule(tolua_S,NULL); 02468 tolua_module(tolua_S,"fawkes",0); 02469 tolua_beginmodule(tolua_S,"fawkes"); 02470 tolua_cclass(tolua_S,"SwitchInterface","fawkes::SwitchInterface","Interface",NULL); 02471 tolua_beginmodule(tolua_S,"SwitchInterface"); 02472 #ifdef __cplusplus 02473 tolua_cclass(tolua_S,"SetMessage","fawkes::SwitchInterface::SetMessage","Message",tolua_collect_fawkes__SwitchInterface__SetMessage); 02474 #else 02475 tolua_cclass(tolua_S,"SetMessage","fawkes::SwitchInterface::SetMessage","Message",NULL); 02476 #endif 02477 tolua_beginmodule(tolua_S,"SetMessage"); 02478 tolua_function(tolua_S,"new",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new00); 02479 tolua_function(tolua_S,"new_local",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new00_local); 02480 tolua_function(tolua_S,".call",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new00_local); 02481 tolua_function(tolua_S,"new",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new01); 02482 tolua_function(tolua_S,"new_local",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new01_local); 02483 tolua_function(tolua_S,".call",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_new01_local); 02484 tolua_function(tolua_S,"delete",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_delete00); 02485 tolua_function(tolua_S,"is_enabled",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_is_enabled00); 02486 tolua_function(tolua_S,"set_enabled",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_set_enabled00); 02487 tolua_function(tolua_S,"maxlenof_enabled",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_maxlenof_enabled00); 02488 tolua_function(tolua_S,"value",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_value00); 02489 tolua_function(tolua_S,"set_value",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_set_value00); 02490 tolua_function(tolua_S,"maxlenof_value",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_SetMessage_maxlenof_value00); 02491 tolua_endmodule(tolua_S); 02492 #ifdef __cplusplus 02493 tolua_cclass(tolua_S,"EnableSwitchMessage","fawkes::SwitchInterface::EnableSwitchMessage","Message",tolua_collect_fawkes__SwitchInterface__EnableSwitchMessage); 02494 #else 02495 tolua_cclass(tolua_S,"EnableSwitchMessage","fawkes::SwitchInterface::EnableSwitchMessage","Message",NULL); 02496 #endif 02497 tolua_beginmodule(tolua_S,"EnableSwitchMessage"); 02498 tolua_function(tolua_S,"new",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableSwitchMessage_new00); 02499 tolua_function(tolua_S,"new_local",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableSwitchMessage_new00_local); 02500 tolua_function(tolua_S,".call",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableSwitchMessage_new00_local); 02501 tolua_function(tolua_S,"delete",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableSwitchMessage_delete00); 02502 tolua_endmodule(tolua_S); 02503 #ifdef __cplusplus 02504 tolua_cclass(tolua_S,"DisableSwitchMessage","fawkes::SwitchInterface::DisableSwitchMessage","Message",tolua_collect_fawkes__SwitchInterface__DisableSwitchMessage); 02505 #else 02506 tolua_cclass(tolua_S,"DisableSwitchMessage","fawkes::SwitchInterface::DisableSwitchMessage","Message",NULL); 02507 #endif 02508 tolua_beginmodule(tolua_S,"DisableSwitchMessage"); 02509 tolua_function(tolua_S,"new",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_DisableSwitchMessage_new00); 02510 tolua_function(tolua_S,"new_local",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_DisableSwitchMessage_new00_local); 02511 tolua_function(tolua_S,".call",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_DisableSwitchMessage_new00_local); 02512 tolua_function(tolua_S,"delete",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_DisableSwitchMessage_delete00); 02513 tolua_endmodule(tolua_S); 02514 #ifdef __cplusplus 02515 tolua_cclass(tolua_S,"EnableDurationMessage","fawkes::SwitchInterface::EnableDurationMessage","Message",tolua_collect_fawkes__SwitchInterface__EnableDurationMessage); 02516 #else 02517 tolua_cclass(tolua_S,"EnableDurationMessage","fawkes::SwitchInterface::EnableDurationMessage","Message",NULL); 02518 #endif 02519 tolua_beginmodule(tolua_S,"EnableDurationMessage"); 02520 tolua_function(tolua_S,"new",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new00); 02521 tolua_function(tolua_S,"new_local",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new00_local); 02522 tolua_function(tolua_S,".call",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new00_local); 02523 tolua_function(tolua_S,"new",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new01); 02524 tolua_function(tolua_S,"new_local",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new01_local); 02525 tolua_function(tolua_S,".call",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_new01_local); 02526 tolua_function(tolua_S,"delete",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_delete00); 02527 tolua_function(tolua_S,"duration",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_duration00); 02528 tolua_function(tolua_S,"set_duration",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_set_duration00); 02529 tolua_function(tolua_S,"maxlenof_duration",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_maxlenof_duration00); 02530 tolua_function(tolua_S,"value",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_value00); 02531 tolua_function(tolua_S,"set_value",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_set_value00); 02532 tolua_function(tolua_S,"maxlenof_value",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_EnableDurationMessage_maxlenof_value00); 02533 tolua_endmodule(tolua_S); 02534 tolua_function(tolua_S,"is_enabled",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_is_enabled00); 02535 tolua_function(tolua_S,"set_enabled",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_enabled00); 02536 tolua_function(tolua_S,"maxlenof_enabled",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_enabled00); 02537 tolua_function(tolua_S,"value",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_value00); 02538 tolua_function(tolua_S,"set_value",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_value00); 02539 tolua_function(tolua_S,"maxlenof_value",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_value00); 02540 tolua_function(tolua_S,"history",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_history00); 02541 tolua_function(tolua_S,"set_history",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_history00); 02542 tolua_function(tolua_S,"maxlenof_history",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_history00); 02543 tolua_function(tolua_S,"short_activations",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_short_activations00); 02544 tolua_function(tolua_S,"set_short_activations",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_short_activations00); 02545 tolua_function(tolua_S,"maxlenof_short_activations",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_short_activations00); 02546 tolua_function(tolua_S,"long_activations",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_long_activations00); 02547 tolua_function(tolua_S,"set_long_activations",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_long_activations00); 02548 tolua_function(tolua_S,"maxlenof_long_activations",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_long_activations00); 02549 tolua_function(tolua_S,"activation_count",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_activation_count00); 02550 tolua_function(tolua_S,"set_activation_count",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_activation_count00); 02551 tolua_function(tolua_S,"maxlenof_activation_count",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_maxlenof_activation_count00); 02552 tolua_function(tolua_S,"oftype",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_oftype00); 02553 tolua_function(tolua_S,"datachunk",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_datachunk00); 02554 tolua_function(tolua_S,"datasize",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_datasize00); 02555 tolua_function(tolua_S,"type",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_type00); 02556 tolua_function(tolua_S,"id",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_id00); 02557 tolua_function(tolua_S,"uid",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_uid00); 02558 tolua_function(tolua_S,"serial",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_serial00); 02559 tolua_function(tolua_S,"mem_serial",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_mem_serial00); 02560 tolua_function(tolua_S,".eq",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface__eq00); 02561 tolua_function(tolua_S,"hash",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_hash00); 02562 tolua_function(tolua_S,"hash_size",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_hash_size00); 02563 tolua_function(tolua_S,"hash_printable",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_hash_printable00); 02564 tolua_function(tolua_S,"is_writer",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_is_writer00); 02565 tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_set_from_chunk00); 02566 tolua_function(tolua_S,"create_message",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_create_message00); 02567 tolua_function(tolua_S,"read",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_read00); 02568 tolua_function(tolua_S,"write",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_write00); 02569 tolua_function(tolua_S,"has_writer",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_has_writer00); 02570 tolua_function(tolua_S,"num_readers",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_num_readers00); 02571 tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_enqueue_copy00); 02572 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_remove00); 02573 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_remove01); 02574 tolua_function(tolua_S,"msgq_size",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_size00); 02575 tolua_function(tolua_S,"msgq_flush",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_flush00); 02576 tolua_function(tolua_S,"msgq_lock",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_lock00); 02577 tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_try_lock00); 02578 tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_unlock00); 02579 tolua_function(tolua_S,"msgq_pop",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_pop00); 02580 tolua_function(tolua_S,"msgq_first",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_first00); 02581 tolua_function(tolua_S,"msgq_empty",tolua_interfaces_SwitchInterface_fawkes_SwitchInterface_msgq_empty00); 02582 tolua_endmodule(tolua_S); 02583 tolua_endmodule(tolua_S); 02584 tolua_endmodule(tolua_S); 02585 return 1; 02586 } 02587 02588 02589 extern "C" { 02590 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501 02591 TOLUA_API int luaopen_interfaces_SwitchInterface (lua_State* tolua_S) { 02592 return tolua_interfaces_SwitchInterface_open(tolua_S); 02593 }; 02594 #endif 02595 } 02596 02597