GCC Code Coverage Report

Directory: src/
File: src/hpp/manipulation_idl/_graph.hh
Date: 2024-12-13 15:43:02
Exec Total Coverage
Lines: 0 257 0.0%
Branches: 0 512 0.0%
Line Branch Exec Source
1 #ifndef hpp_manipulation_idl____graph_hxx__
2 #define hpp_manipulation_idl____graph_hxx__
3
4 //
5 // Implemention of IDL interfaces in file /root/robotpkg/path/py-hpp-manipulation-corba/work/hpp-manipulation-corba-6.0.0/idl/hpp/manipulation_idl/_graph.idl
6 //
7
8 #include <hpp/manipulation_idl/_graph-fwd.hh>
9
10 #include <sstream>
11
12 #include <hpp/corbaserver/fwd.hh>
13 #include <hpp/corbaserver/conversions.hh>
14 #include "hpp/corbaserver/servant-base.hh"
15
16
17
18 //
19 // Implementational code for IDL interface hpp::manipulation_idl::graph_idl::GraphComponent
20 //
21 namespace hpp {
22
23 namespace manipulation_impl {
24
25 namespace graph_impl {
26 template <typename _Base, typename _Storage>
27 ✗ GraphComponentServant<_Base, _Storage>::GraphComponentServant(::hpp::corbaServer::Server* server,
28 const _Storage& s)
29 ✗ : hpp::corbaServer::ServantBase<hpp::manipulation::graph::GraphComponent, _Storage> (server, s)
30 {
31 // add extra constructor code here
32 }
33 template <typename _Base, typename _Storage>
34 ✗ GraphComponentServant<_Base, _Storage>::~GraphComponentServant()
35 {
36 // add extra destructor code here
37 }
38
39 // Methods corresponding to IDL attributes and operations
40
41 template <typename _Base, typename _Storage>
42 ✗ char* GraphComponentServant<_Base, _Storage>::name ()
43 {
44 try {
45 // automatically generated code.
46
47 ✗ char* __return__ = ::hpp::corbaServer::c_str (getT()->name ());
48
49 ✗ return __return__;
50 ✗ } catch (const std::exception& e) {
51 ✗ throw ::hpp::Error (e.what());
52 }
53 }
54
55 template <typename _Base, typename _Storage>
56 ✗ hpp::manipulation_idl::graph_idl::size_t GraphComponentServant<_Base, _Storage>::id ()
57 {
58 try {
59 // automatically generated code.
60
61 ✗ hpp::manipulation_idl::graph_idl::size_t __return__ (getT()->id ());
62
63 ✗ return __return__;
64 ✗ } catch (const std::exception& e) {
65 ✗ throw ::hpp::Error (e.what());
66 }
67 }
68
69 template <typename _Base, typename _Storage>
70 ✗ hpp::manipulation_idl::graph_idl::Graph_ptr GraphComponentServant<_Base, _Storage>::parentGraph ()
71 {
72 try {
73 // automatically generated code.
74
75 ✗ hpp::manipulation::graph::GraphPtr_t __return__ (getT()->parentGraph ());
76
77 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::manipulation_impl::graph_impl::GraphComponent,hpp::manipulation_impl::graph_impl::Graph>(server_, __return__)._retn();
78 ✗ } catch (const std::exception& e) {
79 ✗ throw ::hpp::Error (e.what());
80 }
81 }
82
83 template <typename _Base, typename _Storage>
84 ✗ void GraphComponentServant<_Base, _Storage>::addNumericalConstraint (hpp::constraints_idl::Implicit_ptr nm)
85 {
86 try {
87 // automatically generated code.
88 ✗ hpp::constraints::ImplicitPtr_t _nm = ::hpp::corbaServer::reference_to_object<hpp::constraints::Implicit>(server_, nm);
89 ✗ (getT()->addNumericalConstraint (_nm));
90
91
92 ✗ } catch (const std::exception& e) {
93 ✗ throw ::hpp::Error (e.what());
94 }
95 }
96
97 template <typename _Base, typename _Storage>
98 ✗ void GraphComponentServant<_Base, _Storage>::addNumericalCost (hpp::constraints_idl::Implicit_ptr nm)
99 {
100 try {
101 // automatically generated code.
102 ✗ hpp::constraints::ImplicitPtr_t _nm = ::hpp::corbaServer::reference_to_object<hpp::constraints::Implicit>(server_, nm);
103 ✗ (getT()->addNumericalCost (_nm));
104
105
106 ✗ } catch (const std::exception& e) {
107 ✗ throw ::hpp::Error (e.what());
108 }
109 }
110
111 template <typename _Base, typename _Storage>
112 ✗ hpp::constraints_idl::Implicits* GraphComponentServant<_Base, _Storage>::numericalConstraints ()
113 {
114 try {
115 // automatically generated code.
116
117 ✗ hpp::constraints_idl::Implicits* __return__ = hpp::corbaServer::vectorToSeqServant<hpp::constraints_idl::Implicits,hpp::constraints_impl::Implicit,hpp::constraints_impl::Implicit>(server_) (getT()->numericalConstraints ());
118
119 ✗ return __return__;
120 ✗ } catch (const std::exception& e) {
121 ✗ throw ::hpp::Error (e.what());
122 }
123 }
124
125 template <typename _Base, typename _Storage>
126 ✗ hpp::constraints_idl::Implicits* GraphComponentServant<_Base, _Storage>::numericalCosts ()
127 {
128 try {
129 // automatically generated code.
130
131 ✗ hpp::constraints_idl::Implicits* __return__ = hpp::corbaServer::vectorToSeqServant<hpp::constraints_idl::Implicits,hpp::constraints_impl::Implicit,hpp::constraints_impl::Implicit>(server_) (getT()->numericalCosts ());
132
133 ✗ return __return__;
134 ✗ } catch (const std::exception& e) {
135 ✗ throw ::hpp::Error (e.what());
136 }
137 }
138
139 template <typename _Base, typename _Storage>
140 ✗ void GraphComponentServant<_Base, _Storage>::resetNumericalConstraints ()
141 {
142 try {
143 // automatically generated code.
144
145 ✗ (getT()->resetNumericalConstraints ());
146
147
148 ✗ } catch (const std::exception& e) {
149 ✗ throw ::hpp::Error (e.what());
150 }
151 }
152
153 template <typename _Base, typename _Storage>
154 ✗ void GraphComponentServant<_Base, _Storage>::setSolveLevelByLevel (::CORBA::Boolean input)
155 {
156 try {
157 // automatically generated code.
158
159 ✗ (getT()->solveLevelByLevel (input));
160
161
162 ✗ } catch (const std::exception& e) {
163 ✗ throw ::hpp::Error (e.what());
164 }
165 }
166
167 template <typename _Base, typename _Storage>
168 ✗ ::CORBA::Boolean GraphComponentServant<_Base, _Storage>::getSolveLevelByLevel ()
169 {
170 try {
171 // automatically generated code.
172
173 ✗ ::CORBA::Boolean __return__ (getT()->solveLevelByLevel ());
174
175 ✗ return __return__;
176 ✗ } catch (const std::exception& e) {
177 ✗ throw ::hpp::Error (e.what());
178 }
179 }
180
181 // End of implementational code
182 } // namespace graph_impl
183
184 } // namespace manipulation_impl
185
186 } // namespace hpp
187
188 //
189 // Implementational code for IDL interface hpp::manipulation_idl::graph_idl::StateSelector
190 //
191 namespace hpp {
192
193 namespace manipulation_impl {
194
195 namespace graph_impl {
196 template <typename _Base, typename _Storage>
197 ✗ StateSelectorServant<_Base, _Storage>::StateSelectorServant(::hpp::corbaServer::Server* server,
198 const _Storage& s)
199 ✗ : hpp::corbaServer::ServantBase<hpp::manipulation::graph::StateSelector, _Storage> (server, s)
200 {
201 // add extra constructor code here
202 }
203 template <typename _Base, typename _Storage>
204 ✗ StateSelectorServant<_Base, _Storage>::~StateSelectorServant()
205 {
206 // add extra destructor code here
207 }
208
209 // Methods corresponding to IDL attributes and operations
210
211 template <typename _Base, typename _Storage>
212 ✗ char* StateSelectorServant<_Base, _Storage>::name ()
213 {
214 try {
215 // automatically generated code.
216
217 ✗ char* __return__ = ::hpp::corbaServer::c_str (getT()->name ());
218
219 ✗ return __return__;
220 ✗ } catch (const std::exception& e) {
221 ✗ throw ::hpp::Error (e.what());
222 }
223 }
224
225 template <typename _Base, typename _Storage>
226 ✗ hpp::manipulation_idl::graph_idl::Graph_ptr StateSelectorServant<_Base, _Storage>::parentGraph ()
227 {
228 try {
229 // automatically generated code.
230
231 ✗ hpp::manipulation::graph::GraphPtr_t __return__ (getT()->parentGraph ());
232
233 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::manipulation_impl::graph_impl::GraphComponent,hpp::manipulation_impl::graph_impl::Graph>(server_, __return__)._retn();
234 ✗ } catch (const std::exception& e) {
235 ✗ throw ::hpp::Error (e.what());
236 }
237 }
238
239 template <typename _Base, typename _Storage>
240 ✗ hpp::manipulation_idl::graph_idl::States* StateSelectorServant<_Base, _Storage>::getStates ()
241 {
242 try {
243 // automatically generated code.
244
245 ✗ hpp::manipulation_idl::graph_idl::States* __return__ = hpp::corbaServer::vectorToSeqServant<hpp::manipulation_idl::graph_idl::States,hpp::manipulation_impl::graph_impl::GraphComponent,hpp::manipulation_impl::graph_impl::State>(server_) (getT()->getStates ());
246
247 ✗ return __return__;
248 ✗ } catch (const std::exception& e) {
249 ✗ throw ::hpp::Error (e.what());
250 }
251 }
252
253 // End of implementational code
254 } // namespace graph_impl
255
256 } // namespace manipulation_impl
257
258 } // namespace hpp
259
260 //
261 // Implementational code for IDL interface hpp::manipulation_idl::graph_idl::Graph
262 //
263 namespace hpp {
264
265 namespace manipulation_impl {
266
267 namespace graph_impl {
268 template <typename _Base, typename _Storage>
269 ✗ GraphServant<_Base, _Storage>::GraphServant(::hpp::corbaServer::Server* server,
270 const _Storage& s)
271 ✗ : hpp::manipulation_impl::graph_impl::GraphComponentServant<_Base, _Storage> (server, s)
272 {
273 // add extra constructor code here
274 }
275 template <typename _Base, typename _Storage>
276 ✗ GraphServant<_Base, _Storage>::~GraphServant()
277 {
278 // add extra destructor code here
279 }
280
281 // Methods corresponding to IDL attributes and operations
282
283 template <typename _Base, typename _Storage>
284 ✗ hpp::manipulation_idl::graph_idl::StateSelector_ptr GraphServant<_Base, _Storage>::getStateSelector ()
285 {
286 try {
287 // automatically generated code.
288
289 ✗ hpp::manipulation::graph::StateSelectorPtr_t __return__ (getT()->stateSelector ());
290
291 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::manipulation_impl::graph_impl::StateSelector,hpp::manipulation_impl::graph_impl::StateSelector>(server_, __return__)._retn();
292 ✗ } catch (const std::exception& e) {
293 ✗ throw ::hpp::Error (e.what());
294 }
295 }
296
297 template <typename _Base, typename _Storage>
298 ✗ hpp::manipulation_idl::graph_idl::GraphComponent_ptr GraphServant<_Base, _Storage>::get (hpp::manipulation_idl::graph_idl::size_t id)
299 {
300 try {
301 // automatically generated code.
302
303 ✗ hpp::manipulation::graph::GraphComponentPtr_t __return__ (getT()->get (id));
304
305 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::manipulation_impl::graph_impl::GraphComponent,hpp::manipulation_impl::graph_impl::GraphComponent>(server_, __return__)._retn();
306 ✗ } catch (const std::exception& e) {
307 ✗ throw ::hpp::Error (e.what());
308 }
309 }
310
311 template <typename _Base, typename _Storage>
312 ✗ hpp::manipulation_idl::graph_idl::size_t GraphServant<_Base, _Storage>::nbComponents ()
313 {
314 try {
315 // automatically generated code.
316
317 ✗ hpp::manipulation_idl::graph_idl::size_t __return__ (getT()->nbComponents ());
318
319 ✗ return __return__;
320 ✗ } catch (const std::exception& e) {
321 ✗ throw ::hpp::Error (e.what());
322 }
323 }
324
325 template <typename _Base, typename _Storage>
326 ✗ void GraphServant<_Base, _Storage>::initialize ()
327 {
328 try {
329 // automatically generated code.
330
331 ✗ (getT()->initialize ());
332
333
334 ✗ } catch (const std::exception& e) {
335 ✗ throw ::hpp::Error (e.what());
336 }
337 }
338
339 template <typename _Base, typename _Storage>
340 ✗ hpp::manipulation_idl::graph_idl::State_ptr GraphServant<_Base, _Storage>::getState (const hpp::floatSeq& config)
341 {
342 try {
343 // automatically generated code.
344 ✗ hpp::core::vector_t _config = hpp::corbaServer::floatSeqToVector (config);
345 ✗ hpp::manipulation::graph::StatePtr_t __return__ (getT()->getState (_config));
346
347 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::manipulation_impl::graph_impl::GraphComponent,hpp::manipulation_impl::graph_impl::State>(server_, __return__)._retn();
348 ✗ } catch (const std::exception& e) {
349 ✗ throw ::hpp::Error (e.what());
350 }
351 }
352
353 template <typename _Base, typename _Storage>
354 ✗ hpp::manipulation_idl::graph_idl::Edges* GraphServant<_Base, _Storage>::getEdges (hpp::manipulation_idl::graph_idl::State_ptr from, hpp::manipulation_idl::graph_idl::State_ptr to)
355 {
356 try {
357 // automatically generated code.
358 ✗ hpp::manipulation::graph::StatePtr_t _from = ::hpp::corbaServer::reference_to_object<hpp::manipulation::graph::State>(server_, from);
359 ✗ hpp::manipulation::graph::StatePtr_t _to = ::hpp::corbaServer::reference_to_object<hpp::manipulation::graph::State>(server_, to);
360 ✗ hpp::manipulation_idl::graph_idl::Edges* __return__ = hpp::corbaServer::vectorToSeqServant<hpp::manipulation_idl::graph_idl::Edges,hpp::manipulation_impl::graph_impl::GraphComponent,hpp::manipulation_impl::graph_impl::Edge>(server_) (getT()->getEdges (_from, _to));
361
362 ✗ return __return__;
363 ✗ } catch (const std::exception& e) {
364 ✗ throw ::hpp::Error (e.what());
365 }
366 }
367
368 // End of implementational code
369 } // namespace graph_impl
370
371 } // namespace manipulation_impl
372
373 } // namespace hpp
374
375 //
376 // Implementational code for IDL interface hpp::manipulation_idl::graph_idl::State
377 //
378 namespace hpp {
379
380 namespace manipulation_impl {
381
382 namespace graph_impl {
383 template <typename _Base, typename _Storage>
384 ✗ StateServant<_Base, _Storage>::StateServant(::hpp::corbaServer::Server* server,
385 const _Storage& s)
386 ✗ : hpp::manipulation_impl::graph_impl::GraphComponentServant<_Base, _Storage> (server, s)
387 {
388 // add extra constructor code here
389 }
390 template <typename _Base, typename _Storage>
391 ✗ StateServant<_Base, _Storage>::~StateServant()
392 {
393 // add extra destructor code here
394 }
395
396 // Methods corresponding to IDL attributes and operations
397
398 template <typename _Base, typename _Storage>
399 ✗ ::CORBA::Boolean StateServant<_Base, _Storage>::contains (const hpp::floatSeq& config)
400 {
401 try {
402 // automatically generated code.
403 ✗ hpp::core::vector_t _config = hpp::corbaServer::floatSeqToVector (config);
404 ✗ ::CORBA::Boolean __return__ (getT()->contains (_config));
405
406 ✗ return __return__;
407 ✗ } catch (const std::exception& e) {
408 ✗ throw ::hpp::Error (e.what());
409 }
410 }
411
412 template <typename _Base, typename _Storage>
413 ✗ hpp::manipulation_idl::graph_idl::Edge_ptr StateServant<_Base, _Storage>::linkTo (const char* name, hpp::manipulation_idl::graph_idl::State_ptr to, hpp::size_type weight)
414 {
415 try {
416 // automatically generated code.
417 ✗ std::string _name (name);
418 ✗ hpp::manipulation::graph::StatePtr_t _to = ::hpp::corbaServer::reference_to_object<hpp::manipulation::graph::State>(server_, to);
419 ✗ hpp::manipulation::graph::EdgePtr_t __return__ (getT()->linkTo (_name, _to, weight));
420
421 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::manipulation_impl::graph_impl::GraphComponent,hpp::manipulation_impl::graph_impl::Edge>(server_, __return__)._retn();
422 ✗ } catch (const std::exception& e) {
423 ✗ throw ::hpp::Error (e.what());
424 }
425 }
426
427 template <typename _Base, typename _Storage>
428 ✗ hpp::manipulation_idl::graph_idl::Edges* StateServant<_Base, _Storage>::neighborEdges ()
429 {
430 try {
431 // automatically generated code.
432
433 ✗ hpp::manipulation_idl::graph_idl::Edges* __return__ = hpp::corbaServer::vectorToSeqServant<hpp::manipulation_idl::graph_idl::Edges,hpp::manipulation_impl::graph_impl::GraphComponent,hpp::manipulation_impl::graph_impl::Edge>(server_) (getT()->neighborEdges ());
434
435 ✗ return __return__;
436 ✗ } catch (const std::exception& e) {
437 ✗ throw ::hpp::Error (e.what());
438 }
439 }
440
441 template <typename _Base, typename _Storage>
442 ✗ hpp::manipulation_idl::graph_idl::Edges* StateServant<_Base, _Storage>::hiddenNeighbors ()
443 {
444 try {
445 // automatically generated code.
446
447 ✗ hpp::manipulation_idl::graph_idl::Edges* __return__ = hpp::corbaServer::vectorToSeqServant<hpp::manipulation_idl::graph_idl::Edges,hpp::manipulation_impl::graph_impl::GraphComponent,hpp::manipulation_impl::graph_impl::Edge>(server_) (getT()->hiddenNeighbors ());
448
449 ✗ return __return__;
450 ✗ } catch (const std::exception& e) {
451 ✗ throw ::hpp::Error (e.what());
452 }
453 }
454
455 template <typename _Base, typename _Storage>
456 ✗ hpp::core_idl::ConstraintSet_ptr StateServant<_Base, _Storage>::configConstraint ()
457 {
458 try {
459 // automatically generated code.
460
461 ✗ hpp::core::ConstraintSetPtr_t __return__ (getT()->configConstraint ());
462
463 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Constraint,hpp::core_impl::ConstraintSet>(server_, __return__)._retn();
464 ✗ } catch (const std::exception& e) {
465 ✗ throw ::hpp::Error (e.what());
466 }
467 }
468
469 // End of implementational code
470 } // namespace graph_impl
471
472 } // namespace manipulation_impl
473
474 } // namespace hpp
475
476 //
477 // Implementational code for IDL interface hpp::manipulation_idl::graph_idl::Edge
478 //
479 namespace hpp {
480
481 namespace manipulation_impl {
482
483 namespace graph_impl {
484 template <typename _Base, typename _Storage>
485 ✗ EdgeServant<_Base, _Storage>::EdgeServant(::hpp::corbaServer::Server* server,
486 const _Storage& s)
487 ✗ : hpp::manipulation_impl::graph_impl::GraphComponentServant<_Base, _Storage> (server, s)
488 {
489 // add extra constructor code here
490 }
491 template <typename _Base, typename _Storage>
492 ✗ EdgeServant<_Base, _Storage>::~EdgeServant()
493 {
494 // add extra destructor code here
495 }
496
497 // Methods corresponding to IDL attributes and operations
498
499 template <typename _Base, typename _Storage>
500 ✗ hpp::manipulation_idl::graph_idl::State_ptr EdgeServant<_Base, _Storage>::stateFrom ()
501 {
502 try {
503 // automatically generated code.
504
505 ✗ hpp::manipulation::graph::StatePtr_t __return__ (getT()->stateFrom ());
506
507 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::manipulation_impl::graph_impl::GraphComponent,hpp::manipulation_impl::graph_impl::State>(server_, __return__)._retn();
508 ✗ } catch (const std::exception& e) {
509 ✗ throw ::hpp::Error (e.what());
510 }
511 }
512
513 template <typename _Base, typename _Storage>
514 ✗ hpp::manipulation_idl::graph_idl::State_ptr EdgeServant<_Base, _Storage>::stateTo ()
515 {
516 try {
517 // automatically generated code.
518
519 ✗ hpp::manipulation::graph::StatePtr_t __return__ (getT()->stateTo ());
520
521 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::manipulation_impl::graph_impl::GraphComponent,hpp::manipulation_impl::graph_impl::State>(server_, __return__)._retn();
522 ✗ } catch (const std::exception& e) {
523 ✗ throw ::hpp::Error (e.what());
524 }
525 }
526
527 template <typename _Base, typename _Storage>
528 ✗ hpp::manipulation_idl::graph_idl::State_ptr EdgeServant<_Base, _Storage>::getState ()
529 {
530 try {
531 // automatically generated code.
532
533 ✗ hpp::manipulation::graph::StatePtr_t __return__ (getT()->state ());
534
535 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::manipulation_impl::graph_impl::GraphComponent,hpp::manipulation_impl::graph_impl::State>(server_, __return__)._retn();
536 ✗ } catch (const std::exception& e) {
537 ✗ throw ::hpp::Error (e.what());
538 }
539 }
540
541 template <typename _Base, typename _Storage>
542 ✗ void EdgeServant<_Base, _Storage>::setState (hpp::manipulation_idl::graph_idl::State_ptr st)
543 {
544 try {
545 // automatically generated code.
546 ✗ hpp::manipulation::graph::StatePtr_t _st = ::hpp::corbaServer::reference_to_object<hpp::manipulation::graph::State>(server_, st);
547 ✗ (getT()->state (_st));
548
549
550 ✗ } catch (const std::exception& e) {
551 ✗ throw ::hpp::Error (e.what());
552 }
553 }
554
555 template <typename _Base, typename _Storage>
556 ✗ hpp::intSeqSeq* EdgeServant<_Base, _Storage>::getRelativeMotion ()
557 {
558 try {
559 // generated from /root/robotpkg/path/py-hpp-manipulation-corba/work/hpp-manipulation-corba-6.0.0/idl/hpp/manipulation_idl/_graph.idl:111
560 ✗ return corbaServer::matrixToIntSeqSeq(getT()->relativeMotion().template cast<CORBA::Long>());
561
562 ✗ } catch (const std::exception& e) {
563 ✗ throw ::hpp::Error (e.what());
564 }
565 }
566
567 template <typename _Base, typename _Storage>
568 ✗ hpp::floatSeqSeq* EdgeServant<_Base, _Storage>::getSecurityMargins ()
569 {
570 try {
571 // automatically generated code.
572
573 ✗ hpp::floatSeqSeq* __return__ = hpp::corbaServer::matrixToFloatSeqSeq (getT()->securityMargins ());
574
575 ✗ return __return__;
576 ✗ } catch (const std::exception& e) {
577 ✗ throw ::hpp::Error (e.what());
578 }
579 }
580
581 template <typename _Base, typename _Storage>
582 ✗ void EdgeServant<_Base, _Storage>::setSecurityMarginForPair (hpp::size_type row, hpp::size_type col, hpp::value_type margin)
583 {
584 try {
585 // automatically generated code.
586
587 ✗ (getT()->securityMarginForPair (row, col, margin));
588
589
590 ✗ } catch (const std::exception& e) {
591 ✗ throw ::hpp::Error (e.what());
592 }
593 }
594
595 template <typename _Base, typename _Storage>
596 ✗ ::CORBA::Boolean EdgeServant<_Base, _Storage>::generateTargetConfig (const hpp::floatSeq& qStart, hpp::floatSeq& q)
597 {
598 try {
599 // automatically generated code.
600 ✗ hpp::core::vector_t _qStart = hpp::corbaServer::floatSeqToVector (qStart);
601 ✗ hpp::core::vector_t _q = hpp::corbaServer::floatSeqToVector (q);
602 ✗ ::CORBA::Boolean __return__ (getT()->generateTargetConfig (_qStart, _q));
603 ✗ hpp::corbaServer::vectorToFloatSeq (_q, q);
604 ✗ return __return__;
605 ✗ } catch (const std::exception& e) {
606 ✗ throw ::hpp::Error (e.what());
607 }
608 }
609
610 template <typename _Base, typename _Storage>
611 ✗ hpp::core_idl::SteeringMethod_ptr EdgeServant<_Base, _Storage>::getSteeringMethod ()
612 {
613 try {
614 // automatically generated code.
615
616 ✗ hpp::core::SteeringMethodPtr_t __return__ (getT()->steeringMethod ());
617
618 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::SteeringMethod,hpp::core_impl::SteeringMethod>(server_, __return__)._retn();
619 ✗ } catch (const std::exception& e) {
620 ✗ throw ::hpp::Error (e.what());
621 }
622 }
623
624 template <typename _Base, typename _Storage>
625 ✗ hpp::core_idl::PathValidation_ptr EdgeServant<_Base, _Storage>::getPathValidation ()
626 {
627 try {
628 // automatically generated code.
629
630 ✗ hpp::core::PathValidationPtr_t __return__ (getT()->pathValidation ());
631
632 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::PathValidation,hpp::core_impl::PathValidation>(server_, __return__)._retn();
633 ✗ } catch (const std::exception& e) {
634 ✗ throw ::hpp::Error (e.what());
635 }
636 }
637
638 template <typename _Base, typename _Storage>
639 ✗ hpp::core_idl::ConstraintSet_ptr EdgeServant<_Base, _Storage>::configConstraint ()
640 {
641 try {
642 // automatically generated code.
643
644 ✗ hpp::core::ConstraintSetPtr_t __return__ (getT()->targetConstraint ());
645
646 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Constraint,hpp::core_impl::ConstraintSet>(server_, __return__)._retn();
647 ✗ } catch (const std::exception& e) {
648 ✗ throw ::hpp::Error (e.what());
649 }
650 }
651
652 template <typename _Base, typename _Storage>
653 ✗ hpp::core_idl::ConstraintSet_ptr EdgeServant<_Base, _Storage>::targetConstraint ()
654 {
655 try {
656 // automatically generated code.
657
658 ✗ hpp::core::ConstraintSetPtr_t __return__ (getT()->targetConstraint ());
659
660 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Constraint,hpp::core_impl::ConstraintSet>(server_, __return__)._retn();
661 ✗ } catch (const std::exception& e) {
662 ✗ throw ::hpp::Error (e.what());
663 }
664 }
665
666 template <typename _Base, typename _Storage>
667 ✗ hpp::core_idl::ConstraintSet_ptr EdgeServant<_Base, _Storage>::pathConstraint ()
668 {
669 try {
670 // automatically generated code.
671
672 ✗ hpp::core::ConstraintSetPtr_t __return__ (getT()->pathConstraint ());
673
674 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Constraint,hpp::core_impl::ConstraintSet>(server_, __return__)._retn();
675 ✗ } catch (const std::exception& e) {
676 ✗ throw ::hpp::Error (e.what());
677 }
678 }
679
680 // End of implementational code
681 } // namespace graph_impl
682
683 } // namespace manipulation_impl
684
685 } // namespace hpp
686
687 //
688 // Implementational code for IDL interface hpp::manipulation_idl::graph_idl::LevelSetEdge
689 //
690 namespace hpp {
691
692 namespace manipulation_impl {
693
694 namespace graph_impl {
695 template <typename _Base, typename _Storage>
696 ✗ LevelSetEdgeServant<_Base, _Storage>::LevelSetEdgeServant(::hpp::corbaServer::Server* server,
697 const _Storage& s)
698 ✗ : hpp::manipulation_impl::graph_impl::EdgeServant<_Base, _Storage> (server, s)
699 {
700 // add extra constructor code here
701 }
702 template <typename _Base, typename _Storage>
703 ✗ LevelSetEdgeServant<_Base, _Storage>::~LevelSetEdgeServant()
704 {
705 // add extra destructor code here
706 }
707
708 // Methods corresponding to IDL attributes and operations
709
710 template <typename _Base, typename _Storage>
711 ✗ hpp::constraints_idl::Implicits* LevelSetEdgeServant<_Base, _Storage>::paramConstraints ()
712 {
713 try {
714 // automatically generated code.
715
716 ✗ hpp::constraints_idl::Implicits* __return__ = hpp::corbaServer::vectorToSeqServant<hpp::constraints_idl::Implicits,hpp::constraints_impl::Implicit,hpp::constraints_impl::Implicit>(server_) (getT()->paramConstraints ());
717
718 ✗ return __return__;
719 ✗ } catch (const std::exception& e) {
720 ✗ throw ::hpp::Error (e.what());
721 }
722 }
723
724 template <typename _Base, typename _Storage>
725 ✗ hpp::constraints_idl::Implicits* LevelSetEdgeServant<_Base, _Storage>::conditionConstraints ()
726 {
727 try {
728 // automatically generated code.
729
730 ✗ hpp::constraints_idl::Implicits* __return__ = hpp::corbaServer::vectorToSeqServant<hpp::constraints_idl::Implicits,hpp::constraints_impl::Implicit,hpp::constraints_impl::Implicit>(server_) (getT()->conditionConstraints ());
731
732 ✗ return __return__;
733 ✗ } catch (const std::exception& e) {
734 ✗ throw ::hpp::Error (e.what());
735 }
736 }
737
738 template <typename _Base, typename _Storage>
739 ✗ ::CORBA::Boolean LevelSetEdgeServant<_Base, _Storage>::generateTargetConfigOnLeaf (const hpp::floatSeq& qStart, const hpp::floatSeq& qLeaf, hpp::floatSeq& q)
740 {
741 try {
742 // automatically generated code.
743 ✗ hpp::core::vector_t _qStart = hpp::corbaServer::floatSeqToVector (qStart);
744 ✗ hpp::core::vector_t _qLeaf = hpp::corbaServer::floatSeqToVector (qLeaf);
745 ✗ hpp::core::vector_t _q = hpp::corbaServer::floatSeqToVector (q);
746 ✗ ::CORBA::Boolean __return__ (getT()->generateTargetConfigOnLeaf (_qStart, _qLeaf, _q));
747 ✗ hpp::corbaServer::vectorToFloatSeq (_q, q);
748 ✗ return __return__;
749 ✗ } catch (const std::exception& e) {
750 ✗ throw ::hpp::Error (e.what());
751 }
752 }
753
754 // End of implementational code
755 } // namespace graph_impl
756
757 } // namespace manipulation_impl
758
759 } // namespace hpp
760
761 //
762 // Implementational code for IDL interface hpp::manipulation_idl::graph_idl::Validation
763 //
764 namespace hpp {
765
766 namespace manipulation_impl {
767
768 namespace graph_impl {
769 template <typename _Base, typename _Storage>
770 ✗ ValidationServant<_Base, _Storage>::ValidationServant(::hpp::corbaServer::Server* server,
771 const _Storage& s)
772 ✗ : hpp::corbaServer::ServantBase<hpp::manipulation::graph::Validation, _Storage> (server, s)
773 {
774 // add extra constructor code here
775 }
776 template <typename _Base, typename _Storage>
777 ✗ ValidationServant<_Base, _Storage>::~ValidationServant()
778 {
779 // add extra destructor code here
780 }
781
782 // Methods corresponding to IDL attributes and operations
783
784 template <typename _Base, typename _Storage>
785 ✗ char* ValidationServant<_Base, _Storage>::str ()
786 {
787 try {
788 // automatically generated code.
789 ✗ std::ostringstream oss; oss << *get();
790 ✗ std::string res = oss.str();
791 ✗ return CORBA::string_dup(res.c_str());
792 ✗ } catch (const std::exception& e) {
793 ✗ throw ::hpp::Error (e.what());
794 }
795 }
796
797 template <typename _Base, typename _Storage>
798 ✗ ::CORBA::Boolean ValidationServant<_Base, _Storage>::hasErrors ()
799 {
800 try {
801 // automatically generated code.
802
803 ✗ ::CORBA::Boolean __return__ (getT()->hasErrors ());
804
805 ✗ return __return__;
806 ✗ } catch (const std::exception& e) {
807 ✗ throw ::hpp::Error (e.what());
808 }
809 }
810
811 template <typename _Base, typename _Storage>
812 ✗ ::CORBA::Boolean ValidationServant<_Base, _Storage>::hasWarnings ()
813 {
814 try {
815 // automatically generated code.
816
817 ✗ ::CORBA::Boolean __return__ (getT()->hasWarnings ());
818
819 ✗ return __return__;
820 ✗ } catch (const std::exception& e) {
821 ✗ throw ::hpp::Error (e.what());
822 }
823 }
824
825 template <typename _Base, typename _Storage>
826 ✗ hpp::stringSeqSeq* ValidationServant<_Base, _Storage>::getCollisionsForNode (const char* name)
827 {
828 try {
829 // generated from /root/robotpkg/path/py-hpp-manipulation-corba/work/hpp-manipulation-corba-6.0.0/idl/hpp/manipulation_idl/_graph.idl:152
830 ✗ std::string _name (name);
831 ✗ hpp::stringSeqSeq* __return__ (hpp::corbaServer::vectorToStringSeqSeq(getT()->getCollisionsForNode (_name)));
832 ✗ return __return__;
833
834 ✗ } catch (const std::exception& e) {
835 ✗ throw ::hpp::Error (e.what());
836 }
837 }
838
839 template <typename _Base, typename _Storage>
840 ✗ ::CORBA::Boolean ValidationServant<_Base, _Storage>::validate (hpp::manipulation_idl::graph_idl::GraphComponent_ptr comp)
841 {
842 try {
843 // automatically generated code.
844 ✗ hpp::manipulation::graph::GraphComponentPtr_t _comp = ::hpp::corbaServer::reference_to_object<hpp::manipulation::graph::GraphComponent>(server_, comp);
845 ✗ ::CORBA::Boolean __return__ (getT()->validate (_comp));
846
847 ✗ return __return__;
848 ✗ } catch (const std::exception& e) {
849 ✗ throw ::hpp::Error (e.what());
850 }
851 }
852
853 // End of implementational code
854 } // namespace graph_impl
855
856 } // namespace manipulation_impl
857
858 } // namespace hpp
859
860
861
862
863
864 #endif // hpp_manipulation_idl____graph_hxx__
865
866