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 */
29 TOLUA_API int tolua_fawkesutils_open (lua_State* tolua_S);
30 
31 #include <utils/kalman/kalman_1d.h>
32 #include <utils/time/time.h>
33 #include <utils/time/clock.h>
34 
35 /* function to release collected object via destructor */
36 #ifdef __cplusplus
37 
38 static 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 
45 static 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 */
55 static 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::Time");
60  tolua_usertype(tolua_S,"fawkes::Clock");
61 }
62 
63 /* method: new of class fawkes::KalmanFilter1D */
64 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_new00
65 static 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
101 static 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
138 static 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
167 static 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
200 static 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;
227 tolua_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
234 static 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
266 static 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;
288 tolua_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
295 static 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;
321 tolua_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
328 static 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;
356 tolua_lerror:
357  return tolua_fawkesutils_fawkes_KalmanFilter1D_predict02(tolua_S);
358 }
359 #endif //#ifndef TOLUA_DISABLE
360 
361 /* get function: tv_sec of class timeval */
362 #ifndef TOLUA_DISABLE_tolua_get_timeval_tv_sec
363 static int tolua_get_timeval_tv_sec(lua_State* tolua_S)
364 {
365  timeval* self = (timeval*) tolua_tousertype(tolua_S,1,0);
366 #ifndef TOLUA_RELEASE
367  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_sec'",NULL);
368 #endif
369  tolua_pushnumber(tolua_S,(lua_Number)self->tv_sec);
370  return 1;
371 }
372 #endif //#ifndef TOLUA_DISABLE
373 
374 /* set function: tv_sec of class timeval */
375 #ifndef TOLUA_DISABLE_tolua_set_timeval_tv_sec
376 static int tolua_set_timeval_tv_sec(lua_State* tolua_S)
377 {
378  timeval* self = (timeval*) tolua_tousertype(tolua_S,1,0);
379 #ifndef TOLUA_RELEASE
380  tolua_Error tolua_err;
381  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_sec'",NULL);
382  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
383  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
384 #endif
385  self->tv_sec = ((long int) tolua_tonumber(tolua_S,2,0))
386 ;
387  return 0;
388 }
389 #endif //#ifndef TOLUA_DISABLE
390 
391 /* get function: tv_usec of class timeval */
392 #ifndef TOLUA_DISABLE_tolua_get_timeval_tv_usec
393 static int tolua_get_timeval_tv_usec(lua_State* tolua_S)
394 {
395  timeval* self = (timeval*) tolua_tousertype(tolua_S,1,0);
396 #ifndef TOLUA_RELEASE
397  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_usec'",NULL);
398 #endif
399  tolua_pushnumber(tolua_S,(lua_Number)self->tv_usec);
400  return 1;
401 }
402 #endif //#ifndef TOLUA_DISABLE
403 
404 /* set function: tv_usec of class timeval */
405 #ifndef TOLUA_DISABLE_tolua_set_timeval_tv_usec
406 static int tolua_set_timeval_tv_usec(lua_State* tolua_S)
407 {
408  timeval* self = (timeval*) tolua_tousertype(tolua_S,1,0);
409 #ifndef TOLUA_RELEASE
410  tolua_Error tolua_err;
411  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_usec'",NULL);
412  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
413  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
414 #endif
415  self->tv_usec = ((long int) tolua_tonumber(tolua_S,2,0))
416 ;
417  return 0;
418 }
419 #endif //#ifndef TOLUA_DISABLE
420 
421 /* method: new of class fawkes::Time */
422 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new00
423 static int tolua_fawkesutils_fawkes_Time_new00(lua_State* tolua_S)
424 {
425 #ifndef TOLUA_RELEASE
426  tolua_Error tolua_err;
427  if (
428  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
429  !tolua_isnoobj(tolua_S,2,&tolua_err)
430  )
431  goto tolua_lerror;
432  else
433 #endif
434  {
435  {
436  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)());
437  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
438  }
439  }
440  return 1;
441 #ifndef TOLUA_RELEASE
442  tolua_lerror:
443  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
444  return 0;
445 #endif
446 }
447 #endif //#ifndef TOLUA_DISABLE
448 
449 /* method: new_local of class fawkes::Time */
450 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new00_local
451 static int tolua_fawkesutils_fawkes_Time_new00_local(lua_State* tolua_S)
452 {
453 #ifndef TOLUA_RELEASE
454  tolua_Error tolua_err;
455  if (
456  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
457  !tolua_isnoobj(tolua_S,2,&tolua_err)
458  )
459  goto tolua_lerror;
460  else
461 #endif
462  {
463  {
464  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)());
465  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
466  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
467  }
468  }
469  return 1;
470 #ifndef TOLUA_RELEASE
471  tolua_lerror:
472  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
473  return 0;
474 #endif
475 }
476 #endif //#ifndef TOLUA_DISABLE
477 
478 /* method: new of class fawkes::Time */
479 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new01
480 static int tolua_fawkesutils_fawkes_Time_new01(lua_State* tolua_S)
481 {
482  tolua_Error tolua_err;
483  if (
484  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
485  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
486  !tolua_isnoobj(tolua_S,3,&tolua_err)
487  )
488  goto tolua_lerror;
489  else
490  {
491  long ms = ((long) tolua_tonumber(tolua_S,2,0));
492  {
493  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(ms));
494  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
495  }
496  }
497  return 1;
498 tolua_lerror:
499  return tolua_fawkesutils_fawkes_Time_new00(tolua_S);
500 }
501 #endif //#ifndef TOLUA_DISABLE
502 
503 /* method: new_local of class fawkes::Time */
504 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new01_local
505 static int tolua_fawkesutils_fawkes_Time_new01_local(lua_State* tolua_S)
506 {
507  tolua_Error tolua_err;
508  if (
509  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
510  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
511  !tolua_isnoobj(tolua_S,3,&tolua_err)
512  )
513  goto tolua_lerror;
514  else
515  {
516  long ms = ((long) tolua_tonumber(tolua_S,2,0));
517  {
518  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(ms));
519  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
520  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
521  }
522  }
523  return 1;
524 tolua_lerror:
525  return tolua_fawkesutils_fawkes_Time_new00_local(tolua_S);
526 }
527 #endif //#ifndef TOLUA_DISABLE
528 
529 /* method: new of class fawkes::Time */
530 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new02
531 static int tolua_fawkesutils_fawkes_Time_new02(lua_State* tolua_S)
532 {
533  tolua_Error tolua_err;
534  if (
535  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
536  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
537  !tolua_isnoobj(tolua_S,3,&tolua_err)
538  )
539  goto tolua_lerror;
540  else
541  {
542  float sec = ((float) tolua_tonumber(tolua_S,2,0));
543  {
544  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec));
545  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
546  }
547  }
548  return 1;
549 tolua_lerror:
550  return tolua_fawkesutils_fawkes_Time_new01(tolua_S);
551 }
552 #endif //#ifndef TOLUA_DISABLE
553 
554 /* method: new_local of class fawkes::Time */
555 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new02_local
556 static int tolua_fawkesutils_fawkes_Time_new02_local(lua_State* tolua_S)
557 {
558  tolua_Error tolua_err;
559  if (
560  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
561  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
562  !tolua_isnoobj(tolua_S,3,&tolua_err)
563  )
564  goto tolua_lerror;
565  else
566  {
567  float sec = ((float) tolua_tonumber(tolua_S,2,0));
568  {
569  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec));
570  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
571  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
572  }
573  }
574  return 1;
575 tolua_lerror:
576  return tolua_fawkesutils_fawkes_Time_new01_local(tolua_S);
577 }
578 #endif //#ifndef TOLUA_DISABLE
579 
580 /* method: new of class fawkes::Time */
581 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new03
582 static int tolua_fawkesutils_fawkes_Time_new03(lua_State* tolua_S)
583 {
584  tolua_Error tolua_err;
585  if (
586  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
587  !tolua_isusertype(tolua_S,2,"fawkes::Clock",0,&tolua_err) ||
588  !tolua_isnoobj(tolua_S,3,&tolua_err)
589  )
590  goto tolua_lerror;
591  else
592  {
593  fawkes::Clock* clock = ((fawkes::Clock*) tolua_tousertype(tolua_S,2,0));
594  {
595  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(clock));
596  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
597  }
598  }
599  return 1;
600 tolua_lerror:
601  return tolua_fawkesutils_fawkes_Time_new02(tolua_S);
602 }
603 #endif //#ifndef TOLUA_DISABLE
604 
605 /* method: new_local of class fawkes::Time */
606 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new03_local
607 static int tolua_fawkesutils_fawkes_Time_new03_local(lua_State* tolua_S)
608 {
609  tolua_Error tolua_err;
610  if (
611  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
612  !tolua_isusertype(tolua_S,2,"fawkes::Clock",0,&tolua_err) ||
613  !tolua_isnoobj(tolua_S,3,&tolua_err)
614  )
615  goto tolua_lerror;
616  else
617  {
618  fawkes::Clock* clock = ((fawkes::Clock*) tolua_tousertype(tolua_S,2,0));
619  {
620  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(clock));
621  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
622  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
623  }
624  }
625  return 1;
626 tolua_lerror:
627  return tolua_fawkesutils_fawkes_Time_new02_local(tolua_S);
628 }
629 #endif //#ifndef TOLUA_DISABLE
630 
631 /* method: new of class fawkes::Time */
632 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new04
633 static int tolua_fawkesutils_fawkes_Time_new04(lua_State* tolua_S)
634 {
635  tolua_Error tolua_err;
636  if (
637  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
638  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
639  !tolua_isnoobj(tolua_S,3,&tolua_err)
640  )
641  goto tolua_lerror;
642  else
643  {
644  const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
645  {
646  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(*t));
647  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
648  }
649  }
650  return 1;
651 tolua_lerror:
652  return tolua_fawkesutils_fawkes_Time_new03(tolua_S);
653 }
654 #endif //#ifndef TOLUA_DISABLE
655 
656 /* method: new_local of class fawkes::Time */
657 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new04_local
658 static int tolua_fawkesutils_fawkes_Time_new04_local(lua_State* tolua_S)
659 {
660  tolua_Error tolua_err;
661  if (
662  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
663  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
664  !tolua_isnoobj(tolua_S,3,&tolua_err)
665  )
666  goto tolua_lerror;
667  else
668  {
669  const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
670  {
671  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(*t));
672  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
673  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
674  }
675  }
676  return 1;
677 tolua_lerror:
678  return tolua_fawkesutils_fawkes_Time_new03_local(tolua_S);
679 }
680 #endif //#ifndef TOLUA_DISABLE
681 
682 /* method: new of class fawkes::Time */
683 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new05
684 static int tolua_fawkesutils_fawkes_Time_new05(lua_State* tolua_S)
685 {
686  tolua_Error tolua_err;
687  if (
688  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
689  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
690  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
691  !tolua_isnoobj(tolua_S,4,&tolua_err)
692  )
693  goto tolua_lerror;
694  else
695  {
696  long sec = ((long) tolua_tonumber(tolua_S,2,0));
697  long usec = ((long) tolua_tonumber(tolua_S,3,0));
698  {
699  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec,usec));
700  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
701  }
702  }
703  return 1;
704 tolua_lerror:
705  return tolua_fawkesutils_fawkes_Time_new04(tolua_S);
706 }
707 #endif //#ifndef TOLUA_DISABLE
708 
709 /* method: new_local of class fawkes::Time */
710 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new05_local
711 static int tolua_fawkesutils_fawkes_Time_new05_local(lua_State* tolua_S)
712 {
713  tolua_Error tolua_err;
714  if (
715  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
716  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
717  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
718  !tolua_isnoobj(tolua_S,4,&tolua_err)
719  )
720  goto tolua_lerror;
721  else
722  {
723  long sec = ((long) tolua_tonumber(tolua_S,2,0));
724  long usec = ((long) tolua_tonumber(tolua_S,3,0));
725  {
726  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec,usec));
727  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
728  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
729  }
730  }
731  return 1;
732 tolua_lerror:
733  return tolua_fawkesutils_fawkes_Time_new04_local(tolua_S);
734 }
735 #endif //#ifndef TOLUA_DISABLE
736 
737 /* method: new of class fawkes::Time */
738 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new06
739 static int tolua_fawkesutils_fawkes_Time_new06(lua_State* tolua_S)
740 {
741  tolua_Error tolua_err;
742  if (
743  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
744  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
745  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
746  !tolua_isusertype(tolua_S,4,"fawkes::Clock",0,&tolua_err) ||
747  !tolua_isnoobj(tolua_S,5,&tolua_err)
748  )
749  goto tolua_lerror;
750  else
751  {
752  long sec = ((long) tolua_tonumber(tolua_S,2,0));
753  long usec = ((long) tolua_tonumber(tolua_S,3,0));
754  fawkes::Clock* clock = ((fawkes::Clock*) tolua_tousertype(tolua_S,4,0));
755  {
756  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec,usec,clock));
757  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
758  }
759  }
760  return 1;
761 tolua_lerror:
762  return tolua_fawkesutils_fawkes_Time_new05(tolua_S);
763 }
764 #endif //#ifndef TOLUA_DISABLE
765 
766 /* method: new_local of class fawkes::Time */
767 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new06_local
768 static int tolua_fawkesutils_fawkes_Time_new06_local(lua_State* tolua_S)
769 {
770  tolua_Error tolua_err;
771  if (
772  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
773  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
774  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
775  !tolua_isusertype(tolua_S,4,"fawkes::Clock",0,&tolua_err) ||
776  !tolua_isnoobj(tolua_S,5,&tolua_err)
777  )
778  goto tolua_lerror;
779  else
780  {
781  long sec = ((long) tolua_tonumber(tolua_S,2,0));
782  long usec = ((long) tolua_tonumber(tolua_S,3,0));
783  fawkes::Clock* clock = ((fawkes::Clock*) tolua_tousertype(tolua_S,4,0));
784  {
785  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec,usec,clock));
786  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
787  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
788  }
789  }
790  return 1;
791 tolua_lerror:
792  return tolua_fawkesutils_fawkes_Time_new05_local(tolua_S);
793 }
794 #endif //#ifndef TOLUA_DISABLE
795 
796 /* method: delete of class fawkes::Time */
797 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_delete00
798 static int tolua_fawkesutils_fawkes_Time_delete00(lua_State* tolua_S)
799 {
800 #ifndef TOLUA_RELEASE
801  tolua_Error tolua_err;
802  if (
803  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
804  !tolua_isnoobj(tolua_S,2,&tolua_err)
805  )
806  goto tolua_lerror;
807  else
808 #endif
809  {
810  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
811 #ifndef TOLUA_RELEASE
812  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
813 #endif
814  Mtolua_delete(self);
815  }
816  return 0;
817 #ifndef TOLUA_RELEASE
818  tolua_lerror:
819  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
820  return 0;
821 #endif
822 }
823 #endif //#ifndef TOLUA_DISABLE
824 
825 /* method: in_sec of class fawkes::Time */
826 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_sec00
827 static int tolua_fawkesutils_fawkes_Time_in_sec00(lua_State* tolua_S)
828 {
829 #ifndef TOLUA_RELEASE
830  tolua_Error tolua_err;
831  if (
832  !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
833  !tolua_isnoobj(tolua_S,2,&tolua_err)
834  )
835  goto tolua_lerror;
836  else
837 #endif
838  {
839  const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
840 #ifndef TOLUA_RELEASE
841  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_sec'",NULL);
842 #endif
843  {
844  float tolua_ret = (float) self->in_sec();
845  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
846  }
847  }
848  return 1;
849 #ifndef TOLUA_RELEASE
850  tolua_lerror:
851  tolua_error(tolua_S,"#ferror in function 'in_sec'.",&tolua_err);
852  return 0;
853 #endif
854 }
855 #endif //#ifndef TOLUA_DISABLE
856 
857 /* method: in_msec of class fawkes::Time */
858 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_msec00
859 static int tolua_fawkesutils_fawkes_Time_in_msec00(lua_State* tolua_S)
860 {
861 #ifndef TOLUA_RELEASE
862  tolua_Error tolua_err;
863  if (
864  !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
865  !tolua_isnoobj(tolua_S,2,&tolua_err)
866  )
867  goto tolua_lerror;
868  else
869 #endif
870  {
871  const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
872 #ifndef TOLUA_RELEASE
873  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_msec'",NULL);
874 #endif
875  {
876  long tolua_ret = (long) self->in_msec();
877  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
878  }
879  }
880  return 1;
881 #ifndef TOLUA_RELEASE
882  tolua_lerror:
883  tolua_error(tolua_S,"#ferror in function 'in_msec'.",&tolua_err);
884  return 0;
885 #endif
886 }
887 #endif //#ifndef TOLUA_DISABLE
888 
889 /* method: in_usec of class fawkes::Time */
890 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_usec00
891 static int tolua_fawkesutils_fawkes_Time_in_usec00(lua_State* tolua_S)
892 {
893 #ifndef TOLUA_RELEASE
894  tolua_Error tolua_err;
895  if (
896  !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
897  !tolua_isnoobj(tolua_S,2,&tolua_err)
898  )
899  goto tolua_lerror;
900  else
901 #endif
902  {
903  const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
904 #ifndef TOLUA_RELEASE
905  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_usec'",NULL);
906 #endif
907  {
908  long tolua_ret = (long) self->in_usec();
909  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
910  }
911  }
912  return 1;
913 #ifndef TOLUA_RELEASE
914  tolua_lerror:
915  tolua_error(tolua_S,"#ferror in function 'in_usec'.",&tolua_err);
916  return 0;
917 #endif
918 }
919 #endif //#ifndef TOLUA_DISABLE
920 
921 /* method: get_timeval of class fawkes::Time */
922 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_get_timeval00
923 static int tolua_fawkesutils_fawkes_Time_get_timeval00(lua_State* tolua_S)
924 {
925 #ifndef TOLUA_RELEASE
926  tolua_Error tolua_err;
927  if (
928  !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
929  !tolua_isnoobj(tolua_S,2,&tolua_err)
930  )
931  goto tolua_lerror;
932  else
933 #endif
934  {
935  const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
936 #ifndef TOLUA_RELEASE
937  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_timeval'",NULL);
938 #endif
939  {
940  const timeval* tolua_ret = (const timeval*) self->get_timeval();
941  tolua_pushusertype(tolua_S,(void*)tolua_ret,"const timeval");
942  }
943  }
944  return 1;
945 #ifndef TOLUA_RELEASE
946  tolua_lerror:
947  tolua_error(tolua_S,"#ferror in function 'get_timeval'.",&tolua_err);
948  return 0;
949 #endif
950 }
951 #endif //#ifndef TOLUA_DISABLE
952 
953 /* method: set_time of class fawkes::Time */
954 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time00
955 static int tolua_fawkesutils_fawkes_Time_set_time00(lua_State* tolua_S)
956 {
957 #ifndef TOLUA_RELEASE
958  tolua_Error tolua_err;
959  if (
960  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
961  !tolua_isusertype(tolua_S,2,"const timeval",0,&tolua_err) ||
962  !tolua_isnoobj(tolua_S,3,&tolua_err)
963  )
964  goto tolua_lerror;
965  else
966 #endif
967  {
968  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
969  const timeval* tv = ((const timeval*) tolua_tousertype(tolua_S,2,0));
970 #ifndef TOLUA_RELEASE
971  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'",NULL);
972 #endif
973  {
974  self->set_time(tv);
975  }
976  }
977  return 0;
978 #ifndef TOLUA_RELEASE
979  tolua_lerror:
980  tolua_error(tolua_S,"#ferror in function 'set_time'.",&tolua_err);
981  return 0;
982 #endif
983 }
984 #endif //#ifndef TOLUA_DISABLE
985 
986 /* method: set_time of class fawkes::Time */
987 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time01
988 static int tolua_fawkesutils_fawkes_Time_set_time01(lua_State* tolua_S)
989 {
990  tolua_Error tolua_err;
991  if (
992  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
993  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
994  !tolua_isnoobj(tolua_S,3,&tolua_err)
995  )
996  goto tolua_lerror;
997  else
998  {
999  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1000  long ms = ((long) tolua_tonumber(tolua_S,2,0));
1001 #ifndef TOLUA_RELEASE
1002  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'",NULL);
1003 #endif
1004  {
1005  self->set_time(ms);
1006  }
1007  }
1008  return 0;
1009 tolua_lerror:
1010  return tolua_fawkesutils_fawkes_Time_set_time00(tolua_S);
1011 }
1012 #endif //#ifndef TOLUA_DISABLE
1013 
1014 /* method: set_time of class fawkes::Time */
1015 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time02
1016 static int tolua_fawkesutils_fawkes_Time_set_time02(lua_State* tolua_S)
1017 {
1018  tolua_Error tolua_err;
1019  if (
1020  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1021  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1022  !tolua_isnoobj(tolua_S,3,&tolua_err)
1023  )
1024  goto tolua_lerror;
1025  else
1026  {
1027  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1028  float sec = ((float) tolua_tonumber(tolua_S,2,0));
1029 #ifndef TOLUA_RELEASE
1030  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'",NULL);
1031 #endif
1032  {
1033  self->set_time(sec);
1034  }
1035  }
1036  return 0;
1037 tolua_lerror:
1038  return tolua_fawkesutils_fawkes_Time_set_time01(tolua_S);
1039 }
1040 #endif //#ifndef TOLUA_DISABLE
1041 
1042 /* method: set_time of class fawkes::Time */
1043 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time03
1044 static int tolua_fawkesutils_fawkes_Time_set_time03(lua_State* tolua_S)
1045 {
1046  tolua_Error tolua_err;
1047  if (
1048  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1049  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
1050  !tolua_isnoobj(tolua_S,3,&tolua_err)
1051  )
1052  goto tolua_lerror;
1053  else
1054  {
1055  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1056  const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1057 #ifndef TOLUA_RELEASE
1058  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'",NULL);
1059 #endif
1060  {
1061  self->set_time(*t);
1062  }
1063  }
1064  return 0;
1065 tolua_lerror:
1066  return tolua_fawkesutils_fawkes_Time_set_time02(tolua_S);
1067 }
1068 #endif //#ifndef TOLUA_DISABLE
1069 
1070 /* method: add of class fawkes::Time */
1071 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_add00
1072 static int tolua_fawkesutils_fawkes_Time_add00(lua_State* tolua_S)
1073 {
1074 #ifndef TOLUA_RELEASE
1075  tolua_Error tolua_err;
1076  if (
1077  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1078  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1079  !tolua_isnoobj(tolua_S,3,&tolua_err)
1080  )
1081  goto tolua_lerror;
1082  else
1083 #endif
1084  {
1085  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1086  float seconds = ((float) tolua_tonumber(tolua_S,2,0));
1087 #ifndef TOLUA_RELEASE
1088  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'add'",NULL);
1089 #endif
1090  {
1091  self->add(seconds);
1092  }
1093  }
1094  return 0;
1095 #ifndef TOLUA_RELEASE
1096  tolua_lerror:
1097  tolua_error(tolua_S,"#ferror in function 'add'.",&tolua_err);
1098  return 0;
1099 #endif
1100 }
1101 #endif //#ifndef TOLUA_DISABLE
1102 
1103 /* method: stamp of class fawkes::Time */
1104 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_stamp00
1105 static int tolua_fawkesutils_fawkes_Time_stamp00(lua_State* tolua_S)
1106 {
1107 #ifndef TOLUA_RELEASE
1108  tolua_Error tolua_err;
1109  if (
1110  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1111  !tolua_isnoobj(tolua_S,2,&tolua_err)
1112  )
1113  goto tolua_lerror;
1114  else
1115 #endif
1116  {
1117  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1118 #ifndef TOLUA_RELEASE
1119  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'stamp'",NULL);
1120 #endif
1121  {
1122  fawkes::Time& tolua_ret = (fawkes::Time&) self->stamp();
1123  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::Time");
1124  }
1125  }
1126  return 1;
1127 #ifndef TOLUA_RELEASE
1128  tolua_lerror:
1129  tolua_error(tolua_S,"#ferror in function 'stamp'.",&tolua_err);
1130  return 0;
1131 #endif
1132 }
1133 #endif //#ifndef TOLUA_DISABLE
1134 
1135 /* method: operator+ of class fawkes::Time */
1136 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time__add00
1137 static int tolua_fawkesutils_fawkes_Time__add00(lua_State* tolua_S)
1138 {
1139 #ifndef TOLUA_RELEASE
1140  tolua_Error tolua_err;
1141  if (
1142  !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
1143  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
1144  !tolua_isnoobj(tolua_S,3,&tolua_err)
1145  )
1146  goto tolua_lerror;
1147  else
1148 #endif
1149  {
1150  const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1151  const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1152 #ifndef TOLUA_RELEASE
1153  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'",NULL);
1154 #endif
1155  {
1156  fawkes::Time tolua_ret = (fawkes::Time) self->operator+(*t);
1157  {
1158 #ifdef __cplusplus
1159  void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
1160  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
1161  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1162 #else
1163  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
1164  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
1165  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1166 #endif
1167  }
1168  }
1169  }
1170  return 1;
1171 #ifndef TOLUA_RELEASE
1172  tolua_lerror:
1173  tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
1174  return 0;
1175 #endif
1176 }
1177 #endif //#ifndef TOLUA_DISABLE
1178 
1179 /* method: operator- of class fawkes::Time */
1180 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time__sub00
1181 static int tolua_fawkesutils_fawkes_Time__sub00(lua_State* tolua_S)
1182 {
1183 #ifndef TOLUA_RELEASE
1184  tolua_Error tolua_err;
1185  if (
1186  !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
1187  !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err) ||
1188  !tolua_isnoobj(tolua_S,3,&tolua_err)
1189  )
1190  goto tolua_lerror;
1191  else
1192 #endif
1193  {
1194  const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1195  const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1196 #ifndef TOLUA_RELEASE
1197  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'",NULL);
1198 #endif
1199  {
1200  float tolua_ret = (float) self->operator-(t);
1201  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1202  }
1203  }
1204  return 1;
1205 #ifndef TOLUA_RELEASE
1206  tolua_lerror:
1207  tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
1208  return 0;
1209 #endif
1210 }
1211 #endif //#ifndef TOLUA_DISABLE
1212 
1213 /* method: str of class fawkes::Time */
1214 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_str00
1215 static int tolua_fawkesutils_fawkes_Time_str00(lua_State* tolua_S)
1216 {
1217 #ifndef TOLUA_RELEASE
1218  tolua_Error tolua_err;
1219  if (
1220  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1221  !tolua_isnoobj(tolua_S,2,&tolua_err)
1222  )
1223  goto tolua_lerror;
1224  else
1225 #endif
1226  {
1227  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1228 #ifndef TOLUA_RELEASE
1229  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str'",NULL);
1230 #endif
1231  {
1232  const char* tolua_ret = (const char*) self->str();
1233  tolua_pushstring(tolua_S,(const char*)tolua_ret);
1234  }
1235  }
1236  return 1;
1237 #ifndef TOLUA_RELEASE
1238  tolua_lerror:
1239  tolua_error(tolua_S,"#ferror in function 'str'.",&tolua_err);
1240  return 0;
1241 #endif
1242 }
1243 #endif //#ifndef TOLUA_DISABLE
1244 
1245 /* method: str_r of class fawkes::Time */
1246 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_str_r00
1247 static int tolua_fawkesutils_fawkes_Time_str_r00(lua_State* tolua_S)
1248 {
1249 #ifndef TOLUA_RELEASE
1250  tolua_Error tolua_err;
1251  if (
1252  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1253  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1254  !tolua_isnoobj(tolua_S,3,&tolua_err)
1255  )
1256  goto tolua_lerror;
1257  else
1258 #endif
1259  {
1260  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
1261  char* s = ((char*) tolua_tostring(tolua_S,2,0));
1262 #ifndef TOLUA_RELEASE
1263  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str_r'",NULL);
1264 #endif
1265  {
1266  self->str_r(s);
1267  }
1268  }
1269  return 0;
1270 #ifndef TOLUA_RELEASE
1271  tolua_lerror:
1272  tolua_error(tolua_S,"#ferror in function 'str_r'.",&tolua_err);
1273  return 0;
1274 #endif
1275 }
1276 #endif //#ifndef TOLUA_DISABLE
1277 
1278 /* method: instance of class fawkes::Clock */
1279 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_instance00
1280 static int tolua_fawkesutils_fawkes_Clock_instance00(lua_State* tolua_S)
1281 {
1282 #ifndef TOLUA_RELEASE
1283  tolua_Error tolua_err;
1284  if (
1285  !tolua_isusertable(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
1286  !tolua_isnoobj(tolua_S,2,&tolua_err)
1287  )
1288  goto tolua_lerror;
1289  else
1290 #endif
1291  {
1292  {
1294  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Clock");
1295  }
1296  }
1297  return 1;
1298 #ifndef TOLUA_RELEASE
1299  tolua_lerror:
1300  tolua_error(tolua_S,"#ferror in function 'instance'.",&tolua_err);
1301  return 0;
1302 #endif
1303 }
1304 #endif //#ifndef TOLUA_DISABLE
1305 
1306 /* method: finalize of class fawkes::Clock */
1307 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_finalize00
1308 static int tolua_fawkesutils_fawkes_Clock_finalize00(lua_State* tolua_S)
1309 {
1310 #ifndef TOLUA_RELEASE
1311  tolua_Error tolua_err;
1312  if (
1313  !tolua_isusertable(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
1314  !tolua_isnoobj(tolua_S,2,&tolua_err)
1315  )
1316  goto tolua_lerror;
1317  else
1318 #endif
1319  {
1320  {
1322  }
1323  }
1324  return 0;
1325 #ifndef TOLUA_RELEASE
1326  tolua_lerror:
1327  tolua_error(tolua_S,"#ferror in function 'finalize'.",&tolua_err);
1328  return 0;
1329 #endif
1330 }
1331 #endif //#ifndef TOLUA_DISABLE
1332 
1333 /* method: is_ext_default_timesource of class fawkes::Clock */
1334 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00
1335 static int tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00(lua_State* tolua_S)
1336 {
1337 #ifndef TOLUA_RELEASE
1338  tolua_Error tolua_err;
1339  if (
1340  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
1341  !tolua_isnoobj(tolua_S,2,&tolua_err)
1342  )
1343  goto tolua_lerror;
1344  else
1345 #endif
1346  {
1347  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1348 #ifndef TOLUA_RELEASE
1349  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_ext_default_timesource'",NULL);
1350 #endif
1351  {
1352  bool tolua_ret = (bool) self->is_ext_default_timesource();
1353  tolua_pushboolean(tolua_S,(bool)tolua_ret);
1354  }
1355  }
1356  return 1;
1357 #ifndef TOLUA_RELEASE
1358  tolua_lerror:
1359  tolua_error(tolua_S,"#ferror in function 'is_ext_default_timesource'.",&tolua_err);
1360  return 0;
1361 #endif
1362 }
1363 #endif //#ifndef TOLUA_DISABLE
1364 
1365 /* method: has_ext_timesource of class fawkes::Clock */
1366 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_has_ext_timesource00
1367 static int tolua_fawkesutils_fawkes_Clock_has_ext_timesource00(lua_State* tolua_S)
1368 {
1369 #ifndef TOLUA_RELEASE
1370  tolua_Error tolua_err;
1371  if (
1372  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
1373  !tolua_isnoobj(tolua_S,2,&tolua_err)
1374  )
1375  goto tolua_lerror;
1376  else
1377 #endif
1378  {
1379  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1380 #ifndef TOLUA_RELEASE
1381  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_ext_timesource'",NULL);
1382 #endif
1383  {
1384  bool tolua_ret = (bool) self->has_ext_timesource();
1385  tolua_pushboolean(tolua_S,(bool)tolua_ret);
1386  }
1387  }
1388  return 1;
1389 #ifndef TOLUA_RELEASE
1390  tolua_lerror:
1391  tolua_error(tolua_S,"#ferror in function 'has_ext_timesource'.",&tolua_err);
1392  return 0;
1393 #endif
1394 }
1395 #endif //#ifndef TOLUA_DISABLE
1396 
1397 /* method: ext_to_realtime of class fawkes::Clock */
1398 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_ext_to_realtime00
1399 static int tolua_fawkesutils_fawkes_Clock_ext_to_realtime00(lua_State* tolua_S)
1400 {
1401 #ifndef TOLUA_RELEASE
1402  tolua_Error tolua_err;
1403  if (
1404  !tolua_isusertype(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
1405  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
1406  !tolua_isnoobj(tolua_S,3,&tolua_err)
1407  )
1408  goto tolua_lerror;
1409  else
1410 #endif
1411  {
1412  fawkes::Clock* self = (fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1413  const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1414 #ifndef TOLUA_RELEASE
1415  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ext_to_realtime'",NULL);
1416 #endif
1417  {
1418  fawkes::Time tolua_ret = (fawkes::Time) self->ext_to_realtime(*t);
1419  {
1420 #ifdef __cplusplus
1421  void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
1422  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
1423  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1424 #else
1425  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
1426  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
1427  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1428 #endif
1429  }
1430  }
1431  }
1432  return 1;
1433 #ifndef TOLUA_RELEASE
1434  tolua_lerror:
1435  tolua_error(tolua_S,"#ferror in function 'ext_to_realtime'.",&tolua_err);
1436  return 0;
1437 #endif
1438 }
1439 #endif //#ifndef TOLUA_DISABLE
1440 
1441 /* method: get_time of class fawkes::Clock */
1442 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time00
1443 static int tolua_fawkesutils_fawkes_Clock_get_time00(lua_State* tolua_S)
1444 {
1445 #ifndef TOLUA_RELEASE
1446  tolua_Error tolua_err;
1447  if (
1448  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
1449  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
1450  !tolua_isnoobj(tolua_S,3,&tolua_err)
1451  )
1452  goto tolua_lerror;
1453  else
1454 #endif
1455  {
1456  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1457  fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1458 #ifndef TOLUA_RELEASE
1459  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'",NULL);
1460 #endif
1461  {
1462  self->get_time(*time);
1463  }
1464  }
1465  return 0;
1466 #ifndef TOLUA_RELEASE
1467  tolua_lerror:
1468  tolua_error(tolua_S,"#ferror in function 'get_time'.",&tolua_err);
1469  return 0;
1470 #endif
1471 }
1472 #endif //#ifndef TOLUA_DISABLE
1473 
1474 /* method: get_time of class fawkes::Clock */
1475 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time01
1476 static int tolua_fawkesutils_fawkes_Clock_get_time01(lua_State* tolua_S)
1477 {
1478  tolua_Error tolua_err;
1479  if (
1480  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
1481  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
1482  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1483  !tolua_isnoobj(tolua_S,4,&tolua_err)
1484  )
1485  goto tolua_lerror;
1486  else
1487  {
1488  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1489  fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1490  fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int) tolua_tonumber(tolua_S,3,0));
1491 #ifndef TOLUA_RELEASE
1492  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'",NULL);
1493 #endif
1494  {
1495  self->get_time(*time,sel);
1496  }
1497  }
1498  return 0;
1499 tolua_lerror:
1500  return tolua_fawkesutils_fawkes_Clock_get_time00(tolua_S);
1501 }
1502 #endif //#ifndef TOLUA_DISABLE
1503 
1504 /* method: get_time of class fawkes::Clock */
1505 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time02
1506 static int tolua_fawkesutils_fawkes_Clock_get_time02(lua_State* tolua_S)
1507 {
1508  tolua_Error tolua_err;
1509  if (
1510  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
1511  !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
1512  !tolua_isnoobj(tolua_S,3,&tolua_err)
1513  )
1514  goto tolua_lerror;
1515  else
1516  {
1517  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1518  fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1519 #ifndef TOLUA_RELEASE
1520  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'",NULL);
1521 #endif
1522  {
1523  self->get_time(time);
1524  }
1525  }
1526  return 0;
1527 tolua_lerror:
1528  return tolua_fawkesutils_fawkes_Clock_get_time01(tolua_S);
1529 }
1530 #endif //#ifndef TOLUA_DISABLE
1531 
1532 /* method: get_time of class fawkes::Clock */
1533 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time03
1534 static int tolua_fawkesutils_fawkes_Clock_get_time03(lua_State* tolua_S)
1535 {
1536  tolua_Error tolua_err;
1537  if (
1538  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
1539  !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
1540  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1541  !tolua_isnoobj(tolua_S,4,&tolua_err)
1542  )
1543  goto tolua_lerror;
1544  else
1545  {
1546  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1547  fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1548  fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int) tolua_tonumber(tolua_S,3,0));
1549 #ifndef TOLUA_RELEASE
1550  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'",NULL);
1551 #endif
1552  {
1553  self->get_time(time,sel);
1554  }
1555  }
1556  return 0;
1557 tolua_lerror:
1558  return tolua_fawkesutils_fawkes_Clock_get_time02(tolua_S);
1559 }
1560 #endif //#ifndef TOLUA_DISABLE
1561 
1562 /* method: get_time of class fawkes::Clock */
1563 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time04
1564 static int tolua_fawkesutils_fawkes_Clock_get_time04(lua_State* tolua_S)
1565 {
1566  tolua_Error tolua_err;
1567  if (
1568  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
1569  !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
1570  !tolua_isnoobj(tolua_S,3,&tolua_err)
1571  )
1572  goto tolua_lerror;
1573  else
1574  {
1575  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1576  struct timeval* tv = ((struct timeval*) tolua_tousertype(tolua_S,2,0));
1577 #ifndef TOLUA_RELEASE
1578  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'",NULL);
1579 #endif
1580  {
1581  self->get_time(tv);
1582  }
1583  }
1584  return 0;
1585 tolua_lerror:
1586  return tolua_fawkesutils_fawkes_Clock_get_time03(tolua_S);
1587 }
1588 #endif //#ifndef TOLUA_DISABLE
1589 
1590 /* method: get_time of class fawkes::Clock */
1591 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time05
1592 static int tolua_fawkesutils_fawkes_Clock_get_time05(lua_State* tolua_S)
1593 {
1594  tolua_Error tolua_err;
1595  if (
1596  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
1597  !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
1598  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1599  !tolua_isnoobj(tolua_S,4,&tolua_err)
1600  )
1601  goto tolua_lerror;
1602  else
1603  {
1604  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1605  struct timeval* tv = ((struct timeval*) tolua_tousertype(tolua_S,2,0));
1606  fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int) tolua_tonumber(tolua_S,3,0));
1607 #ifndef TOLUA_RELEASE
1608  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'",NULL);
1609 #endif
1610  {
1611  self->get_time(tv,sel);
1612  }
1613  }
1614  return 0;
1615 tolua_lerror:
1616  return tolua_fawkesutils_fawkes_Clock_get_time04(tolua_S);
1617 }
1618 #endif //#ifndef TOLUA_DISABLE
1619 
1620 /* method: get_systime of class fawkes::Clock */
1621 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime00
1622 static int tolua_fawkesutils_fawkes_Clock_get_systime00(lua_State* tolua_S)
1623 {
1624 #ifndef TOLUA_RELEASE
1625  tolua_Error tolua_err;
1626  if (
1627  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
1628  !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
1629  !tolua_isnoobj(tolua_S,3,&tolua_err)
1630  )
1631  goto tolua_lerror;
1632  else
1633 #endif
1634  {
1635  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1636  struct timeval* tv = ((struct timeval*) tolua_tousertype(tolua_S,2,0));
1637 #ifndef TOLUA_RELEASE
1638  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'",NULL);
1639 #endif
1640  {
1641  self->get_systime(tv);
1642  }
1643  }
1644  return 0;
1645 #ifndef TOLUA_RELEASE
1646  tolua_lerror:
1647  tolua_error(tolua_S,"#ferror in function 'get_systime'.",&tolua_err);
1648  return 0;
1649 #endif
1650 }
1651 #endif //#ifndef TOLUA_DISABLE
1652 
1653 /* method: get_systime of class fawkes::Clock */
1654 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime01
1655 static int tolua_fawkesutils_fawkes_Clock_get_systime01(lua_State* tolua_S)
1656 {
1657  tolua_Error tolua_err;
1658  if (
1659  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
1660  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
1661  !tolua_isnoobj(tolua_S,3,&tolua_err)
1662  )
1663  goto tolua_lerror;
1664  else
1665  {
1666  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1667  fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1668 #ifndef TOLUA_RELEASE
1669  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'",NULL);
1670 #endif
1671  {
1672  self->get_systime(*time);
1673  }
1674  }
1675  return 0;
1676 tolua_lerror:
1677  return tolua_fawkesutils_fawkes_Clock_get_systime00(tolua_S);
1678 }
1679 #endif //#ifndef TOLUA_DISABLE
1680 
1681 /* method: get_systime of class fawkes::Clock */
1682 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime02
1683 static int tolua_fawkesutils_fawkes_Clock_get_systime02(lua_State* tolua_S)
1684 {
1685  tolua_Error tolua_err;
1686  if (
1687  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
1688  !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
1689  !tolua_isnoobj(tolua_S,3,&tolua_err)
1690  )
1691  goto tolua_lerror;
1692  else
1693  {
1694  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1695  fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1696 #ifndef TOLUA_RELEASE
1697  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'",NULL);
1698 #endif
1699  {
1700  self->get_systime(time);
1701  }
1702  }
1703  return 0;
1704 tolua_lerror:
1705  return tolua_fawkesutils_fawkes_Clock_get_systime01(tolua_S);
1706 }
1707 #endif //#ifndef TOLUA_DISABLE
1708 
1709 /* method: now of class fawkes::Clock */
1710 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_now00
1711 static int tolua_fawkesutils_fawkes_Clock_now00(lua_State* tolua_S)
1712 {
1713 #ifndef TOLUA_RELEASE
1714  tolua_Error tolua_err;
1715  if (
1716  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
1717  !tolua_isnoobj(tolua_S,2,&tolua_err)
1718  )
1719  goto tolua_lerror;
1720  else
1721 #endif
1722  {
1723  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1724 #ifndef TOLUA_RELEASE
1725  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'now'",NULL);
1726 #endif
1727  {
1728  fawkes::Time tolua_ret = (fawkes::Time) self->now();
1729  {
1730 #ifdef __cplusplus
1731  void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
1732  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
1733  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1734 #else
1735  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
1736  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
1737  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1738 #endif
1739  }
1740  }
1741  }
1742  return 1;
1743 #ifndef TOLUA_RELEASE
1744  tolua_lerror:
1745  tolua_error(tolua_S,"#ferror in function 'now'.",&tolua_err);
1746  return 0;
1747 #endif
1748 }
1749 #endif //#ifndef TOLUA_DISABLE
1750 
1751 /* method: elapsed of class fawkes::Clock */
1752 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_elapsed00
1753 static int tolua_fawkesutils_fawkes_Clock_elapsed00(lua_State* tolua_S)
1754 {
1755 #ifndef TOLUA_RELEASE
1756  tolua_Error tolua_err;
1757  if (
1758  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
1759  !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
1760  !tolua_isnoobj(tolua_S,3,&tolua_err)
1761  )
1762  goto tolua_lerror;
1763  else
1764 #endif
1765  {
1766  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1767  fawkes::Time* t = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1768 #ifndef TOLUA_RELEASE
1769  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'elapsed'",NULL);
1770 #endif
1771  {
1772  float tolua_ret = (float) self->elapsed(t);
1773  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1774  }
1775  }
1776  return 1;
1777 #ifndef TOLUA_RELEASE
1778  tolua_lerror:
1779  tolua_error(tolua_S,"#ferror in function 'elapsed'.",&tolua_err);
1780  return 0;
1781 #endif
1782 }
1783 #endif //#ifndef TOLUA_DISABLE
1784 
1785 /* method: sys_elapsed of class fawkes::Clock */
1786 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_sys_elapsed00
1787 static int tolua_fawkesutils_fawkes_Clock_sys_elapsed00(lua_State* tolua_S)
1788 {
1789 #ifndef TOLUA_RELEASE
1790  tolua_Error tolua_err;
1791  if (
1792  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
1793  !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
1794  !tolua_isnoobj(tolua_S,3,&tolua_err)
1795  )
1796  goto tolua_lerror;
1797  else
1798 #endif
1799  {
1800  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
1801  fawkes::Time* t = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1802 #ifndef TOLUA_RELEASE
1803  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sys_elapsed'",NULL);
1804 #endif
1805  {
1806  float tolua_ret = (float) self->sys_elapsed(t);
1807  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1808  }
1809  }
1810  return 1;
1811 #ifndef TOLUA_RELEASE
1812  tolua_lerror:
1813  tolua_error(tolua_S,"#ferror in function 'sys_elapsed'.",&tolua_err);
1814  return 0;
1815 #endif
1816 }
1817 #endif //#ifndef TOLUA_DISABLE
1818 
1819 /* Open function */
1820 TOLUA_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_cclass(tolua_S,"timeval","timeval","",NULL);
1847  tolua_beginmodule(tolua_S,"timeval");
1848  tolua_variable(tolua_S,"tv_sec",tolua_get_timeval_tv_sec,tolua_set_timeval_tv_sec);
1849  tolua_variable(tolua_S,"tv_usec",tolua_get_timeval_tv_usec,tolua_set_timeval_tv_usec);
1850  tolua_endmodule(tolua_S);
1851  tolua_module(tolua_S,"fawkes",0);
1852  tolua_beginmodule(tolua_S,"fawkes");
1853  #ifdef __cplusplus
1854  tolua_cclass(tolua_S,"Time","fawkes::Time","",tolua_collect_fawkes__Time);
1855  #else
1856  tolua_cclass(tolua_S,"Time","fawkes::Time","",NULL);
1857  #endif
1858  tolua_beginmodule(tolua_S,"Time");
1859  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new00);
1860  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new00_local);
1861  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new00_local);
1862  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new01);
1863  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new01_local);
1864  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new01_local);
1865  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new02);
1866  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new02_local);
1867  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new02_local);
1868  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new03);
1869  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new03_local);
1870  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new03_local);
1871  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new04);
1872  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new04_local);
1873  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new04_local);
1874  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new05);
1875  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new05_local);
1876  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new05_local);
1877  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new06);
1878  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new06_local);
1879  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new06_local);
1880  tolua_function(tolua_S,"delete",tolua_fawkesutils_fawkes_Time_delete00);
1881  tolua_function(tolua_S,"in_sec",tolua_fawkesutils_fawkes_Time_in_sec00);
1882  tolua_function(tolua_S,"in_msec",tolua_fawkesutils_fawkes_Time_in_msec00);
1883  tolua_function(tolua_S,"in_usec",tolua_fawkesutils_fawkes_Time_in_usec00);
1884  tolua_function(tolua_S,"get_timeval",tolua_fawkesutils_fawkes_Time_get_timeval00);
1885  tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time00);
1886  tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time01);
1887  tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time02);
1888  tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time03);
1889  tolua_function(tolua_S,"add",tolua_fawkesutils_fawkes_Time_add00);
1890  tolua_function(tolua_S,"stamp",tolua_fawkesutils_fawkes_Time_stamp00);
1891  tolua_function(tolua_S,".add",tolua_fawkesutils_fawkes_Time__add00);
1892  tolua_function(tolua_S,".sub",tolua_fawkesutils_fawkes_Time__sub00);
1893  tolua_function(tolua_S,"str",tolua_fawkesutils_fawkes_Time_str00);
1894  tolua_function(tolua_S,"str_r",tolua_fawkesutils_fawkes_Time_str_r00);
1895  tolua_endmodule(tolua_S);
1896  tolua_endmodule(tolua_S);
1897  tolua_module(tolua_S,"fawkes",0);
1898  tolua_beginmodule(tolua_S,"fawkes");
1899  tolua_cclass(tolua_S,"Clock","fawkes::Clock","",NULL);
1900  tolua_beginmodule(tolua_S,"Clock");
1901  tolua_constant(tolua_S,"DEFAULT",fawkes::Clock::DEFAULT);
1902  tolua_constant(tolua_S,"REALTIME",fawkes::Clock::REALTIME);
1903  tolua_constant(tolua_S,"EXTERNAL",fawkes::Clock::EXTERNAL);
1904  tolua_function(tolua_S,"instance",tolua_fawkesutils_fawkes_Clock_instance00);
1905  tolua_function(tolua_S,"finalize",tolua_fawkesutils_fawkes_Clock_finalize00);
1906  tolua_function(tolua_S,"is_ext_default_timesource",tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00);
1907  tolua_function(tolua_S,"has_ext_timesource",tolua_fawkesutils_fawkes_Clock_has_ext_timesource00);
1908  tolua_function(tolua_S,"ext_to_realtime",tolua_fawkesutils_fawkes_Clock_ext_to_realtime00);
1909  tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time00);
1910  tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time01);
1911  tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time02);
1912  tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time03);
1913  tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time04);
1914  tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time05);
1915  tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime00);
1916  tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime01);
1917  tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime02);
1918  tolua_function(tolua_S,"now",tolua_fawkesutils_fawkes_Clock_now00);
1919  tolua_function(tolua_S,"elapsed",tolua_fawkesutils_fawkes_Clock_elapsed00);
1920  tolua_function(tolua_S,"sys_elapsed",tolua_fawkesutils_fawkes_Clock_sys_elapsed00);
1921  tolua_endmodule(tolua_S);
1922  tolua_endmodule(tolua_S);
1923  tolua_endmodule(tolua_S);
1924  return 1;
1925 }
1926 
1927 
1928 extern "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 
double in_sec() const
Convet time to seconds.
Definition: time.cpp:232
TimesourceSelector
Select the time source.
Definition: clock.h:39
const timeval * get_timeval() const
Obtain the timeval where the time is stored.
Definition: time.h:109
static Clock * instance()
Clock initializer.
Definition: clock.cpp:65
const char * str(bool utc=false) const
Output function.
Definition: time.cpp:872
float predict() const
Predicts the next position based on the past observations.
Definition: kalman_1d.cpp:82
This is supposed to be the central clock in Fawkes.
Definition: clock.h:34
A class for handling time.
Definition: time.h:91
long in_msec() const
Convert the stored time into milli-seconds.
Definition: time.cpp:242
select the external time source
Definition: clock.h:42
select the system time source
Definition: clock.h:41
static void finalize()
Finalize.
Definition: clock.cpp:77
long in_usec() const
Convert the stored time into micro-seconds.
Definition: time.cpp:252
Time & stamp()
Set this time to the current time.
Definition: time.cpp:783
One-dimensional Kalman filter implementation for single-precision floats.
Definition: kalman_1d.h:25
select the default time source
Definition: clock.h:40