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/clock.h>
33 #include <utils/time/time.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::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
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 /* method: instance of class fawkes::Clock */
362 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_instance00
363 static 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
391 static 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
418 static 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
450 static 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
482 static 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
526 static 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
559 static 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;
582 tolua_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
589 static 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;
610 tolua_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
617 static 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;
640 tolua_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
647 static 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;
668 tolua_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
675 static 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;
698 tolua_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
705 static 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
738 static 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;
759 tolua_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
766 static 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;
787 tolua_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
794 static 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
836 static 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
870 static 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
904 static 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
917 static 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
934 static 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
947 static 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
964 static 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
992 static 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
1021 static 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;
1039 tolua_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
1046 static 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;
1065 tolua_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
1072 static 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;
1090 tolua_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
1097 static 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;
1116 tolua_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
1123 static 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;
1141 tolua_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
1148 static 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;
1167 tolua_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
1174 static 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;
1192 tolua_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
1199 static 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;
1218 tolua_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
1225 static 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;
1245 tolua_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
1252 static 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;
1273 tolua_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
1280 static 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;
1302 tolua_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
1309 static 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;
1332 tolua_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
1339 static 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
1368 static 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
1400 static 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
1432 static 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
1464 static 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
1496 static 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
1529 static 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;
1550 tolua_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
1557 static 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;
1578 tolua_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
1585 static 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;
1606 tolua_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
1613 static 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
1646 static 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
1678 static 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
1722 static 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
1756 static 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
1788 static 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 */
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_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 
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 
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
static Clock * instance()
Clock initializer.
Definition: clock.cpp:63
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
A class for handling time.
Definition: time.h:93
Time & stamp()
Set this time to the current time.
Definition: time.cpp:704
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
long in_msec() const
Convert the stored time into milli-seconds.
Definition: time.cpp:228