hpp-corbaserver 5.0.0
Corba server for Humanoid Path Planner applications
Loading...
Searching...
No Matches
path_planners.hh
Go to the documentation of this file.
1#ifndef hpp_core_idl__path__planners_hxx__
2#define hpp_core_idl__path__planners_hxx__
3
4//
5// Implemention of IDL interfaces in file /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-5.0.0/idl/hpp/core_idl/path_planners.idl
6//
7
9
10#include <sstream>
11
15
16
17
18//
19// Implementational code for IDL interface hpp::core_idl::ConnectedComponent
20//
21namespace hpp {
22
23namespace core_impl {
24template <typename _Base, typename _Storage>
26 const _Storage& s)
27 : hpp::corbaServer::ServantBase<hpp::core::ConnectedComponent, _Storage> (server, s)
28{
29 // add extra constructor code here
30}
31template <typename _Base, typename _Storage>
33{
34 // add extra destructor code here
35}
36
37// Methods corresponding to IDL attributes and operations
38
39template <typename _Base, typename _Storage>
41{
42 try {
43 // automatically generated code.
44 _ServantBase::deleteThis();
45 } catch (const std::exception& e) {
46 throw ::hpp::Error (e.what());
47 }
48}
49
50template <typename _Base, typename _Storage>
52{
53 try {
54 // automatically generated code.
55 return _ServantBase::deleteIfExpired();
56 } catch (const std::exception& e) {
57 throw ::hpp::Error (e.what());
58 }
59}
60
61template <typename _Base, typename _Storage>
63{
64 try {
65 // automatically generated code.
66 _ServantBase::persistantStorage(persistant);
67 } catch (const std::exception& e) {
68 throw ::hpp::Error (e.what());
69 }
70}
71
72template <typename _Base, typename _Storage>
74{
75 try {
76 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-5.0.0/idl/hpp/core_idl/path_planners.idl:22
77 hpp::core::NodeVector_t nodes = getT()->nodes();
78 hpp::core::matrix_t configs (nodes.size(),
79 nodes[0]->configuration().size());
80 size_type i = 0;
81 for (hpp::core::NodeVector_t::const_iterator _node = nodes.begin();
82 _node != nodes.end(); ++_node)
83 configs.row(i++) = (*_node)->configuration();
85
86 } catch (const std::exception& e) {
87 throw ::hpp::Error (e.what());
88 }
89}
90
91// End of implementational code
92} // namespace core_impl
93
94} // namespace hpp
95
96//
97// Implementational code for IDL interface hpp::core_idl::Roadmap
98//
99namespace hpp {
100
101namespace core_impl {
102template <typename _Base, typename _Storage>
104 const _Storage& s)
105 : hpp::corbaServer::ServantBase<hpp::core::Roadmap, _Storage> (server, s)
106{
107 // add extra constructor code here
108}
109template <typename _Base, typename _Storage>
111{
112 // add extra destructor code here
113}
114
115// Methods corresponding to IDL attributes and operations
116
117template <typename _Base, typename _Storage>
119{
120 try {
121 // automatically generated code.
122 _ServantBase::deleteThis();
123 } catch (const std::exception& e) {
124 throw ::hpp::Error (e.what());
125 }
126}
127
128template <typename _Base, typename _Storage>
130{
131 try {
132 // automatically generated code.
133 return _ServantBase::deleteIfExpired();
134 } catch (const std::exception& e) {
135 throw ::hpp::Error (e.what());
136 }
137}
138
139template <typename _Base, typename _Storage>
141{
142 try {
143 // automatically generated code.
144 _ServantBase::persistantStorage(persistant);
145 } catch (const std::exception& e) {
146 throw ::hpp::Error (e.what());
147 }
148}
149
150template <typename _Base, typename _Storage>
152{
153 try {
154 // automatically generated code.
155
156 (getT()->clear ());
157
158
159 } catch (const std::exception& e) {
160 throw ::hpp::Error (e.what());
161 }
162}
163
164template <typename _Base, typename _Storage>
166{
167 try {
168 // automatically generated code.
169 hpp::core::vector_t _config = hpp::corbaServer::floatSeqToVector (config);
170 (getT()->addNode (_config));
171
172
173 } catch (const std::exception& e) {
174 throw ::hpp::Error (e.what());
175 }
176}
177
178template <typename _Base, typename _Storage>
179void RoadmapServant<_Base, _Storage>::addNodeAndEdge (const hpp::floatSeq& cfgfrom, const hpp::floatSeq& cfgto, hpp::core_idl::Path_ptr path_)
180{
181 try {
182 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-5.0.0/idl/hpp/core_idl/path_planners.idl:37
183 core::PathPtr_t path (corbaServer::reference_to_servant_base<core::Path>(server_, path_)->get());
184 getT()->addEdge(getT()->addNode(corbaServer::floatSeqToVector(cfgfrom)),
185 getT()->addNode(corbaServer::floatSeqToVector(cfgto )), path);
186
187 } catch (const std::exception& e) {
188 throw ::hpp::Error (e.what());
189 }
190}
191
192template <typename _Base, typename _Storage>
193void RoadmapServant<_Base, _Storage>::addNodeAndEdges (const hpp::floatSeq& cfgfrom, const hpp::floatSeq& cfgto, hpp::core_idl::Path_ptr path_)
194{
195 try {
196 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-5.0.0/idl/hpp/core_idl/path_planners.idl:37
197 core::PathPtr_t path (corbaServer::reference_to_servant_base<core::Path>(server_, path_)->get());
198 getT()->addEdges(getT()->addNode(corbaServer::floatSeqToVector(cfgfrom)),
199 getT()->addNode(corbaServer::floatSeqToVector(cfgto )), path);
200
201 } catch (const std::exception& e) {
202 throw ::hpp::Error (e.what());
203 }
204}
205
206template <typename _Base, typename _Storage>
208{
209 try {
210 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-5.0.0/idl/hpp/core_idl/path_planners.idl:37
211 return corbaServer::vectorToFloatSeq(getT()->nearestNode(
212 corbaServer::floatSeqToVector(config), distance, reverse)->configuration());
213
214 } catch (const std::exception& e) {
215 throw ::hpp::Error (e.what());
216 }
217}
218
219template <typename _Base, typename _Storage>
221{
222 try {
223 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-5.0.0/idl/hpp/core_idl/path_planners.idl:37
224 hpp::core::Nodes_t nodes = getT()->nearestNodes(
226 hpp::core::matrix_t configs (nodes.size(), config.length());
227 size_type i = 0;
228 for (hpp::core::Nodes_t::const_iterator _node = nodes.begin(); _node != nodes.end(); ++_node)
229 configs.row(i++) = (*_node)->configuration();
230 return corbaServer::matrixToFloatSeqSeq(configs);
231
232 } catch (const std::exception& e) {
233 throw ::hpp::Error (e.what());
234 }
235}
236
237template <typename _Base, typename _Storage>
239{
240 try {
241 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-5.0.0/idl/hpp/core_idl/path_planners.idl:37
242 return getT()->nodes().size();
243
244 } catch (const std::exception& e) {
245 throw ::hpp::Error (e.what());
246 }
247}
248
249template <typename _Base, typename _Storage>
251{
252 try {
253 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-5.0.0/idl/hpp/core_idl/path_planners.idl:37
254 return corbaServer::vectorToFloatSeq((*std::next(getT()->nodes().begin(), i))->configuration());
255
256 } catch (const std::exception& e) {
257 throw ::hpp::Error (e.what());
258 }
259}
260
261template <typename _Base, typename _Storage>
263{
264 try {
265 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-5.0.0/idl/hpp/core_idl/path_planners.idl:37
266 return getT()->edges().size();
267
268 } catch (const std::exception& e) {
269 throw ::hpp::Error (e.what());
270 }
271}
272
273template <typename _Base, typename _Storage>
275{
276 try {
277 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-5.0.0/idl/hpp/core_idl/path_planners.idl:37
278 return corbaServer::makeServant<hpp::core_idl::Path_ptr> (server_,
279 new Path (server_, (*std::next(getT()->edges().begin(),i))->path()));
280
281 } catch (const std::exception& e) {
282 throw ::hpp::Error (e.what());
283 }
284}
285
286template <typename _Base, typename _Storage>
288{
289 try {
290 // automatically generated code.
291
293
294 return __return__;
295 } catch (const std::exception& e) {
296 throw ::hpp::Error (e.what());
297 }
298}
299
300// End of implementational code
301} // namespace core_impl
302
303} // namespace hpp
304
305//
306// Implementational code for IDL interface hpp::core_idl::PathPlanner
307//
308namespace hpp {
309
310namespace core_impl {
311template <typename _Base, typename _Storage>
313 const _Storage& s)
314 : hpp::corbaServer::ServantBase<hpp::core::PathPlanner, _Storage> (server, s)
315{
316 // add extra constructor code here
317}
318template <typename _Base, typename _Storage>
320{
321 // add extra destructor code here
322}
323
324// Methods corresponding to IDL attributes and operations
325
326template <typename _Base, typename _Storage>
328{
329 try {
330 // automatically generated code.
331 _ServantBase::deleteThis();
332 } catch (const std::exception& e) {
333 throw ::hpp::Error (e.what());
334 }
335}
336
337template <typename _Base, typename _Storage>
339{
340 try {
341 // automatically generated code.
342 return _ServantBase::deleteIfExpired();
343 } catch (const std::exception& e) {
344 throw ::hpp::Error (e.what());
345 }
346}
347
348template <typename _Base, typename _Storage>
350{
351 try {
352 // automatically generated code.
353 _ServantBase::persistantStorage(persistant);
354 } catch (const std::exception& e) {
355 throw ::hpp::Error (e.what());
356 }
357}
358
359template <typename _Base, typename _Storage>
360hpp::core_idl::PathVector_ptr PathPlannerServant<_Base, _Storage>::solve ()
361{
362 try {
363 // automatically generated code.
364
365 hpp::core::PathVectorPtr_t __return__ (getT()->solve ());
366
367 return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Path,hpp::core_impl::PathVector>(server_, __return__)._retn();
368 } catch (const std::exception& e) {
369 throw ::hpp::Error (e.what());
370 }
371}
372
373template <typename _Base, typename _Storage>
375{
376 try {
377 // automatically generated code.
378
379 (getT()->startSolve ());
380
381
382 } catch (const std::exception& e) {
383 throw ::hpp::Error (e.what());
384 }
385}
386
387template <typename _Base, typename _Storage>
389{
390 try {
391 // automatically generated code.
392
393 (getT()->tryConnectInitAndGoals ());
394
395
396 } catch (const std::exception& e) {
397 throw ::hpp::Error (e.what());
398 }
399}
400
401template <typename _Base, typename _Storage>
403{
404 try {
405 // automatically generated code.
406
407 (getT()->oneStep ());
408
409
410 } catch (const std::exception& e) {
411 throw ::hpp::Error (e.what());
412 }
413}
414
415template <typename _Base, typename _Storage>
417{
418 try {
419 // automatically generated code.
420
421 hpp::core::PathVectorPtr_t __return__ (getT()->computePath ());
422
423 return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Path,hpp::core_impl::PathVector>(server_, __return__)._retn();
424 } catch (const std::exception& e) {
425 throw ::hpp::Error (e.what());
426 }
427}
428
429template <typename _Base, typename _Storage>
430hpp::core_idl::PathVector_ptr PathPlannerServant<_Base, _Storage>::finishSolve (hpp::core_idl::PathVector_ptr path)
431{
432 try {
433 // automatically generated code.
434 hpp::core::PathVectorPtr_t _path = ::hpp::corbaServer::reference_to_object<hpp::core::PathVector>(server_, path);
435 hpp::core::PathVectorPtr_t __return__ (getT()->finishSolve (_path));
436
437 return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Path,hpp::core_impl::PathVector>(server_, __return__)._retn();
438 } catch (const std::exception& e) {
439 throw ::hpp::Error (e.what());
440 }
441}
442
443template <typename _Base, typename _Storage>
445{
446 try {
447 // automatically generated code.
448
449 (getT()->interrupt ());
450
451
452 } catch (const std::exception& e) {
453 throw ::hpp::Error (e.what());
454 }
455}
456
457template <typename _Base, typename _Storage>
459{
460 try {
461 // automatically generated code.
462
463 (getT()->maxIterations (n));
464
465
466 } catch (const std::exception& e) {
467 throw ::hpp::Error (e.what());
468 }
469}
470
471template <typename _Base, typename _Storage>
473{
474 try {
475 // automatically generated code.
476
477 (getT()->timeOut (seconds));
478
479
480 } catch (const std::exception& e) {
481 throw ::hpp::Error (e.what());
482 }
483}
484
485template <typename _Base, typename _Storage>
487{
488 try {
489 // automatically generated code.
490
491 hpp::core::RoadmapPtr_t __return__ (getT()->roadmap ());
492
493 return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Roadmap,hpp::core_impl::Roadmap>(server_, __return__)._retn();
494 } catch (const std::exception& e) {
495 throw ::hpp::Error (e.what());
496 }
497}
498
499template <typename _Base, typename _Storage>
501{
502 try {
503 // automatically generated code.
504
505 (getT()->stopWhenProblemIsSolved (enable));
506
507
508 } catch (const std::exception& e) {
509 throw ::hpp::Error (e.what());
510 }
511}
512
513// End of implementational code
514} // namespace core_impl
515
516} // namespace hpp
517
518//
519// Implementational code for IDL interface hpp::core_idl::PathOptimizer
520//
521namespace hpp {
522
523namespace core_impl {
524template <typename _Base, typename _Storage>
526 const _Storage& s)
527 : hpp::corbaServer::ServantBase<hpp::core::PathOptimizer, _Storage> (server, s)
528{
529 // add extra constructor code here
530}
531template <typename _Base, typename _Storage>
533{
534 // add extra destructor code here
535}
536
537// Methods corresponding to IDL attributes and operations
538
539template <typename _Base, typename _Storage>
541{
542 try {
543 // automatically generated code.
544 _ServantBase::deleteThis();
545 } catch (const std::exception& e) {
546 throw ::hpp::Error (e.what());
547 }
548}
549
550template <typename _Base, typename _Storage>
552{
553 try {
554 // automatically generated code.
555 return _ServantBase::deleteIfExpired();
556 } catch (const std::exception& e) {
557 throw ::hpp::Error (e.what());
558 }
559}
560
561template <typename _Base, typename _Storage>
563{
564 try {
565 // automatically generated code.
566 _ServantBase::persistantStorage(persistant);
567 } catch (const std::exception& e) {
568 throw ::hpp::Error (e.what());
569 }
570}
571
572template <typename _Base, typename _Storage>
573hpp::core_idl::PathVector_ptr PathOptimizerServant<_Base, _Storage>::optimize (hpp::core_idl::PathVector_ptr path)
574{
575 try {
576 // automatically generated code.
577 hpp::core::PathVectorPtr_t _path = ::hpp::corbaServer::reference_to_object<hpp::core::PathVector>(server_, path);
578 hpp::core::PathVectorPtr_t __return__ (getT()->optimize (_path));
579
580 return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Path,hpp::core_impl::PathVector>(server_, __return__)._retn();
581 } catch (const std::exception& e) {
582 throw ::hpp::Error (e.what());
583 }
584}
585
586template <typename _Base, typename _Storage>
588{
589 try {
590 // automatically generated code.
591
592 (getT()->interrupt ());
593
594
595 } catch (const std::exception& e) {
596 throw ::hpp::Error (e.what());
597 }
598}
599
600template <typename _Base, typename _Storage>
602{
603 try {
604 // automatically generated code.
605
606 (getT()->maxIterations (n));
607
608
609 } catch (const std::exception& e) {
610 throw ::hpp::Error (e.what());
611 }
612}
613
614template <typename _Base, typename _Storage>
616{
617 try {
618 // automatically generated code.
619
620 (getT()->timeOut (seconds));
621
622
623 } catch (const std::exception& e) {
624 throw ::hpp::Error (e.what());
625 }
626}
627
628// End of implementational code
629} // namespace core_impl
630
631} // namespace hpp
632
633
634
635
636
637#endif // hpp_core_idl__path__planners_hxx__
638
bool persistantStorage() const
See persistantStorage(bool)
Definition: servant-base.hh:166
Implementation of Hpp module Corba server.
Definition: server.hh:78
Definition: path_planners-fwd.hh:34
void deleteThis()
Definition: path_planners.hh:40
hpp::floatSeqSeq * nodes()
Definition: path_planners.hh:73
ConnectedComponentServant(::hpp::corbaServer::Server *server, const _Storage &s)
Definition: path_planners.hh:25
virtual ~ConnectedComponentServant()
Definition: path_planners.hh:32
::CORBA::Boolean deleteIfExpired()
Definition: path_planners.hh:51
Definition: path_planners-fwd.hh:238
::CORBA::Boolean deleteIfExpired()
Definition: path_planners.hh:551
PathOptimizerServant(::hpp::corbaServer::Server *server, const _Storage &s)
Definition: path_planners.hh:525
hpp::core_idl::PathVector_ptr optimize(hpp::core_idl::PathVector_ptr path)
Definition: path_planners.hh:573
void timeOut(hpp::value_type seconds)
Definition: path_planners.hh:615
void deleteThis()
Definition: path_planners.hh:540
virtual ~PathOptimizerServant()
Definition: path_planners.hh:532
void interrupt()
Definition: path_planners.hh:587
void maxIterations(hpp::size_type n)
Definition: path_planners.hh:601
Definition: path_planners-fwd.hh:160
hpp::core_idl::PathVector_ptr computePath()
Definition: path_planners.hh:416
void tryConnectInitAndGoals()
Definition: path_planners.hh:388
void maxIterations(hpp::size_type n)
Definition: path_planners.hh:458
void oneStep()
Definition: path_planners.hh:402
void stopWhenProblemIsSolved(::CORBA::Boolean enable)
Definition: path_planners.hh:500
void deleteThis()
Definition: path_planners.hh:327
virtual ~PathPlannerServant()
Definition: path_planners.hh:319
hpp::core_idl::Roadmap_ptr getRoadmap()
Definition: path_planners.hh:486
void startSolve()
Definition: path_planners.hh:374
void timeOut(hpp::value_type seconds)
Definition: path_planners.hh:472
PathPlannerServant(::hpp::corbaServer::Server *server, const _Storage &s)
Definition: path_planners.hh:312
void interrupt()
Definition: path_planners.hh:444
hpp::core_idl::PathVector_ptr finishSolve(hpp::core_idl::PathVector_ptr path)
Definition: path_planners.hh:430
hpp::core_idl::PathVector_ptr solve()
Definition: path_planners.hh:360
::CORBA::Boolean deleteIfExpired()
Definition: path_planners.hh:338
Definition: paths-fwd.hh:29
Definition: path_planners-fwd.hh:82
virtual ~RoadmapServant()
Definition: path_planners.hh:110
hpp::floatSeq * nearestNode(const hpp::floatSeq &config, hpp::value_type &distance, ::CORBA::Boolean reverse)
Definition: path_planners.hh:207
hpp::size_type getNbEdges()
Definition: path_planners.hh:262
hpp::core_idl::ConnectedComponentSeq * getConnectedComponents()
Definition: path_planners.hh:287
hpp::core_idl::Path_ptr getEdge(hpp::size_type i)
Definition: path_planners.hh:274
void clear()
Definition: path_planners.hh:151
void deleteThis()
Definition: path_planners.hh:118
void addNodeAndEdge(const hpp::floatSeq &cfgfrom, const hpp::floatSeq &cfgto, hpp::core_idl::Path_ptr path_)
Definition: path_planners.hh:179
hpp::floatSeqSeq * nearestNodes(const hpp::floatSeq &config, hpp::size_type &k)
Definition: path_planners.hh:220
hpp::size_type getNbNodes()
Definition: path_planners.hh:238
RoadmapServant(::hpp::corbaServer::Server *server, const _Storage &s)
Definition: path_planners.hh:103
::CORBA::Boolean deleteIfExpired()
Definition: path_planners.hh:129
void addNode(const hpp::floatSeq &config)
Definition: path_planners.hh:165
hpp::floatSeq * getNode(hpp::size_type i)
Definition: path_planners.hh:250
void addNodeAndEdges(const hpp::floatSeq &cfgfrom, const hpp::floatSeq &cfgto, hpp::core_idl::Path_ptr path_)
Definition: path_planners.hh:193
floatSeq * vectorToFloatSeq(core::vectorIn_t input)
vector_t floatSeqToVector(const floatSeq &dofArray, const size_type expectedSize=-1)
floatSeqSeq * matrixToFloatSeqSeq(core::matrixIn_t input)
Returns a sequence of the rows of the input matrix.
sequence< ConnectedComponent > ConnectedComponentSeq
Definition: path_planners.idl:35
Implement CORBA interface `‘Obstacle’'.
Definition: client.hh:46
long long size_type
Definition: common.idl:19
sequence< double > floatSeq
Robot configuration is defined by a sequence of dof value.
Definition: common.idl:34
sequence< floatSeq > floatSeqSeq
Definition: common.idl:35
double value_type
Definition: common.idl:18
Definition: servant-base.hh:451