hpp-corbaserver 4.14.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-4.14.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
56 hpp::size_type __return__ (getT()->outputSize ());
57
58 return __return__;
59 } catch (const std::exception& e) {
60 throw ::hpp::Error (e.what());
61 }
62}
63
64template <typename _Base, typename _Storage>
66{
67 try {
68 // automatically generated code.
69
70 hpp::size_type __return__ (getT()->outputDerivativeSize ());
71
72 return __return__;
73 } catch (const std::exception& e) {
74 throw ::hpp::Error (e.what());
75 }
76}
77
78template <typename _Base, typename _Storage>
80{
81 try {
82 // automatically generated code.
83
84 hpp::value_type __return__ (getT()->length ());
85
86 return __return__;
87 } catch (const std::exception& e) {
88 throw ::hpp::Error (e.what());
89 }
90}
91
92template <typename _Base, typename _Storage>
94{
95 try {
96 // automatically generated code.
97
98 hpp::floatSeq* __return__ = hpp::corbaServer::vectorToFloatSeq (getT()->initial ());
99
100 return __return__;
101 } catch (const std::exception& e) {
102 throw ::hpp::Error (e.what());
103 }
104}
105
106template <typename _Base, typename _Storage>
108{
109 try {
110 // automatically generated code.
111
112 hpp::floatSeq* __return__ = hpp::corbaServer::vectorToFloatSeq (getT()->end ());
113
114 return __return__;
115 } catch (const std::exception& e) {
116 throw ::hpp::Error (e.what());
117 }
118}
119
120template <typename _Base, typename _Storage>
121hpp::core_idl::ConstraintSet_ptr PathServant<_Base, _Storage>::constraints ()
122{
123 try {
124 // automatically generated code.
125
126 hpp::core::ConstraintSetPtr_t __return__ (getT()->constraints ());
127
128 return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Constraint,hpp::core_impl::ConstraintSet>(server_, __return__)._retn();
129 } catch (const std::exception& e) {
130 throw ::hpp::Error (e.what());
131 }
132}
133
134template <typename _Base, typename _Storage>
136{
137 try {
138 // automatically generated code.
139 std::ostringstream oss; oss << *get();
140 std::string res = oss.str();
141 return CORBA::string_dup(res.c_str());
142 } catch (const std::exception& e) {
143 throw ::hpp::Error (e.what());
144 }
145}
146
147template <typename _Base, typename _Storage>
149{
150 try {
151 // automatically generated code.
152
153 hpp::floatSeq* __return__ = hpp::corbaServer::vectorToFloatSeq (getT()->eval (t, success));
154
155 return __return__;
156 } catch (const std::exception& e) {
157 throw ::hpp::Error (e.what());
158 }
159}
160
161template <typename _Base, typename _Storage>
163{
164 try {
165 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-4.14.0/idl/hpp/core_idl/paths.idl:23
166 hpp::core::vector_t res (get()->outputSize());
167 success = get()->at (t, res);
169
170 } catch (const std::exception& e) {
171 throw ::hpp::Error (e.what());
172 }
173}
174
175template <typename _Base, typename _Storage>
177{
178 try {
179 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-4.14.0/idl/hpp/core_idl/paths.idl:23
180 hpp::core::vector_t res (get()->outputDerivativeSize());
181 get()->derivative (res, t, order);
183
184 } catch (const std::exception& e) {
185 throw ::hpp::Error (e.what());
186 }
187}
188
189template <typename _Base, typename _Storage>
191{
192 try {
193 // automatically generated code.
194
195 hpp::core::PathPtr_t __return__ (getT()->extract (tmin, tmax));
196
197 return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Path,hpp::core_impl::Path>(server_, __return__)._retn();
198 } catch (const std::exception& e) {
199 throw ::hpp::Error (e.what());
200 }
201}
202
203template <typename _Base, typename _Storage>
204hpp::core_idl::PathVector_ptr PathServant<_Base, _Storage>::asVector ()
205{
206 try {
207 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-4.14.0/idl/hpp/core_idl/paths.idl:23
208 hpp::core::PathPtr_t p = get();
209 hpp::core::PathVectorPtr_t pv =
210 hpp::core::PathVector::create (p->outputSize(), p->outputDerivativeSize());
211 pv->appendPath (p);
212
213 return hpp::corbaServer::makeServant<hpp::core_idl::PathVector_ptr>
214 (server_, new PathVector (server_, pv));
215
216 } catch (const std::exception& e) {
217 throw ::hpp::Error (e.what());
218 }
219}
220
221template <typename _Base, typename _Storage>
223{
224 try {
225 // automatically generated code.
226
227 hpp::core::PathPtr_t __return__ (getT()->reverse ());
228
229 return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Path,hpp::core_impl::Path>(server_, __return__)._retn();
230 } catch (const std::exception& e) {
231 throw ::hpp::Error (e.what());
232 }
233}
234
235// End of implementational code
236} // namespace core_impl
237
238} // namespace hpp
239
240//
241// Implementational code for IDL interface hpp::core_idl::PathVector
242//
243namespace hpp {
244
245namespace core_impl {
246template <typename _Base, typename _Storage>
248 const _Storage& s)
249 : hpp::core_impl::PathServant<_Base, _Storage> (server, s)
250{
251 // add extra constructor code here
252}
253template <typename _Base, typename _Storage>
255{
256 // add extra destructor code here
257}
258
259// Methods corresponding to IDL attributes and operations
260
261template <typename _Base, typename _Storage>
263{
264 try {
265 // automatically generated code.
266
267 hpp::core_idl::size_t __return__ (getT()->numberPaths ());
268
269 return __return__;
270 } catch (const std::exception& e) {
271 throw ::hpp::Error (e.what());
272 }
273}
274
275template <typename _Base, typename _Storage>
277{
278 try {
279 // automatically generated code.
280
281 hpp::core_idl::size_t __return__ (getT()->rankAtParam (param, localParam));
282
283 return __return__;
284 } catch (const std::exception& e) {
285 throw ::hpp::Error (e.what());
286 }
287}
288
289template <typename _Base, typename _Storage>
291{
292 try {
293 // automatically generated code.
294
295 hpp::core::PathPtr_t __return__ (getT()->pathAtRank (rank));
296
297 return ::hpp::corbaServer::makeServantDownCast<hpp::core_impl::Path,hpp::core_impl::Path>(server_, __return__)._retn();
298 } catch (const std::exception& e) {
299 throw ::hpp::Error (e.what());
300 }
301}
302
303template <typename _Base, typename _Storage>
305{
306 try {
307 // automatically generated code.
308 hpp::core::PathPtr_t _p = ::hpp::corbaServer::reference_to_object<hpp::core::Path>(server_, p);
309 (getT()->appendPath (_p));
310
311
312 } catch (const std::exception& e) {
313 throw ::hpp::Error (e.what());
314 }
315}
316
317template <typename _Base, typename _Storage>
318void PathVectorServant<_Base, _Storage>::concatenate (hpp::core_idl::PathVector_ptr p)
319{
320 try {
321 // automatically generated code.
322 hpp::core::PathVectorPtr_t _p = ::hpp::corbaServer::reference_to_object<hpp::core::PathVector>(server_, p);
323 (getT()->concatenate (_p));
324
325
326 } catch (const std::exception& e) {
327 throw ::hpp::Error (e.what());
328 }
329}
330
331template <typename _Base, typename _Storage>
332hpp::core_idl::PathVector_ptr PathVectorServant<_Base, _Storage>::flatten ()
333{
334 try {
335 // generated from /local/robotpkg/var/tmp/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-4.14.0/idl/hpp/core_idl/paths.idl:67
336 hpp::core::PathPtr_t p = get();
337 hpp::core::PathVectorPtr_t pv =
338 HPP_DYNAMIC_PTR_CAST(hpp::core::PathVector, p);
339 hpp::core::PathVectorPtr_t out =
340 hpp::core::PathVector::create (p->outputSize(), p->outputDerivativeSize());
341 pv->flatten (out);
342
343 return hpp::corbaServer::makeServant<hpp::core_idl::PathVector_ptr>
344 (server_, new PathVector (server_, out));
345
346 } catch (const std::exception& e) {
347 throw ::hpp::Error (e.what());
348 }
349}
350
351// End of implementational code
352} // namespace core_impl
353
354} // namespace hpp
355
356
357
358
359
360#endif // hpp_core_idl__paths_hxx__
361
Implementation of Hpp module Corba server.
Definition: server.hh:77
Definition: paths-fwd.hh:28
hpp::size_type outputSize()
Definition: paths.hh:51
hpp::floatSeq * at(hpp::value_type t, ::CORBA::Boolean &success)
Definition: paths.hh:162
char * str()
Definition: paths.hh:135
hpp::floatSeq * derivative(hpp::value_type t, ::CORBA::Short order)
Definition: paths.hh:176
virtual ~PathServant()
Definition: paths.hh:32
hpp::size_type outputDerivativeSize()
Definition: paths.hh:65
hpp::value_type length()
Definition: paths.hh:79
PathServant(::hpp::corbaServer::Server *server, const _Storage &s)
Definition: paths.hh:25
hpp::floatSeq * initial()
Definition: paths.hh:93
hpp::core_idl::PathVector_ptr asVector()
Definition: paths.hh:204
hpp::floatSeq * end()
Definition: paths.hh:107
hpp::core_idl::Path_ptr reverse()
Definition: paths.hh:222
hpp::floatSeq * call(hpp::value_type t, ::CORBA::Boolean &success)
Definition: paths.hh:148
hpp::core_idl::Path_ptr extract(hpp::value_type tmin, hpp::value_type tmax)
Definition: paths.hh:190
void deleteThis()
Definition: paths.hh:40
hpp::core_idl::ConstraintSet_ptr constraints()
Definition: paths.hh:121
Definition: paths-fwd.hh:104
void concatenate(hpp::core_idl::PathVector_ptr p)
Definition: paths.hh:318
hpp::core_idl::size_t numberPaths()
Definition: paths.hh:262
hpp::core_idl::Path_ptr pathAtRank(hpp::core_idl::size_t rank)
Definition: paths.hh:290
PathVectorServant(::hpp::corbaServer::Server *server, const _Storage &s)
Definition: paths.hh:247
virtual ~PathVectorServant()
Definition: paths.hh:254
hpp::core_idl::size_t rankAtParam(hpp::value_type param, hpp::value_type &localParam)
Definition: paths.hh:276
hpp::core_idl::PathVector_ptr flatten()
Definition: paths.hh:332
void appendPath(hpp::core_idl::Path_ptr p)
Definition: paths.hh:304
floatSeq * vectorToFloatSeq(core::vectorIn_t input)
unsigned long long size_t
Definition: paths.idl:18
Implement CORBA interface `‘Obstacle’'.
Definition: basic-server.hh:35
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