Directory: | ./ |
---|---|
File: | src/hpp/core_idl/_problem.hh |
Date: | 2024-12-13 15:50:05 |
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 |