Fawkes API Fawkes Development Version
fawkesutils_tolua.cpp
1/*
2** Lua binding: fawkesutils
3** Generated automatically by tolua++-1.0.92
4*/
5/* This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version. A runtime exception applies to
9 * this software (see LICENSE.GPL_WRE file mentioned below for details).
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU Library General Public License for more details.
15 *
16 * Read the full text in the LICENSE.GPL_WRE file in the doc directory.
17 */
18
19#include <core/exception.h>
20
21#ifndef __cplusplus
22#include "stdlib.h"
23#endif
24#include "string.h"
25
26#include "tolua++.h"
27
28/* Exported function */
29TOLUA_API int tolua_fawkesutils_open (lua_State* tolua_S);
30
31#include <utils/kalman/kalman_1d.h>
32#include <utils/time/clock.h>
33#include <utils/time/time.h>
34
35/* function to release collected object via destructor */
36#ifdef __cplusplus
37
38static int tolua_collect_fawkes__KalmanFilter1D (lua_State* tolua_S)
39{
40 fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
41 Mtolua_delete(self);
42 return 0;
43}
44
45static int tolua_collect_fawkes__Time (lua_State* tolua_S)
46{
47 fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
48 Mtolua_delete(self);
49 return 0;
50}
51#endif
52
53
54/* function to register type */
55static void tolua_reg_types (lua_State* tolua_S)
56{
57 tolua_usertype(tolua_S,"fawkes::KalmanFilter1D");
58 tolua_usertype(tolua_S,"timeval");
59 tolua_usertype(tolua_S,"fawkes::Clock");
60 tolua_usertype(tolua_S,"fawkes::Time");
61}
62
63/* method: new of class fawkes::KalmanFilter1D */
64#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_new00
65static int tolua_fawkesutils_fawkes_KalmanFilter1D_new00(lua_State* tolua_S)
66{
67#ifndef TOLUA_RELEASE
68 tolua_Error tolua_err;
69 if (
70 !tolua_isusertable(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
71 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
72 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
73 !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
74 !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
75 !tolua_isnoobj(tolua_S,6,&tolua_err)
76 )
77 goto tolua_lerror;
78 else
79#endif
80 {
81 float noise_x = ((float) tolua_tonumber(tolua_S,2,1.0));
82 float noise_z = ((float) tolua_tonumber(tolua_S,3,1.0));
83 float mu = ((float) tolua_tonumber(tolua_S,4,0.0));
84 float sig = ((float) tolua_tonumber(tolua_S,5,1.0));
85 {
86 fawkes::KalmanFilter1D* tolua_ret = (fawkes::KalmanFilter1D*) Mtolua_new((fawkes::KalmanFilter1D)(noise_x,noise_z,mu,sig));
87 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KalmanFilter1D");
88 }
89 }
90 return 1;
91#ifndef TOLUA_RELEASE
92 tolua_lerror:
93 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
94 return 0;
95#endif
96}
97#endif //#ifndef TOLUA_DISABLE
98
99/* method: new_local of class fawkes::KalmanFilter1D */
100#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local
101static int tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local(lua_State* tolua_S)
102{
103#ifndef TOLUA_RELEASE
104 tolua_Error tolua_err;
105 if (
106 !tolua_isusertable(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
107 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
108 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
109 !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
110 !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
111 !tolua_isnoobj(tolua_S,6,&tolua_err)
112 )
113 goto tolua_lerror;
114 else
115#endif
116 {
117 float noise_x = ((float) tolua_tonumber(tolua_S,2,1.0));
118 float noise_z = ((float) tolua_tonumber(tolua_S,3,1.0));
119 float mu = ((float) tolua_tonumber(tolua_S,4,0.0));
120 float sig = ((float) tolua_tonumber(tolua_S,5,1.0));
121 {
122 fawkes::KalmanFilter1D* tolua_ret = (fawkes::KalmanFilter1D*) Mtolua_new((fawkes::KalmanFilter1D)(noise_x,noise_z,mu,sig));
123 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KalmanFilter1D");
124 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
125 }
126 }
127 return 1;
128#ifndef TOLUA_RELEASE
129 tolua_lerror:
130 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
131 return 0;
132#endif
133}
134#endif //#ifndef TOLUA_DISABLE
135
136/* method: delete of class fawkes::KalmanFilter1D */
137#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_delete00
138static int tolua_fawkesutils_fawkes_KalmanFilter1D_delete00(lua_State* tolua_S)
139{
140#ifndef TOLUA_RELEASE
141 tolua_Error tolua_err;
142 if (
143 !tolua_isusertype(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
144 !tolua_isnoobj(tolua_S,2,&tolua_err)
145 )
146 goto tolua_lerror;
147 else
148#endif
149 {
150 fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
151#ifndef TOLUA_RELEASE
152 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
153#endif
154 Mtolua_delete(self);
155 }
156 return 0;
157#ifndef TOLUA_RELEASE
158 tolua_lerror:
159 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
160 return 0;
161#endif
162}
163#endif //#ifndef TOLUA_DISABLE
164
165/* method: filter of class fawkes::KalmanFilter1D */
166#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_filter00
167static int tolua_fawkesutils_fawkes_KalmanFilter1D_filter00(lua_State* tolua_S)
168{
169#ifndef TOLUA_RELEASE
170 tolua_Error tolua_err;
171 if (
172 !tolua_isusertype(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
173 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
174 !tolua_isnoobj(tolua_S,3,&tolua_err)
175 )
176 goto tolua_lerror;
177 else
178#endif
179 {
180 fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
181 float observe = ((float) tolua_tonumber(tolua_S,2,0));
182#ifndef TOLUA_RELEASE
183 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'filter'",NULL);
184#endif
185 {
186 self->filter(observe);
187 }
188 }
189 return 0;
190#ifndef TOLUA_RELEASE
191 tolua_lerror:
192 tolua_error(tolua_S,"#ferror in function 'filter'.",&tolua_err);
193 return 0;
194#endif
195}
196#endif //#ifndef TOLUA_DISABLE
197
198/* method: filter of class fawkes::KalmanFilter1D */
199#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_filter01
200static int tolua_fawkesutils_fawkes_KalmanFilter1D_filter01(lua_State* tolua_S)
201{
202 tolua_Error tolua_err;
203 if (
204 !tolua_isusertype(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
205 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
206 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
207 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
208 !tolua_isnoobj(tolua_S,5,&tolua_err)
209 )
210 goto tolua_lerror;
211 else
212 {
213 fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
214 float observe = ((float) tolua_tonumber(tolua_S,2,0));
215 float mu = ((float) tolua_tonumber(tolua_S,3,0));
216 float sig = ((float) tolua_tonumber(tolua_S,4,0));
217#ifndef TOLUA_RELEASE
218 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'filter'",NULL);
219#endif
220 {
221 self->filter(observe,mu,sig);
222 tolua_pushnumber(tolua_S,(lua_Number)mu);
223 tolua_pushnumber(tolua_S,(lua_Number)sig);
224 }
225 }
226 return 2;
227tolua_lerror:
228 return tolua_fawkesutils_fawkes_KalmanFilter1D_filter00(tolua_S);
229}
230#endif //#ifndef TOLUA_DISABLE
231
232/* method: predict of class fawkes::KalmanFilter1D */
233#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict00
234static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict00(lua_State* tolua_S)
235{
236#ifndef TOLUA_RELEASE
237 tolua_Error tolua_err;
238 if (
239 !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
240 !tolua_isnoobj(tolua_S,2,&tolua_err)
241 )
242 goto tolua_lerror;
243 else
244#endif
245 {
246 const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
247#ifndef TOLUA_RELEASE
248 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'",NULL);
249#endif
250 {
251 float tolua_ret = (float) self->predict();
252 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
253 }
254 }
255 return 1;
256#ifndef TOLUA_RELEASE
257 tolua_lerror:
258 tolua_error(tolua_S,"#ferror in function 'predict'.",&tolua_err);
259 return 0;
260#endif
261}
262#endif //#ifndef TOLUA_DISABLE
263
264/* method: predict of class fawkes::KalmanFilter1D */
265#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict01
266static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict01(lua_State* tolua_S)
267{
268 tolua_Error tolua_err;
269 if (
270 !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
271 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
272 !tolua_isnoobj(tolua_S,3,&tolua_err)
273 )
274 goto tolua_lerror;
275 else
276 {
277 const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
278 float vel = ((float) tolua_tonumber(tolua_S,2,0));
279#ifndef TOLUA_RELEASE
280 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'",NULL);
281#endif
282 {
283 float tolua_ret = (float) self->predict(vel);
284 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
285 }
286 }
287 return 1;
288tolua_lerror:
289 return tolua_fawkesutils_fawkes_KalmanFilter1D_predict00(tolua_S);
290}
291#endif //#ifndef TOLUA_DISABLE
292
293/* method: predict of class fawkes::KalmanFilter1D */
294#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict02
295static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict02(lua_State* tolua_S)
296{
297 tolua_Error tolua_err;
298 if (
299 !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
300 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
301 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
302 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
303 !tolua_isnoobj(tolua_S,5,&tolua_err)
304 )
305 goto tolua_lerror;
306 else
307 {
308 const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
309 float vel = ((float) tolua_tonumber(tolua_S,2,0));
310 int steps = ((int) tolua_tonumber(tolua_S,3,0));
311 float noise_z = ((float) tolua_tonumber(tolua_S,4,0));
312#ifndef TOLUA_RELEASE
313 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'",NULL);
314#endif
315 {
316 float tolua_ret = (float) self->predict(vel,steps,noise_z);
317 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
318 }
319 }
320 return 1;
321tolua_lerror:
322 return tolua_fawkesutils_fawkes_KalmanFilter1D_predict01(tolua_S);
323}
324#endif //#ifndef TOLUA_DISABLE
325
326/* method: predict of class fawkes::KalmanFilter1D */
327#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict03
328static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict03(lua_State* tolua_S)
329{
330 tolua_Error tolua_err;
331 if (
332 !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
333 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
334 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
335 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
336 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
337 !tolua_isnoobj(tolua_S,6,&tolua_err)
338 )
339 goto tolua_lerror;
340 else
341 {
342 const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
343 float mu = ((float) tolua_tonumber(tolua_S,2,0));
344 float vel = ((float) tolua_tonumber(tolua_S,3,0));
345 int steps = ((int) tolua_tonumber(tolua_S,4,0));
346 float noise_z = ((float) tolua_tonumber(tolua_S,5,0));
347#ifndef TOLUA_RELEASE
348 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'",NULL);
349#endif
350 {
351 float tolua_ret = (float) self->predict(mu,vel,steps,noise_z);
352 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
353 }
354 }
355 return 1;
356tolua_lerror:
357 return tolua_fawkesutils_fawkes_KalmanFilter1D_predict02(tolua_S);
358}
359#endif //#ifndef TOLUA_DISABLE
360
361/* method: instance of class fawkes::Clock */
362#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_instance00
363static int tolua_fawkesutils_fawkes_Clock_instance00(lua_State* tolua_S)
364{
365#ifndef TOLUA_RELEASE
366 tolua_Error tolua_err;
367 if (
368 !tolua_isusertable(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
369 !tolua_isnoobj(tolua_S,2,&tolua_err)
370 )
371 goto tolua_lerror;
372 else
373#endif
374 {
375 {
377 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Clock");
378 }
379 }
380 return 1;
381#ifndef TOLUA_RELEASE
382 tolua_lerror:
383 tolua_error(tolua_S,"#ferror in function 'instance'.",&tolua_err);
384 return 0;
385#endif
386}
387#endif //#ifndef TOLUA_DISABLE
388
389/* method: finalize of class fawkes::Clock */
390#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_finalize00
391static int tolua_fawkesutils_fawkes_Clock_finalize00(lua_State* tolua_S)
392{
393#ifndef TOLUA_RELEASE
394 tolua_Error tolua_err;
395 if (
396 !tolua_isusertable(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
397 !tolua_isnoobj(tolua_S,2,&tolua_err)
398 )
399 goto tolua_lerror;
400 else
401#endif
402 {
403 {
405 }
406 }
407 return 0;
408#ifndef TOLUA_RELEASE
409 tolua_lerror:
410 tolua_error(tolua_S,"#ferror in function 'finalize'.",&tolua_err);
411 return 0;
412#endif
413}
414#endif //#ifndef TOLUA_DISABLE
415
416/* method: is_ext_default_timesource of class fawkes::Clock */
417#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00
418static int tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00(lua_State* tolua_S)
419{
420#ifndef TOLUA_RELEASE
421 tolua_Error tolua_err;
422 if (
423 !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
424 !tolua_isnoobj(tolua_S,2,&tolua_err)
425 )
426 goto tolua_lerror;
427 else
428#endif
429 {
430 const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
431#ifndef TOLUA_RELEASE
432 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_ext_default_timesource'",NULL);
433#endif
434 {
435 bool tolua_ret = (bool) self->is_ext_default_timesource();
436 tolua_pushboolean(tolua_S,(bool)tolua_ret);
437 }
438 }
439 return 1;
440#ifndef TOLUA_RELEASE
441 tolua_lerror:
442 tolua_error(tolua_S,"#ferror in function 'is_ext_default_timesource'.",&tolua_err);
443 return 0;
444#endif
445}
446#endif //#ifndef TOLUA_DISABLE
447
448/* method: has_ext_timesource of class fawkes::Clock */
449#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_has_ext_timesource00
450static int tolua_fawkesutils_fawkes_Clock_has_ext_timesource00(lua_State* tolua_S)
451{
452#ifndef TOLUA_RELEASE
453 tolua_Error tolua_err;
454 if (
455 !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
456 !tolua_isnoobj(tolua_S,2,&tolua_err)
457 )
458 goto tolua_lerror;
459 else
460#endif
461 {
462 const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
463#ifndef TOLUA_RELEASE
464 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_ext_timesource'",NULL);
465#endif
466 {
467 bool tolua_ret = (bool) self->has_ext_timesource();
468 tolua_pushboolean(tolua_S,(bool)tolua_ret);
469 }
470 }
471 return 1;
472#ifndef TOLUA_RELEASE
473 tolua_lerror:
474 tolua_error(tolua_S,"#ferror in function 'has_ext_timesource'.",&tolua_err);
475 return 0;
476#endif
477}
478#endif //#ifndef TOLUA_DISABLE
479
480/* method: ext_to_realtime of class fawkes::Clock */
481#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_ext_to_realtime00
482static int tolua_fawkesutils_fawkes_Clock_ext_to_realtime00(lua_State* tolua_S)
483{
484#ifndef TOLUA_RELEASE
485 tolua_Error tolua_err;
486 if (
487 !tolua_isusertype(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
488 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
489 !tolua_isnoobj(tolua_S,3,&tolua_err)
490 )
491 goto tolua_lerror;
492 else
493#endif
494 {
495 fawkes::Clock* self = (fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
496 const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
497#ifndef TOLUA_RELEASE
498 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ext_to_realtime'",NULL);
499#endif
500 {
501 fawkes::Time tolua_ret = (fawkes::Time) self->ext_to_realtime(*t);
502 {
503#ifdef __cplusplus
504 void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
505 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
506 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
507#else
508 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
509 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
510 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
511#endif
512 }
513 }
514 }
515 return 1;
516#ifndef TOLUA_RELEASE
517 tolua_lerror:
518 tolua_error(tolua_S,"#ferror in function 'ext_to_realtime'.",&tolua_err);
519 return 0;
520#endif
521}
522#endif //#ifndef TOLUA_DISABLE
523
524/* method: get_time of class fawkes::Clock */
525#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time00
526static int tolua_fawkesutils_fawkes_Clock_get_time00(lua_State* tolua_S)
527{
528#ifndef TOLUA_RELEASE
529 tolua_Error tolua_err;
530 if (
531 !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
532 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
533 !tolua_isnoobj(tolua_S,3,&tolua_err)
534 )
535 goto tolua_lerror;
536 else
537#endif
538 {
539 const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
540 fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
541#ifndef TOLUA_RELEASE
542 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'",NULL);
543#endif
544 {
545 self->get_time(*time);
546 }
547 }
548 return 0;
549#ifndef TOLUA_RELEASE
550 tolua_lerror:
551 tolua_error(tolua_S,"#ferror in function 'get_time'.",&tolua_err);
552 return 0;
553#endif
554}
555#endif //#ifndef TOLUA_DISABLE
556
557/* method: get_time of class fawkes::Clock */
558#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time01
559static int tolua_fawkesutils_fawkes_Clock_get_time01(lua_State* tolua_S)
560{
561 tolua_Error tolua_err;
562 if (
563 !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
564 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
565 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
566 !tolua_isnoobj(tolua_S,4,&tolua_err)
567 )
568 goto tolua_lerror;
569 else
570 {
571 const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
572 fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
573 fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int) tolua_tonumber(tolua_S,3,0));
574#ifndef TOLUA_RELEASE
575 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'",NULL);
576#endif
577 {
578 self->get_time(*time,sel);
579 }
580 }
581 return 0;
582tolua_lerror:
583 return tolua_fawkesutils_fawkes_Clock_get_time00(tolua_S);
584}
585#endif //#ifndef TOLUA_DISABLE
586
587/* method: get_time of class fawkes::Clock */
588#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time02
589static int tolua_fawkesutils_fawkes_Clock_get_time02(lua_State* tolua_S)
590{
591 tolua_Error tolua_err;
592 if (
593 !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
594 !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
595 !tolua_isnoobj(tolua_S,3,&tolua_err)
596 )
597 goto tolua_lerror;
598 else
599 {
600 const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
601 fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
602#ifndef TOLUA_RELEASE
603 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'",NULL);
604#endif
605 {
606 self->get_time(time);
607 }
608 }
609 return 0;
610tolua_lerror:
611 return tolua_fawkesutils_fawkes_Clock_get_time01(tolua_S);
612}
613#endif //#ifndef TOLUA_DISABLE
614
615/* method: get_time of class fawkes::Clock */
616#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time03
617static int tolua_fawkesutils_fawkes_Clock_get_time03(lua_State* tolua_S)
618{
619 tolua_Error tolua_err;
620 if (
621 !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
622 !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
623 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
624 !tolua_isnoobj(tolua_S,4,&tolua_err)
625 )
626 goto tolua_lerror;
627 else
628 {
629 const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
630 fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
631 fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int) tolua_tonumber(tolua_S,3,0));
632#ifndef TOLUA_RELEASE
633 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'",NULL);
634#endif
635 {
636 self->get_time(time,sel);
637 }
638 }
639 return 0;
640tolua_lerror:
641 return tolua_fawkesutils_fawkes_Clock_get_time02(tolua_S);
642}
643#endif //#ifndef TOLUA_DISABLE
644
645/* method: get_time of class fawkes::Clock */
646#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time04
647static int tolua_fawkesutils_fawkes_Clock_get_time04(lua_State* tolua_S)
648{
649 tolua_Error tolua_err;
650 if (
651 !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
652 !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
653 !tolua_isnoobj(tolua_S,3,&tolua_err)
654 )
655 goto tolua_lerror;
656 else
657 {
658 const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
659 struct timeval* tv = ((struct timeval*) tolua_tousertype(tolua_S,2,0));
660#ifndef TOLUA_RELEASE
661 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'",NULL);
662#endif
663 {
664 self->get_time(tv);
665 }
666 }
667 return 0;
668tolua_lerror:
669 return tolua_fawkesutils_fawkes_Clock_get_time03(tolua_S);
670}
671#endif //#ifndef TOLUA_DISABLE
672
673/* method: get_time of class fawkes::Clock */
674#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time05
675static int tolua_fawkesutils_fawkes_Clock_get_time05(lua_State* tolua_S)
676{
677 tolua_Error tolua_err;
678 if (
679 !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
680 !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
681 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
682 !tolua_isnoobj(tolua_S,4,&tolua_err)
683 )
684 goto tolua_lerror;
685 else
686 {
687 const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
688 struct timeval* tv = ((struct timeval*) tolua_tousertype(tolua_S,2,0));
689 fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int) tolua_tonumber(tolua_S,3,0));
690#ifndef TOLUA_RELEASE
691 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'",NULL);
692#endif
693 {
694 self->get_time(tv,sel);
695 }
696 }
697 return 0;
698tolua_lerror:
699 return tolua_fawkesutils_fawkes_Clock_get_time04(tolua_S);
700}
701#endif //#ifndef TOLUA_DISABLE
702
703/* method: get_systime of class fawkes::Clock */
704#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime00
705static int tolua_fawkesutils_fawkes_Clock_get_systime00(lua_State* tolua_S)
706{
707#ifndef TOLUA_RELEASE
708 tolua_Error tolua_err;
709 if (
710 !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
711 !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
712 !tolua_isnoobj(tolua_S,3,&tolua_err)
713 )
714 goto tolua_lerror;
715 else
716#endif
717 {
718 const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
719 struct timeval* tv = ((struct timeval*) tolua_tousertype(tolua_S,2,0));
720#ifndef TOLUA_RELEASE
721 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'",NULL);
722#endif
723 {
724 self->get_systime(tv);
725 }
726 }
727 return 0;
728#ifndef TOLUA_RELEASE
729 tolua_lerror:
730 tolua_error(tolua_S,"#ferror in function 'get_systime'.",&tolua_err);
731 return 0;
732#endif
733}
734#endif //#ifndef TOLUA_DISABLE
735
736/* method: get_systime of class fawkes::Clock */
737#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime01
738static int tolua_fawkesutils_fawkes_Clock_get_systime01(lua_State* tolua_S)
739{
740 tolua_Error tolua_err;
741 if (
742 !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
743 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
744 !tolua_isnoobj(tolua_S,3,&tolua_err)
745 )
746 goto tolua_lerror;
747 else
748 {
749 const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
750 fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
751#ifndef TOLUA_RELEASE
752 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'",NULL);
753#endif
754 {
755 self->get_systime(*time);
756 }
757 }
758 return 0;
759tolua_lerror:
760 return tolua_fawkesutils_fawkes_Clock_get_systime00(tolua_S);
761}
762#endif //#ifndef TOLUA_DISABLE
763
764/* method: get_systime of class fawkes::Clock */
765#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime02
766static int tolua_fawkesutils_fawkes_Clock_get_systime02(lua_State* tolua_S)
767{
768 tolua_Error tolua_err;
769 if (
770 !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
771 !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
772 !tolua_isnoobj(tolua_S,3,&tolua_err)
773 )
774 goto tolua_lerror;
775 else
776 {
777 const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
778 fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
779#ifndef TOLUA_RELEASE
780 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'",NULL);
781#endif
782 {
783 self->get_systime(time);
784 }
785 }
786 return 0;
787tolua_lerror:
788 return tolua_fawkesutils_fawkes_Clock_get_systime01(tolua_S);
789}
790#endif //#ifndef TOLUA_DISABLE
791
792/* method: now of class fawkes::Clock */
793#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_now00
794static int tolua_fawkesutils_fawkes_Clock_now00(lua_State* tolua_S)
795{
796#ifndef TOLUA_RELEASE
797 tolua_Error tolua_err;
798 if (
799 !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
800 !tolua_isnoobj(tolua_S,2,&tolua_err)
801 )
802 goto tolua_lerror;
803 else
804#endif
805 {
806 const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
807#ifndef TOLUA_RELEASE
808 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'now'",NULL);
809#endif
810 {
811 fawkes::Time tolua_ret = (fawkes::Time) self->now();
812 {
813#ifdef __cplusplus
814 void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
815 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
816 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
817#else
818 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
819 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
820 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
821#endif
822 }
823 }
824 }
825 return 1;
826#ifndef TOLUA_RELEASE
827 tolua_lerror:
828 tolua_error(tolua_S,"#ferror in function 'now'.",&tolua_err);
829 return 0;
830#endif
831}
832#endif //#ifndef TOLUA_DISABLE
833
834/* method: elapsed of class fawkes::Clock */
835#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_elapsed00
836static int tolua_fawkesutils_fawkes_Clock_elapsed00(lua_State* tolua_S)
837{
838#ifndef TOLUA_RELEASE
839 tolua_Error tolua_err;
840 if (
841 !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
842 !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
843 !tolua_isnoobj(tolua_S,3,&tolua_err)
844 )
845 goto tolua_lerror;
846 else
847#endif
848 {
849 const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
850 fawkes::Time* t = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
851#ifndef TOLUA_RELEASE
852 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'elapsed'",NULL);
853#endif
854 {
855 float tolua_ret = (float) self->elapsed(t);
856 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
857 }
858 }
859 return 1;
860#ifndef TOLUA_RELEASE
861 tolua_lerror:
862 tolua_error(tolua_S,"#ferror in function 'elapsed'.",&tolua_err);
863 return 0;
864#endif
865}
866#endif //#ifndef TOLUA_DISABLE
867
868/* method: sys_elapsed of class fawkes::Clock */
869#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_sys_elapsed00
870static int tolua_fawkesutils_fawkes_Clock_sys_elapsed00(lua_State* tolua_S)
871{
872#ifndef TOLUA_RELEASE
873 tolua_Error tolua_err;
874 if (
875 !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
876 !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
877 !tolua_isnoobj(tolua_S,3,&tolua_err)
878 )
879 goto tolua_lerror;
880 else
881#endif
882 {
883 const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
884 fawkes::Time* t = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
885#ifndef TOLUA_RELEASE
886 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sys_elapsed'",NULL);
887#endif
888 {
889 float tolua_ret = (float) self->sys_elapsed(t);
890 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
891 }
892 }
893 return 1;
894#ifndef TOLUA_RELEASE
895 tolua_lerror:
896 tolua_error(tolua_S,"#ferror in function 'sys_elapsed'.",&tolua_err);
897 return 0;
898#endif
899}
900#endif //#ifndef TOLUA_DISABLE
901
902/* get function: tv_sec of class timeval */
903#ifndef TOLUA_DISABLE_tolua_get_timeval_tv_sec
904static int tolua_get_timeval_tv_sec(lua_State* tolua_S)
905{
906 timeval* self = (timeval*) tolua_tousertype(tolua_S,1,0);
907#ifndef TOLUA_RELEASE
908 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_sec'",NULL);
909#endif
910 tolua_pushnumber(tolua_S,(lua_Number)self->tv_sec);
911 return 1;
912}
913#endif //#ifndef TOLUA_DISABLE
914
915/* set function: tv_sec of class timeval */
916#ifndef TOLUA_DISABLE_tolua_set_timeval_tv_sec
917static int tolua_set_timeval_tv_sec(lua_State* tolua_S)
918{
919 timeval* self = (timeval*) tolua_tousertype(tolua_S,1,0);
920#ifndef TOLUA_RELEASE
921 tolua_Error tolua_err;
922 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_sec'",NULL);
923 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
924 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
925#endif
926 self->tv_sec = ((long int) tolua_tonumber(tolua_S,2,0))
927;
928 return 0;
929}
930#endif //#ifndef TOLUA_DISABLE
931
932/* get function: tv_usec of class timeval */
933#ifndef TOLUA_DISABLE_tolua_get_timeval_tv_usec
934static int tolua_get_timeval_tv_usec(lua_State* tolua_S)
935{
936 timeval* self = (timeval*) tolua_tousertype(tolua_S,1,0);
937#ifndef TOLUA_RELEASE
938 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_usec'",NULL);
939#endif
940 tolua_pushnumber(tolua_S,(lua_Number)self->tv_usec);
941 return 1;
942}
943#endif //#ifndef TOLUA_DISABLE
944
945/* set function: tv_usec of class timeval */
946#ifndef TOLUA_DISABLE_tolua_set_timeval_tv_usec
947static int tolua_set_timeval_tv_usec(lua_State* tolua_S)
948{
949 timeval* self = (timeval*) tolua_tousertype(tolua_S,1,0);
950#ifndef TOLUA_RELEASE
951 tolua_Error tolua_err;
952 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_usec'",NULL);
953 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
954 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
955#endif
956 self->tv_usec = ((long int) tolua_tonumber(tolua_S,2,0))
957;
958 return 0;
959}
960#endif //#ifndef TOLUA_DISABLE
961
962/* method: new of class fawkes::Time */
963#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new00
964static int tolua_fawkesutils_fawkes_Time_new00(lua_State* tolua_S)
965{
966#ifndef TOLUA_RELEASE
967 tolua_Error tolua_err;
968 if (
969 !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
970 !tolua_isnoobj(tolua_S,2,&tolua_err)
971 )
972 goto tolua_lerror;
973 else
974#endif
975 {
976 {
977 fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)());
978 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
979 }
980 }
981 return 1;
982#ifndef TOLUA_RELEASE
983 tolua_lerror:
984 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
985 return 0;
986#endif
987}
988#endif //#ifndef TOLUA_DISABLE
989
990/* method: new_local of class fawkes::Time */
991#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new00_local
992static int tolua_fawkesutils_fawkes_Time_new00_local(lua_State* tolua_S)
993{
994#ifndef TOLUA_RELEASE
995 tolua_Error tolua_err;
996 if (
997 !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
998 !tolua_isnoobj(tolua_S,2,&tolua_err)
999 )
1000 goto tolua_lerror;
1001 else
1002#endif
1003 {
1004 {
1005 fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)());
1006 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1007 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1008 }
1009 }
1010 return 1;
1011#ifndef TOLUA_RELEASE
1012 tolua_lerror:
1013 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1014 return 0;
1015#endif
1016}
1017#endif //#ifndef TOLUA_DISABLE
1018
1019/* method: new of class fawkes::Time */
1020#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new01
1021static int tolua_fawkesutils_fawkes_Time_new01(lua_State* tolua_S)
1022{
1023 tolua_Error tolua_err;
1024 if (
1025 !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1026 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1027 !tolua_isnoobj(tolua_S,3,&tolua_err)
1028 )
1029 goto tolua_lerror;
1030 else
1031 {
1032 long ms = ((long) tolua_tonumber(tolua_S,2,0));
1033 {
1034 fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(ms));
1035 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1036 }
1037 }
1038 return 1;
1039tolua_lerror:
1040 return tolua_fawkesutils_fawkes_Time_new00(tolua_S);
1041}
1042#endif //#ifndef TOLUA_DISABLE
1043
1044/* method: new_local of class fawkes::Time */
1045#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new01_local
1046static int tolua_fawkesutils_fawkes_Time_new01_local(lua_State* tolua_S)
1047{
1048 tolua_Error tolua_err;
1049 if (
1050 !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1051 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1052 !tolua_isnoobj(tolua_S,3,&tolua_err)
1053 )
1054 goto tolua_lerror;
1055 else
1056 {
1057 long ms = ((long) tolua_tonumber(tolua_S,2,0));
1058 {
1059 fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(ms));
1060 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1061 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1062 }
1063 }
1064 return 1;
1065tolua_lerror:
1066 return tolua_fawkesutils_fawkes_Time_new00_local(tolua_S);
1067}
1068#endif //#ifndef TOLUA_DISABLE
1069
1070/* method: new of class fawkes::Time */
1071#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new02
1072static int tolua_fawkesutils_fawkes_Time_new02(lua_State* tolua_S)
1073{
1074 tolua_Error tolua_err;
1075 if (
1076 !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1077 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1078 !tolua_isnoobj(tolua_S,3,&tolua_err)
1079 )
1080 goto tolua_lerror;
1081 else
1082 {
1083 float sec = ((float) tolua_tonumber(tolua_S,2,0));
1084 {
1085 fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec));
1086 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1087 }
1088 }
1089 return 1;
1090tolua_lerror:
1091 return tolua_fawkesutils_fawkes_Time_new01(tolua_S);
1092}
1093#endif //#ifndef TOLUA_DISABLE
1094
1095/* method: new_local of class fawkes::Time */
1096#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new02_local
1097static int tolua_fawkesutils_fawkes_Time_new02_local(lua_State* tolua_S)
1098{
1099 tolua_Error tolua_err;
1100 if (
1101 !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1102 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1103 !tolua_isnoobj(tolua_S,3,&tolua_err)
1104 )
1105 goto tolua_lerror;
1106 else
1107 {
1108 float sec = ((float) tolua_tonumber(tolua_S,2,0));
1109 {
1110 fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec));
1111 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1112 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1113 }
1114 }
1115 return 1;
1116tolua_lerror:
1117 return tolua_fawkesutils_fawkes_Time_new01_local(tolua_S);
1118}
1119#endif //#ifndef TOLUA_DISABLE
1120
1121/* method: new of class fawkes::Time */
1122#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new03
1123static int tolua_fawkesutils_fawkes_Time_new03(lua_State* tolua_S)
1124{
1125 tolua_Error tolua_err;
1126 if (
1127 !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1128 !tolua_isusertype(tolua_S,2,"fawkes::Clock",0,&tolua_err) ||
1129 !tolua_isnoobj(tolua_S,3,&tolua_err)
1130 )
1131 goto tolua_lerror;
1132 else
1133 {
1134 fawkes::Clock* clock = ((fawkes::Clock*) tolua_tousertype(tolua_S,2,0));
1135 {
1136 fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(clock));
1137 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1138 }
1139 }
1140 return 1;
1141tolua_lerror:
1142 return tolua_fawkesutils_fawkes_Time_new02(tolua_S);
1143}
1144#endif //#ifndef TOLUA_DISABLE
1145
1146/* method: new_local of class fawkes::Time */
1147#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new03_local
1148static int tolua_fawkesutils_fawkes_Time_new03_local(lua_State* tolua_S)
1149{
1150 tolua_Error tolua_err;
1151 if (
1152 !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1153 !tolua_isusertype(tolua_S,2,"fawkes::Clock",0,&tolua_err) ||
1154 !tolua_isnoobj(tolua_S,3,&tolua_err)
1155 )
1156 goto tolua_lerror;
1157 else
1158 {
1159 fawkes::Clock* clock = ((fawkes::Clock*) tolua_tousertype(tolua_S,2,0));
1160 {
1161 fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(clock));
1162 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1163 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1164 }
1165 }
1166 return 1;
1167tolua_lerror:
1168 return tolua_fawkesutils_fawkes_Time_new02_local(tolua_S);
1169}
1170#endif //#ifndef TOLUA_DISABLE
1171
1172/* method: new of class fawkes::Time */
1173#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new04
1174static int tolua_fawkesutils_fawkes_Time_new04(lua_State* tolua_S)
1175{
1176 tolua_Error tolua_err;
1177 if (
1178 !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1179 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
1180 !tolua_isnoobj(tolua_S,3,&tolua_err)
1181 )
1182 goto tolua_lerror;
1183 else
1184 {
1185 const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1186 {
1187 fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(*t));
1188 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1189 }
1190 }
1191 return 1;
1192tolua_lerror:
1193 return tolua_fawkesutils_fawkes_Time_new03(tolua_S);
1194}
1195#endif //#ifndef TOLUA_DISABLE
1196
1197/* method: new_local of class fawkes::Time */
1198#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new04_local
1199static int tolua_fawkesutils_fawkes_Time_new04_local(lua_State* tolua_S)
1200{
1201 tolua_Error tolua_err;
1202 if (
1203 !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1204 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
1205 !tolua_isnoobj(tolua_S,3,&tolua_err)
1206 )
1207 goto tolua_lerror;
1208 else
1209 {
1210 const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1211 {
1212 fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(*t));
1213 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1214 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1215 }
1216 }
1217 return 1;
1218tolua_lerror:
1219 return tolua_fawkesutils_fawkes_Time_new03_local(tolua_S);
1220}
1221#endif //#ifndef TOLUA_DISABLE
1222
1223/* method: new of class fawkes::Time */
1224#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new05
1225static int tolua_fawkesutils_fawkes_Time_new05(lua_State* tolua_S)
1226{
1227 tolua_Error tolua_err;
1228 if (
1229 !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1230 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1231 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1232 !tolua_isnoobj(tolua_S,4,&tolua_err)
1233 )
1234 goto tolua_lerror;
1235 else
1236 {
1237 long sec = ((long) tolua_tonumber(tolua_S,2,0));
1238 long usec = ((long) tolua_tonumber(tolua_S,3,0));
1239 {
1240 fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec,usec));
1241 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1242 }
1243 }
1244 return 1;
1245tolua_lerror:
1246 return tolua_fawkesutils_fawkes_Time_new04(tolua_S);
1247}
1248#endif //#ifndef TOLUA_DISABLE
1249
1250/* method: new_local of class fawkes::Time */
1251#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new05_local
1252static int tolua_fawkesutils_fawkes_Time_new05_local(lua_State* tolua_S)
1253{
1254 tolua_Error tolua_err;
1255 if (
1256 !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1257 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1258 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1259 !tolua_isnoobj(tolua_S,4,&tolua_err)
1260 )
1261 goto tolua_lerror;
1262 else
1263 {
1264 long sec = ((long) tolua_tonumber(tolua_S,2,0));
1265 long usec = ((long) tolua_tonumber(tolua_S,3,0));
1266 {
1267 fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec,usec));
1268 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1269 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1270 }
1271 }
1272 return 1;
1273tolua_lerror:
1274 return tolua_fawkesutils_fawkes_Time_new04_local(tolua_S);
1275}
1276#endif //#ifndef TOLUA_DISABLE
1277
1278/* method: new of class fawkes::Time */
1279#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new06
1280static int tolua_fawkesutils_fawkes_Time_new06(lua_State* tolua_S)
1281{
1282 tolua_Error tolua_err;
1283 if (
1284 !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1285 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1286 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1287 !tolua_isusertype(tolua_S,4,"fawkes::Clock",0,&tolua_err) ||
1288 !tolua_isnoobj(tolua_S,5,&tolua_err)
1289 )
1290 goto tolua_lerror;
1291 else
1292 {
1293 long sec = ((long) tolua_tonumber(tolua_S,2,0));
1294 long usec = ((long) tolua_tonumber(tolua_S,3,0));
1295 fawkes::Clock* clock = ((fawkes::Clock*) tolua_tousertype(tolua_S,4,0));
1296 {
1297 fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec,usec,clock));
1298 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1299 }
1300 }
1301 return 1;
1302tolua_lerror:
1303 return tolua_fawkesutils_fawkes_Time_new05(tolua_S);
1304}
1305#endif //#ifndef TOLUA_DISABLE
1306
1307/* method: new_local of class fawkes::Time */
1308#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new06_local
1309static int tolua_fawkesutils_fawkes_Time_new06_local(lua_State* tolua_S)
1310{
1311 tolua_Error tolua_err;
1312 if (
1313 !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1314 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1315 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1316 !tolua_isusertype(tolua_S,4,"fawkes::Clock",0,&tolua_err) ||
1317 !tolua_isnoobj(tolua_S,5,&tolua_err)
1318 )
1319 goto tolua_lerror;
1320 else
1321 {
1322 long sec = ((long) tolua_tonumber(tolua_S,2,0));
1323 long usec = ((long) tolua_tonumber(tolua_S,3,0));
1324 fawkes::Clock* clock = ((fawkes::Clock*) tolua_tousertype(tolua_S,4,0));
1325 {
1326 fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec,usec,clock));
1327 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1328 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1329 }
1330 }
1331 return 1;
1332tolua_lerror:
1333 return tolua_fawkesutils_fawkes_Time_new05_local(tolua_S);
1334}
1335#endif //#ifndef TOLUA_DISABLE
1336
1337/* method: delete of class fawkes::Time */
1338#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_delete00
1339static int tolua_fawkesutils_fawkes_Time_delete00(lua_State* tolua_S)
1340{
1341#ifndef TOLUA_RELEASE
1342 tolua_Error tolua_err;
1343 if (
1344 !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1345 !tolua_isnoobj(tolua_S,2,&tolua_err)
1346 )
1347 goto tolua_lerror;
1348 else
1349#endif
1350 {
1351 fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1352#ifndef TOLUA_RELEASE
1353 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
1354#endif
1355 Mtolua_delete(self);
1356 }
1357 return 0;
1358#ifndef TOLUA_RELEASE
1359 tolua_lerror:
1360 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
1361 return 0;
1362#endif
1363}
1364#endif //#ifndef TOLUA_DISABLE
1365
1366/* method: in_sec of class fawkes::Time */
1367#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_sec00
1368static int tolua_fawkesutils_fawkes_Time_in_sec00(lua_State* tolua_S)
1369{
1370#ifndef TOLUA_RELEASE
1371 tolua_Error tolua_err;
1372 if (
1373 !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
1374 !tolua_isnoobj(tolua_S,2,&tolua_err)
1375 )
1376 goto tolua_lerror;
1377 else
1378#endif
1379 {
1380 const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1381#ifndef TOLUA_RELEASE
1382 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_sec'",NULL);
1383#endif
1384 {
1385 float tolua_ret = (float) self->in_sec();
1386 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1387 }
1388 }
1389 return 1;
1390#ifndef TOLUA_RELEASE
1391 tolua_lerror:
1392 tolua_error(tolua_S,"#ferror in function 'in_sec'.",&tolua_err);
1393 return 0;
1394#endif
1395}
1396#endif //#ifndef TOLUA_DISABLE
1397
1398/* method: in_msec of class fawkes::Time */
1399#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_msec00
1400static int tolua_fawkesutils_fawkes_Time_in_msec00(lua_State* tolua_S)
1401{
1402#ifndef TOLUA_RELEASE
1403 tolua_Error tolua_err;
1404 if (
1405 !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
1406 !tolua_isnoobj(tolua_S,2,&tolua_err)
1407 )
1408 goto tolua_lerror;
1409 else
1410#endif
1411 {
1412 const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1413#ifndef TOLUA_RELEASE
1414 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_msec'",NULL);
1415#endif
1416 {
1417 long tolua_ret = (long) self->in_msec();
1418 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1419 }
1420 }
1421 return 1;
1422#ifndef TOLUA_RELEASE
1423 tolua_lerror:
1424 tolua_error(tolua_S,"#ferror in function 'in_msec'.",&tolua_err);
1425 return 0;
1426#endif
1427}
1428#endif //#ifndef TOLUA_DISABLE
1429
1430/* method: in_usec of class fawkes::Time */
1431#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_usec00
1432static int tolua_fawkesutils_fawkes_Time_in_usec00(lua_State* tolua_S)
1433{
1434#ifndef TOLUA_RELEASE
1435 tolua_Error tolua_err;
1436 if (
1437 !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
1438 !tolua_isnoobj(tolua_S,2,&tolua_err)
1439 )
1440 goto tolua_lerror;
1441 else
1442#endif
1443 {
1444 const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1445#ifndef TOLUA_RELEASE
1446 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_usec'",NULL);
1447#endif
1448 {
1449 long tolua_ret = (long) self->in_usec();
1450 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1451 }
1452 }
1453 return 1;
1454#ifndef TOLUA_RELEASE
1455 tolua_lerror:
1456 tolua_error(tolua_S,"#ferror in function 'in_usec'.",&tolua_err);
1457 return 0;
1458#endif
1459}
1460#endif //#ifndef TOLUA_DISABLE
1461
1462/* method: get_timeval of class fawkes::Time */
1463#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_get_timeval00
1464static int tolua_fawkesutils_fawkes_Time_get_timeval00(lua_State* tolua_S)
1465{
1466#ifndef TOLUA_RELEASE
1467 tolua_Error tolua_err;
1468 if (
1469 !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
1470 !tolua_isnoobj(tolua_S,2,&tolua_err)
1471 )
1472 goto tolua_lerror;
1473 else
1474#endif
1475 {
1476 const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1477#ifndef TOLUA_RELEASE
1478 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_timeval'",NULL);
1479#endif
1480 {
1481 const timeval* tolua_ret = (const timeval*) self->get_timeval();
1482 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const timeval");
1483 }
1484 }
1485 return 1;
1486#ifndef TOLUA_RELEASE
1487 tolua_lerror:
1488 tolua_error(tolua_S,"#ferror in function 'get_timeval'.",&tolua_err);
1489 return 0;
1490#endif
1491}
1492#endif //#ifndef TOLUA_DISABLE
1493
1494/* method: set_time of class fawkes::Time */
1495#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time00
1496static int tolua_fawkesutils_fawkes_Time_set_time00(lua_State* tolua_S)
1497{
1498#ifndef TOLUA_RELEASE
1499 tolua_Error tolua_err;
1500 if (
1501 !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1502 !tolua_isusertype(tolua_S,2,"const timeval",0,&tolua_err) ||
1503 !tolua_isnoobj(tolua_S,3,&tolua_err)
1504 )
1505 goto tolua_lerror;
1506 else
1507#endif
1508 {
1509 fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1510 const timeval* tv = ((const timeval*) tolua_tousertype(tolua_S,2,0));
1511#ifndef TOLUA_RELEASE
1512 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'",NULL);
1513#endif
1514 {
1515 self->set_time(tv);
1516 }
1517 }
1518 return 0;
1519#ifndef TOLUA_RELEASE
1520 tolua_lerror:
1521 tolua_error(tolua_S,"#ferror in function 'set_time'.",&tolua_err);
1522 return 0;
1523#endif
1524}
1525#endif //#ifndef TOLUA_DISABLE
1526
1527/* method: set_time of class fawkes::Time */
1528#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time01
1529static int tolua_fawkesutils_fawkes_Time_set_time01(lua_State* tolua_S)
1530{
1531 tolua_Error tolua_err;
1532 if (
1533 !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1534 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1535 !tolua_isnoobj(tolua_S,3,&tolua_err)
1536 )
1537 goto tolua_lerror;
1538 else
1539 {
1540 fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1541 long ms = ((long) tolua_tonumber(tolua_S,2,0));
1542#ifndef TOLUA_RELEASE
1543 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'",NULL);
1544#endif
1545 {
1546 self->set_time(ms);
1547 }
1548 }
1549 return 0;
1550tolua_lerror:
1551 return tolua_fawkesutils_fawkes_Time_set_time00(tolua_S);
1552}
1553#endif //#ifndef TOLUA_DISABLE
1554
1555/* method: set_time of class fawkes::Time */
1556#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time02
1557static int tolua_fawkesutils_fawkes_Time_set_time02(lua_State* tolua_S)
1558{
1559 tolua_Error tolua_err;
1560 if (
1561 !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1562 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1563 !tolua_isnoobj(tolua_S,3,&tolua_err)
1564 )
1565 goto tolua_lerror;
1566 else
1567 {
1568 fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1569 float sec = ((float) tolua_tonumber(tolua_S,2,0));
1570#ifndef TOLUA_RELEASE
1571 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'",NULL);
1572#endif
1573 {
1574 self->set_time(sec);
1575 }
1576 }
1577 return 0;
1578tolua_lerror:
1579 return tolua_fawkesutils_fawkes_Time_set_time01(tolua_S);
1580}
1581#endif //#ifndef TOLUA_DISABLE
1582
1583/* method: set_time of class fawkes::Time */
1584#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time03
1585static int tolua_fawkesutils_fawkes_Time_set_time03(lua_State* tolua_S)
1586{
1587 tolua_Error tolua_err;
1588 if (
1589 !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1590 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
1591 !tolua_isnoobj(tolua_S,3,&tolua_err)
1592 )
1593 goto tolua_lerror;
1594 else
1595 {
1596 fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1597 const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1598#ifndef TOLUA_RELEASE
1599 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'",NULL);
1600#endif
1601 {
1602 self->set_time(*t);
1603 }
1604 }
1605 return 0;
1606tolua_lerror:
1607 return tolua_fawkesutils_fawkes_Time_set_time02(tolua_S);
1608}
1609#endif //#ifndef TOLUA_DISABLE
1610
1611/* method: add of class fawkes::Time */
1612#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_add00
1613static int tolua_fawkesutils_fawkes_Time_add00(lua_State* tolua_S)
1614{
1615#ifndef TOLUA_RELEASE
1616 tolua_Error tolua_err;
1617 if (
1618 !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1619 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1620 !tolua_isnoobj(tolua_S,3,&tolua_err)
1621 )
1622 goto tolua_lerror;
1623 else
1624#endif
1625 {
1626 fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1627 float seconds = ((float) tolua_tonumber(tolua_S,2,0));
1628#ifndef TOLUA_RELEASE
1629 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'add'",NULL);
1630#endif
1631 {
1632 self->add(seconds);
1633 }
1634 }
1635 return 0;
1636#ifndef TOLUA_RELEASE
1637 tolua_lerror:
1638 tolua_error(tolua_S,"#ferror in function 'add'.",&tolua_err);
1639 return 0;
1640#endif
1641}
1642#endif //#ifndef TOLUA_DISABLE
1643
1644/* method: stamp of class fawkes::Time */
1645#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_stamp00
1646static int tolua_fawkesutils_fawkes_Time_stamp00(lua_State* tolua_S)
1647{
1648#ifndef TOLUA_RELEASE
1649 tolua_Error tolua_err;
1650 if (
1651 !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1652 !tolua_isnoobj(tolua_S,2,&tolua_err)
1653 )
1654 goto tolua_lerror;
1655 else
1656#endif
1657 {
1658 fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1659#ifndef TOLUA_RELEASE
1660 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'stamp'",NULL);
1661#endif
1662 {
1663 fawkes::Time& tolua_ret = (fawkes::Time&) self->stamp();
1664 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::Time");
1665 }
1666 }
1667 return 1;
1668#ifndef TOLUA_RELEASE
1669 tolua_lerror:
1670 tolua_error(tolua_S,"#ferror in function 'stamp'.",&tolua_err);
1671 return 0;
1672#endif
1673}
1674#endif //#ifndef TOLUA_DISABLE
1675
1676/* method: operator+ of class fawkes::Time */
1677#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time__add00
1678static int tolua_fawkesutils_fawkes_Time__add00(lua_State* tolua_S)
1679{
1680#ifndef TOLUA_RELEASE
1681 tolua_Error tolua_err;
1682 if (
1683 !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
1684 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
1685 !tolua_isnoobj(tolua_S,3,&tolua_err)
1686 )
1687 goto tolua_lerror;
1688 else
1689#endif
1690 {
1691 const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1692 const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1693#ifndef TOLUA_RELEASE
1694 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'",NULL);
1695#endif
1696 {
1697 fawkes::Time tolua_ret = (fawkes::Time) self->operator+(*t);
1698 {
1699#ifdef __cplusplus
1700 void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
1701 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
1702 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1703#else
1704 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
1705 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
1706 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1707#endif
1708 }
1709 }
1710 }
1711 return 1;
1712#ifndef TOLUA_RELEASE
1713 tolua_lerror:
1714 tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
1715 return 0;
1716#endif
1717}
1718#endif //#ifndef TOLUA_DISABLE
1719
1720/* method: operator- of class fawkes::Time */
1721#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time__sub00
1722static int tolua_fawkesutils_fawkes_Time__sub00(lua_State* tolua_S)
1723{
1724#ifndef TOLUA_RELEASE
1725 tolua_Error tolua_err;
1726 if (
1727 !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
1728 !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err) ||
1729 !tolua_isnoobj(tolua_S,3,&tolua_err)
1730 )
1731 goto tolua_lerror;
1732 else
1733#endif
1734 {
1735 const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1736 const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1737#ifndef TOLUA_RELEASE
1738 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'",NULL);
1739#endif
1740 {
1741 float tolua_ret = (float) self->operator-(t);
1742 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1743 }
1744 }
1745 return 1;
1746#ifndef TOLUA_RELEASE
1747 tolua_lerror:
1748 tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
1749 return 0;
1750#endif
1751}
1752#endif //#ifndef TOLUA_DISABLE
1753
1754/* method: str of class fawkes::Time */
1755#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_str00
1756static int tolua_fawkesutils_fawkes_Time_str00(lua_State* tolua_S)
1757{
1758#ifndef TOLUA_RELEASE
1759 tolua_Error tolua_err;
1760 if (
1761 !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1762 !tolua_isnoobj(tolua_S,2,&tolua_err)
1763 )
1764 goto tolua_lerror;
1765 else
1766#endif
1767 {
1768 fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1769#ifndef TOLUA_RELEASE
1770 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str'",NULL);
1771#endif
1772 {
1773 const char* tolua_ret = (const char*) self->str();
1774 tolua_pushstring(tolua_S,(const char*)tolua_ret);
1775 }
1776 }
1777 return 1;
1778#ifndef TOLUA_RELEASE
1779 tolua_lerror:
1780 tolua_error(tolua_S,"#ferror in function 'str'.",&tolua_err);
1781 return 0;
1782#endif
1783}
1784#endif //#ifndef TOLUA_DISABLE
1785
1786/* method: str_r of class fawkes::Time */
1787#ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_str_r00
1788static int tolua_fawkesutils_fawkes_Time_str_r00(lua_State* tolua_S)
1789{
1790#ifndef TOLUA_RELEASE
1791 tolua_Error tolua_err;
1792 if (
1793 !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1794 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1795 !tolua_isnoobj(tolua_S,3,&tolua_err)
1796 )
1797 goto tolua_lerror;
1798 else
1799#endif
1800 {
1801 fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1802 char* s = ((char*) tolua_tostring(tolua_S,2,0));
1803#ifndef TOLUA_RELEASE
1804 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str_r'",NULL);
1805#endif
1806 {
1807 self->str_r(s);
1808 }
1809 }
1810 return 0;
1811#ifndef TOLUA_RELEASE
1812 tolua_lerror:
1813 tolua_error(tolua_S,"#ferror in function 'str_r'.",&tolua_err);
1814 return 0;
1815#endif
1816}
1817#endif //#ifndef TOLUA_DISABLE
1818
1819/* Open function */
1820TOLUA_API int tolua_fawkesutils_open (lua_State* tolua_S)
1821{
1822 tolua_open(tolua_S);
1823 tolua_reg_types(tolua_S);
1824 tolua_module(tolua_S,NULL,0);
1825 tolua_beginmodule(tolua_S,NULL);
1826 tolua_module(tolua_S,"fawkes",0);
1827 tolua_beginmodule(tolua_S,"fawkes");
1828 #ifdef __cplusplus
1829 tolua_cclass(tolua_S,"KalmanFilter1D","fawkes::KalmanFilter1D","",tolua_collect_fawkes__KalmanFilter1D);
1830 #else
1831 tolua_cclass(tolua_S,"KalmanFilter1D","fawkes::KalmanFilter1D","",NULL);
1832 #endif
1833 tolua_beginmodule(tolua_S,"KalmanFilter1D");
1834 tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_KalmanFilter1D_new00);
1835 tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local);
1836 tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local);
1837 tolua_function(tolua_S,"delete",tolua_fawkesutils_fawkes_KalmanFilter1D_delete00);
1838 tolua_function(tolua_S,"filter",tolua_fawkesutils_fawkes_KalmanFilter1D_filter00);
1839 tolua_function(tolua_S,"filter",tolua_fawkesutils_fawkes_KalmanFilter1D_filter01);
1840 tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict00);
1841 tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict01);
1842 tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict02);
1843 tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict03);
1844 tolua_endmodule(tolua_S);
1845 tolua_endmodule(tolua_S);
1846 tolua_module(tolua_S,"fawkes",0);
1847 tolua_beginmodule(tolua_S,"fawkes");
1848 tolua_cclass(tolua_S,"Clock","fawkes::Clock","",NULL);
1849 tolua_beginmodule(tolua_S,"Clock");
1850 tolua_constant(tolua_S,"DEFAULT",fawkes::Clock::DEFAULT);
1851 tolua_constant(tolua_S,"REALTIME",fawkes::Clock::REALTIME);
1852 tolua_constant(tolua_S,"EXTERNAL",fawkes::Clock::EXTERNAL);
1853 tolua_function(tolua_S,"instance",tolua_fawkesutils_fawkes_Clock_instance00);
1854 tolua_function(tolua_S,"finalize",tolua_fawkesutils_fawkes_Clock_finalize00);
1855 tolua_function(tolua_S,"is_ext_default_timesource",tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00);
1856 tolua_function(tolua_S,"has_ext_timesource",tolua_fawkesutils_fawkes_Clock_has_ext_timesource00);
1857 tolua_function(tolua_S,"ext_to_realtime",tolua_fawkesutils_fawkes_Clock_ext_to_realtime00);
1858 tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time00);
1859 tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time01);
1860 tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time02);
1861 tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time03);
1862 tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time04);
1863 tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time05);
1864 tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime00);
1865 tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime01);
1866 tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime02);
1867 tolua_function(tolua_S,"now",tolua_fawkesutils_fawkes_Clock_now00);
1868 tolua_function(tolua_S,"elapsed",tolua_fawkesutils_fawkes_Clock_elapsed00);
1869 tolua_function(tolua_S,"sys_elapsed",tolua_fawkesutils_fawkes_Clock_sys_elapsed00);
1870 tolua_endmodule(tolua_S);
1871 tolua_endmodule(tolua_S);
1872 tolua_cclass(tolua_S,"timeval","timeval","",NULL);
1873 tolua_beginmodule(tolua_S,"timeval");
1874 tolua_variable(tolua_S,"tv_sec",tolua_get_timeval_tv_sec,tolua_set_timeval_tv_sec);
1875 tolua_variable(tolua_S,"tv_usec",tolua_get_timeval_tv_usec,tolua_set_timeval_tv_usec);
1876 tolua_endmodule(tolua_S);
1877 tolua_module(tolua_S,"fawkes",0);
1878 tolua_beginmodule(tolua_S,"fawkes");
1879 #ifdef __cplusplus
1880 tolua_cclass(tolua_S,"Time","fawkes::Time","",tolua_collect_fawkes__Time);
1881 #else
1882 tolua_cclass(tolua_S,"Time","fawkes::Time","",NULL);
1883 #endif
1884 tolua_beginmodule(tolua_S,"Time");
1885 tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new00);
1886 tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new00_local);
1887 tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new00_local);
1888 tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new01);
1889 tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new01_local);
1890 tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new01_local);
1891 tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new02);
1892 tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new02_local);
1893 tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new02_local);
1894 tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new03);
1895 tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new03_local);
1896 tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new03_local);
1897 tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new04);
1898 tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new04_local);
1899 tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new04_local);
1900 tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new05);
1901 tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new05_local);
1902 tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new05_local);
1903 tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new06);
1904 tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new06_local);
1905 tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new06_local);
1906 tolua_function(tolua_S,"delete",tolua_fawkesutils_fawkes_Time_delete00);
1907 tolua_function(tolua_S,"in_sec",tolua_fawkesutils_fawkes_Time_in_sec00);
1908 tolua_function(tolua_S,"in_msec",tolua_fawkesutils_fawkes_Time_in_msec00);
1909 tolua_function(tolua_S,"in_usec",tolua_fawkesutils_fawkes_Time_in_usec00);
1910 tolua_function(tolua_S,"get_timeval",tolua_fawkesutils_fawkes_Time_get_timeval00);
1911 tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time00);
1912 tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time01);
1913 tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time02);
1914 tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time03);
1915 tolua_function(tolua_S,"add",tolua_fawkesutils_fawkes_Time_add00);
1916 tolua_function(tolua_S,"stamp",tolua_fawkesutils_fawkes_Time_stamp00);
1917 tolua_function(tolua_S,".add",tolua_fawkesutils_fawkes_Time__add00);
1918 tolua_function(tolua_S,".sub",tolua_fawkesutils_fawkes_Time__sub00);
1919 tolua_function(tolua_S,"str",tolua_fawkesutils_fawkes_Time_str00);
1920 tolua_function(tolua_S,"str_r",tolua_fawkesutils_fawkes_Time_str_r00);
1921 tolua_endmodule(tolua_S);
1922 tolua_endmodule(tolua_S);
1923 tolua_endmodule(tolua_S);
1924 return 1;
1925}
1926
1927
1928extern "C" {
1929#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
1930 TOLUA_API int luaopen_fawkesutils (lua_State* tolua_S) {
1931 return tolua_fawkesutils_open(tolua_S);
1932};
1933#endif
1934}
1935
1936
This is supposed to be the central clock in Fawkes.
Definition: clock.h:35
TimesourceSelector
Select the time source.
Definition: clock.h:38
@ DEFAULT
select the default time source
Definition: clock.h:39
@ REALTIME
select the system time source
Definition: clock.h:40
@ EXTERNAL
select the external time source
Definition: clock.h:41
static void finalize()
Finalize.
Definition: clock.cpp:74
float sys_elapsed(Time *t) const
How much system time has elapsed since t? Use only for system time criteria like timeouts.
Definition: clock.cpp:266
bool is_ext_default_timesource() const
Checks whether the external time source is the default time soucre.
Definition: clock.cpp:136
Time now() const
Get the current time.
Definition: clock.cpp:242
void get_time(struct timeval *tv) const
Returns the time of the selected time source.
Definition: clock.cpp:161
bool has_ext_timesource() const
Check whether an external time source is registered.
Definition: clock.cpp:319
static Clock * instance()
Clock initializer.
Definition: clock.cpp:63
void get_systime(struct timeval *tv) const
Returns the system time.
Definition: clock.cpp:215
Time ext_to_realtime(const Time &t)
Convert a time given w.r.t.
Definition: clock.cpp:278
float elapsed(Time *t) const
How much time has elapsed since t? Calculated as "now - t" in seconds.
Definition: clock.cpp:254
One-dimensional Kalman filter implementation for single-precision floats.
Definition: kalman_1d.h:29
float predict() const
Predicts the next position based on the past observations.
Definition: kalman_1d.cpp:82
void filter(float observe)
Filters an observation.
Definition: kalman_1d.cpp:57
A class for handling time.
Definition: time.h:93
Time & stamp()
Set this time to the current time.
Definition: time.cpp:704
void str_r(char *s, bool utc=false)
Output function.
Definition: time.cpp:819
void add(double seconds)
Add seconds.
Definition: time.cpp:322
double in_sec() const
Convet time to seconds.
Definition: time.cpp:219
const timeval * get_timeval() const
Obtain the timeval where the time is stored.
Definition: time.h:112
long in_usec() const
Convert the stored time into micro-seconds.
Definition: time.cpp:237
const char * str(bool utc=false) const
Output function.
Definition: time.cpp:790
void set_time(const timeval *tv)
Sets the time.
Definition: time.cpp:246
long in_msec() const
Convert the stored time into milli-seconds.
Definition: time.cpp:228