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