GCC Code Coverage Report

Directory: ./
File: src/hpp/core_idl/_problem.hh
Date: 2025-05-11 11:10:19
Exec Total Coverage
Lines: 12 140 8.6%
Branches: 6 276 2.2%
Line Branch Exec Source
1 #ifndef hpp_core_idl____problem_hxx__
2 #define hpp_core_idl____problem_hxx__
3
4 //
5 // Implemention of IDL interfaces in file /root/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-6.0.0/idl/hpp/core_idl/_problem.idl
6 //
7
8 #include <hpp/core_idl/_problem-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::core_idl::Problem
20 //
21 namespace hpp {
22
23 namespace core_impl {
24 template <typename _Base, typename _Storage>
25 3 ProblemServant<_Base, _Storage>::ProblemServant(::hpp::corbaServer::Server* server,
26 const _Storage& s)
27
2/4
✓ Branch 3 taken 3 times.
✗ Branch 4 not taken.
✓ Branch 7 taken 3 times.
✗ Branch 8 not taken.
 3 : hpp::corbaServer::ServantBase<hpp::core::Problem, _Storage> (server, s)
28 {
29 // add extra constructor code here
30 3 }
31 template <typename _Base, typename _Storage>
32 12 ProblemServant<_Base, _Storage>::~ProblemServant()
33 {
34 // add extra destructor code here
35 12 }
36
37 // Methods corresponding to IDL attributes and operations
38
39 template <typename _Base, typename _Storage>
40 ✗ void ProblemServant<_Base, _Storage>::deleteThis ()
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>
51 ✗ ::CORBA::Boolean ProblemServant<_Base, _Storage>::deleteIfExpired ()
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>
62 1 void ProblemServant<_Base, _Storage>::persistantStorage (::CORBA::Boolean persistant)
63 {
64 try {
65 // automatically generated code.
66
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 _ServantBase::persistantStorage(persistant);
67 ✗ } catch (const std::exception& e) {
68 ✗ throw ::hpp::Error (e.what());
69 }
70 1 }
71
72 template <typename _Base, typename _Storage>
73 2 hpp::pinocchio_idl::Device_ptr ProblemServant<_Base, _Storage>::robot ()
74 {
75 try {
76 // automatically generated code.
77
78
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
 2 hpp::pinocchio::DevicePtr_t __return__ (getT()->robot ());
79
80
2/4
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 2 times.
✗ Branch 6 not taken.
 4 return ::hpp::corbaServer::makeServantDownCast<hpp::pinocchio_impl::Device,hpp::pinocchio_impl::Device>(server_, __return__)._retn();
81
0/2
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 2 } catch (const std::exception& e) {
82 ✗ throw ::hpp::Error (e.what());
83 }
84 }
85
86 template <typename _Base, typename _Storage>
87 ✗ void ProblemServant<_Base, _Storage>::setInitConfig (const hpp::floatSeq& init)
88 {
89 try {
90 // generated from /root/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-6.0.0/idl/hpp/core_idl/_problem.idl:33
91 ✗ pinocchio::Configuration_t q (corbaServer::floatSeqToConfig(getT()->robot(), init, true));
92 ✗ getT()->initConfig (q);
93
94 ✗ } catch (const std::exception& e) {
95 ✗ throw ::hpp::Error (e.what());
96 }
97 }
98
99 template <typename _Base, typename _Storage>
100 ✗ hpp::floatSeq* ProblemServant<_Base, _Storage>::getInitConfig ()
101 {
102 try {
103 // automatically generated code.
104
105 ✗ hpp::floatSeq* __return__ = hpp::corbaServer::vectorToFloatSeq (getT()->initConfig ());
106
107 ✗ return __return__;
108 ✗ } catch (const std::exception& e) {
109 ✗ throw ::hpp::Error (e.what());
110 }
111 }
112
113 template <typename _Base, typename _Storage>
114 ✗ void ProblemServant<_Base, _Storage>::addGoalConfig (const hpp::floatSeq& goal)
115 {
116 try {
117 // generated from /root/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-6.0.0/idl/hpp/core_idl/_problem.idl:33
118 ✗ pinocchio::Configuration_t q (corbaServer::floatSeqToConfig(getT()->robot(), goal, true));
119 ✗ getT()->addGoalConfig (q);
120
121 ✗ } catch (const std::exception& e) {
122 ✗ throw ::hpp::Error (e.what());
123 }
124 }
125
126 template <typename _Base, typename _Storage>
127 ✗ void ProblemServant<_Base, _Storage>::resetGoalConfigs ()
128 {
129 try {
130 // automatically generated code.
131
132 ✗ (getT()->resetGoalConfigs ());
133
134
135 ✗ } catch (const std::exception& e) {
136 ✗ throw ::hpp::Error (e.what());
137 }
138 }
139
140 template <typename _Base, typename _Storage>
141 ✗ hpp::core_idl::Constraint_ptr ProblemServant<_Base, _Storage>::getConstraints ()
142 {
143 try {
144 // automatically generated code.
145
146 ✗ hpp::core::ConstraintPtr_t __return__ (getT()->constraints ());
147
148 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Constraint,hpp::core_impl::Constraint>(server_, __return__)._retn();
149 ✗ } catch (const std::exception& e) {
150 ✗ throw ::hpp::Error (e.what());
151 }
152 }
153
154 template <typename _Base, typename _Storage>
155 ✗ void ProblemServant<_Base, _Storage>::setConstraints (hpp::core_idl::Constraint_ptr constraints)
156 {
157 try {
158 // generated from /root/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-6.0.0/idl/hpp/core_idl/_problem.idl:33
159 ✗ hpp::core::ConstraintPtr_t c = ::hpp::corbaServer::reference_to_servant_base<hpp::core::Constraint>(server_, constraints)->get();
160 ✗ hpp::core::ConstraintSetPtr_t cs = HPP_DYNAMIC_PTR_CAST(hpp::core::ConstraintSet, c);
161 ✗ if (!cs) throw hpp::Error("Constraint is not of type ConstraintSet");
162 ✗ (getT()->constraints (cs));
163
164 ✗ } catch (const std::exception& e) {
165 ✗ throw ::hpp::Error (e.what());
166 }
167 }
168
169 template <typename _Base, typename _Storage>
170 ✗ hpp::core_idl::Distance_ptr ProblemServant<_Base, _Storage>::getDistance ()
171 {
172 try {
173 // automatically generated code.
174
175 ✗ hpp::core::DistancePtr_t __return__ (getT()->distance ());
176
177 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Distance,hpp::core_impl::Distance>(server_, __return__)._retn();
178 ✗ } catch (const std::exception& e) {
179 ✗ throw ::hpp::Error (e.what());
180 }
181 }
182
183 template <typename _Base, typename _Storage>
184 ✗ void ProblemServant<_Base, _Storage>::setDistance (hpp::core_idl::Distance_ptr d)
185 {
186 try {
187 // automatically generated code.
188 ✗ hpp::core::DistancePtr_t _d = ::hpp::corbaServer::reference_to_object<hpp::core::Distance>(server_, d);
189 ✗ (getT()->distance (_d));
190
191
192 ✗ } catch (const std::exception& e) {
193 ✗ throw ::hpp::Error (e.what());
194 }
195 }
196
197 template <typename _Base, typename _Storage>
198 ✗ hpp::core_idl::SteeringMethod_ptr ProblemServant<_Base, _Storage>::getSteeringMethod ()
199 {
200 try {
201 // automatically generated code.
202
203 ✗ hpp::core::SteeringMethodPtr_t __return__ (getT()->steeringMethod ());
204
205 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::SteeringMethod,hpp::core_impl::SteeringMethod>(server_, __return__)._retn();
206 ✗ } catch (const std::exception& e) {
207 ✗ throw ::hpp::Error (e.what());
208 }
209 }
210
211 template <typename _Base, typename _Storage>
212 ✗ void ProblemServant<_Base, _Storage>::setSteeringMethod (hpp::core_idl::SteeringMethod_ptr d)
213 {
214 try {
215 // automatically generated code.
216 ✗ hpp::core::SteeringMethodPtr_t _d = ::hpp::corbaServer::reference_to_object<hpp::core::SteeringMethod>(server_, d);
217 ✗ (getT()->steeringMethod (_d));
218
219
220 ✗ } catch (const std::exception& e) {
221 ✗ throw ::hpp::Error (e.what());
222 }
223 }
224
225 template <typename _Base, typename _Storage>
226 ✗ hpp::core_idl::PathValidation_ptr ProblemServant<_Base, _Storage>::getPathValidation ()
227 {
228 try {
229 // automatically generated code.
230
231 ✗ hpp::core::PathValidationPtr_t __return__ (getT()->pathValidation ());
232
233 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::PathValidation,hpp::core_impl::PathValidation>(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 ✗ void ProblemServant<_Base, _Storage>::setPathValidation (hpp::core_idl::PathValidation_ptr d)
241 {
242 try {
243 // automatically generated code.
244 ✗ hpp::core::PathValidationPtr_t _d = ::hpp::corbaServer::reference_to_object<hpp::core::PathValidation>(server_, d);
245 ✗ (getT()->pathValidation (_d));
246
247
248 ✗ } catch (const std::exception& e) {
249 ✗ throw ::hpp::Error (e.what());
250 }
251 }
252
253 template <typename _Base, typename _Storage>
254 ✗ hpp::core_idl::PathProjector_ptr ProblemServant<_Base, _Storage>::getPathProjector ()
255 {
256 try {
257 // automatically generated code.
258
259 ✗ hpp::core::PathProjectorPtr_t __return__ (getT()->pathProjector ());
260
261 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::PathProjector,hpp::core_impl::PathProjector>(server_, __return__)._retn();
262 ✗ } catch (const std::exception& e) {
263 ✗ throw ::hpp::Error (e.what());
264 }
265 }
266
267 template <typename _Base, typename _Storage>
268 ✗ void ProblemServant<_Base, _Storage>::setPathProjector (hpp::core_idl::PathProjector_ptr p)
269 {
270 try {
271 // automatically generated code.
272 ✗ hpp::core::PathProjectorPtr_t _p = ::hpp::corbaServer::reference_to_object<hpp::core::PathProjector>(server_, p);
273 ✗ (getT()->pathProjector (_p));
274
275
276 ✗ } catch (const std::exception& e) {
277 ✗ throw ::hpp::Error (e.what());
278 }
279 }
280
281 template <typename _Base, typename _Storage>
282 ✗ hpp::core_idl::ConfigValidation_ptr ProblemServant<_Base, _Storage>::getConfigValidations ()
283 {
284 try {
285 // automatically generated code.
286
287 ✗ hpp::core::ConfigValidationPtr_t __return__ (getT()->configValidations ());
288
289 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::ConfigValidation,hpp::core_impl::ConfigValidation>(server_, __return__)._retn();
290 ✗ } catch (const std::exception& e) {
291 ✗ throw ::hpp::Error (e.what());
292 }
293 }
294
295 template <typename _Base, typename _Storage>
296 ✗ void ProblemServant<_Base, _Storage>::clearConfigValidations ()
297 {
298 try {
299 // automatically generated code.
300
301 ✗ (getT()->clearConfigValidations ());
302
303
304 ✗ } catch (const std::exception& e) {
305 ✗ throw ::hpp::Error (e.what());
306 }
307 }
308
309 template <typename _Base, typename _Storage>
310 ✗ void ProblemServant<_Base, _Storage>::addConfigValidation (hpp::core_idl::ConfigValidation_ptr cfgValidation)
311 {
312 try {
313 // automatically generated code.
314 ✗ hpp::core::ConfigValidationPtr_t _cfgValidation = ::hpp::corbaServer::reference_to_object<hpp::core::ConfigValidation>(server_, cfgValidation);
315 ✗ (getT()->addConfigValidation (_cfgValidation));
316
317
318 ✗ } catch (const std::exception& e) {
319 ✗ throw ::hpp::Error (e.what());
320 }
321 }
322
323 template <typename _Base, typename _Storage>
324 ✗ hpp::core_idl::ConfigurationShooter_ptr ProblemServant<_Base, _Storage>::getConfigurationShooter ()
325 {
326 try {
327 // automatically generated code.
328
329 ✗ hpp::core::ConfigurationShooterPtr_t __return__ (getT()->configurationShooter ());
330
331 ✗ return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::ConfigurationShooter,hpp::core_impl::ConfigurationShooter>(server_, __return__)._retn();
332 ✗ } catch (const std::exception& e) {
333 ✗ throw ::hpp::Error (e.what());
334 }
335 }
336
337 template <typename _Base, typename _Storage>
338 ✗ void ProblemServant<_Base, _Storage>::setConfigurationShooter (hpp::core_idl::ConfigurationShooter_ptr d)
339 {
340 try {
341 // automatically generated code.
342 ✗ hpp::core::ConfigurationShooterPtr_t _d = ::hpp::corbaServer::reference_to_object<hpp::core::ConfigurationShooter>(server_, d);
343 ✗ (getT()->configurationShooter (_d));
344
345
346 ✗ } catch (const std::exception& e) {
347 ✗ throw ::hpp::Error (e.what());
348 }
349 }
350
351 template <typename _Base, typename _Storage>
352 ✗ void ProblemServant<_Base, _Storage>::filterCollisionPairs ()
353 {
354 try {
355 // automatically generated code.
356
357 ✗ (getT()->filterCollisionPairs ());
358
359
360 ✗ } catch (const std::exception& e) {
361 ✗ throw ::hpp::Error (e.what());
362 }
363 }
364
365 template <typename _Base, typename _Storage>
366 ✗ void ProblemServant<_Base, _Storage>::setSecurityMargins (const hpp::floatSeqSeq& margins)
367 {
368 try {
369 // automatically generated code.
370 ✗ hpp::core::matrix_t _margins = hpp::corbaServer::floatSeqSeqToMatrix (margins);
371 ✗ (getT()->setSecurityMargins (_margins));
372
373
374 ✗ } catch (const std::exception& e) {
375 ✗ throw ::hpp::Error (e.what());
376 }
377 }
378
379 template <typename _Base, typename _Storage>
380 ✗ void ProblemServant<_Base, _Storage>::addObstacle (hpp::pinocchio_idl::CollisionObject_ptr object)
381 {
382 try {
383 // automatically generated code.
384 ✗ hpp::pinocchio::CollisionObjectPtr_t _object = ::hpp::corbaServer::reference_to_object<hpp::pinocchio::CollisionObject>(server_, object);
385 ✗ (getT()->addObstacle (_object));
386
387
388 ✗ } catch (const std::exception& e) {
389 ✗ throw ::hpp::Error (e.what());
390 }
391 }
392
393 template <typename _Base, typename _Storage>
394 ✗ void ProblemServant<_Base, _Storage>::setParameter (const char* name, const ::CORBA::Any& value)
395 {
396 try {
397 // generated from /root/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-6.0.0/idl/hpp/core_idl/_problem.idl:33
398 ✗ getT()->setParameter(name, hpp::corbaServer::toParameter(value));
399
400 ✗ } catch (const std::exception& e) {
401 ✗ throw ::hpp::Error (e.what());
402 }
403 }
404
405 template <typename _Base, typename _Storage>
406 ✗ ::CORBA::Any* ProblemServant<_Base, _Storage>::getParameter (const char* name)
407 {
408 try {
409 // generated from /root/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-6.0.0/idl/hpp/core_idl/_problem.idl:33
410 ✗ return hpp::corbaServer::toCorbaAnyPtr(getT()->getParameter(name));
411
412 ✗ } catch (const std::exception& e) {
413 ✗ throw ::hpp::Error (e.what());
414 }
415 }
416
417 // End of implementational code
418 } // namespace core_impl
419
420 } // namespace hpp
421
422
423
424
425
426 #endif // hpp_core_idl____problem_hxx__
427
428