hpp-corbaserver  5.0.0
Corba server for Humanoid Path Planner applications
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 
12 #include <hpp/corbaserver/fwd.hh>
15 
16 
17 
18 //
19 // Implementational code for IDL interface hpp::core_idl::ConnectedComponent
20 //
21 namespace hpp {
22 
23 namespace core_impl {
24 template <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 }
31 template <typename _Base, typename _Storage>
33 {
34  // add extra destructor code here
35 }
36 
37 // Methods corresponding to IDL attributes and operations
38 
39 template <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 
50 template <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 
61 template <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 
72 template <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();
84  return corbaServer::matrixToFloatSeqSeq(configs);
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 //
99 namespace hpp {
100 
101 namespace core_impl {
102 template <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 }
109 template <typename _Base, typename _Storage>
111 {
112  // add extra destructor code here
113 }
114 
115 // Methods corresponding to IDL attributes and operations
116 
117 template <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 
128 template <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 
139 template <typename _Base, typename _Storage>
140 void RoadmapServant<_Base, _Storage>::persistantStorage (::CORBA::Boolean persistant)
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 
150 template <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 
164 template <typename _Base, typename _Storage>
166 {
167  try {
168  // automatically generated code.
170  (getT()->addNode (_config));
171 
172 
173  } catch (const std::exception& e) {
174  throw ::hpp::Error (e.what());
175  }
176 }
177 
178 template <typename _Base, typename _Storage>
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 
192 template <typename _Base, typename _Storage>
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 
206 template <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 
219 template <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(
225  corbaServer::floatSeqToVector(config), k);
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 
237 template <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 
249 template <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 
261 template <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 
273 template <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 
286 template <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 //
308 namespace hpp {
309 
310 namespace core_impl {
311 template <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 }
318 template <typename _Base, typename _Storage>
320 {
321  // add extra destructor code here
322 }
323 
324 // Methods corresponding to IDL attributes and operations
325 
326 template <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 
337 template <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 
348 template <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 
359 template <typename _Base, typename _Storage>
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 
373 template <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 
387 template <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 
401 template <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 
415 template <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 
429 template <typename _Base, typename _Storage>
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 
443 template <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 
457 template <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 
471 template <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 
485 template <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 
499 template <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 //
521 namespace hpp {
522 
523 namespace core_impl {
524 template <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 }
531 template <typename _Base, typename _Storage>
533 {
534  // add extra destructor code here
535 }
536 
537 // Methods corresponding to IDL attributes and operations
538 
539 template <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 
550 template <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 
561 template <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 
572 template <typename _Base, typename _Storage>
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 
586 template <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 
600 template <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 
614 template <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 
void timeOut(hpp::value_type seconds)
Definition: path_planners.hh:472
core::NodeVector_t NodeVector_t
Definition: fwd.hh:92
void clear()
Definition: path_planners.hh:151
Definition: path_planners-fwd.hh:80
void stopWhenProblemIsSolved(::CORBA::Boolean enable)
Definition: path_planners.hh:500
void deleteThis()
Definition: path_planners.hh:540
hpp::core_idl::Roadmap_ptr getRoadmap()
Definition: path_planners.hh:486
hpp::core_idl::Path_ptr getEdge(hpp::size_type i)
Definition: path_planners.hh:274
Implement CORBA interface `‘Obstacle’&#39;.
Definition: client.hh:46
ConnectedComponentServant(::hpp::corbaServer::Server *server, const _Storage &s)
Definition: path_planners.hh:25
RoadmapServant(::hpp::corbaServer::Server *server, const _Storage &s)
Definition: path_planners.hh:103
double value_type
Definition: common.idl:18
void deleteThis()
Definition: path_planners.hh:118
hpp::core_idl::ConnectedComponentSeq * getConnectedComponents()
Definition: path_planners.hh:287
::CORBA::Boolean deleteIfExpired()
Definition: path_planners.hh:551
sequence< floatSeq > floatSeqSeq
Definition: common.idl:35
hpp::floatSeqSeq * nearestNodes(const hpp::floatSeq &config, hpp::size_type &k)
Definition: path_planners.hh:220
hpp::core_idl::PathVector_ptr optimize(hpp::core_idl::PathVector_ptr path)
Definition: path_planners.hh:573
::CORBA::Boolean deleteIfExpired()
Definition: path_planners.hh:338
_objref_Roadmap * Roadmap_ptr
Definition: path_planners-idl.hh:342
virtual ~PathPlannerServant()
Definition: path_planners.hh:319
void deleteThis()
Definition: path_planners.hh:40
vector_t floatSeqToVector(const floatSeq &dofArray, const size_type expectedSize=-1)
virtual ~PathOptimizerServant()
Definition: path_planners.hh:532
hpp::floatSeqSeq * nodes()
Definition: path_planners.hh:73
hpp::floatSeq * getNode(hpp::size_type i)
Definition: path_planners.hh:250
bool persistantStorage() const
See persistantStorage(bool)
Definition: servant-base.hh:166
hpp::core_idl::PathVector_ptr computePath()
Definition: path_planners.hh:416
Definition: path_planners-fwd.hh:236
void addNode(const hpp::floatSeq &config)
Definition: path_planners.hh:165
virtual ~RoadmapServant()
Definition: path_planners.hh:110
pinocchio::vector_t vector_t
Definition: fwd.hh:108
hpp::size_type getNbEdges()
Definition: path_planners.hh:262
void oneStep()
Definition: path_planners.hh:402
hpp::size_type getNbNodes()
Definition: path_planners.hh:238
::CORBA::Boolean deleteIfExpired()
Definition: path_planners.hh:129
void startSolve()
Definition: path_planners.hh:374
PathServant< POA_hpp::core_idl::Path, hpp::weak_ptr< hpp::core::Path > > Path
Definition: paths-fwd.hh:92
void interrupt()
Definition: path_planners.hh:444
hpp::floatSeq * nearestNode(const hpp::floatSeq &config, hpp::value_type &distance, ::CORBA::Boolean reverse)
Definition: path_planners.hh:207
void interrupt()
Definition: path_planners.hh:587
void timeOut(hpp::value_type seconds)
Definition: path_planners.hh:615
_objref_PathVector * PathVector_ptr
Definition: paths-idl.hh:82
Definition: servant-base.hh:451
void maxIterations(hpp::size_type n)
Definition: path_planners.hh:458
::CORBA::Boolean deleteIfExpired()
Definition: path_planners.hh:51
void maxIterations(hpp::size_type n)
Definition: path_planners.hh:601
core::PathVectorPtr_t PathVectorPtr_t
Definition: fwd.hh:99
Implementation of Hpp module Corba server.
Definition: server.hh:78
pinocchio::matrix_t matrix_t
Definition: fwd.hh:106
void addNodeAndEdge(const hpp::floatSeq &cfgfrom, const hpp::floatSeq &cfgto, hpp::core_idl::Path_ptr path_)
Definition: path_planners.hh:179
Definition: path_planners-fwd.hh:158
sequence< ConnectedComponent > ConnectedComponentSeq
Definition: path_planners.idl:33
floatSeqSeq * matrixToFloatSeqSeq(core::matrixIn_t input)
Returns a sequence of the rows of the input matrix.
hpp::core_idl::PathVector_ptr finishSolve(hpp::core_idl::PathVector_ptr path)
Definition: path_planners.hh:430
floatSeq * vectorToFloatSeq(core::vectorIn_t input)
virtual ~ConnectedComponentServant()
Definition: path_planners.hh:32
void deleteThis()
Definition: path_planners.hh:327
Definition: path_planners-fwd.hh:32
_objref_Path * Path_ptr
Definition: path_planners-idl.hh:83
sequence< double > floatSeq
Robot configuration is defined by a sequence of dof value.
Definition: common.idl:34
hpp::core_idl::PathVector_ptr solve()
Definition: path_planners.hh:360
core::Nodes_t Nodes_t
Definition: fwd.hh:91
core::PathPtr_t PathPtr_t
Definition: fwd.hh:96
void addNodeAndEdges(const hpp::floatSeq &cfgfrom, const hpp::floatSeq &cfgto, hpp::core_idl::Path_ptr path_)
Definition: path_planners.hh:193
void tryConnectInitAndGoals()
Definition: path_planners.hh:388
PathPlannerServant(::hpp::corbaServer::Server *server, const _Storage &s)
Definition: path_planners.hh:312
PathOptimizerServant(::hpp::corbaServer::Server *server, const _Storage &s)
Definition: path_planners.hh:525
long long size_type
Definition: common.idl:19