hpp-corbaserver 5.0.0
Corba server for Humanoid Path Planner applications
Loading...
Searching...
No Matches
paths.hh
Go to the documentation of this file.
1#ifndef hpp_core_idl__paths_hxx__
2#define hpp_core_idl__paths_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/paths.idl
6//
7
9
10#include <sstream>
11
15
16
17
18//
19// Implementational code for IDL interface hpp::core_idl::Path
20//
21namespace hpp {
22
23namespace core_impl {
24template <typename _Base, typename _Storage>
26 const _Storage& s)
27 : hpp::corbaServer::ServantBase<hpp::core::Path, _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>
62void PathServant<_Base, _Storage>::persistantStorage (::CORBA::Boolean persistant)
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 // automatically generated code.
77
78 hpp::size_type __return__ (getT()->outputSize ());
79
80 return __return__;
81 } catch (const std::exception& e) {
82 throw ::hpp::Error (e.what());
83 }
84}
85
86template <typename _Base, typename _Storage>
88{
89 try {
90 // automatically generated code.
91
92 hpp::size_type __return__ (getT()->outputDerivativeSize ());
93
94 return __return__;
95 } catch (const std::exception& e) {
96 throw ::hpp::Error (e.what());
97 }
98}
99
100template <typename _Base, typename _Storage>
102{
103 try {
104 // automatically generated code.
105
106 hpp::value_type __return__ (getT()->length ());
107
108 return __return__;
109 } catch (const std::exception& e) {
110 throw ::hpp::Error (e.what());
111 }
112}
113
114template <typename _Base, typename _Storage>
116{
117 try {
118 // automatically generated code.
119
120 hpp::floatSeq* __return__ = hpp::corbaServer::vectorToFloatSeq (getT()->initial ());
121
122 return __return__;
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
134 hpp::floatSeq* __return__ = hpp::corbaServer::vectorToFloatSeq (getT()->end ());
135
136 return __return__;
137 } catch (const std::exception& e) {
138 throw ::hpp::Error (e.what());
139 }
140}
141
142template <typename _Base, typename _Storage>
143hpp::core_idl::ConstraintSet_ptr PathServant<_Base, _Storage>::constraints ()
144{
145 try {
146 // automatically generated code.
147
148 hpp::core::ConstraintSetPtr_t __return__ (getT()->constraints ());
149
150 return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Constraint,hpp::core_impl::ConstraintSet>(server_, __return__)._retn();
151 } catch (const std::exception& e) {
152 throw ::hpp::Error (e.what());
153 }
154}
155
156template <typename _Base, typename _Storage>
158{
159 try {
160 // automatically generated code.
161 std::ostringstream oss; oss << *get();
162 std::string res = oss.str();
163 return CORBA::string_dup(res.c_str());
164 } catch (const std::exception& e) {
165 throw ::hpp::Error (e.what());
166 }
167}
168
169template <typename _Base, typename _Storage>
171{
172 try {
173 // automatically generated code.
174
175 hpp::floatSeq* __return__ = hpp::corbaServer::vectorToFloatSeq (getT()->eval (t, success));
176
177 return __return__;
178 } catch (const std::exception& e) {
179 throw ::hpp::Error (e.what());
180 }
181}
182
183template <typename _Base, typename _Storage>
185{
186 try {
187 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-5.0.0/idl/hpp/core_idl/paths.idl:23
188 hpp::core::vector_t res (get()->outputSize());
189 success = get()->at (t, res);
191
192 } catch (const std::exception& e) {
193 throw ::hpp::Error (e.what());
194 }
195}
196
197template <typename _Base, typename _Storage>
199{
200 try {
201 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-5.0.0/idl/hpp/core_idl/paths.idl:23
202 hpp::core::vector_t res (get()->outputDerivativeSize());
203 get()->derivative (res, t, order);
205
206 } catch (const std::exception& e) {
207 throw ::hpp::Error (e.what());
208 }
209}
210
211template <typename _Base, typename _Storage>
213{
214 try {
215 // automatically generated code.
216
217 hpp::core::PathPtr_t __return__ (getT()->extract (tmin, tmax));
218
219 return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Path,hpp::core_impl::Path>(server_, __return__)._retn();
220 } catch (const std::exception& e) {
221 throw ::hpp::Error (e.what());
222 }
223}
224
225template <typename _Base, typename _Storage>
226hpp::core_idl::PathVector_ptr PathServant<_Base, _Storage>::asVector ()
227{
228 try {
229 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-5.0.0/idl/hpp/core_idl/paths.idl:23
230 hpp::core::PathPtr_t p = get();
231 hpp::core::PathVectorPtr_t pv =
232 hpp::core::PathVector::create (p->outputSize(), p->outputDerivativeSize());
233 pv->appendPath (p);
234
235 return hpp::corbaServer::makeServant<hpp::core_idl::PathVector_ptr>
236 (server_, new PathVector (server_, pv));
237
238 } catch (const std::exception& e) {
239 throw ::hpp::Error (e.what());
240 }
241}
242
243template <typename _Base, typename _Storage>
245{
246 try {
247 // automatically generated code.
248
249 hpp::core::PathPtr_t __return__ (getT()->reverse ());
250
251 return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Path,hpp::core_impl::Path>(server_, __return__)._retn();
252 } catch (const std::exception& e) {
253 throw ::hpp::Error (e.what());
254 }
255}
256
257// End of implementational code
258} // namespace core_impl
259
260} // namespace hpp
261
262//
263// Implementational code for IDL interface hpp::core_idl::PathVector
264//
265namespace hpp {
266
267namespace core_impl {
268template <typename _Base, typename _Storage>
270 const _Storage& s)
271 : hpp::core_impl::PathServant<_Base, _Storage> (server, s)
272{
273 // add extra constructor code here
274}
275template <typename _Base, typename _Storage>
277{
278 // add extra destructor code here
279}
280
281// Methods corresponding to IDL attributes and operations
282
283template <typename _Base, typename _Storage>
285{
286 try {
287 // automatically generated code.
288
289 hpp::core_idl::size_t __return__ (getT()->numberPaths ());
290
291 return __return__;
292 } catch (const std::exception& e) {
293 throw ::hpp::Error (e.what());
294 }
295}
296
297template <typename _Base, typename _Storage>
299{
300 try {
301 // automatically generated code.
302
303 hpp::core_idl::size_t __return__ (getT()->rankAtParam (param, localParam));
304
305 return __return__;
306 } catch (const std::exception& e) {
307 throw ::hpp::Error (e.what());
308 }
309}
310
311template <typename _Base, typename _Storage>
313{
314 try {
315 // automatically generated code.
316
317 hpp::core::PathPtr_t __return__ (getT()->pathAtRank (rank));
318
319 return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Path,hpp::core_impl::Path>(server_, __return__)._retn();
320 } catch (const std::exception& e) {
321 throw ::hpp::Error (e.what());
322 }
323}
324
325template <typename _Base, typename _Storage>
327{
328 try {
329 // automatically generated code.
330 hpp::core::PathPtr_t _p = ::hpp::corbaServer::reference_to_object<hpp::core::Path>(server_, p);
331 (getT()->appendPath (_p));
332
333
334 } catch (const std::exception& e) {
335 throw ::hpp::Error (e.what());
336 }
337}
338
339template <typename _Base, typename _Storage>
340void PathVectorServant<_Base, _Storage>::concatenate (hpp::core_idl::PathVector_ptr p)
341{
342 try {
343 // automatically generated code.
344 hpp::core::PathVectorPtr_t _p = ::hpp::corbaServer::reference_to_object<hpp::core::PathVector>(server_, p);
345 (getT()->concatenate (_p));
346
347
348 } catch (const std::exception& e) {
349 throw ::hpp::Error (e.what());
350 }
351}
352
353template <typename _Base, typename _Storage>
354hpp::core_idl::PathVector_ptr PathVectorServant<_Base, _Storage>::flatten ()
355{
356 try {
357 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-5.0.0/idl/hpp/core_idl/paths.idl:67
358 hpp::core::PathPtr_t p = get();
359 hpp::core::PathVectorPtr_t pv =
360 HPP_DYNAMIC_PTR_CAST(hpp::core::PathVector, p);
361 hpp::core::PathVectorPtr_t out =
362 hpp::core::PathVector::create (p->outputSize(), p->outputDerivativeSize());
363 pv->flatten (out);
364
365 return hpp::corbaServer::makeServant<hpp::core_idl::PathVector_ptr>
366 (server_, new PathVector (server_, out));
367
368 } catch (const std::exception& e) {
369 throw ::hpp::Error (e.what());
370 }
371}
372
373// End of implementational code
374} // namespace core_impl
375
376} // namespace hpp
377
378//
379// Implementational code for IDL interface hpp::core_idl::path_idl::Hermite
380//
381namespace hpp {
382
383namespace core_impl {
384
385namespace path_impl {
386template <typename _Base, typename _Storage>
388 const _Storage& s)
389 : hpp::core_impl::PathServant<_Base, _Storage> (server, s)
390{
391 // add extra constructor code here
392}
393template <typename _Base, typename _Storage>
395{
396 // add extra destructor code here
397}
398
399// Methods corresponding to IDL attributes and operations
400
401// End of implementational code
402} // namespace path_impl
403
404} // namespace core_impl
405
406} // namespace hpp
407
408
409
410
411
412#endif // hpp_core_idl__paths_hxx__
413
bool persistantStorage() const
See persistantStorage(bool)
Definition: servant-base.hh:166
Implementation of Hpp module Corba server.
Definition: server.hh:78
Definition: paths-fwd.hh:29
hpp::size_type outputSize()
Definition: paths.hh:73
hpp::floatSeq * at(hpp::value_type t, ::CORBA::Boolean &success)
Definition: paths.hh:184
::CORBA::Boolean deleteIfExpired()
Definition: paths.hh:51
char * str()
Definition: paths.hh:157
hpp::floatSeq * derivative(hpp::value_type t, ::CORBA::Short order)
Definition: paths.hh:198
virtual ~PathServant()
Definition: paths.hh:32
hpp::size_type outputDerivativeSize()
Definition: paths.hh:87
hpp::value_type length()
Definition: paths.hh:101
PathServant(::hpp::corbaServer::Server *server, const _Storage &s)
Definition: paths.hh:25
hpp::floatSeq * initial()
Definition: paths.hh:115
hpp::core_idl::PathVector_ptr asVector()
Definition: paths.hh:226
hpp::floatSeq * end()
Definition: paths.hh:129
hpp::core_idl::Path_ptr reverse()
Definition: paths.hh:244
hpp::floatSeq * call(hpp::value_type t, ::CORBA::Boolean &success)
Definition: paths.hh:170
hpp::core_idl::Path_ptr extract(hpp::value_type tmin, hpp::value_type tmax)
Definition: paths.hh:212
void deleteThis()
Definition: paths.hh:40
hpp::core_idl::ConstraintSet_ptr constraints()
Definition: paths.hh:143
Definition: paths-fwd.hh:111
void concatenate(hpp::core_idl::PathVector_ptr p)
Definition: paths.hh:340
hpp::core_idl::size_t numberPaths()
Definition: paths.hh:284
hpp::core_idl::Path_ptr pathAtRank(hpp::core_idl::size_t rank)
Definition: paths.hh:312
PathVectorServant(::hpp::corbaServer::Server *server, const _Storage &s)
Definition: paths.hh:269
virtual ~PathVectorServant()
Definition: paths.hh:276
hpp::core_idl::size_t rankAtParam(hpp::value_type param, hpp::value_type &localParam)
Definition: paths.hh:298
hpp::core_idl::PathVector_ptr flatten()
Definition: paths.hh:354
void appendPath(hpp::core_idl::Path_ptr p)
Definition: paths.hh:326
HermiteServant(::hpp::corbaServer::Server *server, const _Storage &s)
Definition: paths.hh:387
virtual ~HermiteServant()
Definition: paths.hh:394
floatSeq * vectorToFloatSeq(core::vectorIn_t input)
unsigned long long size_t
Definition: paths.idl:18
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
double value_type
Definition: common.idl:18