GCC Code Coverage Report


Directory: ./
File: src/hpp/corbaserver/obstacleSK.cc
Date: 2024-12-13 15:50:05
Exec Total Coverage
Lines: 18 555 3.2%
Branches: 6 360 1.7%

Line Branch Exec Source
1 // This file is generated by omniidl (C++ backend) - omniORB_4_3. Do not edit.
2
3 #include "obstacle-idl.hh"
4 #include <omniORB4/IOP_S.h>
5 #include <omniORB4/IOP_C.h>
6 #include <omniORB4/callDescriptor.h>
7 #include <omniORB4/callHandle.h>
8 #include <omniORB4/objTracker.h>
9
10
11 OMNI_USING_NAMESPACE(omni)
12
13 OMNI_MAYBE_UNUSED static const char* _0RL_library_version = omniORB_4_3;
14
15
16
17 hpp::corbaserver::Obstacle_ptr hpp::corbaserver::Obstacle_Helper::_nil() {
18 return ::hpp::corbaserver::Obstacle::_nil();
19 }
20
21 ::CORBA::Boolean hpp::corbaserver::Obstacle_Helper::is_nil(::hpp::corbaserver::Obstacle_ptr p) {
22 return ::CORBA::is_nil(p);
23
24 }
25
26 void hpp::corbaserver::Obstacle_Helper::release(::hpp::corbaserver::Obstacle_ptr p) {
27 ::CORBA::release(p);
28 }
29
30 void hpp::corbaserver::Obstacle_Helper::marshalObjRef(::hpp::corbaserver::Obstacle_ptr obj, cdrStream& s) {
31 ::hpp::corbaserver::Obstacle::_marshalObjRef(obj, s);
32 }
33
34 hpp::corbaserver::Obstacle_ptr hpp::corbaserver::Obstacle_Helper::unmarshalObjRef(cdrStream& s) {
35 return ::hpp::corbaserver::Obstacle::_unmarshalObjRef(s);
36 }
37
38 void hpp::corbaserver::Obstacle_Helper::duplicate(::hpp::corbaserver::Obstacle_ptr obj) {
39 if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
40 }
41
42 hpp::corbaserver::Obstacle_ptr
43 hpp::corbaserver::Obstacle::_duplicate(::hpp::corbaserver::Obstacle_ptr obj)
44 {
45 if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
46 return obj;
47 }
48
49 hpp::corbaserver::Obstacle_ptr
50 hpp::corbaserver::Obstacle::_narrow(::CORBA::Object_ptr obj)
51 {
52 if (!obj || obj->_NP_is_nil() || obj->_NP_is_pseudo()) return _nil();
53 _ptr_type e = (_ptr_type) obj->_PR_getobj()->_realNarrow(_PD_repoId);
54 return e ? e : _nil();
55 }
56
57
58 hpp::corbaserver::Obstacle_ptr
59 hpp::corbaserver::Obstacle::_unchecked_narrow(::CORBA::Object_ptr obj)
60 {
61 if (!obj || obj->_NP_is_nil() || obj->_NP_is_pseudo()) return _nil();
62 _ptr_type e = (_ptr_type) obj->_PR_getobj()->_uncheckedNarrow(_PD_repoId);
63 return e ? e : _nil();
64 }
65
66 hpp::corbaserver::Obstacle_ptr
67 hpp::corbaserver::Obstacle::_nil()
68 {
69 #ifdef OMNI_UNLOADABLE_STUBS
70 static _objref_Obstacle _the_nil_obj;
71 return &_the_nil_obj;
72 #else
73 static _objref_Obstacle* _the_nil_ptr = 0;
74 if (!_the_nil_ptr) {
75 omni::nilRefLock().lock();
76 if (!_the_nil_ptr) {
77 _the_nil_ptr = new _objref_Obstacle;
78 registerNilCorbaObject(_the_nil_ptr);
79 }
80 omni::nilRefLock().unlock();
81 }
82 return _the_nil_ptr;
83 #endif
84 }
85
86 const char* hpp::corbaserver::Obstacle::_PD_repoId = "IDL:hpp/corbaserver/Obstacle:1.0";
87
88
89 32 hpp::corbaserver::_objref_Obstacle::~_objref_Obstacle() {
90
91 }
92
93
94 16 hpp::corbaserver::_objref_Obstacle::_objref_Obstacle(omniIOR* ior, omniIdentity* id) :
95
1/2
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
16 omniObjRef(::hpp::corbaserver::Obstacle::_PD_repoId, ior, id, 1)
96
97
98 {
99 16 _PR_setobj(this);
100 }
101
102 void*
103 26 hpp::corbaserver::_objref_Obstacle::_ptrToObjRef(const char* id)
104 {
105
1/2
✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
26 if (id == ::hpp::corbaserver::Obstacle::_PD_repoId)
106 26 return (::hpp::corbaserver::Obstacle_ptr) this;
107
108 if (id == ::CORBA::Object::_PD_repoId)
109 return (::CORBA::Object_ptr) this;
110
111 if (omni::strMatch(id, ::hpp::corbaserver::Obstacle::_PD_repoId))
112 return (::hpp::corbaserver::Obstacle_ptr) this;
113
114 if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
115 return (::CORBA::Object_ptr) this;
116
117 return 0;
118 }
119
120
121 //
122 // Code for hpp::corbaserver::Obstacle::loadObstacleModel
123
124 // Proxy call descriptor class. Mangled signature:
125 // void_i_cstring_i_cstring_e_chpp_mError
126 class _0RL_cd_f91f86e0ac88b4e7_00000000
127 : public omniCallDescriptor
128 {
129 public:
130 inline _0RL_cd_f91f86e0ac88b4e7_00000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
131 : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
132 {
133
134 }
135
136 void marshalArguments(cdrStream&);
137 void unmarshalArguments(cdrStream&);
138
139
140 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
141 static const char* const _user_exns[];
142
143 ::CORBA::String_var arg_0_;
144 const char* arg_0;
145 ::CORBA::String_var arg_1_;
146 const char* arg_1;
147 };
148
149 void _0RL_cd_f91f86e0ac88b4e7_00000000::marshalArguments(cdrStream& _n)
150 {
151 _n.marshalString(arg_0,0);
152 _n.marshalString(arg_1,0);
153
154 }
155
156 void _0RL_cd_f91f86e0ac88b4e7_00000000::unmarshalArguments(cdrStream& _n)
157 {
158 arg_0_ = _n.unmarshalString(0);
159 arg_0 = arg_0_.in();
160 arg_1_ = _n.unmarshalString(0);
161 arg_1 = arg_1_.in();
162
163 }
164
165 const char* const _0RL_cd_f91f86e0ac88b4e7_00000000::_user_exns[] = {
166 hpp::Error::_PD_repoId
167 };
168
169 void _0RL_cd_f91f86e0ac88b4e7_00000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
170 {
171 if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
172 hpp::Error _ex;
173 _ex <<= s;
174 if (iop_client) iop_client->RequestCompleted();
175 throw _ex;
176 }
177
178
179 else {
180 if (iop_client) iop_client->RequestCompleted(1);
181 OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
182 (::CORBA::CompletionStatus)s.completion());
183 }
184 }
185
186 // Local call call-back function.
187 static void
188 _0RL_lcfn_f91f86e0ac88b4e7_10000000(omniCallDescriptor* cd, omniServant* svnt)
189 {
190 _0RL_cd_f91f86e0ac88b4e7_00000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_00000000*)cd;
191 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
192 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
193 impl->loadObstacleModel(tcd->arg_0, tcd->arg_1);
194 #else
195 if (!cd->is_upcall())
196 impl->loadObstacleModel(tcd->arg_0, tcd->arg_1);
197 else {
198 try {
199 impl->loadObstacleModel(tcd->arg_0, tcd->arg_1);
200 }
201 catch(hpp::Error& ex) {
202 throw omniORB::StubUserException(ex._NP_duplicate());
203 }
204
205
206 }
207 #endif
208
209
210 }
211
212 void hpp::corbaserver::_objref_Obstacle::loadObstacleModel(const char* filename, const char* prefix)
213 {
214 _0RL_cd_f91f86e0ac88b4e7_00000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_10000000, "loadObstacleModel", 18);
215 _call_desc.arg_0 = filename;
216 _call_desc.arg_1 = prefix;
217
218 _invoke(_call_desc);
219
220
221
222 }
223
224
225 //
226 // Code for hpp::corbaserver::Obstacle::loadPolyhedron
227
228 // Local call call-back function.
229 static void
230 _0RL_lcfn_f91f86e0ac88b4e7_20000000(omniCallDescriptor* cd, omniServant* svnt)
231 {
232 _0RL_cd_f91f86e0ac88b4e7_00000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_00000000*)cd;
233 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
234 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
235 impl->loadPolyhedron(tcd->arg_0, tcd->arg_1);
236 #else
237 if (!cd->is_upcall())
238 impl->loadPolyhedron(tcd->arg_0, tcd->arg_1);
239 else {
240 try {
241 impl->loadPolyhedron(tcd->arg_0, tcd->arg_1);
242 }
243 catch(hpp::Error& ex) {
244 throw omniORB::StubUserException(ex._NP_duplicate());
245 }
246
247
248 }
249 #endif
250
251
252 }
253
254 void hpp::corbaserver::_objref_Obstacle::loadPolyhedron(const char* obstacleName, const char* filename)
255 {
256 _0RL_cd_f91f86e0ac88b4e7_00000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_20000000, "loadPolyhedron", 15);
257 _call_desc.arg_0 = obstacleName;
258 _call_desc.arg_1 = filename;
259
260 _invoke(_call_desc);
261
262
263
264 }
265
266
267 //
268 // Code for hpp::corbaserver::Obstacle::loadObstacleModelFromString
269
270 // Local call call-back function.
271 static void
272 _0RL_lcfn_f91f86e0ac88b4e7_30000000(omniCallDescriptor* cd, omniServant* svnt)
273 {
274 _0RL_cd_f91f86e0ac88b4e7_00000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_00000000*)cd;
275 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
276 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
277 impl->loadObstacleModelFromString(tcd->arg_0, tcd->arg_1);
278 #else
279 if (!cd->is_upcall())
280 impl->loadObstacleModelFromString(tcd->arg_0, tcd->arg_1);
281 else {
282 try {
283 impl->loadObstacleModelFromString(tcd->arg_0, tcd->arg_1);
284 }
285 catch(hpp::Error& ex) {
286 throw omniORB::StubUserException(ex._NP_duplicate());
287 }
288
289
290 }
291 #endif
292
293
294 }
295
296 void hpp::corbaserver::_objref_Obstacle::loadObstacleModelFromString(const char* urdfString, const char* prefix)
297 {
298 _0RL_cd_f91f86e0ac88b4e7_00000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_30000000, "loadObstacleModelFromString", 28);
299 _call_desc.arg_0 = urdfString;
300 _call_desc.arg_1 = prefix;
301
302 _invoke(_call_desc);
303
304
305
306 }
307
308
309 //
310 // Code for hpp::corbaserver::Obstacle::removeObstacle
311
312 // Proxy call descriptor class. Mangled signature:
313 // void_i_cstring_e_chpp_mError
314 class _0RL_cd_f91f86e0ac88b4e7_40000000
315 : public omniCallDescriptor
316 {
317 public:
318 inline _0RL_cd_f91f86e0ac88b4e7_40000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
319 : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
320 {
321
322 }
323
324 void marshalArguments(cdrStream&);
325 void unmarshalArguments(cdrStream&);
326
327
328 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
329 static const char* const _user_exns[];
330
331 ::CORBA::String_var arg_0_;
332 const char* arg_0;
333 };
334
335 void _0RL_cd_f91f86e0ac88b4e7_40000000::marshalArguments(cdrStream& _n)
336 {
337 _n.marshalString(arg_0,0);
338
339 }
340
341 void _0RL_cd_f91f86e0ac88b4e7_40000000::unmarshalArguments(cdrStream& _n)
342 {
343 arg_0_ = _n.unmarshalString(0);
344 arg_0 = arg_0_.in();
345
346 }
347
348 const char* const _0RL_cd_f91f86e0ac88b4e7_40000000::_user_exns[] = {
349 hpp::Error::_PD_repoId
350 };
351
352 void _0RL_cd_f91f86e0ac88b4e7_40000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
353 {
354 if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
355 hpp::Error _ex;
356 _ex <<= s;
357 if (iop_client) iop_client->RequestCompleted();
358 throw _ex;
359 }
360
361
362 else {
363 if (iop_client) iop_client->RequestCompleted(1);
364 OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
365 (::CORBA::CompletionStatus)s.completion());
366 }
367 }
368
369 // Local call call-back function.
370 static void
371 _0RL_lcfn_f91f86e0ac88b4e7_50000000(omniCallDescriptor* cd, omniServant* svnt)
372 {
373 _0RL_cd_f91f86e0ac88b4e7_40000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_40000000*)cd;
374 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
375 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
376 impl->removeObstacle(tcd->arg_0);
377 #else
378 if (!cd->is_upcall())
379 impl->removeObstacle(tcd->arg_0);
380 else {
381 try {
382 impl->removeObstacle(tcd->arg_0);
383 }
384 catch(hpp::Error& ex) {
385 throw omniORB::StubUserException(ex._NP_duplicate());
386 }
387
388
389 }
390 #endif
391
392
393 }
394
395 void hpp::corbaserver::_objref_Obstacle::removeObstacle(const char* objectName)
396 {
397 _0RL_cd_f91f86e0ac88b4e7_40000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_50000000, "removeObstacle", 15);
398 _call_desc.arg_0 = objectName;
399
400 _invoke(_call_desc);
401
402
403
404 }
405
406
407 //
408 // Code for hpp::corbaserver::Obstacle::removeObstacleFromJoint
409
410 // Proxy call descriptor class. Mangled signature:
411 // void_i_cstring_i_cstring_i_cboolean_i_cboolean_e_chpp_mError
412 class _0RL_cd_f91f86e0ac88b4e7_60000000
413 : public omniCallDescriptor
414 {
415 public:
416 inline _0RL_cd_f91f86e0ac88b4e7_60000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
417 : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
418 {
419
420 }
421
422 void marshalArguments(cdrStream&);
423 void unmarshalArguments(cdrStream&);
424
425
426 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
427 static const char* const _user_exns[];
428
429 ::CORBA::String_var arg_0_;
430 const char* arg_0;
431 ::CORBA::String_var arg_1_;
432 const char* arg_1;
433 ::CORBA::Boolean arg_2;
434 ::CORBA::Boolean arg_3;
435 };
436
437 void _0RL_cd_f91f86e0ac88b4e7_60000000::marshalArguments(cdrStream& _n)
438 {
439 _n.marshalString(arg_0,0);
440 _n.marshalString(arg_1,0);
441 _n.marshalBoolean(arg_2);
442 _n.marshalBoolean(arg_3);
443
444 }
445
446 void _0RL_cd_f91f86e0ac88b4e7_60000000::unmarshalArguments(cdrStream& _n)
447 {
448 arg_0_ = _n.unmarshalString(0);
449 arg_0 = arg_0_.in();
450 arg_1_ = _n.unmarshalString(0);
451 arg_1 = arg_1_.in();
452 arg_2 = _n.unmarshalBoolean();
453 arg_3 = _n.unmarshalBoolean();
454
455 }
456
457 const char* const _0RL_cd_f91f86e0ac88b4e7_60000000::_user_exns[] = {
458 hpp::Error::_PD_repoId
459 };
460
461 void _0RL_cd_f91f86e0ac88b4e7_60000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
462 {
463 if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
464 hpp::Error _ex;
465 _ex <<= s;
466 if (iop_client) iop_client->RequestCompleted();
467 throw _ex;
468 }
469
470
471 else {
472 if (iop_client) iop_client->RequestCompleted(1);
473 OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
474 (::CORBA::CompletionStatus)s.completion());
475 }
476 }
477
478 // Local call call-back function.
479 static void
480 _0RL_lcfn_f91f86e0ac88b4e7_70000000(omniCallDescriptor* cd, omniServant* svnt)
481 {
482 _0RL_cd_f91f86e0ac88b4e7_60000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_60000000*)cd;
483 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
484 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
485 impl->removeObstacleFromJoint(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
486 #else
487 if (!cd->is_upcall())
488 impl->removeObstacleFromJoint(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
489 else {
490 try {
491 impl->removeObstacleFromJoint(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
492 }
493 catch(hpp::Error& ex) {
494 throw omniORB::StubUserException(ex._NP_duplicate());
495 }
496
497
498 }
499 #endif
500
501
502 }
503
504 void hpp::corbaserver::_objref_Obstacle::removeObstacleFromJoint(const char* objectName, const char* jointName, ::CORBA::Boolean collision, ::CORBA::Boolean distance)
505 {
506 _0RL_cd_f91f86e0ac88b4e7_60000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_70000000, "removeObstacleFromJoint", 24);
507 _call_desc.arg_0 = objectName;
508 _call_desc.arg_1 = jointName;
509 _call_desc.arg_2 = collision;
510 _call_desc.arg_3 = distance;
511
512 _invoke(_call_desc);
513
514
515
516 }
517
518
519 //
520 // Code for hpp::corbaserver::Obstacle::cutObstacle
521
522 // Proxy call descriptor class. Mangled signature:
523 // void_i_cstring_i_chpp_mfloatSeq_e_chpp_mError
524 class _0RL_cd_f91f86e0ac88b4e7_80000000
525 : public omniCallDescriptor
526 {
527 public:
528 inline _0RL_cd_f91f86e0ac88b4e7_80000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
529 : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
530 {
531
532 }
533
534 void marshalArguments(cdrStream&);
535 void unmarshalArguments(cdrStream&);
536
537
538 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
539 static const char* const _user_exns[];
540
541 ::CORBA::String_var arg_0_;
542 const char* arg_0;
543 hpp::floatSeq_var arg_1_;
544 const hpp::floatSeq* arg_1;
545 };
546
547 void _0RL_cd_f91f86e0ac88b4e7_80000000::marshalArguments(cdrStream& _n)
548 {
549 _n.marshalString(arg_0,0);
550 (const hpp::floatSeq&) *arg_1 >>= _n;
551
552 }
553
554 void _0RL_cd_f91f86e0ac88b4e7_80000000::unmarshalArguments(cdrStream& _n)
555 {
556 arg_0_ = _n.unmarshalString(0);
557 arg_0 = arg_0_.in();
558 arg_1_ = new hpp::floatSeq;
559 (hpp::floatSeq&)arg_1_ <<= _n;
560 arg_1 = &arg_1_.in();
561
562 }
563
564 const char* const _0RL_cd_f91f86e0ac88b4e7_80000000::_user_exns[] = {
565 hpp::Error::_PD_repoId
566 };
567
568 void _0RL_cd_f91f86e0ac88b4e7_80000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
569 {
570 if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
571 hpp::Error _ex;
572 _ex <<= s;
573 if (iop_client) iop_client->RequestCompleted();
574 throw _ex;
575 }
576
577
578 else {
579 if (iop_client) iop_client->RequestCompleted(1);
580 OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
581 (::CORBA::CompletionStatus)s.completion());
582 }
583 }
584
585 // Local call call-back function.
586 static void
587 _0RL_lcfn_f91f86e0ac88b4e7_90000000(omniCallDescriptor* cd, omniServant* svnt)
588 {
589 _0RL_cd_f91f86e0ac88b4e7_80000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_80000000*)cd;
590 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
591 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
592 impl->cutObstacle(tcd->arg_0, *tcd->arg_1);
593 #else
594 if (!cd->is_upcall())
595 impl->cutObstacle(tcd->arg_0, *tcd->arg_1);
596 else {
597 try {
598 impl->cutObstacle(tcd->arg_0, *tcd->arg_1);
599 }
600 catch(hpp::Error& ex) {
601 throw omniORB::StubUserException(ex._NP_duplicate());
602 }
603
604
605 }
606 #endif
607
608
609 }
610
611 void hpp::corbaserver::_objref_Obstacle::cutObstacle(const char* objectName, const ::hpp::floatSeq& aabb)
612 {
613 _0RL_cd_f91f86e0ac88b4e7_80000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_90000000, "cutObstacle", 12);
614 _call_desc.arg_0 = objectName;
615 _call_desc.arg_1 = &(::hpp::floatSeq&) aabb;
616
617 _invoke(_call_desc);
618
619
620
621 }
622
623
624 //
625 // Code for hpp::corbaserver::Obstacle::addObstacle
626
627 // Proxy call descriptor class. Mangled signature:
628 // void_i_cstring_i_cboolean_i_cboolean_e_chpp_mError
629 class _0RL_cd_f91f86e0ac88b4e7_a0000000
630 : public omniCallDescriptor
631 {
632 public:
633 inline _0RL_cd_f91f86e0ac88b4e7_a0000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
634 : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
635 {
636
637 }
638
639 void marshalArguments(cdrStream&);
640 void unmarshalArguments(cdrStream&);
641
642
643 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
644 static const char* const _user_exns[];
645
646 ::CORBA::String_var arg_0_;
647 const char* arg_0;
648 ::CORBA::Boolean arg_1;
649 ::CORBA::Boolean arg_2;
650 };
651
652 void _0RL_cd_f91f86e0ac88b4e7_a0000000::marshalArguments(cdrStream& _n)
653 {
654 _n.marshalString(arg_0,0);
655 _n.marshalBoolean(arg_1);
656 _n.marshalBoolean(arg_2);
657
658 }
659
660 void _0RL_cd_f91f86e0ac88b4e7_a0000000::unmarshalArguments(cdrStream& _n)
661 {
662 arg_0_ = _n.unmarshalString(0);
663 arg_0 = arg_0_.in();
664 arg_1 = _n.unmarshalBoolean();
665 arg_2 = _n.unmarshalBoolean();
666
667 }
668
669 const char* const _0RL_cd_f91f86e0ac88b4e7_a0000000::_user_exns[] = {
670 hpp::Error::_PD_repoId
671 };
672
673 void _0RL_cd_f91f86e0ac88b4e7_a0000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
674 {
675 if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
676 hpp::Error _ex;
677 _ex <<= s;
678 if (iop_client) iop_client->RequestCompleted();
679 throw _ex;
680 }
681
682
683 else {
684 if (iop_client) iop_client->RequestCompleted(1);
685 OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
686 (::CORBA::CompletionStatus)s.completion());
687 }
688 }
689
690 // Local call call-back function.
691 static void
692 _0RL_lcfn_f91f86e0ac88b4e7_b0000000(omniCallDescriptor* cd, omniServant* svnt)
693 {
694 _0RL_cd_f91f86e0ac88b4e7_a0000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_a0000000*)cd;
695 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
696 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
697 impl->addObstacle(tcd->arg_0, tcd->arg_1, tcd->arg_2);
698 #else
699 if (!cd->is_upcall())
700 impl->addObstacle(tcd->arg_0, tcd->arg_1, tcd->arg_2);
701 else {
702 try {
703 impl->addObstacle(tcd->arg_0, tcd->arg_1, tcd->arg_2);
704 }
705 catch(hpp::Error& ex) {
706 throw omniORB::StubUserException(ex._NP_duplicate());
707 }
708
709
710 }
711 #endif
712
713
714 }
715
716 void hpp::corbaserver::_objref_Obstacle::addObstacle(const char* objectName, ::CORBA::Boolean collision, ::CORBA::Boolean distance)
717 {
718 _0RL_cd_f91f86e0ac88b4e7_a0000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_b0000000, "addObstacle", 12);
719 _call_desc.arg_0 = objectName;
720 _call_desc.arg_1 = collision;
721 _call_desc.arg_2 = distance;
722
723 _invoke(_call_desc);
724
725
726
727 }
728
729
730 //
731 // Code for hpp::corbaserver::Obstacle::moveObstacle
732
733 // Proxy call descriptor class. Mangled signature:
734 // void_i_cstring_i_a7_cdouble_e_chpp_mError
735 class _0RL_cd_f91f86e0ac88b4e7_c0000000
736 : public omniCallDescriptor
737 {
738 public:
739 inline _0RL_cd_f91f86e0ac88b4e7_c0000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
740 : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
741 {
742
743 }
744
745 void marshalArguments(cdrStream&);
746 void unmarshalArguments(cdrStream&);
747
748
749 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
750 static const char* const _user_exns[];
751
752 ::CORBA::String_var arg_0_;
753 const char* arg_0;
754 hpp::Transform_ arg_1_;
755 const hpp::Transform__slice* arg_1;
756 };
757
758 void _0RL_cd_f91f86e0ac88b4e7_c0000000::marshalArguments(cdrStream& _n)
759 {
760 _n.marshalString(arg_0,0);
761
762 #ifndef OMNI_MIXED_ENDIAN_DOUBLE
763 if (! _n.marshal_byte_swap()) {
764 _n.put_octet_array((_CORBA_Octet*)((::CORBA::Double*)arg_1),56,omni::ALIGN_8);
765 }
766 else
767 #endif
768 {
769 _n.declareArrayLength(omni::ALIGN_8, 56);
770 for (_CORBA_ULong _0i0 = 0; _0i0 < 7; _0i0++){
771 arg_1[_0i0] >>= _n;
772 }
773 }
774
775 }
776
777 void _0RL_cd_f91f86e0ac88b4e7_c0000000::unmarshalArguments(cdrStream& _n)
778 {
779 arg_0_ = _n.unmarshalString(0);
780 arg_0 = arg_0_.in();
781 _n.unmarshalArrayDouble((_CORBA_Double*)((::CORBA::Double*)arg_1_), 7);
782 arg_1 = &arg_1_[0];
783
784 }
785
786 const char* const _0RL_cd_f91f86e0ac88b4e7_c0000000::_user_exns[] = {
787 hpp::Error::_PD_repoId
788 };
789
790 void _0RL_cd_f91f86e0ac88b4e7_c0000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
791 {
792 if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
793 hpp::Error _ex;
794 _ex <<= s;
795 if (iop_client) iop_client->RequestCompleted();
796 throw _ex;
797 }
798
799
800 else {
801 if (iop_client) iop_client->RequestCompleted(1);
802 OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
803 (::CORBA::CompletionStatus)s.completion());
804 }
805 }
806
807 // Local call call-back function.
808 static void
809 _0RL_lcfn_f91f86e0ac88b4e7_d0000000(omniCallDescriptor* cd, omniServant* svnt)
810 {
811 _0RL_cd_f91f86e0ac88b4e7_c0000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_c0000000*)cd;
812 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
813 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
814 impl->moveObstacle(tcd->arg_0, tcd->arg_1);
815 #else
816 if (!cd->is_upcall())
817 impl->moveObstacle(tcd->arg_0, tcd->arg_1);
818 else {
819 try {
820 impl->moveObstacle(tcd->arg_0, tcd->arg_1);
821 }
822 catch(hpp::Error& ex) {
823 throw omniORB::StubUserException(ex._NP_duplicate());
824 }
825
826
827 }
828 #endif
829
830
831 }
832
833 void hpp::corbaserver::_objref_Obstacle::moveObstacle(const char* objectName, const ::hpp::Transform_ cfg)
834 {
835 _0RL_cd_f91f86e0ac88b4e7_c0000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_d0000000, "moveObstacle", 13);
836 _call_desc.arg_0 = objectName;
837 _call_desc.arg_1 = &cfg[0];
838
839 _invoke(_call_desc);
840
841
842
843 }
844
845
846 //
847 // Code for hpp::corbaserver::Obstacle::getObstaclePosition
848
849 // Proxy call descriptor class. Mangled signature:
850 // void_i_cstring_o_a7_cdouble_e_chpp_mError
851 class _0RL_cd_f91f86e0ac88b4e7_e0000000
852 : public omniCallDescriptor
853 {
854 public:
855 inline _0RL_cd_f91f86e0ac88b4e7_e0000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
856 : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
857 {
858
859 }
860
861 void marshalArguments(cdrStream&);
862 void unmarshalArguments(cdrStream&);
863
864 void unmarshalReturnedValues(cdrStream&);
865 void marshalReturnedValues(cdrStream&);
866
867 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
868 static const char* const _user_exns[];
869
870 ::CORBA::String_var arg_0_;
871 const char* arg_0;
872 hpp::Transform_ arg_1_;
873 hpp::Transform__slice* arg_1;
874 };
875
876 void _0RL_cd_f91f86e0ac88b4e7_e0000000::marshalArguments(cdrStream& _n)
877 {
878 _n.marshalString(arg_0,0);
879
880 }
881
882 void _0RL_cd_f91f86e0ac88b4e7_e0000000::unmarshalArguments(cdrStream& _n)
883 {
884 arg_0_ = _n.unmarshalString(0);
885 arg_0 = arg_0_.in();
886
887 }
888
889 void _0RL_cd_f91f86e0ac88b4e7_e0000000::marshalReturnedValues(cdrStream& _n)
890 {
891
892 #ifndef OMNI_MIXED_ENDIAN_DOUBLE
893 if (! _n.marshal_byte_swap()) {
894 _n.put_octet_array((_CORBA_Octet*)((::CORBA::Double*)arg_1),56,omni::ALIGN_8);
895 }
896 else
897 #endif
898 {
899 _n.declareArrayLength(omni::ALIGN_8, 56);
900 for (_CORBA_ULong _0i0 = 0; _0i0 < 7; _0i0++){
901 arg_1[_0i0] >>= _n;
902 }
903 }
904
905 }
906
907 void _0RL_cd_f91f86e0ac88b4e7_e0000000::unmarshalReturnedValues(cdrStream& _n)
908 {
909 _n.unmarshalArrayDouble((_CORBA_Double*)((::CORBA::Double*)arg_1), 7);
910
911 }
912
913 const char* const _0RL_cd_f91f86e0ac88b4e7_e0000000::_user_exns[] = {
914 hpp::Error::_PD_repoId
915 };
916
917 void _0RL_cd_f91f86e0ac88b4e7_e0000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
918 {
919 if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
920 hpp::Error _ex;
921 _ex <<= s;
922 if (iop_client) iop_client->RequestCompleted();
923 throw _ex;
924 }
925
926
927 else {
928 if (iop_client) iop_client->RequestCompleted(1);
929 OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
930 (::CORBA::CompletionStatus)s.completion());
931 }
932 }
933
934 // Local call call-back function.
935 static void
936 _0RL_lcfn_f91f86e0ac88b4e7_f0000000(omniCallDescriptor* cd, omniServant* svnt)
937 {
938 _0RL_cd_f91f86e0ac88b4e7_e0000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_e0000000*)cd;
939 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
940 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
941 impl->getObstaclePosition(tcd->arg_0, tcd->arg_1);
942 #else
943 if (!cd->is_upcall())
944 impl->getObstaclePosition(tcd->arg_0, tcd->arg_1);
945 else {
946 try {
947 impl->getObstaclePosition(tcd->arg_0, tcd->arg_1);
948 }
949 catch(hpp::Error& ex) {
950 throw omniORB::StubUserException(ex._NP_duplicate());
951 }
952
953
954 }
955 #endif
956
957
958 }
959
960 void hpp::corbaserver::_objref_Obstacle::getObstaclePosition(const char* objectName, ::hpp::Transform_ cfg)
961 {
962 _0RL_cd_f91f86e0ac88b4e7_e0000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_f0000000, "getObstaclePosition", 20);
963 _call_desc.arg_0 = objectName;
964 _call_desc.arg_1 = &cfg[0];
965
966 _invoke(_call_desc);
967
968
969
970 }
971
972
973 //
974 // Code for hpp::corbaserver::Obstacle::getObstacleNames
975
976 // Proxy call descriptor class. Mangled signature:
977 // _chpp_mNames__t_i_cboolean_i_cboolean_e_chpp_mError
978 class _0RL_cd_f91f86e0ac88b4e7_01000000
979 : public omniCallDescriptor
980 {
981 public:
982 inline _0RL_cd_f91f86e0ac88b4e7_01000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
983 : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
984 {
985
986 }
987
988 void marshalArguments(cdrStream&);
989 void unmarshalArguments(cdrStream&);
990
991 void unmarshalReturnedValues(cdrStream&);
992 void marshalReturnedValues(cdrStream&);
993
994 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
995 static const char* const _user_exns[];
996
997 ::CORBA::Boolean arg_0;
998 ::CORBA::Boolean arg_1;
999 hpp::Names_t_var result;
1000 };
1001
1002 void _0RL_cd_f91f86e0ac88b4e7_01000000::marshalArguments(cdrStream& _n)
1003 {
1004 _n.marshalBoolean(arg_0);
1005 _n.marshalBoolean(arg_1);
1006
1007 }
1008
1009 void _0RL_cd_f91f86e0ac88b4e7_01000000::unmarshalArguments(cdrStream& _n)
1010 {
1011 arg_0 = _n.unmarshalBoolean();
1012 arg_1 = _n.unmarshalBoolean();
1013
1014 }
1015
1016 void _0RL_cd_f91f86e0ac88b4e7_01000000::marshalReturnedValues(cdrStream& _n)
1017 {
1018 (const hpp::Names_t&) result >>= _n;
1019
1020 }
1021
1022 void _0RL_cd_f91f86e0ac88b4e7_01000000::unmarshalReturnedValues(cdrStream& _n)
1023 {
1024 result = new hpp::Names_t;
1025 (hpp::Names_t&)result <<= _n;
1026
1027 }
1028
1029 const char* const _0RL_cd_f91f86e0ac88b4e7_01000000::_user_exns[] = {
1030 hpp::Error::_PD_repoId
1031 };
1032
1033 void _0RL_cd_f91f86e0ac88b4e7_01000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
1034 {
1035 if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
1036 hpp::Error _ex;
1037 _ex <<= s;
1038 if (iop_client) iop_client->RequestCompleted();
1039 throw _ex;
1040 }
1041
1042
1043 else {
1044 if (iop_client) iop_client->RequestCompleted(1);
1045 OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
1046 (::CORBA::CompletionStatus)s.completion());
1047 }
1048 }
1049
1050 // Local call call-back function.
1051 static void
1052 _0RL_lcfn_f91f86e0ac88b4e7_11000000(omniCallDescriptor* cd, omniServant* svnt)
1053 {
1054 _0RL_cd_f91f86e0ac88b4e7_01000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_01000000*)cd;
1055 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
1056 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1057 tcd->result = impl->getObstacleNames(tcd->arg_0, tcd->arg_1);
1058 #else
1059 if (!cd->is_upcall())
1060 tcd->result = impl->getObstacleNames(tcd->arg_0, tcd->arg_1);
1061 else {
1062 try {
1063 tcd->result = impl->getObstacleNames(tcd->arg_0, tcd->arg_1);
1064 }
1065 catch(hpp::Error& ex) {
1066 throw omniORB::StubUserException(ex._NP_duplicate());
1067 }
1068
1069
1070 }
1071 #endif
1072
1073
1074 }
1075
1076 hpp::Names_t* hpp::corbaserver::_objref_Obstacle::getObstacleNames(::CORBA::Boolean collision, ::CORBA::Boolean distance)
1077 {
1078 _0RL_cd_f91f86e0ac88b4e7_01000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_11000000, "getObstacleNames", 17);
1079 _call_desc.arg_0 = collision;
1080 _call_desc.arg_1 = distance;
1081
1082 _invoke(_call_desc);
1083 return _call_desc.result._retn();
1084
1085
1086 }
1087
1088
1089 //
1090 // Code for hpp::corbaserver::Obstacle::createPolyhedron
1091
1092 // Local call call-back function.
1093 static void
1094 _0RL_lcfn_f91f86e0ac88b4e7_21000000(omniCallDescriptor* cd, omniServant* svnt)
1095 {
1096 _0RL_cd_f91f86e0ac88b4e7_40000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_40000000*)cd;
1097 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
1098 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1099 impl->createPolyhedron(tcd->arg_0);
1100 #else
1101 if (!cd->is_upcall())
1102 impl->createPolyhedron(tcd->arg_0);
1103 else {
1104 try {
1105 impl->createPolyhedron(tcd->arg_0);
1106 }
1107 catch(hpp::Error& ex) {
1108 throw omniORB::StubUserException(ex._NP_duplicate());
1109 }
1110
1111
1112 }
1113 #endif
1114
1115
1116 }
1117
1118 void hpp::corbaserver::_objref_Obstacle::createPolyhedron(const char* polyName)
1119 {
1120 _0RL_cd_f91f86e0ac88b4e7_40000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_21000000, "createPolyhedron", 17);
1121 _call_desc.arg_0 = polyName;
1122
1123 _invoke(_call_desc);
1124
1125
1126
1127 }
1128
1129
1130 //
1131 // Code for hpp::corbaserver::Obstacle::createBox
1132
1133 // Proxy call descriptor class. Mangled signature:
1134 // void_i_cstring_i_cdouble_i_cdouble_i_cdouble_e_chpp_mError
1135 class _0RL_cd_f91f86e0ac88b4e7_31000000
1136 : public omniCallDescriptor
1137 {
1138 public:
1139 inline _0RL_cd_f91f86e0ac88b4e7_31000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
1140 : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
1141 {
1142
1143 }
1144
1145 void marshalArguments(cdrStream&);
1146 void unmarshalArguments(cdrStream&);
1147
1148
1149 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
1150 static const char* const _user_exns[];
1151
1152 ::CORBA::String_var arg_0_;
1153 const char* arg_0;
1154 ::CORBA::Double arg_1;
1155 ::CORBA::Double arg_2;
1156 ::CORBA::Double arg_3;
1157 };
1158
1159 void _0RL_cd_f91f86e0ac88b4e7_31000000::marshalArguments(cdrStream& _n)
1160 {
1161 _n.marshalString(arg_0,0);
1162 arg_1 >>= _n;
1163 arg_2 >>= _n;
1164 arg_3 >>= _n;
1165
1166 }
1167
1168 void _0RL_cd_f91f86e0ac88b4e7_31000000::unmarshalArguments(cdrStream& _n)
1169 {
1170 arg_0_ = _n.unmarshalString(0);
1171 arg_0 = arg_0_.in();
1172 (::CORBA::Double&)arg_1 <<= _n;
1173 (::CORBA::Double&)arg_2 <<= _n;
1174 (::CORBA::Double&)arg_3 <<= _n;
1175
1176 }
1177
1178 const char* const _0RL_cd_f91f86e0ac88b4e7_31000000::_user_exns[] = {
1179 hpp::Error::_PD_repoId
1180 };
1181
1182 void _0RL_cd_f91f86e0ac88b4e7_31000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
1183 {
1184 if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
1185 hpp::Error _ex;
1186 _ex <<= s;
1187 if (iop_client) iop_client->RequestCompleted();
1188 throw _ex;
1189 }
1190
1191
1192 else {
1193 if (iop_client) iop_client->RequestCompleted(1);
1194 OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
1195 (::CORBA::CompletionStatus)s.completion());
1196 }
1197 }
1198
1199 // Local call call-back function.
1200 static void
1201 _0RL_lcfn_f91f86e0ac88b4e7_41000000(omniCallDescriptor* cd, omniServant* svnt)
1202 {
1203 _0RL_cd_f91f86e0ac88b4e7_31000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_31000000*)cd;
1204 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
1205 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1206 impl->createBox(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
1207 #else
1208 if (!cd->is_upcall())
1209 impl->createBox(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
1210 else {
1211 try {
1212 impl->createBox(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
1213 }
1214 catch(hpp::Error& ex) {
1215 throw omniORB::StubUserException(ex._NP_duplicate());
1216 }
1217
1218
1219 }
1220 #endif
1221
1222
1223 }
1224
1225 void hpp::corbaserver::_objref_Obstacle::createBox(const char* inBoxName, ::CORBA::Double x, ::CORBA::Double y, ::CORBA::Double z)
1226 {
1227 _0RL_cd_f91f86e0ac88b4e7_31000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_41000000, "createBox", 10);
1228 _call_desc.arg_0 = inBoxName;
1229 _call_desc.arg_1 = x;
1230 _call_desc.arg_2 = y;
1231 _call_desc.arg_3 = z;
1232
1233 _invoke(_call_desc);
1234
1235
1236
1237 }
1238
1239
1240 //
1241 // Code for hpp::corbaserver::Obstacle::createSphere
1242
1243 // Proxy call descriptor class. Mangled signature:
1244 // void_i_cstring_i_cdouble_e_chpp_mError
1245 class _0RL_cd_f91f86e0ac88b4e7_51000000
1246 : public omniCallDescriptor
1247 {
1248 public:
1249 inline _0RL_cd_f91f86e0ac88b4e7_51000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
1250 : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
1251 {
1252
1253 }
1254
1255 void marshalArguments(cdrStream&);
1256 void unmarshalArguments(cdrStream&);
1257
1258
1259 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
1260 static const char* const _user_exns[];
1261
1262 ::CORBA::String_var arg_0_;
1263 const char* arg_0;
1264 ::CORBA::Double arg_1;
1265 };
1266
1267 void _0RL_cd_f91f86e0ac88b4e7_51000000::marshalArguments(cdrStream& _n)
1268 {
1269 _n.marshalString(arg_0,0);
1270 arg_1 >>= _n;
1271
1272 }
1273
1274 void _0RL_cd_f91f86e0ac88b4e7_51000000::unmarshalArguments(cdrStream& _n)
1275 {
1276 arg_0_ = _n.unmarshalString(0);
1277 arg_0 = arg_0_.in();
1278 (::CORBA::Double&)arg_1 <<= _n;
1279
1280 }
1281
1282 const char* const _0RL_cd_f91f86e0ac88b4e7_51000000::_user_exns[] = {
1283 hpp::Error::_PD_repoId
1284 };
1285
1286 void _0RL_cd_f91f86e0ac88b4e7_51000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
1287 {
1288 if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
1289 hpp::Error _ex;
1290 _ex <<= s;
1291 if (iop_client) iop_client->RequestCompleted();
1292 throw _ex;
1293 }
1294
1295
1296 else {
1297 if (iop_client) iop_client->RequestCompleted(1);
1298 OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
1299 (::CORBA::CompletionStatus)s.completion());
1300 }
1301 }
1302
1303 // Local call call-back function.
1304 static void
1305 _0RL_lcfn_f91f86e0ac88b4e7_61000000(omniCallDescriptor* cd, omniServant* svnt)
1306 {
1307 _0RL_cd_f91f86e0ac88b4e7_51000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_51000000*)cd;
1308 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
1309 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1310 impl->createSphere(tcd->arg_0, tcd->arg_1);
1311 #else
1312 if (!cd->is_upcall())
1313 impl->createSphere(tcd->arg_0, tcd->arg_1);
1314 else {
1315 try {
1316 impl->createSphere(tcd->arg_0, tcd->arg_1);
1317 }
1318 catch(hpp::Error& ex) {
1319 throw omniORB::StubUserException(ex._NP_duplicate());
1320 }
1321
1322
1323 }
1324 #endif
1325
1326
1327 }
1328
1329 void hpp::corbaserver::_objref_Obstacle::createSphere(const char* name, ::CORBA::Double radius)
1330 {
1331 _0RL_cd_f91f86e0ac88b4e7_51000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_61000000, "createSphere", 13);
1332 _call_desc.arg_0 = name;
1333 _call_desc.arg_1 = radius;
1334
1335 _invoke(_call_desc);
1336
1337
1338
1339 }
1340
1341
1342 //
1343 // Code for hpp::corbaserver::Obstacle::createCylinder
1344
1345 // Proxy call descriptor class. Mangled signature:
1346 // void_i_cstring_i_cdouble_i_cdouble_e_chpp_mError
1347 class _0RL_cd_f91f86e0ac88b4e7_71000000
1348 : public omniCallDescriptor
1349 {
1350 public:
1351 inline _0RL_cd_f91f86e0ac88b4e7_71000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
1352 : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
1353 {
1354
1355 }
1356
1357 void marshalArguments(cdrStream&);
1358 void unmarshalArguments(cdrStream&);
1359
1360
1361 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
1362 static const char* const _user_exns[];
1363
1364 ::CORBA::String_var arg_0_;
1365 const char* arg_0;
1366 ::CORBA::Double arg_1;
1367 ::CORBA::Double arg_2;
1368 };
1369
1370 void _0RL_cd_f91f86e0ac88b4e7_71000000::marshalArguments(cdrStream& _n)
1371 {
1372 _n.marshalString(arg_0,0);
1373 arg_1 >>= _n;
1374 arg_2 >>= _n;
1375
1376 }
1377
1378 void _0RL_cd_f91f86e0ac88b4e7_71000000::unmarshalArguments(cdrStream& _n)
1379 {
1380 arg_0_ = _n.unmarshalString(0);
1381 arg_0 = arg_0_.in();
1382 (::CORBA::Double&)arg_1 <<= _n;
1383 (::CORBA::Double&)arg_2 <<= _n;
1384
1385 }
1386
1387 const char* const _0RL_cd_f91f86e0ac88b4e7_71000000::_user_exns[] = {
1388 hpp::Error::_PD_repoId
1389 };
1390
1391 void _0RL_cd_f91f86e0ac88b4e7_71000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
1392 {
1393 if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
1394 hpp::Error _ex;
1395 _ex <<= s;
1396 if (iop_client) iop_client->RequestCompleted();
1397 throw _ex;
1398 }
1399
1400
1401 else {
1402 if (iop_client) iop_client->RequestCompleted(1);
1403 OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
1404 (::CORBA::CompletionStatus)s.completion());
1405 }
1406 }
1407
1408 // Local call call-back function.
1409 static void
1410 _0RL_lcfn_f91f86e0ac88b4e7_81000000(omniCallDescriptor* cd, omniServant* svnt)
1411 {
1412 _0RL_cd_f91f86e0ac88b4e7_71000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_71000000*)cd;
1413 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
1414 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1415 impl->createCylinder(tcd->arg_0, tcd->arg_1, tcd->arg_2);
1416 #else
1417 if (!cd->is_upcall())
1418 impl->createCylinder(tcd->arg_0, tcd->arg_1, tcd->arg_2);
1419 else {
1420 try {
1421 impl->createCylinder(tcd->arg_0, tcd->arg_1, tcd->arg_2);
1422 }
1423 catch(hpp::Error& ex) {
1424 throw omniORB::StubUserException(ex._NP_duplicate());
1425 }
1426
1427
1428 }
1429 #endif
1430
1431
1432 }
1433
1434 void hpp::corbaserver::_objref_Obstacle::createCylinder(const char* name, ::CORBA::Double radius, ::CORBA::Double length)
1435 {
1436 _0RL_cd_f91f86e0ac88b4e7_71000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_81000000, "createCylinder", 15);
1437 _call_desc.arg_0 = name;
1438 _call_desc.arg_1 = radius;
1439 _call_desc.arg_2 = length;
1440
1441 _invoke(_call_desc);
1442
1443
1444
1445 }
1446
1447
1448 //
1449 // Code for hpp::corbaserver::Obstacle::addPoint
1450
1451 // Proxy call descriptor class. Mangled signature:
1452 // _cunsigned_plong_i_cstring_i_cdouble_i_cdouble_i_cdouble_e_chpp_mError
1453 class _0RL_cd_f91f86e0ac88b4e7_91000000
1454 : public omniCallDescriptor
1455 {
1456 public:
1457 inline _0RL_cd_f91f86e0ac88b4e7_91000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
1458 : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
1459 {
1460
1461 }
1462
1463 void marshalArguments(cdrStream&);
1464 void unmarshalArguments(cdrStream&);
1465
1466 void unmarshalReturnedValues(cdrStream&);
1467 void marshalReturnedValues(cdrStream&);
1468
1469 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
1470 static const char* const _user_exns[];
1471
1472 ::CORBA::String_var arg_0_;
1473 const char* arg_0;
1474 ::CORBA::Double arg_1;
1475 ::CORBA::Double arg_2;
1476 ::CORBA::Double arg_3;
1477 ::CORBA::ULong result;
1478 };
1479
1480 void _0RL_cd_f91f86e0ac88b4e7_91000000::marshalArguments(cdrStream& _n)
1481 {
1482 _n.marshalString(arg_0,0);
1483 arg_1 >>= _n;
1484 arg_2 >>= _n;
1485 arg_3 >>= _n;
1486
1487 }
1488
1489 void _0RL_cd_f91f86e0ac88b4e7_91000000::unmarshalArguments(cdrStream& _n)
1490 {
1491 arg_0_ = _n.unmarshalString(0);
1492 arg_0 = arg_0_.in();
1493 (::CORBA::Double&)arg_1 <<= _n;
1494 (::CORBA::Double&)arg_2 <<= _n;
1495 (::CORBA::Double&)arg_3 <<= _n;
1496
1497 }
1498
1499 void _0RL_cd_f91f86e0ac88b4e7_91000000::marshalReturnedValues(cdrStream& _n)
1500 {
1501 result >>= _n;
1502
1503 }
1504
1505 void _0RL_cd_f91f86e0ac88b4e7_91000000::unmarshalReturnedValues(cdrStream& _n)
1506 {
1507 (::CORBA::ULong&)result <<= _n;
1508
1509 }
1510
1511 const char* const _0RL_cd_f91f86e0ac88b4e7_91000000::_user_exns[] = {
1512 hpp::Error::_PD_repoId
1513 };
1514
1515 void _0RL_cd_f91f86e0ac88b4e7_91000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
1516 {
1517 if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
1518 hpp::Error _ex;
1519 _ex <<= s;
1520 if (iop_client) iop_client->RequestCompleted();
1521 throw _ex;
1522 }
1523
1524
1525 else {
1526 if (iop_client) iop_client->RequestCompleted(1);
1527 OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
1528 (::CORBA::CompletionStatus)s.completion());
1529 }
1530 }
1531
1532 // Local call call-back function.
1533 static void
1534 _0RL_lcfn_f91f86e0ac88b4e7_a1000000(omniCallDescriptor* cd, omniServant* svnt)
1535 {
1536 _0RL_cd_f91f86e0ac88b4e7_91000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_91000000*)cd;
1537 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
1538 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1539 tcd->result = impl->addPoint(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
1540 #else
1541 if (!cd->is_upcall())
1542 tcd->result = impl->addPoint(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
1543 else {
1544 try {
1545 tcd->result = impl->addPoint(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
1546 }
1547 catch(hpp::Error& ex) {
1548 throw omniORB::StubUserException(ex._NP_duplicate());
1549 }
1550
1551
1552 }
1553 #endif
1554
1555
1556 }
1557
1558 ::CORBA::ULong hpp::corbaserver::_objref_Obstacle::addPoint(const char* polyName, ::CORBA::Double x, ::CORBA::Double y, ::CORBA::Double z)
1559 {
1560 _0RL_cd_f91f86e0ac88b4e7_91000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_a1000000, "addPoint", 9);
1561 _call_desc.arg_0 = polyName;
1562 _call_desc.arg_1 = x;
1563 _call_desc.arg_2 = y;
1564 _call_desc.arg_3 = z;
1565
1566 _invoke(_call_desc);
1567 return _call_desc.result;
1568
1569
1570 }
1571
1572
1573 //
1574 // Code for hpp::corbaserver::Obstacle::addTriangle
1575
1576 // Proxy call descriptor class. Mangled signature:
1577 // _cunsigned_plong_i_cstring_i_cunsigned_plong_i_cunsigned_plong_i_cunsigned_plong_e_chpp_mError
1578 class _0RL_cd_f91f86e0ac88b4e7_b1000000
1579 : public omniCallDescriptor
1580 {
1581 public:
1582 inline _0RL_cd_f91f86e0ac88b4e7_b1000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
1583 : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
1584 {
1585
1586 }
1587
1588 void marshalArguments(cdrStream&);
1589 void unmarshalArguments(cdrStream&);
1590
1591 void unmarshalReturnedValues(cdrStream&);
1592 void marshalReturnedValues(cdrStream&);
1593
1594 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
1595 static const char* const _user_exns[];
1596
1597 ::CORBA::String_var arg_0_;
1598 const char* arg_0;
1599 ::CORBA::ULong arg_1;
1600 ::CORBA::ULong arg_2;
1601 ::CORBA::ULong arg_3;
1602 ::CORBA::ULong result;
1603 };
1604
1605 void _0RL_cd_f91f86e0ac88b4e7_b1000000::marshalArguments(cdrStream& _n)
1606 {
1607 _n.marshalString(arg_0,0);
1608 arg_1 >>= _n;
1609 arg_2 >>= _n;
1610 arg_3 >>= _n;
1611
1612 }
1613
1614 void _0RL_cd_f91f86e0ac88b4e7_b1000000::unmarshalArguments(cdrStream& _n)
1615 {
1616 arg_0_ = _n.unmarshalString(0);
1617 arg_0 = arg_0_.in();
1618 (::CORBA::ULong&)arg_1 <<= _n;
1619 (::CORBA::ULong&)arg_2 <<= _n;
1620 (::CORBA::ULong&)arg_3 <<= _n;
1621
1622 }
1623
1624 void _0RL_cd_f91f86e0ac88b4e7_b1000000::marshalReturnedValues(cdrStream& _n)
1625 {
1626 result >>= _n;
1627
1628 }
1629
1630 void _0RL_cd_f91f86e0ac88b4e7_b1000000::unmarshalReturnedValues(cdrStream& _n)
1631 {
1632 (::CORBA::ULong&)result <<= _n;
1633
1634 }
1635
1636 const char* const _0RL_cd_f91f86e0ac88b4e7_b1000000::_user_exns[] = {
1637 hpp::Error::_PD_repoId
1638 };
1639
1640 void _0RL_cd_f91f86e0ac88b4e7_b1000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
1641 {
1642 if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
1643 hpp::Error _ex;
1644 _ex <<= s;
1645 if (iop_client) iop_client->RequestCompleted();
1646 throw _ex;
1647 }
1648
1649
1650 else {
1651 if (iop_client) iop_client->RequestCompleted(1);
1652 OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
1653 (::CORBA::CompletionStatus)s.completion());
1654 }
1655 }
1656
1657 // Local call call-back function.
1658 static void
1659 _0RL_lcfn_f91f86e0ac88b4e7_c1000000(omniCallDescriptor* cd, omniServant* svnt)
1660 {
1661 _0RL_cd_f91f86e0ac88b4e7_b1000000* tcd = (_0RL_cd_f91f86e0ac88b4e7_b1000000*)cd;
1662 hpp::corbaserver::_impl_Obstacle* impl = (hpp::corbaserver::_impl_Obstacle*) svnt->_ptrToInterface(hpp::corbaserver::Obstacle::_PD_repoId);
1663 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1664 tcd->result = impl->addTriangle(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
1665 #else
1666 if (!cd->is_upcall())
1667 tcd->result = impl->addTriangle(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
1668 else {
1669 try {
1670 tcd->result = impl->addTriangle(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
1671 }
1672 catch(hpp::Error& ex) {
1673 throw omniORB::StubUserException(ex._NP_duplicate());
1674 }
1675
1676
1677 }
1678 #endif
1679
1680
1681 }
1682
1683 ::CORBA::ULong hpp::corbaserver::_objref_Obstacle::addTriangle(const char* polyName, ::CORBA::ULong pt1, ::CORBA::ULong pt2, ::CORBA::ULong pt3)
1684 {
1685 _0RL_cd_f91f86e0ac88b4e7_b1000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_c1000000, "addTriangle", 12);
1686 _call_desc.arg_0 = polyName;
1687 _call_desc.arg_1 = pt1;
1688 _call_desc.arg_2 = pt2;
1689 _call_desc.arg_3 = pt3;
1690
1691 _invoke(_call_desc);
1692 return _call_desc.result;
1693
1694
1695 }
1696
1697 16 hpp::corbaserver::_pof_Obstacle::~_pof_Obstacle() {}
1698
1699
1700 omniObjRef*
1701 8 hpp::corbaserver::_pof_Obstacle::newObjRef(omniIOR* ior, omniIdentity* id)
1702 {
1703
2/4
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
8 return new ::hpp::corbaserver::_objref_Obstacle(ior, id);
1704 }
1705
1706
1707 ::CORBA::Boolean
1708 8 hpp::corbaserver::_pof_Obstacle::is_a(const char* id) const
1709 {
1710
1/2
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
8 if (omni::ptrStrMatch(id, ::hpp::corbaserver::Obstacle::_PD_repoId))
1711 8 return 1;
1712
1713 return 0;
1714 }
1715
1716 const hpp::corbaserver::_pof_Obstacle _the_pof_hpp_mcorbaserver_mObstacle;
1717
1718 hpp::corbaserver::_impl_Obstacle::~_impl_Obstacle() {}
1719
1720
1721 ::CORBA::Boolean
1722 hpp::corbaserver::_impl_Obstacle::_dispatch(omniCallHandle& _handle)
1723 {
1724 const char* op = _handle.operation_name();
1725
1726 if (omni::strMatch(op, "loadObstacleModel")) {
1727
1728 _0RL_cd_f91f86e0ac88b4e7_00000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_10000000, "loadObstacleModel", 18, 1);
1729
1730 _handle.upcall(this,_call_desc);
1731 return 1;
1732 }
1733
1734 if (omni::strMatch(op, "loadPolyhedron")) {
1735
1736 _0RL_cd_f91f86e0ac88b4e7_00000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_20000000, "loadPolyhedron", 15, 1);
1737
1738 _handle.upcall(this,_call_desc);
1739 return 1;
1740 }
1741
1742 if (omni::strMatch(op, "loadObstacleModelFromString")) {
1743
1744 _0RL_cd_f91f86e0ac88b4e7_00000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_30000000, "loadObstacleModelFromString", 28, 1);
1745
1746 _handle.upcall(this,_call_desc);
1747 return 1;
1748 }
1749
1750 if (omni::strMatch(op, "removeObstacle")) {
1751
1752 _0RL_cd_f91f86e0ac88b4e7_40000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_50000000, "removeObstacle", 15, 1);
1753
1754 _handle.upcall(this,_call_desc);
1755 return 1;
1756 }
1757
1758 if (omni::strMatch(op, "removeObstacleFromJoint")) {
1759
1760 _0RL_cd_f91f86e0ac88b4e7_60000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_70000000, "removeObstacleFromJoint", 24, 1);
1761
1762 _handle.upcall(this,_call_desc);
1763 return 1;
1764 }
1765
1766 if (omni::strMatch(op, "cutObstacle")) {
1767
1768 _0RL_cd_f91f86e0ac88b4e7_80000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_90000000, "cutObstacle", 12, 1);
1769
1770 _handle.upcall(this,_call_desc);
1771 return 1;
1772 }
1773
1774 if (omni::strMatch(op, "addObstacle")) {
1775
1776 _0RL_cd_f91f86e0ac88b4e7_a0000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_b0000000, "addObstacle", 12, 1);
1777
1778 _handle.upcall(this,_call_desc);
1779 return 1;
1780 }
1781
1782 if (omni::strMatch(op, "moveObstacle")) {
1783
1784 _0RL_cd_f91f86e0ac88b4e7_c0000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_d0000000, "moveObstacle", 13, 1);
1785
1786 _handle.upcall(this,_call_desc);
1787 return 1;
1788 }
1789
1790 if (omni::strMatch(op, "getObstaclePosition")) {
1791
1792 _0RL_cd_f91f86e0ac88b4e7_e0000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_f0000000, "getObstaclePosition", 20, 1);
1793 _call_desc.arg_1 = _call_desc.arg_1_;
1794 _handle.upcall(this,_call_desc);
1795 return 1;
1796 }
1797
1798 if (omni::strMatch(op, "getObstacleNames")) {
1799
1800 _0RL_cd_f91f86e0ac88b4e7_01000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_11000000, "getObstacleNames", 17, 1);
1801
1802 _handle.upcall(this,_call_desc);
1803 return 1;
1804 }
1805
1806 if (omni::strMatch(op, "createPolyhedron")) {
1807
1808 _0RL_cd_f91f86e0ac88b4e7_40000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_21000000, "createPolyhedron", 17, 1);
1809
1810 _handle.upcall(this,_call_desc);
1811 return 1;
1812 }
1813
1814 if (omni::strMatch(op, "createBox")) {
1815
1816 _0RL_cd_f91f86e0ac88b4e7_31000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_41000000, "createBox", 10, 1);
1817
1818 _handle.upcall(this,_call_desc);
1819 return 1;
1820 }
1821
1822 if (omni::strMatch(op, "createSphere")) {
1823
1824 _0RL_cd_f91f86e0ac88b4e7_51000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_61000000, "createSphere", 13, 1);
1825
1826 _handle.upcall(this,_call_desc);
1827 return 1;
1828 }
1829
1830 if (omni::strMatch(op, "createCylinder")) {
1831
1832 _0RL_cd_f91f86e0ac88b4e7_71000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_81000000, "createCylinder", 15, 1);
1833
1834 _handle.upcall(this,_call_desc);
1835 return 1;
1836 }
1837
1838 if (omni::strMatch(op, "addPoint")) {
1839
1840 _0RL_cd_f91f86e0ac88b4e7_91000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_a1000000, "addPoint", 9, 1);
1841
1842 _handle.upcall(this,_call_desc);
1843 return 1;
1844 }
1845
1846 if (omni::strMatch(op, "addTriangle")) {
1847
1848 _0RL_cd_f91f86e0ac88b4e7_b1000000 _call_desc(_0RL_lcfn_f91f86e0ac88b4e7_c1000000, "addTriangle", 12, 1);
1849
1850 _handle.upcall(this,_call_desc);
1851 return 1;
1852 }
1853
1854
1855 return 0;
1856 }
1857
1858 void*
1859 8 hpp::corbaserver::_impl_Obstacle::_ptrToInterface(const char* id)
1860 {
1861
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
8 if (id == ::hpp::corbaserver::Obstacle::_PD_repoId)
1862 8 return (::hpp::corbaserver::_impl_Obstacle*) this;
1863
1864 if (id == ::CORBA::Object::_PD_repoId)
1865 return (void*) 1;
1866
1867 if (omni::strMatch(id, ::hpp::corbaserver::Obstacle::_PD_repoId))
1868 return (::hpp::corbaserver::_impl_Obstacle*) this;
1869
1870 if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
1871 return (void*) 1;
1872 return 0;
1873 }
1874
1875 const char*
1876 17 hpp::corbaserver::_impl_Obstacle::_mostDerivedRepoId()
1877 {
1878 17 return ::hpp::corbaserver::Obstacle::_PD_repoId;
1879 }
1880
1881 POA_hpp::corbaserver::Obstacle::~Obstacle() {}
1882
1883