Fawkes API Fawkes Development Version
fawkesnavgraph_tolua.cpp
1/*
2** Lua binding: fawkesnavgraph
3** Generated automatically by tolua++-1.0.92
4*/
5/* This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version. A runtime exception applies to
9 * this software (see LICENSE.GPL_WRE file mentioned below for details).
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU Library General Public License for more details.
15 *
16 * Read the full text in the LICENSE.GPL_WRE file in the doc directory.
17 */
18
19#include <core/exception.h>
20
21#ifndef __cplusplus
22#include "stdlib.h"
23#endif
24#include "string.h"
25
26#include "tolua++.h"
27
28/* Exported function */
29TOLUA_API int tolua_fawkesnavgraph_open (lua_State* tolua_S);
30
31#include <navgraph/navgraph.h>
32#include <navgraph/yaml_navgraph.h>
33#include <vector>
34#include <string>
35#include <functional>
36using namespace std;
37using namespace fawkes;
38#include <navgraph/navgraph_node.h>
39#include <string>
40#include <vector>
41using namespace std;
42
43/* function to release collected object via destructor */
44#ifdef __cplusplus
45
46static int tolua_collect_vector_fawkes__NavGraphNode_ (lua_State* tolua_S)
47{
48 vector<fawkes::NavGraphNode>* self = (vector<fawkes::NavGraphNode>*) tolua_tousertype(tolua_S,1,0);
49 Mtolua_delete(self);
50 return 0;
51}
52
53static int tolua_collect_fawkes__NavGraphNode (lua_State* tolua_S)
54{
55 fawkes::NavGraphNode* self = (fawkes::NavGraphNode*) tolua_tousertype(tolua_S,1,0);
56 Mtolua_delete(self);
57 return 0;
58}
59
60static int tolua_collect_vector_string_ (lua_State* tolua_S)
61{
62 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
63 Mtolua_delete(self);
64 return 0;
65}
66
67static int tolua_collect_fawkes__NavGraph (lua_State* tolua_S)
68{
69 fawkes::NavGraph* self = (fawkes::NavGraph*) tolua_tousertype(tolua_S,1,0);
70 Mtolua_delete(self);
71 return 0;
72}
73#endif
74
75
76/* function to register type */
77static void tolua_reg_types (lua_State* tolua_S)
78{
79 tolua_usertype(tolua_S,"vector<fawkes::NavGraphNode>");
80 tolua_usertype(tolua_S,"fawkes::NavGraphNode");
81 tolua_usertype(tolua_S,"vector<string>");
82 tolua_usertype(tolua_S,"fawkes::NavGraph");
83}
84
85/* method: new of class fawkes::NavGraph */
86#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_new00
87static int tolua_fawkesnavgraph_fawkes_NavGraph_new00(lua_State* tolua_S)
88{
89#ifndef TOLUA_RELEASE
90 tolua_Error tolua_err;
91 if (
92 !tolua_isusertable(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
93 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
94 !tolua_isnoobj(tolua_S,3,&tolua_err)
95 )
96 goto tolua_lerror;
97 else
98#endif
99 {
100 string graph_name = ((string) tolua_tocppstring(tolua_S,2,0));
101 bool exc_caught = false;
102 try {
103 {
104 fawkes::NavGraph* tolua_ret = (fawkes::NavGraph*) Mtolua_new((fawkes::NavGraph)(graph_name));
105 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavGraph");
106 }
107 } catch (fawkes::Exception &e) {
108 exc_caught = true;
109 lua_pushstring(tolua_S, e.what_no_backtrace());
110 }
111 catch (std::exception &e) {
112 exc_caught = true;
113 lua_pushstring(tolua_S, e.what());
114 }
115 if (exc_caught) lua_error(tolua_S);
116
117 }
118 return 1;
119#ifndef TOLUA_RELEASE
120 tolua_lerror:
121 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
122 return 0;
123#endif
124}
125#endif //#ifndef TOLUA_DISABLE
126
127/* method: new_local of class fawkes::NavGraph */
128#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_new00_local
129static int tolua_fawkesnavgraph_fawkes_NavGraph_new00_local(lua_State* tolua_S)
130{
131#ifndef TOLUA_RELEASE
132 tolua_Error tolua_err;
133 if (
134 !tolua_isusertable(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
135 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
136 !tolua_isnoobj(tolua_S,3,&tolua_err)
137 )
138 goto tolua_lerror;
139 else
140#endif
141 {
142 string graph_name = ((string) tolua_tocppstring(tolua_S,2,0));
143 bool exc_caught = false;
144 try {
145 {
146 fawkes::NavGraph* tolua_ret = (fawkes::NavGraph*) Mtolua_new((fawkes::NavGraph)(graph_name));
147 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavGraph");
148 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
149 }
150 } catch (fawkes::Exception &e) {
151 exc_caught = true;
152 lua_pushstring(tolua_S, e.what_no_backtrace());
153 }
154 catch (std::exception &e) {
155 exc_caught = true;
156 lua_pushstring(tolua_S, e.what());
157 }
158 if (exc_caught) lua_error(tolua_S);
159
160 }
161 return 1;
162#ifndef TOLUA_RELEASE
163 tolua_lerror:
164 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
165 return 0;
166#endif
167}
168#endif //#ifndef TOLUA_DISABLE
169
170/* method: delete of class fawkes::NavGraph */
171#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_delete00
172static int tolua_fawkesnavgraph_fawkes_NavGraph_delete00(lua_State* tolua_S)
173{
174#ifndef TOLUA_RELEASE
175 tolua_Error tolua_err;
176 if (
177 !tolua_isusertype(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
178 !tolua_isnoobj(tolua_S,2,&tolua_err)
179 )
180 goto tolua_lerror;
181 else
182#endif
183 {
184 fawkes::NavGraph* self = (fawkes::NavGraph*) tolua_tousertype(tolua_S,1,0);
185#ifndef TOLUA_RELEASE
186 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
187#endif
188 bool exc_caught = false;
189 try {
190 Mtolua_delete(self);
191 } catch (fawkes::Exception &e) {
192 exc_caught = true;
193 lua_pushstring(tolua_S, e.what_no_backtrace());
194 }
195 catch (std::exception &e) {
196 exc_caught = true;
197 lua_pushstring(tolua_S, e.what());
198 }
199 if (exc_caught) lua_error(tolua_S);
200
201 }
202 return 0;
203#ifndef TOLUA_RELEASE
204 tolua_lerror:
205 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
206 return 0;
207#endif
208}
209#endif //#ifndef TOLUA_DISABLE
210
211/* method: name of class fawkes::NavGraph */
212#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_name00
213static int tolua_fawkesnavgraph_fawkes_NavGraph_name00(lua_State* tolua_S)
214{
215#ifndef TOLUA_RELEASE
216 tolua_Error tolua_err;
217 if (
218 !tolua_isusertype(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
219 !tolua_isnoobj(tolua_S,2,&tolua_err)
220 )
221 goto tolua_lerror;
222 else
223#endif
224 {
225 fawkes::NavGraph* self = (fawkes::NavGraph*) tolua_tousertype(tolua_S,1,0);
226#ifndef TOLUA_RELEASE
227 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL);
228#endif
229 bool exc_caught = false;
230 try {
231 {
232 string tolua_ret = (string) self->name();
233 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
234 }
235 } catch (fawkes::Exception &e) {
236 exc_caught = true;
237 lua_pushstring(tolua_S, e.what_no_backtrace());
238 }
239 catch (std::exception &e) {
240 exc_caught = true;
241 lua_pushstring(tolua_S, e.what());
242 }
243 if (exc_caught) lua_error(tolua_S);
244
245 }
246 return 1;
247#ifndef TOLUA_RELEASE
248 tolua_lerror:
249 tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
250 return 0;
251#endif
252}
253#endif //#ifndef TOLUA_DISABLE
254
255/* method: nodes of class fawkes::NavGraph */
256#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_nodes00
257static int tolua_fawkesnavgraph_fawkes_NavGraph_nodes00(lua_State* tolua_S)
258{
259#ifndef TOLUA_RELEASE
260 tolua_Error tolua_err;
261 if (
262 !tolua_isusertype(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
263 !tolua_isnoobj(tolua_S,2,&tolua_err)
264 )
265 goto tolua_lerror;
266 else
267#endif
268 {
269 fawkes::NavGraph* self = (fawkes::NavGraph*) tolua_tousertype(tolua_S,1,0);
270#ifndef TOLUA_RELEASE
271 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'nodes'", NULL);
272#endif
273 bool exc_caught = false;
274 try {
275 {
276 vector<fawkes::NavGraphNode> tolua_ret = (vector<fawkes::NavGraphNode>) self->nodes();
277 {
278#ifdef __cplusplus
279 void* tolua_obj = Mtolua_new((vector<fawkes::NavGraphNode>)(tolua_ret));
280 tolua_pushusertype(tolua_S,tolua_obj,"vector<fawkes::NavGraphNode>");
281 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
282#else
283 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(vector<fawkes::NavGraphNode>));
284 tolua_pushusertype(tolua_S,tolua_obj,"vector<fawkes::NavGraphNode>");
285 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
286#endif
287 }
288 }
289 } catch (fawkes::Exception &e) {
290 exc_caught = true;
291 lua_pushstring(tolua_S, e.what_no_backtrace());
292 }
293 catch (std::exception &e) {
294 exc_caught = true;
295 lua_pushstring(tolua_S, e.what());
296 }
297 if (exc_caught) lua_error(tolua_S);
298
299 }
300 return 1;
301#ifndef TOLUA_RELEASE
302 tolua_lerror:
303 tolua_error(tolua_S,"#ferror in function 'nodes'.",&tolua_err);
304 return 0;
305#endif
306}
307#endif //#ifndef TOLUA_DISABLE
308
309/* method: node of class fawkes::NavGraph */
310#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_node00
311static int tolua_fawkesnavgraph_fawkes_NavGraph_node00(lua_State* tolua_S)
312{
313#ifndef TOLUA_RELEASE
314 tolua_Error tolua_err;
315 if (
316 !tolua_isusertype(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
317 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
318 !tolua_isnoobj(tolua_S,3,&tolua_err)
319 )
320 goto tolua_lerror;
321 else
322#endif
323 {
324 fawkes::NavGraph* self = (fawkes::NavGraph*) tolua_tousertype(tolua_S,1,0);
325 string name_or_alias = ((string) tolua_tocppstring(tolua_S,2,0));
326#ifndef TOLUA_RELEASE
327 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'node'", NULL);
328#endif
329 bool exc_caught = false;
330 try {
331 {
332 fawkes::NavGraphNode tolua_ret = (fawkes::NavGraphNode) self->node(name_or_alias);
333 {
334#ifdef __cplusplus
335 void* tolua_obj = Mtolua_new((fawkes::NavGraphNode)(tolua_ret));
336 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::NavGraphNode");
337 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
338#else
339 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::NavGraphNode));
340 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::NavGraphNode");
341 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
342#endif
343 }
344 }
345 } catch (fawkes::Exception &e) {
346 exc_caught = true;
347 lua_pushstring(tolua_S, e.what_no_backtrace());
348 }
349 catch (std::exception &e) {
350 exc_caught = true;
351 lua_pushstring(tolua_S, e.what());
352 }
353 if (exc_caught) lua_error(tolua_S);
354
355 }
356 return 1;
357#ifndef TOLUA_RELEASE
358 tolua_lerror:
359 tolua_error(tolua_S,"#ferror in function 'node'.",&tolua_err);
360 return 0;
361#endif
362}
363#endif //#ifndef TOLUA_DISABLE
364
365/* method: closest_node of class fawkes::NavGraph */
366#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_closest_node00
367static int tolua_fawkesnavgraph_fawkes_NavGraph_closest_node00(lua_State* tolua_S)
368{
369#ifndef TOLUA_RELEASE
370 tolua_Error tolua_err;
371 if (
372 !tolua_isusertype(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
373 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
374 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
375 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
376 !tolua_isnoobj(tolua_S,5,&tolua_err)
377 )
378 goto tolua_lerror;
379 else
380#endif
381 {
382 fawkes::NavGraph* self = (fawkes::NavGraph*) tolua_tousertype(tolua_S,1,0);
383 float pos_x = ((float) tolua_tonumber(tolua_S,2,0));
384 float pos_y = ((float) tolua_tonumber(tolua_S,3,0));
385 string property = ((string) tolua_tocppstring(tolua_S,4,0));
386#ifndef TOLUA_RELEASE
387 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'closest_node'", NULL);
388#endif
389 bool exc_caught = false;
390 try {
391 {
392 fawkes::NavGraphNode tolua_ret = (fawkes::NavGraphNode) self->closest_node(pos_x,pos_y,property);
393 {
394#ifdef __cplusplus
395 void* tolua_obj = Mtolua_new((fawkes::NavGraphNode)(tolua_ret));
396 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::NavGraphNode");
397 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
398#else
399 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::NavGraphNode));
400 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::NavGraphNode");
401 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
402#endif
403 }
404 }
405 } catch (fawkes::Exception &e) {
406 exc_caught = true;
407 lua_pushstring(tolua_S, e.what_no_backtrace());
408 }
409 catch (std::exception &e) {
410 exc_caught = true;
411 lua_pushstring(tolua_S, e.what());
412 }
413 if (exc_caught) lua_error(tolua_S);
414
415 }
416 return 1;
417#ifndef TOLUA_RELEASE
418 tolua_lerror:
419 tolua_error(tolua_S,"#ferror in function 'closest_node'.",&tolua_err);
420 return 0;
421#endif
422}
423#endif //#ifndef TOLUA_DISABLE
424
425/* method: closest_node_to of class fawkes::NavGraph */
426#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_closest_node_to00
427static int tolua_fawkesnavgraph_fawkes_NavGraph_closest_node_to00(lua_State* tolua_S)
428{
429#ifndef TOLUA_RELEASE
430 tolua_Error tolua_err;
431 if (
432 !tolua_isusertype(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
433 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
434 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
435 !tolua_isnoobj(tolua_S,4,&tolua_err)
436 )
437 goto tolua_lerror;
438 else
439#endif
440 {
441 fawkes::NavGraph* self = (fawkes::NavGraph*) tolua_tousertype(tolua_S,1,0);
442 std::string node_name = ((std::string) tolua_tocppstring(tolua_S,2,0));
443 string property = ((string) tolua_tocppstring(tolua_S,3,0));
444#ifndef TOLUA_RELEASE
445 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'closest_node_to'", NULL);
446#endif
447 bool exc_caught = false;
448 try {
449 {
450 fawkes::NavGraphNode tolua_ret = (fawkes::NavGraphNode) self->closest_node_to(node_name,property);
451 {
452#ifdef __cplusplus
453 void* tolua_obj = Mtolua_new((fawkes::NavGraphNode)(tolua_ret));
454 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::NavGraphNode");
455 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
456#else
457 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::NavGraphNode));
458 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::NavGraphNode");
459 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
460#endif
461 }
462 }
463 } catch (fawkes::Exception &e) {
464 exc_caught = true;
465 lua_pushstring(tolua_S, e.what_no_backtrace());
466 }
467 catch (std::exception &e) {
468 exc_caught = true;
469 lua_pushstring(tolua_S, e.what());
470 }
471 if (exc_caught) lua_error(tolua_S);
472
473 }
474 return 1;
475#ifndef TOLUA_RELEASE
476 tolua_lerror:
477 tolua_error(tolua_S,"#ferror in function 'closest_node_to'.",&tolua_err);
478 return 0;
479#endif
480}
481#endif //#ifndef TOLUA_DISABLE
482
483/* method: closest_node_with_unconnected of class fawkes::NavGraph */
484#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_closest_node_with_unconnected00
485static int tolua_fawkesnavgraph_fawkes_NavGraph_closest_node_with_unconnected00(lua_State* tolua_S)
486{
487#ifndef TOLUA_RELEASE
488 tolua_Error tolua_err;
489 if (
490 !tolua_isusertype(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
491 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
492 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
493 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
494 !tolua_isnoobj(tolua_S,5,&tolua_err)
495 )
496 goto tolua_lerror;
497 else
498#endif
499 {
500 fawkes::NavGraph* self = (fawkes::NavGraph*) tolua_tousertype(tolua_S,1,0);
501 float pos_x = ((float) tolua_tonumber(tolua_S,2,0));
502 float pos_y = ((float) tolua_tonumber(tolua_S,3,0));
503 string property = ((string) tolua_tocppstring(tolua_S,4,0));
504#ifndef TOLUA_RELEASE
505 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'closest_node_with_unconnected'", NULL);
506#endif
507 bool exc_caught = false;
508 try {
509 {
510 fawkes::NavGraphNode tolua_ret = (fawkes::NavGraphNode) self->closest_node_with_unconnected(pos_x,pos_y,property);
511 {
512#ifdef __cplusplus
513 void* tolua_obj = Mtolua_new((fawkes::NavGraphNode)(tolua_ret));
514 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::NavGraphNode");
515 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
516#else
517 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::NavGraphNode));
518 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::NavGraphNode");
519 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
520#endif
521 }
522 }
523 } catch (fawkes::Exception &e) {
524 exc_caught = true;
525 lua_pushstring(tolua_S, e.what_no_backtrace());
526 }
527 catch (std::exception &e) {
528 exc_caught = true;
529 lua_pushstring(tolua_S, e.what());
530 }
531 if (exc_caught) lua_error(tolua_S);
532
533 }
534 return 1;
535#ifndef TOLUA_RELEASE
536 tolua_lerror:
537 tolua_error(tolua_S,"#ferror in function 'closest_node_with_unconnected'.",&tolua_err);
538 return 0;
539#endif
540}
541#endif //#ifndef TOLUA_DISABLE
542
543/* method: closest_node_to_with_unconnected of class fawkes::NavGraph */
544#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_closest_node_to_with_unconnected00
545static int tolua_fawkesnavgraph_fawkes_NavGraph_closest_node_to_with_unconnected00(lua_State* tolua_S)
546{
547#ifndef TOLUA_RELEASE
548 tolua_Error tolua_err;
549 if (
550 !tolua_isusertype(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
551 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
552 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
553 !tolua_isnoobj(tolua_S,4,&tolua_err)
554 )
555 goto tolua_lerror;
556 else
557#endif
558 {
559 fawkes::NavGraph* self = (fawkes::NavGraph*) tolua_tousertype(tolua_S,1,0);
560 std::string node_name = ((std::string) tolua_tocppstring(tolua_S,2,0));
561 string property = ((string) tolua_tocppstring(tolua_S,3,0));
562#ifndef TOLUA_RELEASE
563 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'closest_node_to_with_unconnected'", NULL);
564#endif
565 bool exc_caught = false;
566 try {
567 {
568 fawkes::NavGraphNode tolua_ret = (fawkes::NavGraphNode) self->closest_node_to_with_unconnected(node_name,property);
569 {
570#ifdef __cplusplus
571 void* tolua_obj = Mtolua_new((fawkes::NavGraphNode)(tolua_ret));
572 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::NavGraphNode");
573 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
574#else
575 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::NavGraphNode));
576 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::NavGraphNode");
577 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
578#endif
579 }
580 }
581 } catch (fawkes::Exception &e) {
582 exc_caught = true;
583 lua_pushstring(tolua_S, e.what_no_backtrace());
584 }
585 catch (std::exception &e) {
586 exc_caught = true;
587 lua_pushstring(tolua_S, e.what());
588 }
589 if (exc_caught) lua_error(tolua_S);
590
591 }
592 return 1;
593#ifndef TOLUA_RELEASE
594 tolua_lerror:
595 tolua_error(tolua_S,"#ferror in function 'closest_node_to_with_unconnected'.",&tolua_err);
596 return 0;
597#endif
598}
599#endif //#ifndef TOLUA_DISABLE
600
601/* method: search_nodes of class fawkes::NavGraph */
602#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_search_nodes00
603static int tolua_fawkesnavgraph_fawkes_NavGraph_search_nodes00(lua_State* tolua_S)
604{
605#ifndef TOLUA_RELEASE
606 tolua_Error tolua_err;
607 if (
608 !tolua_isusertype(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
609 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
610 !tolua_isnoobj(tolua_S,3,&tolua_err)
611 )
612 goto tolua_lerror;
613 else
614#endif
615 {
616 fawkes::NavGraph* self = (fawkes::NavGraph*) tolua_tousertype(tolua_S,1,0);
617 string property = ((string) tolua_tocppstring(tolua_S,2,0));
618#ifndef TOLUA_RELEASE
619 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'search_nodes'", NULL);
620#endif
621 bool exc_caught = false;
622 try {
623 {
624 vector<fawkes::NavGraphNode> tolua_ret = (vector<fawkes::NavGraphNode>) self->search_nodes(property);
625 {
626#ifdef __cplusplus
627 void* tolua_obj = Mtolua_new((vector<fawkes::NavGraphNode>)(tolua_ret));
628 tolua_pushusertype(tolua_S,tolua_obj,"vector<fawkes::NavGraphNode>");
629 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
630#else
631 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(vector<fawkes::NavGraphNode>));
632 tolua_pushusertype(tolua_S,tolua_obj,"vector<fawkes::NavGraphNode>");
633 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
634#endif
635 }
636 }
637 } catch (fawkes::Exception &e) {
638 exc_caught = true;
639 lua_pushstring(tolua_S, e.what_no_backtrace());
640 }
641 catch (std::exception &e) {
642 exc_caught = true;
643 lua_pushstring(tolua_S, e.what());
644 }
645 if (exc_caught) lua_error(tolua_S);
646
647 }
648 return 1;
649#ifndef TOLUA_RELEASE
650 tolua_lerror:
651 tolua_error(tolua_S,"#ferror in function 'search_nodes'.",&tolua_err);
652 return 0;
653#endif
654}
655#endif //#ifndef TOLUA_DISABLE
656
657/* method: default_property of class fawkes::NavGraph */
658#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_default_property00
659static int tolua_fawkesnavgraph_fawkes_NavGraph_default_property00(lua_State* tolua_S)
660{
661#ifndef TOLUA_RELEASE
662 tolua_Error tolua_err;
663 if (
664 !tolua_isusertype(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
665 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
666 !tolua_isnoobj(tolua_S,3,&tolua_err)
667 )
668 goto tolua_lerror;
669 else
670#endif
671 {
672 fawkes::NavGraph* self = (fawkes::NavGraph*) tolua_tousertype(tolua_S,1,0);
673 string prop = ((string) tolua_tocppstring(tolua_S,2,0));
674#ifndef TOLUA_RELEASE
675 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'default_property'", NULL);
676#endif
677 bool exc_caught = false;
678 try {
679 {
680 string tolua_ret = (string) self->default_property(prop);
681 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
682 tolua_pushcppstring(tolua_S,(const char*)prop);
683 }
684 } catch (fawkes::Exception &e) {
685 exc_caught = true;
686 lua_pushstring(tolua_S, e.what_no_backtrace());
687 }
688 catch (std::exception &e) {
689 exc_caught = true;
690 lua_pushstring(tolua_S, e.what());
691 }
692 if (exc_caught) lua_error(tolua_S);
693
694 }
695 return 2;
696#ifndef TOLUA_RELEASE
697 tolua_lerror:
698 tolua_error(tolua_S,"#ferror in function 'default_property'.",&tolua_err);
699 return 0;
700#endif
701}
702#endif //#ifndef TOLUA_DISABLE
703
704/* method: default_property_as_float of class fawkes::NavGraph */
705#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_default_property_as_float00
706static int tolua_fawkesnavgraph_fawkes_NavGraph_default_property_as_float00(lua_State* tolua_S)
707{
708#ifndef TOLUA_RELEASE
709 tolua_Error tolua_err;
710 if (
711 !tolua_isusertype(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
712 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
713 !tolua_isnoobj(tolua_S,3,&tolua_err)
714 )
715 goto tolua_lerror;
716 else
717#endif
718 {
719 fawkes::NavGraph* self = (fawkes::NavGraph*) tolua_tousertype(tolua_S,1,0);
720 string prop = ((string) tolua_tocppstring(tolua_S,2,0));
721#ifndef TOLUA_RELEASE
722 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'default_property_as_float'", NULL);
723#endif
724 bool exc_caught = false;
725 try {
726 {
727 float tolua_ret = (float) self->default_property_as_float(prop);
728 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
729 tolua_pushcppstring(tolua_S,(const char*)prop);
730 }
731 } catch (fawkes::Exception &e) {
732 exc_caught = true;
733 lua_pushstring(tolua_S, e.what_no_backtrace());
734 }
735 catch (std::exception &e) {
736 exc_caught = true;
737 lua_pushstring(tolua_S, e.what());
738 }
739 if (exc_caught) lua_error(tolua_S);
740
741 }
742 return 2;
743#ifndef TOLUA_RELEASE
744 tolua_lerror:
745 tolua_error(tolua_S,"#ferror in function 'default_property_as_float'.",&tolua_err);
746 return 0;
747#endif
748}
749#endif //#ifndef TOLUA_DISABLE
750
751/* method: default_property_as_int of class fawkes::NavGraph */
752#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_default_property_as_int00
753static int tolua_fawkesnavgraph_fawkes_NavGraph_default_property_as_int00(lua_State* tolua_S)
754{
755#ifndef TOLUA_RELEASE
756 tolua_Error tolua_err;
757 if (
758 !tolua_isusertype(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
759 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
760 !tolua_isnoobj(tolua_S,3,&tolua_err)
761 )
762 goto tolua_lerror;
763 else
764#endif
765 {
766 fawkes::NavGraph* self = (fawkes::NavGraph*) tolua_tousertype(tolua_S,1,0);
767 string prop = ((string) tolua_tocppstring(tolua_S,2,0));
768#ifndef TOLUA_RELEASE
769 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'default_property_as_int'", NULL);
770#endif
771 bool exc_caught = false;
772 try {
773 {
774 int tolua_ret = (int) self->default_property_as_int(prop);
775 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
776 tolua_pushcppstring(tolua_S,(const char*)prop);
777 }
778 } catch (fawkes::Exception &e) {
779 exc_caught = true;
780 lua_pushstring(tolua_S, e.what_no_backtrace());
781 }
782 catch (std::exception &e) {
783 exc_caught = true;
784 lua_pushstring(tolua_S, e.what());
785 }
786 if (exc_caught) lua_error(tolua_S);
787
788 }
789 return 2;
790#ifndef TOLUA_RELEASE
791 tolua_lerror:
792 tolua_error(tolua_S,"#ferror in function 'default_property_as_int'.",&tolua_err);
793 return 0;
794#endif
795}
796#endif //#ifndef TOLUA_DISABLE
797
798/* method: default_property_as_bool of class fawkes::NavGraph */
799#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraph_default_property_as_bool00
800static int tolua_fawkesnavgraph_fawkes_NavGraph_default_property_as_bool00(lua_State* tolua_S)
801{
802#ifndef TOLUA_RELEASE
803 tolua_Error tolua_err;
804 if (
805 !tolua_isusertype(tolua_S,1,"fawkes::NavGraph",0,&tolua_err) ||
806 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
807 !tolua_isnoobj(tolua_S,3,&tolua_err)
808 )
809 goto tolua_lerror;
810 else
811#endif
812 {
813 fawkes::NavGraph* self = (fawkes::NavGraph*) tolua_tousertype(tolua_S,1,0);
814 string prop = ((string) tolua_tocppstring(tolua_S,2,0));
815#ifndef TOLUA_RELEASE
816 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'default_property_as_bool'", NULL);
817#endif
818 bool exc_caught = false;
819 try {
820 {
821 bool tolua_ret = (bool) self->default_property_as_bool(prop);
822 tolua_pushboolean(tolua_S,(bool)tolua_ret);
823 tolua_pushcppstring(tolua_S,(const char*)prop);
824 }
825 } catch (fawkes::Exception &e) {
826 exc_caught = true;
827 lua_pushstring(tolua_S, e.what_no_backtrace());
828 }
829 catch (std::exception &e) {
830 exc_caught = true;
831 lua_pushstring(tolua_S, e.what());
832 }
833 if (exc_caught) lua_error(tolua_S);
834
835 }
836 return 2;
837#ifndef TOLUA_RELEASE
838 tolua_lerror:
839 tolua_error(tolua_S,"#ferror in function 'default_property_as_bool'.",&tolua_err);
840 return 0;
841#endif
842}
843#endif //#ifndef TOLUA_DISABLE
844
845/* function: fawkes::load_yaml_navgraph */
846#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_load_yaml_navgraph00
847static int tolua_fawkesnavgraph_fawkes_load_yaml_navgraph00(lua_State* tolua_S)
848{
849#ifndef TOLUA_RELEASE
850 tolua_Error tolua_err;
851 if (
852 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
853 !tolua_isnoobj(tolua_S,2,&tolua_err)
854 )
855 goto tolua_lerror;
856 else
857#endif
858 {
859 std::string filename = ((std::string) tolua_tocppstring(tolua_S,1,0));
860 bool exc_caught = false;
861 try {
862 {
864 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavGraph");
865 }
866 } catch (fawkes::Exception &e) {
867 exc_caught = true;
868 lua_pushstring(tolua_S, e.what_no_backtrace());
869 }
870 catch (std::exception &e) {
871 exc_caught = true;
872 lua_pushstring(tolua_S, e.what());
873 }
874 if (exc_caught) lua_error(tolua_S);
875
876 }
877 return 1;
878#ifndef TOLUA_RELEASE
879 tolua_lerror:
880 tolua_error(tolua_S,"#ferror in function 'load_yaml_navgraph'.",&tolua_err);
881 return 0;
882#endif
883}
884#endif //#ifndef TOLUA_DISABLE
885
886/* method: clear of class vector<string> */
887#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_string__clear00
888static int tolua_fawkesnavgraph_vector_string__clear00(lua_State* tolua_S)
889{
890#ifndef TOLUA_RELEASE
891 tolua_Error tolua_err;
892 if (
893 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
894 !tolua_isnoobj(tolua_S,2,&tolua_err)
895 )
896 goto tolua_lerror;
897 else
898#endif
899 {
900 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
901#ifndef TOLUA_RELEASE
902 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
903#endif
904 bool exc_caught = false;
905 try {
906 {
907 self->clear();
908 }
909 } catch (fawkes::Exception &e) {
910 exc_caught = true;
911 lua_pushstring(tolua_S, e.what_no_backtrace());
912 }
913 catch (std::exception &e) {
914 exc_caught = true;
915 lua_pushstring(tolua_S, e.what());
916 }
917 if (exc_caught) lua_error(tolua_S);
918
919 }
920 return 0;
921#ifndef TOLUA_RELEASE
922 tolua_lerror:
923 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
924 return 0;
925#endif
926}
927#endif //#ifndef TOLUA_DISABLE
928
929/* method: size of class vector<string> */
930#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_string__size00
931static int tolua_fawkesnavgraph_vector_string__size00(lua_State* tolua_S)
932{
933#ifndef TOLUA_RELEASE
934 tolua_Error tolua_err;
935 if (
936 !tolua_isusertype(tolua_S,1,"const vector<string>",0,&tolua_err) ||
937 !tolua_isnoobj(tolua_S,2,&tolua_err)
938 )
939 goto tolua_lerror;
940 else
941#endif
942 {
943 const vector<string>* self = (const vector<string>*) tolua_tousertype(tolua_S,1,0);
944#ifndef TOLUA_RELEASE
945 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
946#endif
947 bool exc_caught = false;
948 try {
949 {
950 int tolua_ret = (int) self->size();
951 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
952 }
953 } catch (fawkes::Exception &e) {
954 exc_caught = true;
955 lua_pushstring(tolua_S, e.what_no_backtrace());
956 }
957 catch (std::exception &e) {
958 exc_caught = true;
959 lua_pushstring(tolua_S, e.what());
960 }
961 if (exc_caught) lua_error(tolua_S);
962
963 }
964 return 1;
965#ifndef TOLUA_RELEASE
966 tolua_lerror:
967 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
968 return 0;
969#endif
970}
971#endif //#ifndef TOLUA_DISABLE
972
973/* method: operator[] of class vector<string> */
974#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_string___geti00
975static int tolua_fawkesnavgraph_vector_string___geti00(lua_State* tolua_S)
976{
977#ifndef TOLUA_RELEASE
978 tolua_Error tolua_err;
979 if (
980 !tolua_isusertype(tolua_S,1,"const vector<string>",0,&tolua_err) ||
981 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
982 !tolua_isnoobj(tolua_S,3,&tolua_err)
983 )
984 goto tolua_lerror;
985 else
986#endif
987 {
988 const vector<string>* self = (const vector<string>*) tolua_tousertype(tolua_S,1,0);
989 int index = ((int) tolua_tonumber(tolua_S,2,0));
990#ifndef TOLUA_RELEASE
991 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
992#endif
993 bool exc_caught = false;
994 try {
995 {
996 const string tolua_ret = (const string) self->operator[](index);
997 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
998 }
999 } catch (fawkes::Exception &e) {
1000 exc_caught = true;
1001 lua_pushstring(tolua_S, e.what_no_backtrace());
1002 }
1003 catch (std::exception &e) {
1004 exc_caught = true;
1005 lua_pushstring(tolua_S, e.what());
1006 }
1007 if (exc_caught) lua_error(tolua_S);
1008
1009 }
1010 return 1;
1011#ifndef TOLUA_RELEASE
1012 tolua_lerror:
1013 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
1014 return 0;
1015#endif
1016}
1017#endif //#ifndef TOLUA_DISABLE
1018
1019/* method: operator&[] of class vector<string> */
1020#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_string___seti00
1021static int tolua_fawkesnavgraph_vector_string___seti00(lua_State* tolua_S)
1022{
1023#ifndef TOLUA_RELEASE
1024 tolua_Error tolua_err;
1025 if (
1026 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
1027 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1028 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
1029 !tolua_isnoobj(tolua_S,4,&tolua_err)
1030 )
1031 goto tolua_lerror;
1032 else
1033#endif
1034 {
1035 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
1036 int index = ((int) tolua_tonumber(tolua_S,2,0));
1037 string tolua_value = ((string) tolua_tocppstring(tolua_S,3,0));
1038#ifndef TOLUA_RELEASE
1039 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
1040#endif
1041 bool exc_caught = false;
1042 try {
1043 self->operator[](index) = tolua_value;
1044 } catch (fawkes::Exception &e) {
1045 exc_caught = true;
1046 lua_pushstring(tolua_S, e.what_no_backtrace());
1047 }
1048 catch (std::exception &e) {
1049 exc_caught = true;
1050 lua_pushstring(tolua_S, e.what());
1051 }
1052 if (exc_caught) lua_error(tolua_S);
1053
1054 }
1055 return 0;
1056#ifndef TOLUA_RELEASE
1057 tolua_lerror:
1058 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
1059 return 0;
1060#endif
1061}
1062#endif //#ifndef TOLUA_DISABLE
1063
1064/* method: operator[] of class vector<string> */
1065#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_string___geti01
1066static int tolua_fawkesnavgraph_vector_string___geti01(lua_State* tolua_S)
1067{
1068 tolua_Error tolua_err;
1069 if (
1070 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
1071 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1072 !tolua_isnoobj(tolua_S,3,&tolua_err)
1073 )
1074 goto tolua_lerror;
1075 else
1076 {
1077 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
1078 int index = ((int) tolua_tonumber(tolua_S,2,0));
1079#ifndef TOLUA_RELEASE
1080 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
1081#endif
1082 bool exc_caught = false;
1083 try {
1084 {
1085 string tolua_ret = (string) self->operator[](index);
1086 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
1087 }
1088 } catch (fawkes::Exception &e) {
1089 exc_caught = true;
1090 lua_pushstring(tolua_S, e.what_no_backtrace());
1091 }
1092 catch (std::exception &e) {
1093 exc_caught = true;
1094 lua_pushstring(tolua_S, e.what());
1095 }
1096 if (exc_caught) lua_error(tolua_S);
1097
1098 }
1099 return 1;
1100tolua_lerror:
1101 return tolua_fawkesnavgraph_vector_string___geti00(tolua_S);
1102}
1103#endif //#ifndef TOLUA_DISABLE
1104
1105/* method: push_back of class vector<string> */
1106#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_string__push_back00
1107static int tolua_fawkesnavgraph_vector_string__push_back00(lua_State* tolua_S)
1108{
1109#ifndef TOLUA_RELEASE
1110 tolua_Error tolua_err;
1111 if (
1112 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
1113 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
1114 !tolua_isnoobj(tolua_S,3,&tolua_err)
1115 )
1116 goto tolua_lerror;
1117 else
1118#endif
1119 {
1120 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
1121 string val = ((string) tolua_tocppstring(tolua_S,2,0));
1122#ifndef TOLUA_RELEASE
1123 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
1124#endif
1125 bool exc_caught = false;
1126 try {
1127 {
1128 self->push_back(val);
1129 }
1130 } catch (fawkes::Exception &e) {
1131 exc_caught = true;
1132 lua_pushstring(tolua_S, e.what_no_backtrace());
1133 }
1134 catch (std::exception &e) {
1135 exc_caught = true;
1136 lua_pushstring(tolua_S, e.what());
1137 }
1138 if (exc_caught) lua_error(tolua_S);
1139
1140 }
1141 return 0;
1142#ifndef TOLUA_RELEASE
1143 tolua_lerror:
1144 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
1145 return 0;
1146#endif
1147}
1148#endif //#ifndef TOLUA_DISABLE
1149
1150/* method: new of class vector<string> */
1151#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_string__new00
1152static int tolua_fawkesnavgraph_vector_string__new00(lua_State* tolua_S)
1153{
1154#ifndef TOLUA_RELEASE
1155 tolua_Error tolua_err;
1156 if (
1157 !tolua_isusertable(tolua_S,1,"vector<string>",0,&tolua_err) ||
1158 !tolua_isnoobj(tolua_S,2,&tolua_err)
1159 )
1160 goto tolua_lerror;
1161 else
1162#endif
1163 {
1164 bool exc_caught = false;
1165 try {
1166 {
1167 vector<string>* tolua_ret = (vector<string>*) Mtolua_new((vector<string>)());
1168 tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<string>");
1169 }
1170 } catch (fawkes::Exception &e) {
1171 exc_caught = true;
1172 lua_pushstring(tolua_S, e.what_no_backtrace());
1173 }
1174 catch (std::exception &e) {
1175 exc_caught = true;
1176 lua_pushstring(tolua_S, e.what());
1177 }
1178 if (exc_caught) lua_error(tolua_S);
1179
1180 }
1181 return 1;
1182#ifndef TOLUA_RELEASE
1183 tolua_lerror:
1184 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1185 return 0;
1186#endif
1187}
1188#endif //#ifndef TOLUA_DISABLE
1189
1190/* method: new_local of class vector<string> */
1191#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_string__new00_local
1192static int tolua_fawkesnavgraph_vector_string__new00_local(lua_State* tolua_S)
1193{
1194#ifndef TOLUA_RELEASE
1195 tolua_Error tolua_err;
1196 if (
1197 !tolua_isusertable(tolua_S,1,"vector<string>",0,&tolua_err) ||
1198 !tolua_isnoobj(tolua_S,2,&tolua_err)
1199 )
1200 goto tolua_lerror;
1201 else
1202#endif
1203 {
1204 bool exc_caught = false;
1205 try {
1206 {
1207 vector<string>* tolua_ret = (vector<string>*) Mtolua_new((vector<string>)());
1208 tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<string>");
1209 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1210 }
1211 } catch (fawkes::Exception &e) {
1212 exc_caught = true;
1213 lua_pushstring(tolua_S, e.what_no_backtrace());
1214 }
1215 catch (std::exception &e) {
1216 exc_caught = true;
1217 lua_pushstring(tolua_S, e.what());
1218 }
1219 if (exc_caught) lua_error(tolua_S);
1220
1221 }
1222 return 1;
1223#ifndef TOLUA_RELEASE
1224 tolua_lerror:
1225 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1226 return 0;
1227#endif
1228}
1229#endif //#ifndef TOLUA_DISABLE
1230
1231/* method: delete of class vector<string> */
1232#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_string__delete00
1233static int tolua_fawkesnavgraph_vector_string__delete00(lua_State* tolua_S)
1234{
1235#ifndef TOLUA_RELEASE
1236 tolua_Error tolua_err;
1237 if (
1238 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
1239 !tolua_isnoobj(tolua_S,2,&tolua_err)
1240 )
1241 goto tolua_lerror;
1242 else
1243#endif
1244 {
1245 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
1246#ifndef TOLUA_RELEASE
1247 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
1248#endif
1249 bool exc_caught = false;
1250 try {
1251 Mtolua_delete(self);
1252 } catch (fawkes::Exception &e) {
1253 exc_caught = true;
1254 lua_pushstring(tolua_S, e.what_no_backtrace());
1255 }
1256 catch (std::exception &e) {
1257 exc_caught = true;
1258 lua_pushstring(tolua_S, e.what());
1259 }
1260 if (exc_caught) lua_error(tolua_S);
1261
1262 }
1263 return 0;
1264#ifndef TOLUA_RELEASE
1265 tolua_lerror:
1266 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
1267 return 0;
1268#endif
1269}
1270#endif //#ifndef TOLUA_DISABLE
1271
1272/* method: clear of class vector<fawkes::NavGraphNode> */
1273#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__clear00
1274static int tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__clear00(lua_State* tolua_S)
1275{
1276#ifndef TOLUA_RELEASE
1277 tolua_Error tolua_err;
1278 if (
1279 !tolua_isusertype(tolua_S,1,"vector<fawkes::NavGraphNode>",0,&tolua_err) ||
1280 !tolua_isnoobj(tolua_S,2,&tolua_err)
1281 )
1282 goto tolua_lerror;
1283 else
1284#endif
1285 {
1286 vector<fawkes::NavGraphNode>* self = (vector<fawkes::NavGraphNode>*) tolua_tousertype(tolua_S,1,0);
1287#ifndef TOLUA_RELEASE
1288 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
1289#endif
1290 bool exc_caught = false;
1291 try {
1292 {
1293 self->clear();
1294 }
1295 } catch (fawkes::Exception &e) {
1296 exc_caught = true;
1297 lua_pushstring(tolua_S, e.what_no_backtrace());
1298 }
1299 catch (std::exception &e) {
1300 exc_caught = true;
1301 lua_pushstring(tolua_S, e.what());
1302 }
1303 if (exc_caught) lua_error(tolua_S);
1304
1305 }
1306 return 0;
1307#ifndef TOLUA_RELEASE
1308 tolua_lerror:
1309 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
1310 return 0;
1311#endif
1312}
1313#endif //#ifndef TOLUA_DISABLE
1314
1315/* method: size of class vector<fawkes::NavGraphNode> */
1316#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__size00
1317static int tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__size00(lua_State* tolua_S)
1318{
1319#ifndef TOLUA_RELEASE
1320 tolua_Error tolua_err;
1321 if (
1322 !tolua_isusertype(tolua_S,1,"const vector<fawkes::NavGraphNode>",0,&tolua_err) ||
1323 !tolua_isnoobj(tolua_S,2,&tolua_err)
1324 )
1325 goto tolua_lerror;
1326 else
1327#endif
1328 {
1329 const vector<fawkes::NavGraphNode>* self = (const vector<fawkes::NavGraphNode>*) tolua_tousertype(tolua_S,1,0);
1330#ifndef TOLUA_RELEASE
1331 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
1332#endif
1333 bool exc_caught = false;
1334 try {
1335 {
1336 int tolua_ret = (int) self->size();
1337 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1338 }
1339 } catch (fawkes::Exception &e) {
1340 exc_caught = true;
1341 lua_pushstring(tolua_S, e.what_no_backtrace());
1342 }
1343 catch (std::exception &e) {
1344 exc_caught = true;
1345 lua_pushstring(tolua_S, e.what());
1346 }
1347 if (exc_caught) lua_error(tolua_S);
1348
1349 }
1350 return 1;
1351#ifndef TOLUA_RELEASE
1352 tolua_lerror:
1353 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
1354 return 0;
1355#endif
1356}
1357#endif //#ifndef TOLUA_DISABLE
1358
1359/* method: operator[] of class vector<fawkes::NavGraphNode> */
1360#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_fawkes__NavGraphNode___geti00
1361static int tolua_fawkesnavgraph_vector_fawkes__NavGraphNode___geti00(lua_State* tolua_S)
1362{
1363#ifndef TOLUA_RELEASE
1364 tolua_Error tolua_err;
1365 if (
1366 !tolua_isusertype(tolua_S,1,"const vector<fawkes::NavGraphNode>",0,&tolua_err) ||
1367 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1368 !tolua_isnoobj(tolua_S,3,&tolua_err)
1369 )
1370 goto tolua_lerror;
1371 else
1372#endif
1373 {
1374 const vector<fawkes::NavGraphNode>* self = (const vector<fawkes::NavGraphNode>*) tolua_tousertype(tolua_S,1,0);
1375 int index = ((int) tolua_tonumber(tolua_S,2,0));
1376#ifndef TOLUA_RELEASE
1377 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
1378#endif
1379 bool exc_caught = false;
1380 try {
1381 {
1382 const fawkes::NavGraphNode tolua_ret = (const fawkes::NavGraphNode) self->operator[](index);
1383 {
1384#ifdef __cplusplus
1385 void* tolua_obj = Mtolua_new((fawkes::NavGraphNode)(tolua_ret));
1386 tolua_pushusertype(tolua_S,tolua_obj,"const fawkes::NavGraphNode");
1387 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1388#else
1389 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const fawkes::NavGraphNode));
1390 tolua_pushusertype(tolua_S,tolua_obj,"const fawkes::NavGraphNode");
1391 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1392#endif
1393 }
1394 }
1395 } catch (fawkes::Exception &e) {
1396 exc_caught = true;
1397 lua_pushstring(tolua_S, e.what_no_backtrace());
1398 }
1399 catch (std::exception &e) {
1400 exc_caught = true;
1401 lua_pushstring(tolua_S, e.what());
1402 }
1403 if (exc_caught) lua_error(tolua_S);
1404
1405 }
1406 return 1;
1407#ifndef TOLUA_RELEASE
1408 tolua_lerror:
1409 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
1410 return 0;
1411#endif
1412}
1413#endif //#ifndef TOLUA_DISABLE
1414
1415/* method: operator&[] of class vector<fawkes::NavGraphNode> */
1416#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_fawkes__NavGraphNode___seti00
1417static int tolua_fawkesnavgraph_vector_fawkes__NavGraphNode___seti00(lua_State* tolua_S)
1418{
1419#ifndef TOLUA_RELEASE
1420 tolua_Error tolua_err;
1421 if (
1422 !tolua_isusertype(tolua_S,1,"vector<fawkes::NavGraphNode>",0,&tolua_err) ||
1423 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1424 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"fawkes::NavGraphNode",0,&tolua_err)) ||
1425 !tolua_isnoobj(tolua_S,4,&tolua_err)
1426 )
1427 goto tolua_lerror;
1428 else
1429#endif
1430 {
1431 vector<fawkes::NavGraphNode>* self = (vector<fawkes::NavGraphNode>*) tolua_tousertype(tolua_S,1,0);
1432 int index = ((int) tolua_tonumber(tolua_S,2,0));
1433 fawkes::NavGraphNode tolua_value = *((fawkes::NavGraphNode*) tolua_tousertype(tolua_S,3,0));
1434#ifndef TOLUA_RELEASE
1435 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
1436#endif
1437 bool exc_caught = false;
1438 try {
1439 self->operator[](index) = tolua_value;
1440 } catch (fawkes::Exception &e) {
1441 exc_caught = true;
1442 lua_pushstring(tolua_S, e.what_no_backtrace());
1443 }
1444 catch (std::exception &e) {
1445 exc_caught = true;
1446 lua_pushstring(tolua_S, e.what());
1447 }
1448 if (exc_caught) lua_error(tolua_S);
1449
1450 }
1451 return 0;
1452#ifndef TOLUA_RELEASE
1453 tolua_lerror:
1454 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
1455 return 0;
1456#endif
1457}
1458#endif //#ifndef TOLUA_DISABLE
1459
1460/* method: operator[] of class vector<fawkes::NavGraphNode> */
1461#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_fawkes__NavGraphNode___geti01
1462static int tolua_fawkesnavgraph_vector_fawkes__NavGraphNode___geti01(lua_State* tolua_S)
1463{
1464 tolua_Error tolua_err;
1465 if (
1466 !tolua_isusertype(tolua_S,1,"vector<fawkes::NavGraphNode>",0,&tolua_err) ||
1467 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1468 !tolua_isnoobj(tolua_S,3,&tolua_err)
1469 )
1470 goto tolua_lerror;
1471 else
1472 {
1473 vector<fawkes::NavGraphNode>* self = (vector<fawkes::NavGraphNode>*) tolua_tousertype(tolua_S,1,0);
1474 int index = ((int) tolua_tonumber(tolua_S,2,0));
1475#ifndef TOLUA_RELEASE
1476 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
1477#endif
1478 bool exc_caught = false;
1479 try {
1480 {
1481 fawkes::NavGraphNode tolua_ret = (fawkes::NavGraphNode) self->operator[](index);
1482 {
1483#ifdef __cplusplus
1484 void* tolua_obj = Mtolua_new((fawkes::NavGraphNode)(tolua_ret));
1485 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::NavGraphNode");
1486 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1487#else
1488 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::NavGraphNode));
1489 tolua_pushusertype(tolua_S,tolua_obj,"fawkes::NavGraphNode");
1490 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1491#endif
1492 }
1493 }
1494 } catch (fawkes::Exception &e) {
1495 exc_caught = true;
1496 lua_pushstring(tolua_S, e.what_no_backtrace());
1497 }
1498 catch (std::exception &e) {
1499 exc_caught = true;
1500 lua_pushstring(tolua_S, e.what());
1501 }
1502 if (exc_caught) lua_error(tolua_S);
1503
1504 }
1505 return 1;
1506tolua_lerror:
1507 return tolua_fawkesnavgraph_vector_fawkes__NavGraphNode___geti00(tolua_S);
1508}
1509#endif //#ifndef TOLUA_DISABLE
1510
1511/* method: push_back of class vector<fawkes::NavGraphNode> */
1512#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__push_back00
1513static int tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__push_back00(lua_State* tolua_S)
1514{
1515#ifndef TOLUA_RELEASE
1516 tolua_Error tolua_err;
1517 if (
1518 !tolua_isusertype(tolua_S,1,"vector<fawkes::NavGraphNode>",0,&tolua_err) ||
1519 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::NavGraphNode",0,&tolua_err)) ||
1520 !tolua_isnoobj(tolua_S,3,&tolua_err)
1521 )
1522 goto tolua_lerror;
1523 else
1524#endif
1525 {
1526 vector<fawkes::NavGraphNode>* self = (vector<fawkes::NavGraphNode>*) tolua_tousertype(tolua_S,1,0);
1527 fawkes::NavGraphNode val = *((fawkes::NavGraphNode*) tolua_tousertype(tolua_S,2,0));
1528#ifndef TOLUA_RELEASE
1529 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
1530#endif
1531 bool exc_caught = false;
1532 try {
1533 {
1534 self->push_back(val);
1535 }
1536 } catch (fawkes::Exception &e) {
1537 exc_caught = true;
1538 lua_pushstring(tolua_S, e.what_no_backtrace());
1539 }
1540 catch (std::exception &e) {
1541 exc_caught = true;
1542 lua_pushstring(tolua_S, e.what());
1543 }
1544 if (exc_caught) lua_error(tolua_S);
1545
1546 }
1547 return 0;
1548#ifndef TOLUA_RELEASE
1549 tolua_lerror:
1550 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
1551 return 0;
1552#endif
1553}
1554#endif //#ifndef TOLUA_DISABLE
1555
1556/* method: new of class vector<fawkes::NavGraphNode> */
1557#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__new00
1558static int tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__new00(lua_State* tolua_S)
1559{
1560#ifndef TOLUA_RELEASE
1561 tolua_Error tolua_err;
1562 if (
1563 !tolua_isusertable(tolua_S,1,"vector<fawkes::NavGraphNode>",0,&tolua_err) ||
1564 !tolua_isnoobj(tolua_S,2,&tolua_err)
1565 )
1566 goto tolua_lerror;
1567 else
1568#endif
1569 {
1570 bool exc_caught = false;
1571 try {
1572 {
1573 vector<fawkes::NavGraphNode>* tolua_ret = (vector<fawkes::NavGraphNode>*) Mtolua_new((vector<fawkes::NavGraphNode>)());
1574 tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<fawkes::NavGraphNode>");
1575 }
1576 } catch (fawkes::Exception &e) {
1577 exc_caught = true;
1578 lua_pushstring(tolua_S, e.what_no_backtrace());
1579 }
1580 catch (std::exception &e) {
1581 exc_caught = true;
1582 lua_pushstring(tolua_S, e.what());
1583 }
1584 if (exc_caught) lua_error(tolua_S);
1585
1586 }
1587 return 1;
1588#ifndef TOLUA_RELEASE
1589 tolua_lerror:
1590 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1591 return 0;
1592#endif
1593}
1594#endif //#ifndef TOLUA_DISABLE
1595
1596/* method: new_local of class vector<fawkes::NavGraphNode> */
1597#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__new00_local
1598static int tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__new00_local(lua_State* tolua_S)
1599{
1600#ifndef TOLUA_RELEASE
1601 tolua_Error tolua_err;
1602 if (
1603 !tolua_isusertable(tolua_S,1,"vector<fawkes::NavGraphNode>",0,&tolua_err) ||
1604 !tolua_isnoobj(tolua_S,2,&tolua_err)
1605 )
1606 goto tolua_lerror;
1607 else
1608#endif
1609 {
1610 bool exc_caught = false;
1611 try {
1612 {
1613 vector<fawkes::NavGraphNode>* tolua_ret = (vector<fawkes::NavGraphNode>*) Mtolua_new((vector<fawkes::NavGraphNode>)());
1614 tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<fawkes::NavGraphNode>");
1615 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1616 }
1617 } catch (fawkes::Exception &e) {
1618 exc_caught = true;
1619 lua_pushstring(tolua_S, e.what_no_backtrace());
1620 }
1621 catch (std::exception &e) {
1622 exc_caught = true;
1623 lua_pushstring(tolua_S, e.what());
1624 }
1625 if (exc_caught) lua_error(tolua_S);
1626
1627 }
1628 return 1;
1629#ifndef TOLUA_RELEASE
1630 tolua_lerror:
1631 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1632 return 0;
1633#endif
1634}
1635#endif //#ifndef TOLUA_DISABLE
1636
1637/* method: delete of class vector<fawkes::NavGraphNode> */
1638#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__delete00
1639static int tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__delete00(lua_State* tolua_S)
1640{
1641#ifndef TOLUA_RELEASE
1642 tolua_Error tolua_err;
1643 if (
1644 !tolua_isusertype(tolua_S,1,"vector<fawkes::NavGraphNode>",0,&tolua_err) ||
1645 !tolua_isnoobj(tolua_S,2,&tolua_err)
1646 )
1647 goto tolua_lerror;
1648 else
1649#endif
1650 {
1651 vector<fawkes::NavGraphNode>* self = (vector<fawkes::NavGraphNode>*) tolua_tousertype(tolua_S,1,0);
1652#ifndef TOLUA_RELEASE
1653 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
1654#endif
1655 bool exc_caught = false;
1656 try {
1657 Mtolua_delete(self);
1658 } catch (fawkes::Exception &e) {
1659 exc_caught = true;
1660 lua_pushstring(tolua_S, e.what_no_backtrace());
1661 }
1662 catch (std::exception &e) {
1663 exc_caught = true;
1664 lua_pushstring(tolua_S, e.what());
1665 }
1666 if (exc_caught) lua_error(tolua_S);
1667
1668 }
1669 return 0;
1670#ifndef TOLUA_RELEASE
1671 tolua_lerror:
1672 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
1673 return 0;
1674#endif
1675}
1676#endif //#ifndef TOLUA_DISABLE
1677
1678/* method: new of class fawkes::NavGraphNode */
1679#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraphNode_new00
1680static int tolua_fawkesnavgraph_fawkes_NavGraphNode_new00(lua_State* tolua_S)
1681{
1682#ifndef TOLUA_RELEASE
1683 tolua_Error tolua_err;
1684 if (
1685 !tolua_isusertable(tolua_S,1,"fawkes::NavGraphNode",0,&tolua_err) ||
1686 !tolua_isnoobj(tolua_S,2,&tolua_err)
1687 )
1688 goto tolua_lerror;
1689 else
1690#endif
1691 {
1692 bool exc_caught = false;
1693 try {
1694 {
1695 fawkes::NavGraphNode* tolua_ret = (fawkes::NavGraphNode*) Mtolua_new((fawkes::NavGraphNode)());
1696 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavGraphNode");
1697 }
1698 } catch (fawkes::Exception &e) {
1699 exc_caught = true;
1700 lua_pushstring(tolua_S, e.what_no_backtrace());
1701 }
1702 catch (std::exception &e) {
1703 exc_caught = true;
1704 lua_pushstring(tolua_S, e.what());
1705 }
1706 if (exc_caught) lua_error(tolua_S);
1707
1708 }
1709 return 1;
1710#ifndef TOLUA_RELEASE
1711 tolua_lerror:
1712 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1713 return 0;
1714#endif
1715}
1716#endif //#ifndef TOLUA_DISABLE
1717
1718/* method: new_local of class fawkes::NavGraphNode */
1719#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraphNode_new00_local
1720static int tolua_fawkesnavgraph_fawkes_NavGraphNode_new00_local(lua_State* tolua_S)
1721{
1722#ifndef TOLUA_RELEASE
1723 tolua_Error tolua_err;
1724 if (
1725 !tolua_isusertable(tolua_S,1,"fawkes::NavGraphNode",0,&tolua_err) ||
1726 !tolua_isnoobj(tolua_S,2,&tolua_err)
1727 )
1728 goto tolua_lerror;
1729 else
1730#endif
1731 {
1732 bool exc_caught = false;
1733 try {
1734 {
1735 fawkes::NavGraphNode* tolua_ret = (fawkes::NavGraphNode*) Mtolua_new((fawkes::NavGraphNode)());
1736 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavGraphNode");
1737 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1738 }
1739 } catch (fawkes::Exception &e) {
1740 exc_caught = true;
1741 lua_pushstring(tolua_S, e.what_no_backtrace());
1742 }
1743 catch (std::exception &e) {
1744 exc_caught = true;
1745 lua_pushstring(tolua_S, e.what());
1746 }
1747 if (exc_caught) lua_error(tolua_S);
1748
1749 }
1750 return 1;
1751#ifndef TOLUA_RELEASE
1752 tolua_lerror:
1753 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1754 return 0;
1755#endif
1756}
1757#endif //#ifndef TOLUA_DISABLE
1758
1759/* method: new of class fawkes::NavGraphNode */
1760#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraphNode_new01
1761static int tolua_fawkesnavgraph_fawkes_NavGraphNode_new01(lua_State* tolua_S)
1762{
1763 tolua_Error tolua_err;
1764 if (
1765 !tolua_isusertable(tolua_S,1,"fawkes::NavGraphNode",0,&tolua_err) ||
1766 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
1767 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1768 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
1769 !tolua_isnoobj(tolua_S,5,&tolua_err)
1770 )
1771 goto tolua_lerror;
1772 else
1773 {
1774 string name = ((string) tolua_tocppstring(tolua_S,2,0));
1775 double x = ((double) tolua_tonumber(tolua_S,3,0));
1776 double y = ((double) tolua_tonumber(tolua_S,4,0));
1777 bool exc_caught = false;
1778 try {
1779 {
1780 fawkes::NavGraphNode* tolua_ret = (fawkes::NavGraphNode*) Mtolua_new((fawkes::NavGraphNode)(name,x,y));
1781 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavGraphNode");
1782 }
1783 } catch (fawkes::Exception &e) {
1784 exc_caught = true;
1785 lua_pushstring(tolua_S, e.what_no_backtrace());
1786 }
1787 catch (std::exception &e) {
1788 exc_caught = true;
1789 lua_pushstring(tolua_S, e.what());
1790 }
1791 if (exc_caught) lua_error(tolua_S);
1792
1793 }
1794 return 1;
1795tolua_lerror:
1796 return tolua_fawkesnavgraph_fawkes_NavGraphNode_new00(tolua_S);
1797}
1798#endif //#ifndef TOLUA_DISABLE
1799
1800/* method: new_local of class fawkes::NavGraphNode */
1801#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraphNode_new01_local
1802static int tolua_fawkesnavgraph_fawkes_NavGraphNode_new01_local(lua_State* tolua_S)
1803{
1804 tolua_Error tolua_err;
1805 if (
1806 !tolua_isusertable(tolua_S,1,"fawkes::NavGraphNode",0,&tolua_err) ||
1807 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
1808 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1809 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
1810 !tolua_isnoobj(tolua_S,5,&tolua_err)
1811 )
1812 goto tolua_lerror;
1813 else
1814 {
1815 string name = ((string) tolua_tocppstring(tolua_S,2,0));
1816 double x = ((double) tolua_tonumber(tolua_S,3,0));
1817 double y = ((double) tolua_tonumber(tolua_S,4,0));
1818 bool exc_caught = false;
1819 try {
1820 {
1821 fawkes::NavGraphNode* tolua_ret = (fawkes::NavGraphNode*) Mtolua_new((fawkes::NavGraphNode)(name,x,y));
1822 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavGraphNode");
1823 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1824 }
1825 } catch (fawkes::Exception &e) {
1826 exc_caught = true;
1827 lua_pushstring(tolua_S, e.what_no_backtrace());
1828 }
1829 catch (std::exception &e) {
1830 exc_caught = true;
1831 lua_pushstring(tolua_S, e.what());
1832 }
1833 if (exc_caught) lua_error(tolua_S);
1834
1835 }
1836 return 1;
1837tolua_lerror:
1838 return tolua_fawkesnavgraph_fawkes_NavGraphNode_new00_local(tolua_S);
1839}
1840#endif //#ifndef TOLUA_DISABLE
1841
1842/* method: name of class fawkes::NavGraphNode */
1843#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraphNode_name00
1844static int tolua_fawkesnavgraph_fawkes_NavGraphNode_name00(lua_State* tolua_S)
1845{
1846#ifndef TOLUA_RELEASE
1847 tolua_Error tolua_err;
1848 if (
1849 !tolua_isusertype(tolua_S,1,"const fawkes::NavGraphNode",0,&tolua_err) ||
1850 !tolua_isnoobj(tolua_S,2,&tolua_err)
1851 )
1852 goto tolua_lerror;
1853 else
1854#endif
1855 {
1856 const fawkes::NavGraphNode* self = (const fawkes::NavGraphNode*) tolua_tousertype(tolua_S,1,0);
1857#ifndef TOLUA_RELEASE
1858 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL);
1859#endif
1860 bool exc_caught = false;
1861 try {
1862 {
1863 string tolua_ret = (string) self->name();
1864 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
1865 }
1866 } catch (fawkes::Exception &e) {
1867 exc_caught = true;
1868 lua_pushstring(tolua_S, e.what_no_backtrace());
1869 }
1870 catch (std::exception &e) {
1871 exc_caught = true;
1872 lua_pushstring(tolua_S, e.what());
1873 }
1874 if (exc_caught) lua_error(tolua_S);
1875
1876 }
1877 return 1;
1878#ifndef TOLUA_RELEASE
1879 tolua_lerror:
1880 tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
1881 return 0;
1882#endif
1883}
1884#endif //#ifndef TOLUA_DISABLE
1885
1886/* method: x of class fawkes::NavGraphNode */
1887#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraphNode_x00
1888static int tolua_fawkesnavgraph_fawkes_NavGraphNode_x00(lua_State* tolua_S)
1889{
1890#ifndef TOLUA_RELEASE
1891 tolua_Error tolua_err;
1892 if (
1893 !tolua_isusertype(tolua_S,1,"const fawkes::NavGraphNode",0,&tolua_err) ||
1894 !tolua_isnoobj(tolua_S,2,&tolua_err)
1895 )
1896 goto tolua_lerror;
1897 else
1898#endif
1899 {
1900 const fawkes::NavGraphNode* self = (const fawkes::NavGraphNode*) tolua_tousertype(tolua_S,1,0);
1901#ifndef TOLUA_RELEASE
1902 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
1903#endif
1904 bool exc_caught = false;
1905 try {
1906 {
1907 float tolua_ret = (float) self->x();
1908 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1909 }
1910 } catch (fawkes::Exception &e) {
1911 exc_caught = true;
1912 lua_pushstring(tolua_S, e.what_no_backtrace());
1913 }
1914 catch (std::exception &e) {
1915 exc_caught = true;
1916 lua_pushstring(tolua_S, e.what());
1917 }
1918 if (exc_caught) lua_error(tolua_S);
1919
1920 }
1921 return 1;
1922#ifndef TOLUA_RELEASE
1923 tolua_lerror:
1924 tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
1925 return 0;
1926#endif
1927}
1928#endif //#ifndef TOLUA_DISABLE
1929
1930/* method: y of class fawkes::NavGraphNode */
1931#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraphNode_y00
1932static int tolua_fawkesnavgraph_fawkes_NavGraphNode_y00(lua_State* tolua_S)
1933{
1934#ifndef TOLUA_RELEASE
1935 tolua_Error tolua_err;
1936 if (
1937 !tolua_isusertype(tolua_S,1,"const fawkes::NavGraphNode",0,&tolua_err) ||
1938 !tolua_isnoobj(tolua_S,2,&tolua_err)
1939 )
1940 goto tolua_lerror;
1941 else
1942#endif
1943 {
1944 const fawkes::NavGraphNode* self = (const fawkes::NavGraphNode*) tolua_tousertype(tolua_S,1,0);
1945#ifndef TOLUA_RELEASE
1946 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
1947#endif
1948 bool exc_caught = false;
1949 try {
1950 {
1951 float tolua_ret = (float) self->y();
1952 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1953 }
1954 } catch (fawkes::Exception &e) {
1955 exc_caught = true;
1956 lua_pushstring(tolua_S, e.what_no_backtrace());
1957 }
1958 catch (std::exception &e) {
1959 exc_caught = true;
1960 lua_pushstring(tolua_S, e.what());
1961 }
1962 if (exc_caught) lua_error(tolua_S);
1963
1964 }
1965 return 1;
1966#ifndef TOLUA_RELEASE
1967 tolua_lerror:
1968 tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
1969 return 0;
1970#endif
1971}
1972#endif //#ifndef TOLUA_DISABLE
1973
1974/* method: is_valid of class fawkes::NavGraphNode */
1975#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraphNode_is_valid00
1976static int tolua_fawkesnavgraph_fawkes_NavGraphNode_is_valid00(lua_State* tolua_S)
1977{
1978#ifndef TOLUA_RELEASE
1979 tolua_Error tolua_err;
1980 if (
1981 !tolua_isusertype(tolua_S,1,"const fawkes::NavGraphNode",0,&tolua_err) ||
1982 !tolua_isnoobj(tolua_S,2,&tolua_err)
1983 )
1984 goto tolua_lerror;
1985 else
1986#endif
1987 {
1988 const fawkes::NavGraphNode* self = (const fawkes::NavGraphNode*) tolua_tousertype(tolua_S,1,0);
1989#ifndef TOLUA_RELEASE
1990 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_valid'", NULL);
1991#endif
1992 bool exc_caught = false;
1993 try {
1994 {
1995 bool tolua_ret = (bool) self->is_valid();
1996 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1997 }
1998 } catch (fawkes::Exception &e) {
1999 exc_caught = true;
2000 lua_pushstring(tolua_S, e.what_no_backtrace());
2001 }
2002 catch (std::exception &e) {
2003 exc_caught = true;
2004 lua_pushstring(tolua_S, e.what());
2005 }
2006 if (exc_caught) lua_error(tolua_S);
2007
2008 }
2009 return 1;
2010#ifndef TOLUA_RELEASE
2011 tolua_lerror:
2012 tolua_error(tolua_S,"#ferror in function 'is_valid'.",&tolua_err);
2013 return 0;
2014#endif
2015}
2016#endif //#ifndef TOLUA_DISABLE
2017
2018/* method: reachable_nodes of class fawkes::NavGraphNode */
2019#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraphNode_reachable_nodes00
2020static int tolua_fawkesnavgraph_fawkes_NavGraphNode_reachable_nodes00(lua_State* tolua_S)
2021{
2022#ifndef TOLUA_RELEASE
2023 tolua_Error tolua_err;
2024 if (
2025 !tolua_isusertype(tolua_S,1,"fawkes::NavGraphNode",0,&tolua_err) ||
2026 !tolua_isnoobj(tolua_S,2,&tolua_err)
2027 )
2028 goto tolua_lerror;
2029 else
2030#endif
2031 {
2032 fawkes::NavGraphNode* self = (fawkes::NavGraphNode*) tolua_tousertype(tolua_S,1,0);
2033#ifndef TOLUA_RELEASE
2034 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reachable_nodes'", NULL);
2035#endif
2036 bool exc_caught = false;
2037 try {
2038 {
2039 vector<string>& tolua_ret = (vector<string>&) self->reachable_nodes();
2040 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"vector<string>");
2041 }
2042 } catch (fawkes::Exception &e) {
2043 exc_caught = true;
2044 lua_pushstring(tolua_S, e.what_no_backtrace());
2045 }
2046 catch (std::exception &e) {
2047 exc_caught = true;
2048 lua_pushstring(tolua_S, e.what());
2049 }
2050 if (exc_caught) lua_error(tolua_S);
2051
2052 }
2053 return 1;
2054#ifndef TOLUA_RELEASE
2055 tolua_lerror:
2056 tolua_error(tolua_S,"#ferror in function 'reachable_nodes'.",&tolua_err);
2057 return 0;
2058#endif
2059}
2060#endif //#ifndef TOLUA_DISABLE
2061
2062/* method: has_property of class fawkes::NavGraphNode */
2063#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraphNode_has_property00
2064static int tolua_fawkesnavgraph_fawkes_NavGraphNode_has_property00(lua_State* tolua_S)
2065{
2066#ifndef TOLUA_RELEASE
2067 tolua_Error tolua_err;
2068 if (
2069 !tolua_isusertype(tolua_S,1,"fawkes::NavGraphNode",0,&tolua_err) ||
2070 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
2071 !tolua_isnoobj(tolua_S,3,&tolua_err)
2072 )
2073 goto tolua_lerror;
2074 else
2075#endif
2076 {
2077 fawkes::NavGraphNode* self = (fawkes::NavGraphNode*) tolua_tousertype(tolua_S,1,0);
2078 string property = ((string) tolua_tocppstring(tolua_S,2,0));
2079#ifndef TOLUA_RELEASE
2080 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_property'", NULL);
2081#endif
2082 bool exc_caught = false;
2083 try {
2084 {
2085 bool tolua_ret = (bool) self->has_property(property);
2086 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2087 }
2088 } catch (fawkes::Exception &e) {
2089 exc_caught = true;
2090 lua_pushstring(tolua_S, e.what_no_backtrace());
2091 }
2092 catch (std::exception &e) {
2093 exc_caught = true;
2094 lua_pushstring(tolua_S, e.what());
2095 }
2096 if (exc_caught) lua_error(tolua_S);
2097
2098 }
2099 return 1;
2100#ifndef TOLUA_RELEASE
2101 tolua_lerror:
2102 tolua_error(tolua_S,"#ferror in function 'has_property'.",&tolua_err);
2103 return 0;
2104#endif
2105}
2106#endif //#ifndef TOLUA_DISABLE
2107
2108/* method: property_as_float of class fawkes::NavGraphNode */
2109#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraphNode_property_as_float00
2110static int tolua_fawkesnavgraph_fawkes_NavGraphNode_property_as_float00(lua_State* tolua_S)
2111{
2112#ifndef TOLUA_RELEASE
2113 tolua_Error tolua_err;
2114 if (
2115 !tolua_isusertype(tolua_S,1,"fawkes::NavGraphNode",0,&tolua_err) ||
2116 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
2117 !tolua_isnoobj(tolua_S,3,&tolua_err)
2118 )
2119 goto tolua_lerror;
2120 else
2121#endif
2122 {
2123 fawkes::NavGraphNode* self = (fawkes::NavGraphNode*) tolua_tousertype(tolua_S,1,0);
2124 string prop = ((string) tolua_tocppstring(tolua_S,2,0));
2125#ifndef TOLUA_RELEASE
2126 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'property_as_float'", NULL);
2127#endif
2128 bool exc_caught = false;
2129 try {
2130 {
2131 float tolua_ret = (float) self->property_as_float(prop);
2132 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2133 }
2134 } catch (fawkes::Exception &e) {
2135 exc_caught = true;
2136 lua_pushstring(tolua_S, e.what_no_backtrace());
2137 }
2138 catch (std::exception &e) {
2139 exc_caught = true;
2140 lua_pushstring(tolua_S, e.what());
2141 }
2142 if (exc_caught) lua_error(tolua_S);
2143
2144 }
2145 return 1;
2146#ifndef TOLUA_RELEASE
2147 tolua_lerror:
2148 tolua_error(tolua_S,"#ferror in function 'property_as_float'.",&tolua_err);
2149 return 0;
2150#endif
2151}
2152#endif //#ifndef TOLUA_DISABLE
2153
2154/* method: property_as_int of class fawkes::NavGraphNode */
2155#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraphNode_property_as_int00
2156static int tolua_fawkesnavgraph_fawkes_NavGraphNode_property_as_int00(lua_State* tolua_S)
2157{
2158#ifndef TOLUA_RELEASE
2159 tolua_Error tolua_err;
2160 if (
2161 !tolua_isusertype(tolua_S,1,"fawkes::NavGraphNode",0,&tolua_err) ||
2162 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
2163 !tolua_isnoobj(tolua_S,3,&tolua_err)
2164 )
2165 goto tolua_lerror;
2166 else
2167#endif
2168 {
2169 fawkes::NavGraphNode* self = (fawkes::NavGraphNode*) tolua_tousertype(tolua_S,1,0);
2170 string prop = ((string) tolua_tocppstring(tolua_S,2,0));
2171#ifndef TOLUA_RELEASE
2172 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'property_as_int'", NULL);
2173#endif
2174 bool exc_caught = false;
2175 try {
2176 {
2177 int tolua_ret = (int) self->property_as_int(prop);
2178 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2179 }
2180 } catch (fawkes::Exception &e) {
2181 exc_caught = true;
2182 lua_pushstring(tolua_S, e.what_no_backtrace());
2183 }
2184 catch (std::exception &e) {
2185 exc_caught = true;
2186 lua_pushstring(tolua_S, e.what());
2187 }
2188 if (exc_caught) lua_error(tolua_S);
2189
2190 }
2191 return 1;
2192#ifndef TOLUA_RELEASE
2193 tolua_lerror:
2194 tolua_error(tolua_S,"#ferror in function 'property_as_int'.",&tolua_err);
2195 return 0;
2196#endif
2197}
2198#endif //#ifndef TOLUA_DISABLE
2199
2200/* method: property_as_bool of class fawkes::NavGraphNode */
2201#ifndef TOLUA_DISABLE_tolua_fawkesnavgraph_fawkes_NavGraphNode_property_as_bool00
2202static int tolua_fawkesnavgraph_fawkes_NavGraphNode_property_as_bool00(lua_State* tolua_S)
2203{
2204#ifndef TOLUA_RELEASE
2205 tolua_Error tolua_err;
2206 if (
2207 !tolua_isusertype(tolua_S,1,"fawkes::NavGraphNode",0,&tolua_err) ||
2208 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
2209 !tolua_isnoobj(tolua_S,3,&tolua_err)
2210 )
2211 goto tolua_lerror;
2212 else
2213#endif
2214 {
2215 fawkes::NavGraphNode* self = (fawkes::NavGraphNode*) tolua_tousertype(tolua_S,1,0);
2216 string prop = ((string) tolua_tocppstring(tolua_S,2,0));
2217#ifndef TOLUA_RELEASE
2218 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'property_as_bool'", NULL);
2219#endif
2220 bool exc_caught = false;
2221 try {
2222 {
2223 bool tolua_ret = (bool) self->property_as_bool(prop);
2224 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2225 }
2226 } catch (fawkes::Exception &e) {
2227 exc_caught = true;
2228 lua_pushstring(tolua_S, e.what_no_backtrace());
2229 }
2230 catch (std::exception &e) {
2231 exc_caught = true;
2232 lua_pushstring(tolua_S, e.what());
2233 }
2234 if (exc_caught) lua_error(tolua_S);
2235
2236 }
2237 return 1;
2238#ifndef TOLUA_RELEASE
2239 tolua_lerror:
2240 tolua_error(tolua_S,"#ferror in function 'property_as_bool'.",&tolua_err);
2241 return 0;
2242#endif
2243}
2244#endif //#ifndef TOLUA_DISABLE
2245
2246/* Open function */
2247TOLUA_API int tolua_fawkesnavgraph_open (lua_State* tolua_S)
2248{
2249 tolua_open(tolua_S);
2250 tolua_reg_types(tolua_S);
2251 tolua_module(tolua_S,NULL,0);
2252 tolua_beginmodule(tolua_S,NULL);
2253 tolua_module(tolua_S,"fawkes",0);
2254 tolua_beginmodule(tolua_S,"fawkes");
2255 #ifdef __cplusplus
2256 tolua_cclass(tolua_S,"NavGraph","fawkes::NavGraph","",tolua_collect_fawkes__NavGraph);
2257 #else
2258 tolua_cclass(tolua_S,"NavGraph","fawkes::NavGraph","",NULL);
2259 #endif
2260 tolua_beginmodule(tolua_S,"NavGraph");
2261 tolua_function(tolua_S,"new",tolua_fawkesnavgraph_fawkes_NavGraph_new00);
2262 tolua_function(tolua_S,"new_local",tolua_fawkesnavgraph_fawkes_NavGraph_new00_local);
2263 tolua_function(tolua_S,".call",tolua_fawkesnavgraph_fawkes_NavGraph_new00_local);
2264 tolua_function(tolua_S,"delete",tolua_fawkesnavgraph_fawkes_NavGraph_delete00);
2265 tolua_function(tolua_S,"name",tolua_fawkesnavgraph_fawkes_NavGraph_name00);
2266 tolua_function(tolua_S,"nodes",tolua_fawkesnavgraph_fawkes_NavGraph_nodes00);
2267 tolua_function(tolua_S,"node",tolua_fawkesnavgraph_fawkes_NavGraph_node00);
2268 tolua_function(tolua_S,"closest_node",tolua_fawkesnavgraph_fawkes_NavGraph_closest_node00);
2269 tolua_function(tolua_S,"closest_node_to",tolua_fawkesnavgraph_fawkes_NavGraph_closest_node_to00);
2270 tolua_function(tolua_S,"closest_node_with_unconnected",tolua_fawkesnavgraph_fawkes_NavGraph_closest_node_with_unconnected00);
2271 tolua_function(tolua_S,"closest_node_to_with_unconnected",tolua_fawkesnavgraph_fawkes_NavGraph_closest_node_to_with_unconnected00);
2272 tolua_function(tolua_S,"search_nodes",tolua_fawkesnavgraph_fawkes_NavGraph_search_nodes00);
2273 tolua_function(tolua_S,"default_property",tolua_fawkesnavgraph_fawkes_NavGraph_default_property00);
2274 tolua_function(tolua_S,"default_property_as_float",tolua_fawkesnavgraph_fawkes_NavGraph_default_property_as_float00);
2275 tolua_function(tolua_S,"default_property_as_int",tolua_fawkesnavgraph_fawkes_NavGraph_default_property_as_int00);
2276 tolua_function(tolua_S,"default_property_as_bool",tolua_fawkesnavgraph_fawkes_NavGraph_default_property_as_bool00);
2277 tolua_endmodule(tolua_S);
2278 tolua_function(tolua_S,"load_yaml_navgraph",tolua_fawkesnavgraph_fawkes_load_yaml_navgraph00);
2279 tolua_endmodule(tolua_S);
2280 #ifdef __cplusplus
2281 tolua_cclass(tolua_S,"vector_string_","vector<string>","",tolua_collect_vector_string_);
2282 #else
2283 tolua_cclass(tolua_S,"vector_string_","vector<string>","",NULL);
2284 #endif
2285 tolua_beginmodule(tolua_S,"vector_string_");
2286 tolua_function(tolua_S,"clear",tolua_fawkesnavgraph_vector_string__clear00);
2287 tolua_function(tolua_S,"size",tolua_fawkesnavgraph_vector_string__size00);
2288 tolua_function(tolua_S,".geti",tolua_fawkesnavgraph_vector_string___geti00);
2289 tolua_function(tolua_S,".seti",tolua_fawkesnavgraph_vector_string___seti00);
2290 tolua_function(tolua_S,".geti",tolua_fawkesnavgraph_vector_string___geti01);
2291 tolua_function(tolua_S,"push_back",tolua_fawkesnavgraph_vector_string__push_back00);
2292 tolua_function(tolua_S,"new",tolua_fawkesnavgraph_vector_string__new00);
2293 tolua_function(tolua_S,"new_local",tolua_fawkesnavgraph_vector_string__new00_local);
2294 tolua_function(tolua_S,".call",tolua_fawkesnavgraph_vector_string__new00_local);
2295 tolua_function(tolua_S,"delete",tolua_fawkesnavgraph_vector_string__delete00);
2296 tolua_endmodule(tolua_S);
2297 #ifdef __cplusplus
2298 tolua_cclass(tolua_S,"vector_fawkes__NavGraphNode_","vector<fawkes::NavGraphNode>","",tolua_collect_vector_fawkes__NavGraphNode_);
2299 #else
2300 tolua_cclass(tolua_S,"vector_fawkes__NavGraphNode_","vector<fawkes::NavGraphNode>","",NULL);
2301 #endif
2302 tolua_beginmodule(tolua_S,"vector_fawkes__NavGraphNode_");
2303 tolua_function(tolua_S,"clear",tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__clear00);
2304 tolua_function(tolua_S,"size",tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__size00);
2305 tolua_function(tolua_S,".geti",tolua_fawkesnavgraph_vector_fawkes__NavGraphNode___geti00);
2306 tolua_function(tolua_S,".seti",tolua_fawkesnavgraph_vector_fawkes__NavGraphNode___seti00);
2307 tolua_function(tolua_S,".geti",tolua_fawkesnavgraph_vector_fawkes__NavGraphNode___geti01);
2308 tolua_function(tolua_S,"push_back",tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__push_back00);
2309 tolua_function(tolua_S,"new",tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__new00);
2310 tolua_function(tolua_S,"new_local",tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__new00_local);
2311 tolua_function(tolua_S,".call",tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__new00_local);
2312 tolua_function(tolua_S,"delete",tolua_fawkesnavgraph_vector_fawkes__NavGraphNode__delete00);
2313 tolua_endmodule(tolua_S);
2314 tolua_module(tolua_S,"fawkes",0);
2315 tolua_beginmodule(tolua_S,"fawkes");
2316 #ifdef __cplusplus
2317 tolua_cclass(tolua_S,"NavGraphNode","fawkes::NavGraphNode","",tolua_collect_fawkes__NavGraphNode);
2318 #else
2319 tolua_cclass(tolua_S,"NavGraphNode","fawkes::NavGraphNode","",NULL);
2320 #endif
2321 tolua_beginmodule(tolua_S,"NavGraphNode");
2322 tolua_function(tolua_S,"new",tolua_fawkesnavgraph_fawkes_NavGraphNode_new00);
2323 tolua_function(tolua_S,"new_local",tolua_fawkesnavgraph_fawkes_NavGraphNode_new00_local);
2324 tolua_function(tolua_S,".call",tolua_fawkesnavgraph_fawkes_NavGraphNode_new00_local);
2325 tolua_function(tolua_S,"new",tolua_fawkesnavgraph_fawkes_NavGraphNode_new01);
2326 tolua_function(tolua_S,"new_local",tolua_fawkesnavgraph_fawkes_NavGraphNode_new01_local);
2327 tolua_function(tolua_S,".call",tolua_fawkesnavgraph_fawkes_NavGraphNode_new01_local);
2328 tolua_function(tolua_S,"name",tolua_fawkesnavgraph_fawkes_NavGraphNode_name00);
2329 tolua_function(tolua_S,"x",tolua_fawkesnavgraph_fawkes_NavGraphNode_x00);
2330 tolua_function(tolua_S,"y",tolua_fawkesnavgraph_fawkes_NavGraphNode_y00);
2331 tolua_function(tolua_S,"is_valid",tolua_fawkesnavgraph_fawkes_NavGraphNode_is_valid00);
2332 tolua_function(tolua_S,"reachable_nodes",tolua_fawkesnavgraph_fawkes_NavGraphNode_reachable_nodes00);
2333 tolua_function(tolua_S,"has_property",tolua_fawkesnavgraph_fawkes_NavGraphNode_has_property00);
2334 tolua_function(tolua_S,"property_as_float",tolua_fawkesnavgraph_fawkes_NavGraphNode_property_as_float00);
2335 tolua_function(tolua_S,"property_as_int",tolua_fawkesnavgraph_fawkes_NavGraphNode_property_as_int00);
2336 tolua_function(tolua_S,"property_as_bool",tolua_fawkesnavgraph_fawkes_NavGraphNode_property_as_bool00);
2337 tolua_endmodule(tolua_S);
2338 tolua_endmodule(tolua_S);
2339 tolua_endmodule(tolua_S);
2340 return 1;
2341}
2342
2343
2344extern "C" {
2345#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
2346 TOLUA_API int luaopen_fawkesnavgraph (lua_State* tolua_S) {
2347 return tolua_fawkesnavgraph_open(tolua_S);
2348};
2349#endif
2350}
2351
2352
Base class for exceptions in Fawkes.
Definition: exception.h:36
virtual const char * what_no_backtrace() const noexcept
Get primary string (does not implicitly print the back trace).
Definition: exception.cpp:663
Topological graph node.
Definition: navgraph_node.h:36
float x() const
Get X coordinate in global frame.
Definition: navgraph_node.h:58
bool property_as_bool(const std::string &prop) const
Get property converted to bol.
bool is_valid() const
Check if node is valid, i.e.
int property_as_int(const std::string &prop) const
Get property converted to int.
const std::string & name() const
Get name of node.
Definition: navgraph_node.h:50
float property_as_float(const std::string &prop) const
Get property converted to float.
bool has_property(const std::string &property) const
Check if node has specified property.
float y() const
Get Y coordinate in global frame.
Definition: navgraph_node.h:66
const std::vector< std::string > & reachable_nodes() const
Get reachable nodes.
Topological map graph.
Definition: navgraph.h:50
NavGraphNode closest_node_to_with_unconnected(const std::string &node_name, const std::string &property="") const
Get node closest to another node with a certain property.
Definition: navgraph.cpp:231
NavGraphNode closest_node_with_unconnected(float pos_x, float pos_y, const std::string &property="") const
Get node closest to a specified point with a certain property.
Definition: navgraph.cpp:201
bool default_property_as_bool(const std::string &prop) const
Get property converted to bol.
Definition: navgraph.cpp:814
std::string default_property(const std::string &prop) const
Get specified default property as string.
Definition: navgraph.cpp:779
NavGraphNode closest_node(float pos_x, float pos_y, const std::string &property="") const
Get node closest to a specified point with a certain property.
Definition: navgraph.cpp:186
std::vector< NavGraphNode > search_nodes(const std::string &property) const
Search nodes for given property.
Definition: navgraph.cpp:386
int default_property_as_int(const std::string &prop) const
Get property converted to int.
Definition: navgraph.cpp:804
const std::vector< NavGraphNode > & nodes() const
Get nodes of the graph.
Definition: navgraph.cpp:133
float default_property_as_float(const std::string &prop) const
Get property converted to float.
Definition: navgraph.cpp:794
NavGraphNode node(const std::string &name) const
Get a specified node.
Definition: navgraph.cpp:163
std::string name() const
Get graph name.
Definition: navgraph.cpp:124
NavGraphNode closest_node_to(const std::string &node_name, const std::string &property="") const
Get node closest to another node with a certain property.
Definition: navgraph.cpp:216
Fawkes library namespace.
NavGraph * load_yaml_navgraph(std::string filename, bool allow_multi_graph)
Load topological map graph stored in RCSoft format.