GCC Code Coverage Report

Directory: ./
File: src/hpp/core_idl/path_validationsSK.cc
Date: 2025-05-11 11:10:19
Exec Total Coverage
Lines: 7 1097 0.6%
Branches: 0 948 0.0%
Line Branch Exec Source
1 // This file is generated by omniidl (C++ backend) - omniORB_4_3. Do not edit.
2
3 #include "path_validations-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::core_idl::ConfigValidation_ptr hpp::core_idl::ConfigValidation_Helper::_nil() {
18 ✗ return ::hpp::core_idl::ConfigValidation::_nil();
19 }
20
21 ✗ ::CORBA::Boolean hpp::core_idl::ConfigValidation_Helper::is_nil(::hpp::core_idl::ConfigValidation_ptr p) {
22 ✗ return ::CORBA::is_nil(p);
23
24 }
25
26 ✗ void hpp::core_idl::ConfigValidation_Helper::release(::hpp::core_idl::ConfigValidation_ptr p) {
27 ✗ ::CORBA::release(p);
28 }
29
30 ✗ void hpp::core_idl::ConfigValidation_Helper::marshalObjRef(::hpp::core_idl::ConfigValidation_ptr obj, cdrStream& s) {
31 ✗ ::hpp::core_idl::ConfigValidation::_marshalObjRef(obj, s);
32 }
33
34 ✗ hpp::core_idl::ConfigValidation_ptr hpp::core_idl::ConfigValidation_Helper::unmarshalObjRef(cdrStream& s) {
35 ✗ return ::hpp::core_idl::ConfigValidation::_unmarshalObjRef(s);
36 }
37
38 ✗ void hpp::core_idl::ConfigValidation_Helper::duplicate(::hpp::core_idl::ConfigValidation_ptr obj) {
39 ✗ if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
40 }
41
42 hpp::core_idl::ConfigValidation_ptr
43 ✗ hpp::core_idl::ConfigValidation::_duplicate(::hpp::core_idl::ConfigValidation_ptr obj)
44 {
45 ✗ if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
46 ✗ return obj;
47 }
48
49 hpp::core_idl::ConfigValidation_ptr
50 ✗ hpp::core_idl::ConfigValidation::_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::core_idl::ConfigValidation_ptr
59 ✗ hpp::core_idl::ConfigValidation::_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::core_idl::ConfigValidation_ptr
67 ✗ hpp::core_idl::ConfigValidation::_nil()
68 {
69 #ifdef OMNI_UNLOADABLE_STUBS
70 static _objref_ConfigValidation _the_nil_obj;
71 return &_the_nil_obj;
72 #else
73 static _objref_ConfigValidation* _the_nil_ptr = 0;
74 ✗ if (!_the_nil_ptr) {
75 ✗ omni::nilRefLock().lock();
76 ✗ if (!_the_nil_ptr) {
77 ✗ _the_nil_ptr = new _objref_ConfigValidation;
78 ✗ registerNilCorbaObject(_the_nil_ptr);
79 }
80 ✗ omni::nilRefLock().unlock();
81 }
82 ✗ return _the_nil_ptr;
83 #endif
84 }
85
86 const char* hpp::core_idl::ConfigValidation::_PD_repoId = "IDL:hpp/core_idl/ConfigValidation:1.0";
87
88
89 ✗ hpp::core_idl::_objref_ConfigValidation::~_objref_ConfigValidation() {
90
91 }
92
93
94 ✗ hpp::core_idl::_objref_ConfigValidation::_objref_ConfigValidation(omniIOR* ior, omniIdentity* id) :
95 ✗ omniObjRef(::hpp::core_idl::ConfigValidation::_PD_repoId, ior, id, 1)
96
97
98 {
99 ✗ _PR_setobj(this);
100 }
101
102 void*
103 ✗ hpp::core_idl::_objref_ConfigValidation::_ptrToObjRef(const char* id)
104 {
105 ✗ if (id == ::hpp::core_idl::ConfigValidation::_PD_repoId)
106 ✗ return (::hpp::core_idl::ConfigValidation_ptr) this;
107
108 ✗ if (id == ::CORBA::Object::_PD_repoId)
109 ✗ return (::CORBA::Object_ptr) this;
110
111 ✗ if (omni::strMatch(id, ::hpp::core_idl::ConfigValidation::_PD_repoId))
112 ✗ return (::hpp::core_idl::ConfigValidation_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::core_idl::ConfigValidation::deleteThis
123
124 // Proxy call descriptor class. Mangled signature:
125 // void_e_chpp_mError
126 class _0RL_cd_30be5f04cb3aeac2_00000000
127 : public omniCallDescriptor
128 {
129 public:
130 ✗ inline _0RL_cd_30be5f04cb3aeac2_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
137
138 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
139 static const char* const _user_exns[];
140
141
142 };
143
144 const char* const _0RL_cd_30be5f04cb3aeac2_00000000::_user_exns[] = {
145 hpp::Error::_PD_repoId
146 };
147
148 ✗ void _0RL_cd_30be5f04cb3aeac2_00000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
149 {
150 ✗ if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
151 ✗ hpp::Error _ex;
152 ✗ _ex <<= s;
153 ✗ if (iop_client) iop_client->RequestCompleted();
154 ✗ throw _ex;
155 }
156
157
158 else {
159 ✗ if (iop_client) iop_client->RequestCompleted(1);
160 ✗ OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
161 (::CORBA::CompletionStatus)s.completion());
162 }
163 }
164
165 // Local call call-back function.
166 static void
167 ✗ _0RL_lcfn_30be5f04cb3aeac2_10000000(omniCallDescriptor* _OMNIORB_EX_ONLY_CD(cd), omniServant* svnt)
168 {
169
170 ✗ hpp::core_idl::_impl_ConfigValidation* impl = (hpp::core_idl::_impl_ConfigValidation*) svnt->_ptrToInterface(hpp::core_idl::ConfigValidation::_PD_repoId);
171 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
172 ✗ impl->deleteThis();
173 #else
174 if (!cd->is_upcall())
175 impl->deleteThis();
176 else {
177 try {
178 impl->deleteThis();
179 }
180 catch(hpp::Error& ex) {
181 throw omniORB::StubUserException(ex._NP_duplicate());
182 }
183
184
185 }
186 #endif
187
188
189 }
190
191 ✗ void hpp::core_idl::_objref_ConfigValidation::deleteThis()
192 {
193 ✗ _0RL_cd_30be5f04cb3aeac2_00000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_10000000, "deleteThis", 11);
194
195
196 ✗ _invoke(_call_desc);
197
198
199
200 }
201
202
203 //
204 // Code for hpp::core_idl::ConfigValidation::deleteIfExpired
205
206 // Proxy call descriptor class. Mangled signature:
207 // _cboolean_e_chpp_mError
208 class _0RL_cd_30be5f04cb3aeac2_20000000
209 : public omniCallDescriptor
210 {
211 public:
212 ✗ inline _0RL_cd_30be5f04cb3aeac2_20000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
213 ✗ : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
214 {
215
216 }
217
218
219 void unmarshalReturnedValues(cdrStream&);
220 void marshalReturnedValues(cdrStream&);
221
222 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
223 static const char* const _user_exns[];
224
225 ::CORBA::Boolean result;
226 };
227
228 ✗ void _0RL_cd_30be5f04cb3aeac2_20000000::marshalReturnedValues(cdrStream& _n)
229 {
230 ✗ _n.marshalBoolean(result);
231
232 }
233
234 ✗ void _0RL_cd_30be5f04cb3aeac2_20000000::unmarshalReturnedValues(cdrStream& _n)
235 {
236 ✗ result = _n.unmarshalBoolean();
237
238 }
239
240 const char* const _0RL_cd_30be5f04cb3aeac2_20000000::_user_exns[] = {
241 hpp::Error::_PD_repoId
242 };
243
244 ✗ void _0RL_cd_30be5f04cb3aeac2_20000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
245 {
246 ✗ if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
247 ✗ hpp::Error _ex;
248 ✗ _ex <<= s;
249 ✗ if (iop_client) iop_client->RequestCompleted();
250 ✗ throw _ex;
251 }
252
253
254 else {
255 ✗ if (iop_client) iop_client->RequestCompleted(1);
256 ✗ OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
257 (::CORBA::CompletionStatus)s.completion());
258 }
259 }
260
261 // Local call call-back function.
262 static void
263 ✗ _0RL_lcfn_30be5f04cb3aeac2_30000000(omniCallDescriptor* cd, omniServant* svnt)
264 {
265 ✗ _0RL_cd_30be5f04cb3aeac2_20000000* tcd = (_0RL_cd_30be5f04cb3aeac2_20000000*)cd;
266 ✗ hpp::core_idl::_impl_ConfigValidation* impl = (hpp::core_idl::_impl_ConfigValidation*) svnt->_ptrToInterface(hpp::core_idl::ConfigValidation::_PD_repoId);
267 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
268 ✗ tcd->result = impl->deleteIfExpired();
269 #else
270 if (!cd->is_upcall())
271 tcd->result = impl->deleteIfExpired();
272 else {
273 try {
274 tcd->result = impl->deleteIfExpired();
275 }
276 catch(hpp::Error& ex) {
277 throw omniORB::StubUserException(ex._NP_duplicate());
278 }
279
280
281 }
282 #endif
283
284
285 }
286
287 ✗ ::CORBA::Boolean hpp::core_idl::_objref_ConfigValidation::deleteIfExpired()
288 {
289 ✗ _0RL_cd_30be5f04cb3aeac2_20000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_30000000, "deleteIfExpired", 16);
290
291
292 ✗ _invoke(_call_desc);
293 ✗ return _call_desc.result;
294
295
296 }
297
298
299 //
300 // Code for hpp::core_idl::ConfigValidation::persistantStorage
301
302 // Proxy call descriptor class. Mangled signature:
303 // void_i_cboolean_e_chpp_mError
304 class _0RL_cd_30be5f04cb3aeac2_40000000
305 : public omniCallDescriptor
306 {
307 public:
308 ✗ inline _0RL_cd_30be5f04cb3aeac2_40000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
309 ✗ : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
310 {
311
312 }
313
314 void marshalArguments(cdrStream&);
315 void unmarshalArguments(cdrStream&);
316
317
318 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
319 static const char* const _user_exns[];
320
321 ::CORBA::Boolean arg_0;
322 };
323
324 ✗ void _0RL_cd_30be5f04cb3aeac2_40000000::marshalArguments(cdrStream& _n)
325 {
326 ✗ _n.marshalBoolean(arg_0);
327
328 }
329
330 ✗ void _0RL_cd_30be5f04cb3aeac2_40000000::unmarshalArguments(cdrStream& _n)
331 {
332 ✗ arg_0 = _n.unmarshalBoolean();
333
334 }
335
336 const char* const _0RL_cd_30be5f04cb3aeac2_40000000::_user_exns[] = {
337 hpp::Error::_PD_repoId
338 };
339
340 ✗ void _0RL_cd_30be5f04cb3aeac2_40000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
341 {
342 ✗ if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
343 ✗ hpp::Error _ex;
344 ✗ _ex <<= s;
345 ✗ if (iop_client) iop_client->RequestCompleted();
346 ✗ throw _ex;
347 }
348
349
350 else {
351 ✗ if (iop_client) iop_client->RequestCompleted(1);
352 ✗ OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
353 (::CORBA::CompletionStatus)s.completion());
354 }
355 }
356
357 // Local call call-back function.
358 static void
359 ✗ _0RL_lcfn_30be5f04cb3aeac2_50000000(omniCallDescriptor* cd, omniServant* svnt)
360 {
361 ✗ _0RL_cd_30be5f04cb3aeac2_40000000* tcd = (_0RL_cd_30be5f04cb3aeac2_40000000*)cd;
362 ✗ hpp::core_idl::_impl_ConfigValidation* impl = (hpp::core_idl::_impl_ConfigValidation*) svnt->_ptrToInterface(hpp::core_idl::ConfigValidation::_PD_repoId);
363 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
364 ✗ impl->persistantStorage(tcd->arg_0);
365 #else
366 if (!cd->is_upcall())
367 impl->persistantStorage(tcd->arg_0);
368 else {
369 try {
370 impl->persistantStorage(tcd->arg_0);
371 }
372 catch(hpp::Error& ex) {
373 throw omniORB::StubUserException(ex._NP_duplicate());
374 }
375
376
377 }
378 #endif
379
380
381 }
382
383 ✗ void hpp::core_idl::_objref_ConfigValidation::persistantStorage(::CORBA::Boolean persistant)
384 {
385 ✗ _0RL_cd_30be5f04cb3aeac2_40000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_50000000, "persistantStorage", 18);
386 ✗ _call_desc.arg_0 = persistant;
387
388 ✗ _invoke(_call_desc);
389
390
391
392 }
393
394
395 //
396 // Code for hpp::core_idl::ConfigValidation::validate
397
398 // Proxy call descriptor class. Mangled signature:
399 // _cboolean_i_chpp_mfloatSeq_o_cstring_e_chpp_mError
400 class _0RL_cd_30be5f04cb3aeac2_60000000
401 : public omniCallDescriptor
402 {
403 public:
404 ✗ inline _0RL_cd_30be5f04cb3aeac2_60000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
405 ✗ : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
406 {
407
408 }
409
410 void marshalArguments(cdrStream&);
411 void unmarshalArguments(cdrStream&);
412
413 void unmarshalReturnedValues(cdrStream&);
414 void marshalReturnedValues(cdrStream&);
415
416 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
417 static const char* const _user_exns[];
418
419 hpp::floatSeq_var arg_0_;
420 const hpp::floatSeq* arg_0;
421 ::CORBA::String_var arg_1;
422 ::CORBA::Boolean result;
423 };
424
425 ✗ void _0RL_cd_30be5f04cb3aeac2_60000000::marshalArguments(cdrStream& _n)
426 {
427 ✗ (const hpp::floatSeq&) *arg_0 >>= _n;
428
429 }
430
431 ✗ void _0RL_cd_30be5f04cb3aeac2_60000000::unmarshalArguments(cdrStream& _n)
432 {
433 ✗ arg_0_ = new hpp::floatSeq;
434 ✗ (hpp::floatSeq&)arg_0_ <<= _n;
435 ✗ arg_0 = &arg_0_.in();
436
437 }
438
439 ✗ void _0RL_cd_30be5f04cb3aeac2_60000000::marshalReturnedValues(cdrStream& _n)
440 {
441 ✗ _n.marshalBoolean(result);
442 ✗ _n.marshalString(arg_1,0);
443
444 }
445
446 ✗ void _0RL_cd_30be5f04cb3aeac2_60000000::unmarshalReturnedValues(cdrStream& _n)
447 {
448 ✗ result = _n.unmarshalBoolean();
449 ✗ arg_1 = _n.unmarshalString(0);
450
451 }
452
453 const char* const _0RL_cd_30be5f04cb3aeac2_60000000::_user_exns[] = {
454 hpp::Error::_PD_repoId
455 };
456
457 ✗ void _0RL_cd_30be5f04cb3aeac2_60000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
458 {
459 ✗ if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
460 ✗ hpp::Error _ex;
461 ✗ _ex <<= s;
462 ✗ if (iop_client) iop_client->RequestCompleted();
463 ✗ throw _ex;
464 }
465
466
467 else {
468 ✗ if (iop_client) iop_client->RequestCompleted(1);
469 ✗ OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
470 (::CORBA::CompletionStatus)s.completion());
471 }
472 }
473
474 // Local call call-back function.
475 static void
476 ✗ _0RL_lcfn_30be5f04cb3aeac2_70000000(omniCallDescriptor* cd, omniServant* svnt)
477 {
478 ✗ _0RL_cd_30be5f04cb3aeac2_60000000* tcd = (_0RL_cd_30be5f04cb3aeac2_60000000*)cd;
479 ✗ hpp::core_idl::_impl_ConfigValidation* impl = (hpp::core_idl::_impl_ConfigValidation*) svnt->_ptrToInterface(hpp::core_idl::ConfigValidation::_PD_repoId);
480 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
481 ✗ tcd->result = impl->validate(*tcd->arg_0, tcd->arg_1.out());
482 #else
483 if (!cd->is_upcall())
484 tcd->result = impl->validate(*tcd->arg_0, tcd->arg_1.out());
485 else {
486 try {
487 tcd->result = impl->validate(*tcd->arg_0, tcd->arg_1.out());
488 }
489 catch(hpp::Error& ex) {
490 throw omniORB::StubUserException(ex._NP_duplicate());
491 }
492
493
494 }
495 #endif
496
497
498 }
499
500 ✗ ::CORBA::Boolean hpp::core_idl::_objref_ConfigValidation::validate(const ::hpp::floatSeq& config, ::hpp::core_idl::ValidationReport_out report)
501 {
502 ✗ _0RL_cd_30be5f04cb3aeac2_60000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_70000000, "validate", 9);
503 ✗ _call_desc.arg_0 = &(::hpp::floatSeq&) config;
504
505 ✗ _invoke(_call_desc);
506 ✗ report = _call_desc.arg_1._retn();
507 ✗ return _call_desc.result;
508
509
510 }
511
512 16 hpp::core_idl::_pof_ConfigValidation::~_pof_ConfigValidation() {}
513
514
515 omniObjRef*
516 ✗ hpp::core_idl::_pof_ConfigValidation::newObjRef(omniIOR* ior, omniIdentity* id)
517 {
518 ✗ return new ::hpp::core_idl::_objref_ConfigValidation(ior, id);
519 }
520
521
522 ::CORBA::Boolean
523 ✗ hpp::core_idl::_pof_ConfigValidation::is_a(const char* id) const
524 {
525 ✗ if (omni::ptrStrMatch(id, ::hpp::core_idl::ConfigValidation::_PD_repoId))
526 ✗ return 1;
527
528 ✗ return 0;
529 }
530
531 const hpp::core_idl::_pof_ConfigValidation _the_pof_hpp_mcore__idl_mConfigValidation;
532
533 ✗ hpp::core_idl::_impl_ConfigValidation::~_impl_ConfigValidation() {}
534
535
536 ::CORBA::Boolean
537 ✗ hpp::core_idl::_impl_ConfigValidation::_dispatch(omniCallHandle& _handle)
538 {
539 ✗ const char* op = _handle.operation_name();
540
541 ✗ if (omni::strMatch(op, "deleteThis")) {
542
543 ✗ _0RL_cd_30be5f04cb3aeac2_00000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_10000000, "deleteThis", 11, 1);
544
545 ✗ _handle.upcall(this,_call_desc);
546 ✗ return 1;
547 }
548
549 ✗ if (omni::strMatch(op, "deleteIfExpired")) {
550
551 ✗ _0RL_cd_30be5f04cb3aeac2_20000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_30000000, "deleteIfExpired", 16, 1);
552
553 ✗ _handle.upcall(this,_call_desc);
554 ✗ return 1;
555 }
556
557 ✗ if (omni::strMatch(op, "persistantStorage")) {
558
559 ✗ _0RL_cd_30be5f04cb3aeac2_40000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_50000000, "persistantStorage", 18, 1);
560
561 ✗ _handle.upcall(this,_call_desc);
562 ✗ return 1;
563 }
564
565 ✗ if (omni::strMatch(op, "validate")) {
566
567 ✗ _0RL_cd_30be5f04cb3aeac2_60000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_70000000, "validate", 9, 1);
568
569 ✗ _handle.upcall(this,_call_desc);
570 ✗ return 1;
571 }
572
573
574 ✗ return 0;
575 }
576
577 void*
578 ✗ hpp::core_idl::_impl_ConfigValidation::_ptrToInterface(const char* id)
579 {
580 ✗ if (id == ::hpp::core_idl::ConfigValidation::_PD_repoId)
581 ✗ return (::hpp::core_idl::_impl_ConfigValidation*) this;
582
583 ✗ if (id == ::CORBA::Object::_PD_repoId)
584 ✗ return (void*) 1;
585
586 ✗ if (omni::strMatch(id, ::hpp::core_idl::ConfigValidation::_PD_repoId))
587 ✗ return (::hpp::core_idl::_impl_ConfigValidation*) this;
588
589 ✗ if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
590 ✗ return (void*) 1;
591 ✗ return 0;
592 }
593
594 const char*
595 ✗ hpp::core_idl::_impl_ConfigValidation::_mostDerivedRepoId()
596 {
597 ✗ return ::hpp::core_idl::ConfigValidation::_PD_repoId;
598 }
599
600 ✗ hpp::core_idl::ConfigValidations_ptr hpp::core_idl::ConfigValidations_Helper::_nil() {
601 ✗ return ::hpp::core_idl::ConfigValidations::_nil();
602 }
603
604 ✗ ::CORBA::Boolean hpp::core_idl::ConfigValidations_Helper::is_nil(::hpp::core_idl::ConfigValidations_ptr p) {
605 ✗ return ::CORBA::is_nil(p);
606
607 }
608
609 ✗ void hpp::core_idl::ConfigValidations_Helper::release(::hpp::core_idl::ConfigValidations_ptr p) {
610 ✗ ::CORBA::release(p);
611 }
612
613 ✗ void hpp::core_idl::ConfigValidations_Helper::marshalObjRef(::hpp::core_idl::ConfigValidations_ptr obj, cdrStream& s) {
614 ✗ ::hpp::core_idl::ConfigValidations::_marshalObjRef(obj, s);
615 }
616
617 ✗ hpp::core_idl::ConfigValidations_ptr hpp::core_idl::ConfigValidations_Helper::unmarshalObjRef(cdrStream& s) {
618 ✗ return ::hpp::core_idl::ConfigValidations::_unmarshalObjRef(s);
619 }
620
621 ✗ void hpp::core_idl::ConfigValidations_Helper::duplicate(::hpp::core_idl::ConfigValidations_ptr obj) {
622 ✗ if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
623 }
624
625 hpp::core_idl::ConfigValidations_ptr
626 ✗ hpp::core_idl::ConfigValidations::_duplicate(::hpp::core_idl::ConfigValidations_ptr obj)
627 {
628 ✗ if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
629 ✗ return obj;
630 }
631
632 hpp::core_idl::ConfigValidations_ptr
633 ✗ hpp::core_idl::ConfigValidations::_narrow(::CORBA::Object_ptr obj)
634 {
635 ✗ if (!obj || obj->_NP_is_nil() || obj->_NP_is_pseudo()) return _nil();
636 ✗ _ptr_type e = (_ptr_type) obj->_PR_getobj()->_realNarrow(_PD_repoId);
637 ✗ return e ? e : _nil();
638 }
639
640
641 hpp::core_idl::ConfigValidations_ptr
642 ✗ hpp::core_idl::ConfigValidations::_unchecked_narrow(::CORBA::Object_ptr obj)
643 {
644 ✗ if (!obj || obj->_NP_is_nil() || obj->_NP_is_pseudo()) return _nil();
645 ✗ _ptr_type e = (_ptr_type) obj->_PR_getobj()->_uncheckedNarrow(_PD_repoId);
646 ✗ return e ? e : _nil();
647 }
648
649 hpp::core_idl::ConfigValidations_ptr
650 ✗ hpp::core_idl::ConfigValidations::_nil()
651 {
652 #ifdef OMNI_UNLOADABLE_STUBS
653 static _objref_ConfigValidations _the_nil_obj;
654 return &_the_nil_obj;
655 #else
656 static _objref_ConfigValidations* _the_nil_ptr = 0;
657 ✗ if (!_the_nil_ptr) {
658 ✗ omni::nilRefLock().lock();
659 ✗ if (!_the_nil_ptr) {
660 ✗ _the_nil_ptr = new _objref_ConfigValidations;
661 ✗ registerNilCorbaObject(_the_nil_ptr);
662 }
663 ✗ omni::nilRefLock().unlock();
664 }
665 ✗ return _the_nil_ptr;
666 #endif
667 }
668
669 const char* hpp::core_idl::ConfigValidations::_PD_repoId = "IDL:hpp/core_idl/ConfigValidations:1.0";
670
671
672 ✗ hpp::core_idl::_objref_ConfigValidations::~_objref_ConfigValidations() {
673
674 }
675
676
677 ✗ hpp::core_idl::_objref_ConfigValidations::_objref_ConfigValidations(omniIOR* ior, omniIdentity* id) :
678 omniObjRef(::hpp::core_idl::ConfigValidations::_PD_repoId, ior, id, 1),
679 ✗ _objref_ConfigValidation(ior, id)
680
681 {
682 ✗ _PR_setobj(this);
683 }
684
685 void*
686 ✗ hpp::core_idl::_objref_ConfigValidations::_ptrToObjRef(const char* id)
687 {
688 ✗ if (id == ::hpp::core_idl::ConfigValidations::_PD_repoId)
689 ✗ return (::hpp::core_idl::ConfigValidations_ptr) this;
690 ✗ if (id == ::hpp::core_idl::ConfigValidation::_PD_repoId)
691 ✗ return (::hpp::core_idl::ConfigValidation_ptr) this;
692
693
694 ✗ if (id == ::CORBA::Object::_PD_repoId)
695 ✗ return (::CORBA::Object_ptr) this;
696
697 ✗ if (omni::strMatch(id, ::hpp::core_idl::ConfigValidations::_PD_repoId))
698 ✗ return (::hpp::core_idl::ConfigValidations_ptr) this;
699 ✗ if (omni::strMatch(id, ::hpp::core_idl::ConfigValidation::_PD_repoId))
700 ✗ return (::hpp::core_idl::ConfigValidation_ptr) this;
701
702
703 ✗ if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
704 ✗ return (::CORBA::Object_ptr) this;
705
706 ✗ return 0;
707 }
708
709
710 //
711 // Code for hpp::core_idl::ConfigValidations::add
712
713 // Proxy call descriptor class. Mangled signature:
714 // void_i_chpp_mcore__idl_mConfigValidation_e_chpp_mError
715 class _0RL_cd_30be5f04cb3aeac2_80000000
716 : public omniCallDescriptor
717 {
718 public:
719 ✗ inline _0RL_cd_30be5f04cb3aeac2_80000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
720 ✗ : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
721 {
722
723 }
724
725 void marshalArguments(cdrStream&);
726 void unmarshalArguments(cdrStream&);
727
728
729 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
730 static const char* const _user_exns[];
731
732 hpp::core_idl::ConfigValidation_var arg_0_;
733 hpp::core_idl::ConfigValidation_ptr arg_0;
734 };
735
736 ✗ void _0RL_cd_30be5f04cb3aeac2_80000000::marshalArguments(cdrStream& _n)
737 {
738 ✗ hpp::core_idl::ConfigValidation::_marshalObjRef(arg_0,_n);
739
740 }
741
742 ✗ void _0RL_cd_30be5f04cb3aeac2_80000000::unmarshalArguments(cdrStream& _n)
743 {
744 ✗ arg_0_ = hpp::core_idl::ConfigValidation::_unmarshalObjRef(_n);
745 ✗ arg_0 = arg_0_.in();
746
747 }
748
749 const char* const _0RL_cd_30be5f04cb3aeac2_80000000::_user_exns[] = {
750 hpp::Error::_PD_repoId
751 };
752
753 ✗ void _0RL_cd_30be5f04cb3aeac2_80000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
754 {
755 ✗ if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
756 ✗ hpp::Error _ex;
757 ✗ _ex <<= s;
758 ✗ if (iop_client) iop_client->RequestCompleted();
759 ✗ throw _ex;
760 }
761
762
763 else {
764 ✗ if (iop_client) iop_client->RequestCompleted(1);
765 ✗ OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
766 (::CORBA::CompletionStatus)s.completion());
767 }
768 }
769
770 // Local call call-back function.
771 static void
772 ✗ _0RL_lcfn_30be5f04cb3aeac2_90000000(omniCallDescriptor* cd, omniServant* svnt)
773 {
774 ✗ _0RL_cd_30be5f04cb3aeac2_80000000* tcd = (_0RL_cd_30be5f04cb3aeac2_80000000*)cd;
775 ✗ hpp::core_idl::_impl_ConfigValidations* impl = (hpp::core_idl::_impl_ConfigValidations*) svnt->_ptrToInterface(hpp::core_idl::ConfigValidations::_PD_repoId);
776 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
777 ✗ impl->add(tcd->arg_0);
778 #else
779 if (!cd->is_upcall())
780 impl->add(tcd->arg_0);
781 else {
782 try {
783 impl->add(tcd->arg_0);
784 }
785 catch(hpp::Error& ex) {
786 throw omniORB::StubUserException(ex._NP_duplicate());
787 }
788
789
790 }
791 #endif
792
793
794 }
795
796 ✗ void hpp::core_idl::_objref_ConfigValidations::add(::hpp::core_idl::ConfigValidation_ptr validation)
797 {
798 ✗ _0RL_cd_30be5f04cb3aeac2_80000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_90000000, "add", 4);
799 ✗ _call_desc.arg_0 = validation;
800
801 ✗ _invoke(_call_desc);
802
803
804
805 }
806
807
808 //
809 // Code for hpp::core_idl::ConfigValidations::numberConfigValidations
810
811 // Proxy call descriptor class. Mangled signature:
812 // _clonglong_e_chpp_mError
813 class _0RL_cd_30be5f04cb3aeac2_a0000000
814 : public omniCallDescriptor
815 {
816 public:
817 ✗ inline _0RL_cd_30be5f04cb3aeac2_a0000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
818 ✗ : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
819 {
820
821 }
822
823
824 void unmarshalReturnedValues(cdrStream&);
825 void marshalReturnedValues(cdrStream&);
826
827 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
828 static const char* const _user_exns[];
829
830 hpp::size_type result;
831 };
832
833 ✗ void _0RL_cd_30be5f04cb3aeac2_a0000000::marshalReturnedValues(cdrStream& _n)
834 {
835 ✗ result >>= _n;
836
837 }
838
839 ✗ void _0RL_cd_30be5f04cb3aeac2_a0000000::unmarshalReturnedValues(cdrStream& _n)
840 {
841 ✗ (hpp::size_type&)result <<= _n;
842
843 }
844
845 const char* const _0RL_cd_30be5f04cb3aeac2_a0000000::_user_exns[] = {
846 hpp::Error::_PD_repoId
847 };
848
849 ✗ void _0RL_cd_30be5f04cb3aeac2_a0000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
850 {
851 ✗ if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
852 ✗ hpp::Error _ex;
853 ✗ _ex <<= s;
854 ✗ if (iop_client) iop_client->RequestCompleted();
855 ✗ throw _ex;
856 }
857
858
859 else {
860 ✗ if (iop_client) iop_client->RequestCompleted(1);
861 ✗ OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
862 (::CORBA::CompletionStatus)s.completion());
863 }
864 }
865
866 // Local call call-back function.
867 static void
868 ✗ _0RL_lcfn_30be5f04cb3aeac2_b0000000(omniCallDescriptor* cd, omniServant* svnt)
869 {
870 ✗ _0RL_cd_30be5f04cb3aeac2_a0000000* tcd = (_0RL_cd_30be5f04cb3aeac2_a0000000*)cd;
871 ✗ hpp::core_idl::_impl_ConfigValidations* impl = (hpp::core_idl::_impl_ConfigValidations*) svnt->_ptrToInterface(hpp::core_idl::ConfigValidations::_PD_repoId);
872 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
873 ✗ tcd->result = impl->numberConfigValidations();
874 #else
875 if (!cd->is_upcall())
876 tcd->result = impl->numberConfigValidations();
877 else {
878 try {
879 tcd->result = impl->numberConfigValidations();
880 }
881 catch(hpp::Error& ex) {
882 throw omniORB::StubUserException(ex._NP_duplicate());
883 }
884
885
886 }
887 #endif
888
889
890 }
891
892 ✗ hpp::size_type hpp::core_idl::_objref_ConfigValidations::numberConfigValidations()
893 {
894 ✗ _0RL_cd_30be5f04cb3aeac2_a0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_b0000000, "numberConfigValidations", 24);
895
896
897 ✗ _invoke(_call_desc);
898 ✗ return _call_desc.result;
899
900
901 }
902
903
904 //
905 // Code for hpp::core_idl::ConfigValidations::clear
906
907 // Local call call-back function.
908 static void
909 ✗ _0RL_lcfn_30be5f04cb3aeac2_c0000000(omniCallDescriptor* _OMNIORB_EX_ONLY_CD(cd), omniServant* svnt)
910 {
911
912 ✗ hpp::core_idl::_impl_ConfigValidations* impl = (hpp::core_idl::_impl_ConfigValidations*) svnt->_ptrToInterface(hpp::core_idl::ConfigValidations::_PD_repoId);
913 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
914 ✗ impl->clear();
915 #else
916 if (!cd->is_upcall())
917 impl->clear();
918 else {
919 try {
920 impl->clear();
921 }
922 catch(hpp::Error& ex) {
923 throw omniORB::StubUserException(ex._NP_duplicate());
924 }
925
926
927 }
928 #endif
929
930
931 }
932
933 ✗ void hpp::core_idl::_objref_ConfigValidations::clear()
934 {
935 ✗ _0RL_cd_30be5f04cb3aeac2_00000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_c0000000, "clear", 6);
936
937
938 ✗ _invoke(_call_desc);
939
940
941
942 }
943
944
945 //
946 // Code for hpp::core_idl::ConfigValidations::setSecurityMargins
947
948 // Proxy call descriptor class. Mangled signature:
949 // void_i_chpp_mfloatSeqSeq_e_chpp_mError
950 class _0RL_cd_30be5f04cb3aeac2_d0000000
951 : public omniCallDescriptor
952 {
953 public:
954 ✗ inline _0RL_cd_30be5f04cb3aeac2_d0000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
955 ✗ : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
956 {
957
958 }
959
960 void marshalArguments(cdrStream&);
961 void unmarshalArguments(cdrStream&);
962
963
964 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
965 static const char* const _user_exns[];
966
967 hpp::floatSeqSeq_var arg_0_;
968 const hpp::floatSeqSeq* arg_0;
969 };
970
971 ✗ void _0RL_cd_30be5f04cb3aeac2_d0000000::marshalArguments(cdrStream& _n)
972 {
973 ✗ (const hpp::floatSeqSeq&) *arg_0 >>= _n;
974
975 }
976
977 ✗ void _0RL_cd_30be5f04cb3aeac2_d0000000::unmarshalArguments(cdrStream& _n)
978 {
979 ✗ arg_0_ = new hpp::floatSeqSeq;
980 ✗ (hpp::floatSeqSeq&)arg_0_ <<= _n;
981 ✗ arg_0 = &arg_0_.in();
982
983 }
984
985 const char* const _0RL_cd_30be5f04cb3aeac2_d0000000::_user_exns[] = {
986 hpp::Error::_PD_repoId
987 };
988
989 ✗ void _0RL_cd_30be5f04cb3aeac2_d0000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
990 {
991 ✗ if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
992 ✗ hpp::Error _ex;
993 ✗ _ex <<= s;
994 ✗ if (iop_client) iop_client->RequestCompleted();
995 ✗ throw _ex;
996 }
997
998
999 else {
1000 ✗ if (iop_client) iop_client->RequestCompleted(1);
1001 ✗ OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
1002 (::CORBA::CompletionStatus)s.completion());
1003 }
1004 }
1005
1006 // Local call call-back function.
1007 static void
1008 ✗ _0RL_lcfn_30be5f04cb3aeac2_e0000000(omniCallDescriptor* cd, omniServant* svnt)
1009 {
1010 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000* tcd = (_0RL_cd_30be5f04cb3aeac2_d0000000*)cd;
1011 ✗ hpp::core_idl::_impl_ConfigValidations* impl = (hpp::core_idl::_impl_ConfigValidations*) svnt->_ptrToInterface(hpp::core_idl::ConfigValidations::_PD_repoId);
1012 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1013 ✗ impl->setSecurityMargins(*tcd->arg_0);
1014 #else
1015 if (!cd->is_upcall())
1016 impl->setSecurityMargins(*tcd->arg_0);
1017 else {
1018 try {
1019 impl->setSecurityMargins(*tcd->arg_0);
1020 }
1021 catch(hpp::Error& ex) {
1022 throw omniORB::StubUserException(ex._NP_duplicate());
1023 }
1024
1025
1026 }
1027 #endif
1028
1029
1030 }
1031
1032 ✗ void hpp::core_idl::_objref_ConfigValidations::setSecurityMargins(const ::hpp::floatSeqSeq& margins)
1033 {
1034 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_e0000000, "setSecurityMargins", 19);
1035 ✗ _call_desc.arg_0 = &(::hpp::floatSeqSeq&) margins;
1036
1037 ✗ _invoke(_call_desc);
1038
1039
1040
1041 }
1042
1043
1044 //
1045 // Code for hpp::core_idl::ConfigValidations::setSecurityMarginBetweenBodies
1046
1047 // Proxy call descriptor class. Mangled signature:
1048 // void_i_cstring_i_cstring_i_cdouble_e_chpp_mError
1049 class _0RL_cd_30be5f04cb3aeac2_f0000000
1050 : public omniCallDescriptor
1051 {
1052 public:
1053 ✗ inline _0RL_cd_30be5f04cb3aeac2_f0000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
1054 ✗ : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
1055 {
1056
1057 }
1058
1059 void marshalArguments(cdrStream&);
1060 void unmarshalArguments(cdrStream&);
1061
1062
1063 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
1064 static const char* const _user_exns[];
1065
1066 ::CORBA::String_var arg_0_;
1067 const char* arg_0;
1068 ::CORBA::String_var arg_1_;
1069 const char* arg_1;
1070 hpp::value_type arg_2;
1071 };
1072
1073 ✗ void _0RL_cd_30be5f04cb3aeac2_f0000000::marshalArguments(cdrStream& _n)
1074 {
1075 ✗ _n.marshalString(arg_0,0);
1076 ✗ _n.marshalString(arg_1,0);
1077 ✗ arg_2 >>= _n;
1078
1079 }
1080
1081 ✗ void _0RL_cd_30be5f04cb3aeac2_f0000000::unmarshalArguments(cdrStream& _n)
1082 {
1083 ✗ arg_0_ = _n.unmarshalString(0);
1084 ✗ arg_0 = arg_0_.in();
1085 ✗ arg_1_ = _n.unmarshalString(0);
1086 ✗ arg_1 = arg_1_.in();
1087 ✗ (hpp::value_type&)arg_2 <<= _n;
1088
1089 }
1090
1091 const char* const _0RL_cd_30be5f04cb3aeac2_f0000000::_user_exns[] = {
1092 hpp::Error::_PD_repoId
1093 };
1094
1095 ✗ void _0RL_cd_30be5f04cb3aeac2_f0000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
1096 {
1097 ✗ if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
1098 ✗ hpp::Error _ex;
1099 ✗ _ex <<= s;
1100 ✗ if (iop_client) iop_client->RequestCompleted();
1101 ✗ throw _ex;
1102 }
1103
1104
1105 else {
1106 ✗ if (iop_client) iop_client->RequestCompleted(1);
1107 ✗ OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
1108 (::CORBA::CompletionStatus)s.completion());
1109 }
1110 }
1111
1112 // Local call call-back function.
1113 static void
1114 ✗ _0RL_lcfn_30be5f04cb3aeac2_01000000(omniCallDescriptor* cd, omniServant* svnt)
1115 {
1116 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000* tcd = (_0RL_cd_30be5f04cb3aeac2_f0000000*)cd;
1117 ✗ hpp::core_idl::_impl_ConfigValidations* impl = (hpp::core_idl::_impl_ConfigValidations*) svnt->_ptrToInterface(hpp::core_idl::ConfigValidations::_PD_repoId);
1118 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1119 ✗ impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
1120 #else
1121 if (!cd->is_upcall())
1122 impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
1123 else {
1124 try {
1125 impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
1126 }
1127 catch(hpp::Error& ex) {
1128 throw omniORB::StubUserException(ex._NP_duplicate());
1129 }
1130
1131
1132 }
1133 #endif
1134
1135
1136 }
1137
1138 ✗ void hpp::core_idl::_objref_ConfigValidations::setSecurityMarginBetweenBodies(const char* body_a, const char* body_b, ::hpp::value_type margin)
1139 {
1140 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_01000000, "setSecurityMarginBetweenBodies", 31);
1141 ✗ _call_desc.arg_0 = body_a;
1142 ✗ _call_desc.arg_1 = body_b;
1143 ✗ _call_desc.arg_2 = margin;
1144
1145 ✗ _invoke(_call_desc);
1146
1147
1148
1149 }
1150
1151
1152 //
1153 // Code for hpp::core_idl::ConfigValidations::filterCollisionPairs
1154
1155 // Proxy call descriptor class. Mangled signature:
1156 // void_i_chpp_mintSeqSeq_e_chpp_mError
1157 class _0RL_cd_30be5f04cb3aeac2_11000000
1158 : public omniCallDescriptor
1159 {
1160 public:
1161 ✗ inline _0RL_cd_30be5f04cb3aeac2_11000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
1162 ✗ : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
1163 {
1164
1165 }
1166
1167 void marshalArguments(cdrStream&);
1168 void unmarshalArguments(cdrStream&);
1169
1170
1171 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
1172 static const char* const _user_exns[];
1173
1174 hpp::core_idl::RelativeMotionMatrix_var arg_0_;
1175 const hpp::core_idl::RelativeMotionMatrix* arg_0;
1176 };
1177
1178 ✗ void _0RL_cd_30be5f04cb3aeac2_11000000::marshalArguments(cdrStream& _n)
1179 {
1180 ✗ (const hpp::core_idl::RelativeMotionMatrix&) *arg_0 >>= _n;
1181
1182 }
1183
1184 ✗ void _0RL_cd_30be5f04cb3aeac2_11000000::unmarshalArguments(cdrStream& _n)
1185 {
1186 ✗ arg_0_ = new hpp::core_idl::RelativeMotionMatrix;
1187 ✗ (hpp::core_idl::RelativeMotionMatrix&)arg_0_ <<= _n;
1188 ✗ arg_0 = &arg_0_.in();
1189
1190 }
1191
1192 const char* const _0RL_cd_30be5f04cb3aeac2_11000000::_user_exns[] = {
1193 hpp::Error::_PD_repoId
1194 };
1195
1196 ✗ void _0RL_cd_30be5f04cb3aeac2_11000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
1197 {
1198 ✗ if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
1199 ✗ hpp::Error _ex;
1200 ✗ _ex <<= s;
1201 ✗ if (iop_client) iop_client->RequestCompleted();
1202 ✗ throw _ex;
1203 }
1204
1205
1206 else {
1207 ✗ if (iop_client) iop_client->RequestCompleted(1);
1208 ✗ OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
1209 (::CORBA::CompletionStatus)s.completion());
1210 }
1211 }
1212
1213 // Local call call-back function.
1214 static void
1215 ✗ _0RL_lcfn_30be5f04cb3aeac2_21000000(omniCallDescriptor* cd, omniServant* svnt)
1216 {
1217 ✗ _0RL_cd_30be5f04cb3aeac2_11000000* tcd = (_0RL_cd_30be5f04cb3aeac2_11000000*)cd;
1218 ✗ hpp::core_idl::_impl_ConfigValidations* impl = (hpp::core_idl::_impl_ConfigValidations*) svnt->_ptrToInterface(hpp::core_idl::ConfigValidations::_PD_repoId);
1219 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1220 ✗ impl->filterCollisionPairs(*tcd->arg_0);
1221 #else
1222 if (!cd->is_upcall())
1223 impl->filterCollisionPairs(*tcd->arg_0);
1224 else {
1225 try {
1226 impl->filterCollisionPairs(*tcd->arg_0);
1227 }
1228 catch(hpp::Error& ex) {
1229 throw omniORB::StubUserException(ex._NP_duplicate());
1230 }
1231
1232
1233 }
1234 #endif
1235
1236
1237 }
1238
1239 ✗ void hpp::core_idl::_objref_ConfigValidations::filterCollisionPairs(const ::hpp::core_idl::RelativeMotionMatrix& relMotion)
1240 {
1241 ✗ _0RL_cd_30be5f04cb3aeac2_11000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_21000000, "filterCollisionPairs", 21);
1242 ✗ _call_desc.arg_0 = &(::hpp::core_idl::RelativeMotionMatrix&) relMotion;
1243
1244 ✗ _invoke(_call_desc);
1245
1246
1247
1248 }
1249
1250 16 hpp::core_idl::_pof_ConfigValidations::~_pof_ConfigValidations() {}
1251
1252
1253 omniObjRef*
1254 ✗ hpp::core_idl::_pof_ConfigValidations::newObjRef(omniIOR* ior, omniIdentity* id)
1255 {
1256 ✗ return new ::hpp::core_idl::_objref_ConfigValidations(ior, id);
1257 }
1258
1259
1260 ::CORBA::Boolean
1261 ✗ hpp::core_idl::_pof_ConfigValidations::is_a(const char* id) const
1262 {
1263 ✗ if (omni::ptrStrMatch(id, ::hpp::core_idl::ConfigValidations::_PD_repoId))
1264 ✗ return 1;
1265 ✗ if (omni::ptrStrMatch(id, hpp::core_idl::ConfigValidation::_PD_repoId))
1266 ✗ return 1;
1267
1268
1269 ✗ return 0;
1270 }
1271
1272 const hpp::core_idl::_pof_ConfigValidations _the_pof_hpp_mcore__idl_mConfigValidations;
1273
1274 ✗ hpp::core_idl::_impl_ConfigValidations::~_impl_ConfigValidations() {}
1275
1276
1277 ::CORBA::Boolean
1278 ✗ hpp::core_idl::_impl_ConfigValidations::_dispatch(omniCallHandle& _handle)
1279 {
1280 ✗ const char* op = _handle.operation_name();
1281
1282 ✗ if (omni::strMatch(op, "add")) {
1283
1284 ✗ _0RL_cd_30be5f04cb3aeac2_80000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_90000000, "add", 4, 1);
1285
1286 ✗ _handle.upcall(this,_call_desc);
1287 ✗ return 1;
1288 }
1289
1290 ✗ if (omni::strMatch(op, "numberConfigValidations")) {
1291
1292 ✗ _0RL_cd_30be5f04cb3aeac2_a0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_b0000000, "numberConfigValidations", 24, 1);
1293
1294 ✗ _handle.upcall(this,_call_desc);
1295 ✗ return 1;
1296 }
1297
1298 ✗ if (omni::strMatch(op, "clear")) {
1299
1300 ✗ _0RL_cd_30be5f04cb3aeac2_00000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_c0000000, "clear", 6, 1);
1301
1302 ✗ _handle.upcall(this,_call_desc);
1303 ✗ return 1;
1304 }
1305
1306 ✗ if (omni::strMatch(op, "setSecurityMargins")) {
1307
1308 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_e0000000, "setSecurityMargins", 19, 1);
1309
1310 ✗ _handle.upcall(this,_call_desc);
1311 ✗ return 1;
1312 }
1313
1314 ✗ if (omni::strMatch(op, "setSecurityMarginBetweenBodies")) {
1315
1316 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_01000000, "setSecurityMarginBetweenBodies", 31, 1);
1317
1318 ✗ _handle.upcall(this,_call_desc);
1319 ✗ return 1;
1320 }
1321
1322 ✗ if (omni::strMatch(op, "filterCollisionPairs")) {
1323
1324 ✗ _0RL_cd_30be5f04cb3aeac2_11000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_21000000, "filterCollisionPairs", 21, 1);
1325
1326 ✗ _handle.upcall(this,_call_desc);
1327 ✗ return 1;
1328 }
1329
1330
1331 #ifndef _MSC_VER
1332 ✗ if (_impl_ConfigValidation::_dispatch(_handle)) {
1333 ✗ return 1;
1334 }
1335 #else
1336 // Work-around for incorrect MSVC code generation.
1337 if (((_impl_ConfigValidation*)this)->
1338 _impl_ConfigValidation::_dispatch(_handle)) {
1339 return 1;
1340 }
1341 #endif
1342
1343
1344 ✗ return 0;
1345 }
1346
1347 void*
1348 ✗ hpp::core_idl::_impl_ConfigValidations::_ptrToInterface(const char* id)
1349 {
1350 ✗ if (id == ::hpp::core_idl::ConfigValidations::_PD_repoId)
1351 ✗ return (::hpp::core_idl::_impl_ConfigValidations*) this;
1352 ✗ if (id == ::hpp::core_idl::ConfigValidation::_PD_repoId)
1353 ✗ return (::hpp::core_idl::_impl_ConfigValidation*) this;
1354
1355
1356 ✗ if (id == ::CORBA::Object::_PD_repoId)
1357 ✗ return (void*) 1;
1358
1359 ✗ if (omni::strMatch(id, ::hpp::core_idl::ConfigValidations::_PD_repoId))
1360 ✗ return (::hpp::core_idl::_impl_ConfigValidations*) this;
1361 ✗ if (omni::strMatch(id, ::hpp::core_idl::ConfigValidation::_PD_repoId))
1362 ✗ return (::hpp::core_idl::_impl_ConfigValidation*) this;
1363
1364
1365 ✗ if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
1366 ✗ return (void*) 1;
1367 ✗ return 0;
1368 }
1369
1370 const char*
1371 ✗ hpp::core_idl::_impl_ConfigValidations::_mostDerivedRepoId()
1372 {
1373 ✗ return ::hpp::core_idl::ConfigValidations::_PD_repoId;
1374 }
1375
1376 ✗ hpp::core_idl::CollisionValidation_ptr hpp::core_idl::CollisionValidation_Helper::_nil() {
1377 ✗ return ::hpp::core_idl::CollisionValidation::_nil();
1378 }
1379
1380 ✗ ::CORBA::Boolean hpp::core_idl::CollisionValidation_Helper::is_nil(::hpp::core_idl::CollisionValidation_ptr p) {
1381 ✗ return ::CORBA::is_nil(p);
1382
1383 }
1384
1385 ✗ void hpp::core_idl::CollisionValidation_Helper::release(::hpp::core_idl::CollisionValidation_ptr p) {
1386 ✗ ::CORBA::release(p);
1387 }
1388
1389 ✗ void hpp::core_idl::CollisionValidation_Helper::marshalObjRef(::hpp::core_idl::CollisionValidation_ptr obj, cdrStream& s) {
1390 ✗ ::hpp::core_idl::CollisionValidation::_marshalObjRef(obj, s);
1391 }
1392
1393 ✗ hpp::core_idl::CollisionValidation_ptr hpp::core_idl::CollisionValidation_Helper::unmarshalObjRef(cdrStream& s) {
1394 ✗ return ::hpp::core_idl::CollisionValidation::_unmarshalObjRef(s);
1395 }
1396
1397 ✗ void hpp::core_idl::CollisionValidation_Helper::duplicate(::hpp::core_idl::CollisionValidation_ptr obj) {
1398 ✗ if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
1399 }
1400
1401 hpp::core_idl::CollisionValidation_ptr
1402 ✗ hpp::core_idl::CollisionValidation::_duplicate(::hpp::core_idl::CollisionValidation_ptr obj)
1403 {
1404 ✗ if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
1405 ✗ return obj;
1406 }
1407
1408 hpp::core_idl::CollisionValidation_ptr
1409 ✗ hpp::core_idl::CollisionValidation::_narrow(::CORBA::Object_ptr obj)
1410 {
1411 ✗ if (!obj || obj->_NP_is_nil() || obj->_NP_is_pseudo()) return _nil();
1412 ✗ _ptr_type e = (_ptr_type) obj->_PR_getobj()->_realNarrow(_PD_repoId);
1413 ✗ return e ? e : _nil();
1414 }
1415
1416
1417 hpp::core_idl::CollisionValidation_ptr
1418 ✗ hpp::core_idl::CollisionValidation::_unchecked_narrow(::CORBA::Object_ptr obj)
1419 {
1420 ✗ if (!obj || obj->_NP_is_nil() || obj->_NP_is_pseudo()) return _nil();
1421 ✗ _ptr_type e = (_ptr_type) obj->_PR_getobj()->_uncheckedNarrow(_PD_repoId);
1422 ✗ return e ? e : _nil();
1423 }
1424
1425 hpp::core_idl::CollisionValidation_ptr
1426 ✗ hpp::core_idl::CollisionValidation::_nil()
1427 {
1428 #ifdef OMNI_UNLOADABLE_STUBS
1429 static _objref_CollisionValidation _the_nil_obj;
1430 return &_the_nil_obj;
1431 #else
1432 static _objref_CollisionValidation* _the_nil_ptr = 0;
1433 ✗ if (!_the_nil_ptr) {
1434 ✗ omni::nilRefLock().lock();
1435 ✗ if (!_the_nil_ptr) {
1436 ✗ _the_nil_ptr = new _objref_CollisionValidation;
1437 ✗ registerNilCorbaObject(_the_nil_ptr);
1438 }
1439 ✗ omni::nilRefLock().unlock();
1440 }
1441 ✗ return _the_nil_ptr;
1442 #endif
1443 }
1444
1445 const char* hpp::core_idl::CollisionValidation::_PD_repoId = "IDL:hpp/core_idl/CollisionValidation:1.0";
1446
1447
1448 ✗ hpp::core_idl::_objref_CollisionValidation::~_objref_CollisionValidation() {
1449
1450 }
1451
1452
1453 ✗ hpp::core_idl::_objref_CollisionValidation::_objref_CollisionValidation(omniIOR* ior, omniIdentity* id) :
1454 omniObjRef(::hpp::core_idl::CollisionValidation::_PD_repoId, ior, id, 1),
1455 ✗ _objref_ConfigValidation(ior, id)
1456
1457 {
1458 ✗ _PR_setobj(this);
1459 }
1460
1461 void*
1462 ✗ hpp::core_idl::_objref_CollisionValidation::_ptrToObjRef(const char* id)
1463 {
1464 ✗ if (id == ::hpp::core_idl::CollisionValidation::_PD_repoId)
1465 ✗ return (::hpp::core_idl::CollisionValidation_ptr) this;
1466 ✗ if (id == ::hpp::core_idl::ConfigValidation::_PD_repoId)
1467 ✗ return (::hpp::core_idl::ConfigValidation_ptr) this;
1468
1469
1470 ✗ if (id == ::CORBA::Object::_PD_repoId)
1471 ✗ return (::CORBA::Object_ptr) this;
1472
1473 ✗ if (omni::strMatch(id, ::hpp::core_idl::CollisionValidation::_PD_repoId))
1474 ✗ return (::hpp::core_idl::CollisionValidation_ptr) this;
1475 ✗ if (omni::strMatch(id, ::hpp::core_idl::ConfigValidation::_PD_repoId))
1476 ✗ return (::hpp::core_idl::ConfigValidation_ptr) this;
1477
1478
1479 ✗ if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
1480 ✗ return (::CORBA::Object_ptr) this;
1481
1482 ✗ return 0;
1483 }
1484
1485
1486 //
1487 // Code for hpp::core_idl::CollisionValidation::setSecurityMargins
1488
1489 // Local call call-back function.
1490 static void
1491 ✗ _0RL_lcfn_30be5f04cb3aeac2_31000000(omniCallDescriptor* cd, omniServant* svnt)
1492 {
1493 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000* tcd = (_0RL_cd_30be5f04cb3aeac2_d0000000*)cd;
1494 ✗ hpp::core_idl::_impl_CollisionValidation* impl = (hpp::core_idl::_impl_CollisionValidation*) svnt->_ptrToInterface(hpp::core_idl::CollisionValidation::_PD_repoId);
1495 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1496 ✗ impl->setSecurityMargins(*tcd->arg_0);
1497 #else
1498 if (!cd->is_upcall())
1499 impl->setSecurityMargins(*tcd->arg_0);
1500 else {
1501 try {
1502 impl->setSecurityMargins(*tcd->arg_0);
1503 }
1504 catch(hpp::Error& ex) {
1505 throw omniORB::StubUserException(ex._NP_duplicate());
1506 }
1507
1508
1509 }
1510 #endif
1511
1512
1513 }
1514
1515 ✗ void hpp::core_idl::_objref_CollisionValidation::setSecurityMargins(const ::hpp::floatSeqSeq& margins)
1516 {
1517 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_31000000, "setSecurityMargins", 19);
1518 ✗ _call_desc.arg_0 = &(::hpp::floatSeqSeq&) margins;
1519
1520 ✗ _invoke(_call_desc);
1521
1522
1523
1524 }
1525
1526
1527 //
1528 // Code for hpp::core_idl::CollisionValidation::setSecurityMarginBetweenBodies
1529
1530 // Local call call-back function.
1531 static void
1532 ✗ _0RL_lcfn_30be5f04cb3aeac2_41000000(omniCallDescriptor* cd, omniServant* svnt)
1533 {
1534 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000* tcd = (_0RL_cd_30be5f04cb3aeac2_f0000000*)cd;
1535 ✗ hpp::core_idl::_impl_CollisionValidation* impl = (hpp::core_idl::_impl_CollisionValidation*) svnt->_ptrToInterface(hpp::core_idl::CollisionValidation::_PD_repoId);
1536 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1537 ✗ impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
1538 #else
1539 if (!cd->is_upcall())
1540 impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
1541 else {
1542 try {
1543 impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
1544 }
1545 catch(hpp::Error& ex) {
1546 throw omniORB::StubUserException(ex._NP_duplicate());
1547 }
1548
1549
1550 }
1551 #endif
1552
1553
1554 }
1555
1556 ✗ void hpp::core_idl::_objref_CollisionValidation::setSecurityMarginBetweenBodies(const char* body_a, const char* body_b, ::hpp::value_type margin)
1557 {
1558 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_41000000, "setSecurityMarginBetweenBodies", 31);
1559 ✗ _call_desc.arg_0 = body_a;
1560 ✗ _call_desc.arg_1 = body_b;
1561 ✗ _call_desc.arg_2 = margin;
1562
1563 ✗ _invoke(_call_desc);
1564
1565
1566
1567 }
1568
1569
1570 //
1571 // Code for hpp::core_idl::CollisionValidation::filterCollisionPairs
1572
1573 // Local call call-back function.
1574 static void
1575 ✗ _0RL_lcfn_30be5f04cb3aeac2_51000000(omniCallDescriptor* cd, omniServant* svnt)
1576 {
1577 ✗ _0RL_cd_30be5f04cb3aeac2_11000000* tcd = (_0RL_cd_30be5f04cb3aeac2_11000000*)cd;
1578 ✗ hpp::core_idl::_impl_CollisionValidation* impl = (hpp::core_idl::_impl_CollisionValidation*) svnt->_ptrToInterface(hpp::core_idl::CollisionValidation::_PD_repoId);
1579 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1580 ✗ impl->filterCollisionPairs(*tcd->arg_0);
1581 #else
1582 if (!cd->is_upcall())
1583 impl->filterCollisionPairs(*tcd->arg_0);
1584 else {
1585 try {
1586 impl->filterCollisionPairs(*tcd->arg_0);
1587 }
1588 catch(hpp::Error& ex) {
1589 throw omniORB::StubUserException(ex._NP_duplicate());
1590 }
1591
1592
1593 }
1594 #endif
1595
1596
1597 }
1598
1599 ✗ void hpp::core_idl::_objref_CollisionValidation::filterCollisionPairs(const ::hpp::core_idl::RelativeMotionMatrix& relMotion)
1600 {
1601 ✗ _0RL_cd_30be5f04cb3aeac2_11000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_51000000, "filterCollisionPairs", 21);
1602 ✗ _call_desc.arg_0 = &(::hpp::core_idl::RelativeMotionMatrix&) relMotion;
1603
1604 ✗ _invoke(_call_desc);
1605
1606
1607
1608 }
1609
1610 16 hpp::core_idl::_pof_CollisionValidation::~_pof_CollisionValidation() {}
1611
1612
1613 omniObjRef*
1614 ✗ hpp::core_idl::_pof_CollisionValidation::newObjRef(omniIOR* ior, omniIdentity* id)
1615 {
1616 ✗ return new ::hpp::core_idl::_objref_CollisionValidation(ior, id);
1617 }
1618
1619
1620 ::CORBA::Boolean
1621 ✗ hpp::core_idl::_pof_CollisionValidation::is_a(const char* id) const
1622 {
1623 ✗ if (omni::ptrStrMatch(id, ::hpp::core_idl::CollisionValidation::_PD_repoId))
1624 ✗ return 1;
1625 ✗ if (omni::ptrStrMatch(id, hpp::core_idl::ConfigValidation::_PD_repoId))
1626 ✗ return 1;
1627
1628
1629 ✗ return 0;
1630 }
1631
1632 const hpp::core_idl::_pof_CollisionValidation _the_pof_hpp_mcore__idl_mCollisionValidation;
1633
1634 ✗ hpp::core_idl::_impl_CollisionValidation::~_impl_CollisionValidation() {}
1635
1636
1637 ::CORBA::Boolean
1638 ✗ hpp::core_idl::_impl_CollisionValidation::_dispatch(omniCallHandle& _handle)
1639 {
1640 ✗ const char* op = _handle.operation_name();
1641
1642 ✗ if (omni::strMatch(op, "setSecurityMargins")) {
1643
1644 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_31000000, "setSecurityMargins", 19, 1);
1645
1646 ✗ _handle.upcall(this,_call_desc);
1647 ✗ return 1;
1648 }
1649
1650 ✗ if (omni::strMatch(op, "setSecurityMarginBetweenBodies")) {
1651
1652 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_41000000, "setSecurityMarginBetweenBodies", 31, 1);
1653
1654 ✗ _handle.upcall(this,_call_desc);
1655 ✗ return 1;
1656 }
1657
1658 ✗ if (omni::strMatch(op, "filterCollisionPairs")) {
1659
1660 ✗ _0RL_cd_30be5f04cb3aeac2_11000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_51000000, "filterCollisionPairs", 21, 1);
1661
1662 ✗ _handle.upcall(this,_call_desc);
1663 ✗ return 1;
1664 }
1665
1666
1667 #ifndef _MSC_VER
1668 ✗ if (_impl_ConfigValidation::_dispatch(_handle)) {
1669 ✗ return 1;
1670 }
1671 #else
1672 // Work-around for incorrect MSVC code generation.
1673 if (((_impl_ConfigValidation*)this)->
1674 _impl_ConfigValidation::_dispatch(_handle)) {
1675 return 1;
1676 }
1677 #endif
1678
1679
1680 ✗ return 0;
1681 }
1682
1683 void*
1684 ✗ hpp::core_idl::_impl_CollisionValidation::_ptrToInterface(const char* id)
1685 {
1686 ✗ if (id == ::hpp::core_idl::CollisionValidation::_PD_repoId)
1687 ✗ return (::hpp::core_idl::_impl_CollisionValidation*) this;
1688 ✗ if (id == ::hpp::core_idl::ConfigValidation::_PD_repoId)
1689 ✗ return (::hpp::core_idl::_impl_ConfigValidation*) this;
1690
1691
1692 ✗ if (id == ::CORBA::Object::_PD_repoId)
1693 ✗ return (void*) 1;
1694
1695 ✗ if (omni::strMatch(id, ::hpp::core_idl::CollisionValidation::_PD_repoId))
1696 ✗ return (::hpp::core_idl::_impl_CollisionValidation*) this;
1697 ✗ if (omni::strMatch(id, ::hpp::core_idl::ConfigValidation::_PD_repoId))
1698 ✗ return (::hpp::core_idl::_impl_ConfigValidation*) this;
1699
1700
1701 ✗ if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
1702 ✗ return (void*) 1;
1703 ✗ return 0;
1704 }
1705
1706 const char*
1707 ✗ hpp::core_idl::_impl_CollisionValidation::_mostDerivedRepoId()
1708 {
1709 ✗ return ::hpp::core_idl::CollisionValidation::_PD_repoId;
1710 }
1711
1712 ✗ hpp::core_idl::PathValidation_ptr hpp::core_idl::PathValidation_Helper::_nil() {
1713 ✗ return ::hpp::core_idl::PathValidation::_nil();
1714 }
1715
1716 ✗ ::CORBA::Boolean hpp::core_idl::PathValidation_Helper::is_nil(::hpp::core_idl::PathValidation_ptr p) {
1717 ✗ return ::CORBA::is_nil(p);
1718
1719 }
1720
1721 ✗ void hpp::core_idl::PathValidation_Helper::release(::hpp::core_idl::PathValidation_ptr p) {
1722 ✗ ::CORBA::release(p);
1723 }
1724
1725 ✗ void hpp::core_idl::PathValidation_Helper::marshalObjRef(::hpp::core_idl::PathValidation_ptr obj, cdrStream& s) {
1726 ✗ ::hpp::core_idl::PathValidation::_marshalObjRef(obj, s);
1727 }
1728
1729 ✗ hpp::core_idl::PathValidation_ptr hpp::core_idl::PathValidation_Helper::unmarshalObjRef(cdrStream& s) {
1730 ✗ return ::hpp::core_idl::PathValidation::_unmarshalObjRef(s);
1731 }
1732
1733 ✗ void hpp::core_idl::PathValidation_Helper::duplicate(::hpp::core_idl::PathValidation_ptr obj) {
1734 ✗ if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
1735 }
1736
1737 hpp::core_idl::PathValidation_ptr
1738 ✗ hpp::core_idl::PathValidation::_duplicate(::hpp::core_idl::PathValidation_ptr obj)
1739 {
1740 ✗ if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
1741 ✗ return obj;
1742 }
1743
1744 hpp::core_idl::PathValidation_ptr
1745 ✗ hpp::core_idl::PathValidation::_narrow(::CORBA::Object_ptr obj)
1746 {
1747 ✗ if (!obj || obj->_NP_is_nil() || obj->_NP_is_pseudo()) return _nil();
1748 ✗ _ptr_type e = (_ptr_type) obj->_PR_getobj()->_realNarrow(_PD_repoId);
1749 ✗ return e ? e : _nil();
1750 }
1751
1752
1753 hpp::core_idl::PathValidation_ptr
1754 ✗ hpp::core_idl::PathValidation::_unchecked_narrow(::CORBA::Object_ptr obj)
1755 {
1756 ✗ if (!obj || obj->_NP_is_nil() || obj->_NP_is_pseudo()) return _nil();
1757 ✗ _ptr_type e = (_ptr_type) obj->_PR_getobj()->_uncheckedNarrow(_PD_repoId);
1758 ✗ return e ? e : _nil();
1759 }
1760
1761 hpp::core_idl::PathValidation_ptr
1762 ✗ hpp::core_idl::PathValidation::_nil()
1763 {
1764 #ifdef OMNI_UNLOADABLE_STUBS
1765 static _objref_PathValidation _the_nil_obj;
1766 return &_the_nil_obj;
1767 #else
1768 static _objref_PathValidation* _the_nil_ptr = 0;
1769 ✗ if (!_the_nil_ptr) {
1770 ✗ omni::nilRefLock().lock();
1771 ✗ if (!_the_nil_ptr) {
1772 ✗ _the_nil_ptr = new _objref_PathValidation;
1773 ✗ registerNilCorbaObject(_the_nil_ptr);
1774 }
1775 ✗ omni::nilRefLock().unlock();
1776 }
1777 ✗ return _the_nil_ptr;
1778 #endif
1779 }
1780
1781 const char* hpp::core_idl::PathValidation::_PD_repoId = "IDL:hpp/core_idl/PathValidation:1.0";
1782
1783
1784 ✗ hpp::core_idl::_objref_PathValidation::~_objref_PathValidation() {
1785
1786 }
1787
1788
1789 ✗ hpp::core_idl::_objref_PathValidation::_objref_PathValidation(omniIOR* ior, omniIdentity* id) :
1790 ✗ omniObjRef(::hpp::core_idl::PathValidation::_PD_repoId, ior, id, 1)
1791
1792
1793 {
1794 ✗ _PR_setobj(this);
1795 }
1796
1797 void*
1798 ✗ hpp::core_idl::_objref_PathValidation::_ptrToObjRef(const char* id)
1799 {
1800 ✗ if (id == ::hpp::core_idl::PathValidation::_PD_repoId)
1801 ✗ return (::hpp::core_idl::PathValidation_ptr) this;
1802
1803 ✗ if (id == ::CORBA::Object::_PD_repoId)
1804 ✗ return (::CORBA::Object_ptr) this;
1805
1806 ✗ if (omni::strMatch(id, ::hpp::core_idl::PathValidation::_PD_repoId))
1807 ✗ return (::hpp::core_idl::PathValidation_ptr) this;
1808
1809 ✗ if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
1810 ✗ return (::CORBA::Object_ptr) this;
1811
1812 ✗ return 0;
1813 }
1814
1815
1816 //
1817 // Code for hpp::core_idl::PathValidation::deleteThis
1818
1819 // Local call call-back function.
1820 static void
1821 ✗ _0RL_lcfn_30be5f04cb3aeac2_61000000(omniCallDescriptor* _OMNIORB_EX_ONLY_CD(cd), omniServant* svnt)
1822 {
1823
1824 ✗ hpp::core_idl::_impl_PathValidation* impl = (hpp::core_idl::_impl_PathValidation*) svnt->_ptrToInterface(hpp::core_idl::PathValidation::_PD_repoId);
1825 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1826 ✗ impl->deleteThis();
1827 #else
1828 if (!cd->is_upcall())
1829 impl->deleteThis();
1830 else {
1831 try {
1832 impl->deleteThis();
1833 }
1834 catch(hpp::Error& ex) {
1835 throw omniORB::StubUserException(ex._NP_duplicate());
1836 }
1837
1838
1839 }
1840 #endif
1841
1842
1843 }
1844
1845 ✗ void hpp::core_idl::_objref_PathValidation::deleteThis()
1846 {
1847 ✗ _0RL_cd_30be5f04cb3aeac2_00000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_61000000, "deleteThis", 11);
1848
1849
1850 ✗ _invoke(_call_desc);
1851
1852
1853
1854 }
1855
1856
1857 //
1858 // Code for hpp::core_idl::PathValidation::deleteIfExpired
1859
1860 // Local call call-back function.
1861 static void
1862 ✗ _0RL_lcfn_30be5f04cb3aeac2_71000000(omniCallDescriptor* cd, omniServant* svnt)
1863 {
1864 ✗ _0RL_cd_30be5f04cb3aeac2_20000000* tcd = (_0RL_cd_30be5f04cb3aeac2_20000000*)cd;
1865 ✗ hpp::core_idl::_impl_PathValidation* impl = (hpp::core_idl::_impl_PathValidation*) svnt->_ptrToInterface(hpp::core_idl::PathValidation::_PD_repoId);
1866 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1867 ✗ tcd->result = impl->deleteIfExpired();
1868 #else
1869 if (!cd->is_upcall())
1870 tcd->result = impl->deleteIfExpired();
1871 else {
1872 try {
1873 tcd->result = impl->deleteIfExpired();
1874 }
1875 catch(hpp::Error& ex) {
1876 throw omniORB::StubUserException(ex._NP_duplicate());
1877 }
1878
1879
1880 }
1881 #endif
1882
1883
1884 }
1885
1886 ✗ ::CORBA::Boolean hpp::core_idl::_objref_PathValidation::deleteIfExpired()
1887 {
1888 ✗ _0RL_cd_30be5f04cb3aeac2_20000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_71000000, "deleteIfExpired", 16);
1889
1890
1891 ✗ _invoke(_call_desc);
1892 ✗ return _call_desc.result;
1893
1894
1895 }
1896
1897
1898 //
1899 // Code for hpp::core_idl::PathValidation::persistantStorage
1900
1901 // Local call call-back function.
1902 static void
1903 ✗ _0RL_lcfn_30be5f04cb3aeac2_81000000(omniCallDescriptor* cd, omniServant* svnt)
1904 {
1905 ✗ _0RL_cd_30be5f04cb3aeac2_40000000* tcd = (_0RL_cd_30be5f04cb3aeac2_40000000*)cd;
1906 ✗ hpp::core_idl::_impl_PathValidation* impl = (hpp::core_idl::_impl_PathValidation*) svnt->_ptrToInterface(hpp::core_idl::PathValidation::_PD_repoId);
1907 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
1908 ✗ impl->persistantStorage(tcd->arg_0);
1909 #else
1910 if (!cd->is_upcall())
1911 impl->persistantStorage(tcd->arg_0);
1912 else {
1913 try {
1914 impl->persistantStorage(tcd->arg_0);
1915 }
1916 catch(hpp::Error& ex) {
1917 throw omniORB::StubUserException(ex._NP_duplicate());
1918 }
1919
1920
1921 }
1922 #endif
1923
1924
1925 }
1926
1927 ✗ void hpp::core_idl::_objref_PathValidation::persistantStorage(::CORBA::Boolean persistant)
1928 {
1929 ✗ _0RL_cd_30be5f04cb3aeac2_40000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_81000000, "persistantStorage", 18);
1930 ✗ _call_desc.arg_0 = persistant;
1931
1932 ✗ _invoke(_call_desc);
1933
1934
1935
1936 }
1937
1938
1939 //
1940 // Code for hpp::core_idl::PathValidation::validate
1941
1942 // Proxy call descriptor class. Mangled signature:
1943 // _cboolean_i_chpp_mcore__idl_mPath_i_cboolean_o_chpp_mcore__idl_mPath_o_cstring_e_chpp_mError
1944 class _0RL_cd_30be5f04cb3aeac2_91000000
1945 : public omniCallDescriptor
1946 {
1947 public:
1948 ✗ inline _0RL_cd_30be5f04cb3aeac2_91000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
1949 ✗ : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
1950 {
1951
1952 }
1953
1954 void marshalArguments(cdrStream&);
1955 void unmarshalArguments(cdrStream&);
1956
1957 void unmarshalReturnedValues(cdrStream&);
1958 void marshalReturnedValues(cdrStream&);
1959
1960 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
1961 static const char* const _user_exns[];
1962
1963 hpp::core_idl::Path_var arg_0_;
1964 hpp::core_idl::Path_ptr arg_0;
1965 ::CORBA::Boolean arg_1;
1966 hpp::core_idl::Path_var arg_2;
1967 ::CORBA::String_var arg_3;
1968 ::CORBA::Boolean result;
1969 };
1970
1971 ✗ void _0RL_cd_30be5f04cb3aeac2_91000000::marshalArguments(cdrStream& _n)
1972 {
1973 ✗ hpp::core_idl::Path::_marshalObjRef(arg_0,_n);
1974 ✗ _n.marshalBoolean(arg_1);
1975
1976 }
1977
1978 ✗ void _0RL_cd_30be5f04cb3aeac2_91000000::unmarshalArguments(cdrStream& _n)
1979 {
1980 ✗ arg_0_ = hpp::core_idl::Path::_unmarshalObjRef(_n);
1981 ✗ arg_0 = arg_0_.in();
1982 ✗ arg_1 = _n.unmarshalBoolean();
1983
1984 }
1985
1986 ✗ void _0RL_cd_30be5f04cb3aeac2_91000000::marshalReturnedValues(cdrStream& _n)
1987 {
1988 ✗ _n.marshalBoolean(result);
1989 ✗ hpp::core_idl::Path::_marshalObjRef(arg_2,_n);
1990 ✗ _n.marshalString(arg_3,0);
1991
1992 }
1993
1994 ✗ void _0RL_cd_30be5f04cb3aeac2_91000000::unmarshalReturnedValues(cdrStream& _n)
1995 {
1996 ✗ result = _n.unmarshalBoolean();
1997 ✗ arg_2 = hpp::core_idl::Path::_unmarshalObjRef(_n);
1998 ✗ arg_3 = _n.unmarshalString(0);
1999
2000 }
2001
2002 const char* const _0RL_cd_30be5f04cb3aeac2_91000000::_user_exns[] = {
2003 hpp::Error::_PD_repoId
2004 };
2005
2006 ✗ void _0RL_cd_30be5f04cb3aeac2_91000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
2007 {
2008 ✗ if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
2009 ✗ hpp::Error _ex;
2010 ✗ _ex <<= s;
2011 ✗ if (iop_client) iop_client->RequestCompleted();
2012 ✗ throw _ex;
2013 }
2014
2015
2016 else {
2017 ✗ if (iop_client) iop_client->RequestCompleted(1);
2018 ✗ OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
2019 (::CORBA::CompletionStatus)s.completion());
2020 }
2021 }
2022
2023 // Local call call-back function.
2024 static void
2025 ✗ _0RL_lcfn_30be5f04cb3aeac2_a1000000(omniCallDescriptor* cd, omniServant* svnt)
2026 {
2027 ✗ _0RL_cd_30be5f04cb3aeac2_91000000* tcd = (_0RL_cd_30be5f04cb3aeac2_91000000*)cd;
2028 ✗ hpp::core_idl::_impl_PathValidation* impl = (hpp::core_idl::_impl_PathValidation*) svnt->_ptrToInterface(hpp::core_idl::PathValidation::_PD_repoId);
2029 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
2030 ✗ tcd->result = impl->validate(tcd->arg_0, tcd->arg_1, tcd->arg_2.out(), tcd->arg_3.out());
2031 #else
2032 if (!cd->is_upcall())
2033 tcd->result = impl->validate(tcd->arg_0, tcd->arg_1, tcd->arg_2.out(), tcd->arg_3.out());
2034 else {
2035 try {
2036 tcd->result = impl->validate(tcd->arg_0, tcd->arg_1, tcd->arg_2.out(), tcd->arg_3.out());
2037 }
2038 catch(hpp::Error& ex) {
2039 throw omniORB::StubUserException(ex._NP_duplicate());
2040 }
2041
2042
2043 }
2044 #endif
2045
2046
2047 }
2048
2049 ✗ ::CORBA::Boolean hpp::core_idl::_objref_PathValidation::validate(::hpp::core_idl::Path_ptr p, ::CORBA::Boolean reverse, ::hpp::core_idl::Path_out validPart, ::hpp::core_idl::PathValidationReport_out report)
2050 {
2051 ✗ _0RL_cd_30be5f04cb3aeac2_91000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_a1000000, "validate", 9);
2052 ✗ _call_desc.arg_0 = p;
2053 ✗ _call_desc.arg_1 = reverse;
2054
2055 ✗ _invoke(_call_desc);
2056 ✗ validPart = _call_desc.arg_2._retn();
2057 ✗ report = _call_desc.arg_3._retn();
2058 ✗ return _call_desc.result;
2059
2060
2061 }
2062
2063
2064 //
2065 // Code for hpp::core_idl::PathValidation::validateConfiguration
2066
2067 // Local call call-back function.
2068 static void
2069 ✗ _0RL_lcfn_30be5f04cb3aeac2_b1000000(omniCallDescriptor* cd, omniServant* svnt)
2070 {
2071 ✗ _0RL_cd_30be5f04cb3aeac2_60000000* tcd = (_0RL_cd_30be5f04cb3aeac2_60000000*)cd;
2072 ✗ hpp::core_idl::_impl_PathValidation* impl = (hpp::core_idl::_impl_PathValidation*) svnt->_ptrToInterface(hpp::core_idl::PathValidation::_PD_repoId);
2073 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
2074 ✗ tcd->result = impl->validateConfiguration(*tcd->arg_0, tcd->arg_1.out());
2075 #else
2076 if (!cd->is_upcall())
2077 tcd->result = impl->validateConfiguration(*tcd->arg_0, tcd->arg_1.out());
2078 else {
2079 try {
2080 tcd->result = impl->validateConfiguration(*tcd->arg_0, tcd->arg_1.out());
2081 }
2082 catch(hpp::Error& ex) {
2083 throw omniORB::StubUserException(ex._NP_duplicate());
2084 }
2085
2086
2087 }
2088 #endif
2089
2090
2091 }
2092
2093 ✗ ::CORBA::Boolean hpp::core_idl::_objref_PathValidation::validateConfiguration(const ::hpp::floatSeq& config, ::hpp::core_idl::ValidationReport_out report)
2094 {
2095 ✗ _0RL_cd_30be5f04cb3aeac2_60000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_b1000000, "validateConfiguration", 22);
2096 ✗ _call_desc.arg_0 = &(::hpp::floatSeq&) config;
2097
2098 ✗ _invoke(_call_desc);
2099 ✗ report = _call_desc.arg_1._retn();
2100 ✗ return _call_desc.result;
2101
2102
2103 }
2104
2105 16 hpp::core_idl::_pof_PathValidation::~_pof_PathValidation() {}
2106
2107
2108 omniObjRef*
2109 ✗ hpp::core_idl::_pof_PathValidation::newObjRef(omniIOR* ior, omniIdentity* id)
2110 {
2111 ✗ return new ::hpp::core_idl::_objref_PathValidation(ior, id);
2112 }
2113
2114
2115 ::CORBA::Boolean
2116 ✗ hpp::core_idl::_pof_PathValidation::is_a(const char* id) const
2117 {
2118 ✗ if (omni::ptrStrMatch(id, ::hpp::core_idl::PathValidation::_PD_repoId))
2119 ✗ return 1;
2120
2121 ✗ return 0;
2122 }
2123
2124 const hpp::core_idl::_pof_PathValidation _the_pof_hpp_mcore__idl_mPathValidation;
2125
2126 ✗ hpp::core_idl::_impl_PathValidation::~_impl_PathValidation() {}
2127
2128
2129 ::CORBA::Boolean
2130 ✗ hpp::core_idl::_impl_PathValidation::_dispatch(omniCallHandle& _handle)
2131 {
2132 ✗ const char* op = _handle.operation_name();
2133
2134 ✗ if (omni::strMatch(op, "deleteThis")) {
2135
2136 ✗ _0RL_cd_30be5f04cb3aeac2_00000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_61000000, "deleteThis", 11, 1);
2137
2138 ✗ _handle.upcall(this,_call_desc);
2139 ✗ return 1;
2140 }
2141
2142 ✗ if (omni::strMatch(op, "deleteIfExpired")) {
2143
2144 ✗ _0RL_cd_30be5f04cb3aeac2_20000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_71000000, "deleteIfExpired", 16, 1);
2145
2146 ✗ _handle.upcall(this,_call_desc);
2147 ✗ return 1;
2148 }
2149
2150 ✗ if (omni::strMatch(op, "persistantStorage")) {
2151
2152 ✗ _0RL_cd_30be5f04cb3aeac2_40000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_81000000, "persistantStorage", 18, 1);
2153
2154 ✗ _handle.upcall(this,_call_desc);
2155 ✗ return 1;
2156 }
2157
2158 ✗ if (omni::strMatch(op, "validate")) {
2159
2160 ✗ _0RL_cd_30be5f04cb3aeac2_91000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_a1000000, "validate", 9, 1);
2161
2162 ✗ _handle.upcall(this,_call_desc);
2163 ✗ return 1;
2164 }
2165
2166 ✗ if (omni::strMatch(op, "validateConfiguration")) {
2167
2168 ✗ _0RL_cd_30be5f04cb3aeac2_60000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_b1000000, "validateConfiguration", 22, 1);
2169
2170 ✗ _handle.upcall(this,_call_desc);
2171 ✗ return 1;
2172 }
2173
2174
2175 ✗ return 0;
2176 }
2177
2178 void*
2179 ✗ hpp::core_idl::_impl_PathValidation::_ptrToInterface(const char* id)
2180 {
2181 ✗ if (id == ::hpp::core_idl::PathValidation::_PD_repoId)
2182 ✗ return (::hpp::core_idl::_impl_PathValidation*) this;
2183
2184 ✗ if (id == ::CORBA::Object::_PD_repoId)
2185 ✗ return (void*) 1;
2186
2187 ✗ if (omni::strMatch(id, ::hpp::core_idl::PathValidation::_PD_repoId))
2188 ✗ return (::hpp::core_idl::_impl_PathValidation*) this;
2189
2190 ✗ if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
2191 ✗ return (void*) 1;
2192 ✗ return 0;
2193 }
2194
2195 const char*
2196 ✗ hpp::core_idl::_impl_PathValidation::_mostDerivedRepoId()
2197 {
2198 ✗ return ::hpp::core_idl::PathValidation::_PD_repoId;
2199 }
2200
2201 ✗ hpp::core_idl::PathValidations_ptr hpp::core_idl::PathValidations_Helper::_nil() {
2202 ✗ return ::hpp::core_idl::PathValidations::_nil();
2203 }
2204
2205 ✗ ::CORBA::Boolean hpp::core_idl::PathValidations_Helper::is_nil(::hpp::core_idl::PathValidations_ptr p) {
2206 ✗ return ::CORBA::is_nil(p);
2207
2208 }
2209
2210 ✗ void hpp::core_idl::PathValidations_Helper::release(::hpp::core_idl::PathValidations_ptr p) {
2211 ✗ ::CORBA::release(p);
2212 }
2213
2214 ✗ void hpp::core_idl::PathValidations_Helper::marshalObjRef(::hpp::core_idl::PathValidations_ptr obj, cdrStream& s) {
2215 ✗ ::hpp::core_idl::PathValidations::_marshalObjRef(obj, s);
2216 }
2217
2218 ✗ hpp::core_idl::PathValidations_ptr hpp::core_idl::PathValidations_Helper::unmarshalObjRef(cdrStream& s) {
2219 ✗ return ::hpp::core_idl::PathValidations::_unmarshalObjRef(s);
2220 }
2221
2222 ✗ void hpp::core_idl::PathValidations_Helper::duplicate(::hpp::core_idl::PathValidations_ptr obj) {
2223 ✗ if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
2224 }
2225
2226 hpp::core_idl::PathValidations_ptr
2227 ✗ hpp::core_idl::PathValidations::_duplicate(::hpp::core_idl::PathValidations_ptr obj)
2228 {
2229 ✗ if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
2230 ✗ return obj;
2231 }
2232
2233 hpp::core_idl::PathValidations_ptr
2234 ✗ hpp::core_idl::PathValidations::_narrow(::CORBA::Object_ptr obj)
2235 {
2236 ✗ if (!obj || obj->_NP_is_nil() || obj->_NP_is_pseudo()) return _nil();
2237 ✗ _ptr_type e = (_ptr_type) obj->_PR_getobj()->_realNarrow(_PD_repoId);
2238 ✗ return e ? e : _nil();
2239 }
2240
2241
2242 hpp::core_idl::PathValidations_ptr
2243 ✗ hpp::core_idl::PathValidations::_unchecked_narrow(::CORBA::Object_ptr obj)
2244 {
2245 ✗ if (!obj || obj->_NP_is_nil() || obj->_NP_is_pseudo()) return _nil();
2246 ✗ _ptr_type e = (_ptr_type) obj->_PR_getobj()->_uncheckedNarrow(_PD_repoId);
2247 ✗ return e ? e : _nil();
2248 }
2249
2250 hpp::core_idl::PathValidations_ptr
2251 ✗ hpp::core_idl::PathValidations::_nil()
2252 {
2253 #ifdef OMNI_UNLOADABLE_STUBS
2254 static _objref_PathValidations _the_nil_obj;
2255 return &_the_nil_obj;
2256 #else
2257 static _objref_PathValidations* _the_nil_ptr = 0;
2258 ✗ if (!_the_nil_ptr) {
2259 ✗ omni::nilRefLock().lock();
2260 ✗ if (!_the_nil_ptr) {
2261 ✗ _the_nil_ptr = new _objref_PathValidations;
2262 ✗ registerNilCorbaObject(_the_nil_ptr);
2263 }
2264 ✗ omni::nilRefLock().unlock();
2265 }
2266 ✗ return _the_nil_ptr;
2267 #endif
2268 }
2269
2270 const char* hpp::core_idl::PathValidations::_PD_repoId = "IDL:hpp/core_idl/PathValidations:1.0";
2271
2272
2273 ✗ hpp::core_idl::_objref_PathValidations::~_objref_PathValidations() {
2274
2275 }
2276
2277
2278 ✗ hpp::core_idl::_objref_PathValidations::_objref_PathValidations(omniIOR* ior, omniIdentity* id) :
2279 omniObjRef(::hpp::core_idl::PathValidations::_PD_repoId, ior, id, 1),
2280 ✗ _objref_PathValidation(ior, id)
2281
2282 {
2283 ✗ _PR_setobj(this);
2284 }
2285
2286 void*
2287 ✗ hpp::core_idl::_objref_PathValidations::_ptrToObjRef(const char* id)
2288 {
2289 ✗ if (id == ::hpp::core_idl::PathValidations::_PD_repoId)
2290 ✗ return (::hpp::core_idl::PathValidations_ptr) this;
2291 ✗ if (id == ::hpp::core_idl::PathValidation::_PD_repoId)
2292 ✗ return (::hpp::core_idl::PathValidation_ptr) this;
2293
2294
2295 ✗ if (id == ::CORBA::Object::_PD_repoId)
2296 ✗ return (::CORBA::Object_ptr) this;
2297
2298 ✗ if (omni::strMatch(id, ::hpp::core_idl::PathValidations::_PD_repoId))
2299 ✗ return (::hpp::core_idl::PathValidations_ptr) this;
2300 ✗ if (omni::strMatch(id, ::hpp::core_idl::PathValidation::_PD_repoId))
2301 ✗ return (::hpp::core_idl::PathValidation_ptr) this;
2302
2303
2304 ✗ if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
2305 ✗ return (::CORBA::Object_ptr) this;
2306
2307 ✗ return 0;
2308 }
2309
2310
2311 //
2312 // Code for hpp::core_idl::PathValidations::setSecurityMargins
2313
2314 // Local call call-back function.
2315 static void
2316 ✗ _0RL_lcfn_30be5f04cb3aeac2_c1000000(omniCallDescriptor* cd, omniServant* svnt)
2317 {
2318 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000* tcd = (_0RL_cd_30be5f04cb3aeac2_d0000000*)cd;
2319 ✗ hpp::core_idl::_impl_PathValidations* impl = (hpp::core_idl::_impl_PathValidations*) svnt->_ptrToInterface(hpp::core_idl::PathValidations::_PD_repoId);
2320 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
2321 ✗ impl->setSecurityMargins(*tcd->arg_0);
2322 #else
2323 if (!cd->is_upcall())
2324 impl->setSecurityMargins(*tcd->arg_0);
2325 else {
2326 try {
2327 impl->setSecurityMargins(*tcd->arg_0);
2328 }
2329 catch(hpp::Error& ex) {
2330 throw omniORB::StubUserException(ex._NP_duplicate());
2331 }
2332
2333
2334 }
2335 #endif
2336
2337
2338 }
2339
2340 ✗ void hpp::core_idl::_objref_PathValidations::setSecurityMargins(const ::hpp::floatSeqSeq& margins)
2341 {
2342 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_c1000000, "setSecurityMargins", 19);
2343 ✗ _call_desc.arg_0 = &(::hpp::floatSeqSeq&) margins;
2344
2345 ✗ _invoke(_call_desc);
2346
2347
2348
2349 }
2350
2351
2352 //
2353 // Code for hpp::core_idl::PathValidations::setSecurityMarginBetweenBodies
2354
2355 // Local call call-back function.
2356 static void
2357 ✗ _0RL_lcfn_30be5f04cb3aeac2_d1000000(omniCallDescriptor* cd, omniServant* svnt)
2358 {
2359 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000* tcd = (_0RL_cd_30be5f04cb3aeac2_f0000000*)cd;
2360 ✗ hpp::core_idl::_impl_PathValidations* impl = (hpp::core_idl::_impl_PathValidations*) svnt->_ptrToInterface(hpp::core_idl::PathValidations::_PD_repoId);
2361 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
2362 ✗ impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
2363 #else
2364 if (!cd->is_upcall())
2365 impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
2366 else {
2367 try {
2368 impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
2369 }
2370 catch(hpp::Error& ex) {
2371 throw omniORB::StubUserException(ex._NP_duplicate());
2372 }
2373
2374
2375 }
2376 #endif
2377
2378
2379 }
2380
2381 ✗ void hpp::core_idl::_objref_PathValidations::setSecurityMarginBetweenBodies(const char* body_a, const char* body_b, ::hpp::value_type margin)
2382 {
2383 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_d1000000, "setSecurityMarginBetweenBodies", 31);
2384 ✗ _call_desc.arg_0 = body_a;
2385 ✗ _call_desc.arg_1 = body_b;
2386 ✗ _call_desc.arg_2 = margin;
2387
2388 ✗ _invoke(_call_desc);
2389
2390
2391
2392 }
2393
2394
2395 //
2396 // Code for hpp::core_idl::PathValidations::filterCollisionPairs
2397
2398 // Local call call-back function.
2399 static void
2400 ✗ _0RL_lcfn_30be5f04cb3aeac2_e1000000(omniCallDescriptor* cd, omniServant* svnt)
2401 {
2402 ✗ _0RL_cd_30be5f04cb3aeac2_11000000* tcd = (_0RL_cd_30be5f04cb3aeac2_11000000*)cd;
2403 ✗ hpp::core_idl::_impl_PathValidations* impl = (hpp::core_idl::_impl_PathValidations*) svnt->_ptrToInterface(hpp::core_idl::PathValidations::_PD_repoId);
2404 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
2405 ✗ impl->filterCollisionPairs(*tcd->arg_0);
2406 #else
2407 if (!cd->is_upcall())
2408 impl->filterCollisionPairs(*tcd->arg_0);
2409 else {
2410 try {
2411 impl->filterCollisionPairs(*tcd->arg_0);
2412 }
2413 catch(hpp::Error& ex) {
2414 throw omniORB::StubUserException(ex._NP_duplicate());
2415 }
2416
2417
2418 }
2419 #endif
2420
2421
2422 }
2423
2424 ✗ void hpp::core_idl::_objref_PathValidations::filterCollisionPairs(const ::hpp::core_idl::RelativeMotionMatrix& relMotion)
2425 {
2426 ✗ _0RL_cd_30be5f04cb3aeac2_11000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_e1000000, "filterCollisionPairs", 21);
2427 ✗ _call_desc.arg_0 = &(::hpp::core_idl::RelativeMotionMatrix&) relMotion;
2428
2429 ✗ _invoke(_call_desc);
2430
2431
2432
2433 }
2434
2435 16 hpp::core_idl::_pof_PathValidations::~_pof_PathValidations() {}
2436
2437
2438 omniObjRef*
2439 ✗ hpp::core_idl::_pof_PathValidations::newObjRef(omniIOR* ior, omniIdentity* id)
2440 {
2441 ✗ return new ::hpp::core_idl::_objref_PathValidations(ior, id);
2442 }
2443
2444
2445 ::CORBA::Boolean
2446 ✗ hpp::core_idl::_pof_PathValidations::is_a(const char* id) const
2447 {
2448 ✗ if (omni::ptrStrMatch(id, ::hpp::core_idl::PathValidations::_PD_repoId))
2449 ✗ return 1;
2450 ✗ if (omni::ptrStrMatch(id, hpp::core_idl::PathValidation::_PD_repoId))
2451 ✗ return 1;
2452
2453
2454 ✗ return 0;
2455 }
2456
2457 const hpp::core_idl::_pof_PathValidations _the_pof_hpp_mcore__idl_mPathValidations;
2458
2459 ✗ hpp::core_idl::_impl_PathValidations::~_impl_PathValidations() {}
2460
2461
2462 ::CORBA::Boolean
2463 ✗ hpp::core_idl::_impl_PathValidations::_dispatch(omniCallHandle& _handle)
2464 {
2465 ✗ const char* op = _handle.operation_name();
2466
2467 ✗ if (omni::strMatch(op, "setSecurityMargins")) {
2468
2469 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_c1000000, "setSecurityMargins", 19, 1);
2470
2471 ✗ _handle.upcall(this,_call_desc);
2472 ✗ return 1;
2473 }
2474
2475 ✗ if (omni::strMatch(op, "setSecurityMarginBetweenBodies")) {
2476
2477 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_d1000000, "setSecurityMarginBetweenBodies", 31, 1);
2478
2479 ✗ _handle.upcall(this,_call_desc);
2480 ✗ return 1;
2481 }
2482
2483 ✗ if (omni::strMatch(op, "filterCollisionPairs")) {
2484
2485 ✗ _0RL_cd_30be5f04cb3aeac2_11000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_e1000000, "filterCollisionPairs", 21, 1);
2486
2487 ✗ _handle.upcall(this,_call_desc);
2488 ✗ return 1;
2489 }
2490
2491
2492 #ifndef _MSC_VER
2493 ✗ if (_impl_PathValidation::_dispatch(_handle)) {
2494 ✗ return 1;
2495 }
2496 #else
2497 // Work-around for incorrect MSVC code generation.
2498 if (((_impl_PathValidation*)this)->
2499 _impl_PathValidation::_dispatch(_handle)) {
2500 return 1;
2501 }
2502 #endif
2503
2504
2505 ✗ return 0;
2506 }
2507
2508 void*
2509 ✗ hpp::core_idl::_impl_PathValidations::_ptrToInterface(const char* id)
2510 {
2511 ✗ if (id == ::hpp::core_idl::PathValidations::_PD_repoId)
2512 ✗ return (::hpp::core_idl::_impl_PathValidations*) this;
2513 ✗ if (id == ::hpp::core_idl::PathValidation::_PD_repoId)
2514 ✗ return (::hpp::core_idl::_impl_PathValidation*) this;
2515
2516
2517 ✗ if (id == ::CORBA::Object::_PD_repoId)
2518 ✗ return (void*) 1;
2519
2520 ✗ if (omni::strMatch(id, ::hpp::core_idl::PathValidations::_PD_repoId))
2521 ✗ return (::hpp::core_idl::_impl_PathValidations*) this;
2522 ✗ if (omni::strMatch(id, ::hpp::core_idl::PathValidation::_PD_repoId))
2523 ✗ return (::hpp::core_idl::_impl_PathValidation*) this;
2524
2525
2526 ✗ if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
2527 ✗ return (void*) 1;
2528 ✗ return 0;
2529 }
2530
2531 const char*
2532 ✗ hpp::core_idl::_impl_PathValidations::_mostDerivedRepoId()
2533 {
2534 ✗ return ::hpp::core_idl::PathValidations::_PD_repoId;
2535 }
2536
2537 ✗ hpp::core_idl::ContinuousValidation_ptr hpp::core_idl::ContinuousValidation_Helper::_nil() {
2538 ✗ return ::hpp::core_idl::ContinuousValidation::_nil();
2539 }
2540
2541 ✗ ::CORBA::Boolean hpp::core_idl::ContinuousValidation_Helper::is_nil(::hpp::core_idl::ContinuousValidation_ptr p) {
2542 ✗ return ::CORBA::is_nil(p);
2543
2544 }
2545
2546 ✗ void hpp::core_idl::ContinuousValidation_Helper::release(::hpp::core_idl::ContinuousValidation_ptr p) {
2547 ✗ ::CORBA::release(p);
2548 }
2549
2550 ✗ void hpp::core_idl::ContinuousValidation_Helper::marshalObjRef(::hpp::core_idl::ContinuousValidation_ptr obj, cdrStream& s) {
2551 ✗ ::hpp::core_idl::ContinuousValidation::_marshalObjRef(obj, s);
2552 }
2553
2554 ✗ hpp::core_idl::ContinuousValidation_ptr hpp::core_idl::ContinuousValidation_Helper::unmarshalObjRef(cdrStream& s) {
2555 ✗ return ::hpp::core_idl::ContinuousValidation::_unmarshalObjRef(s);
2556 }
2557
2558 ✗ void hpp::core_idl::ContinuousValidation_Helper::duplicate(::hpp::core_idl::ContinuousValidation_ptr obj) {
2559 ✗ if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
2560 }
2561
2562 hpp::core_idl::ContinuousValidation_ptr
2563 ✗ hpp::core_idl::ContinuousValidation::_duplicate(::hpp::core_idl::ContinuousValidation_ptr obj)
2564 {
2565 ✗ if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
2566 ✗ return obj;
2567 }
2568
2569 hpp::core_idl::ContinuousValidation_ptr
2570 ✗ hpp::core_idl::ContinuousValidation::_narrow(::CORBA::Object_ptr obj)
2571 {
2572 ✗ if (!obj || obj->_NP_is_nil() || obj->_NP_is_pseudo()) return _nil();
2573 ✗ _ptr_type e = (_ptr_type) obj->_PR_getobj()->_realNarrow(_PD_repoId);
2574 ✗ return e ? e : _nil();
2575 }
2576
2577
2578 hpp::core_idl::ContinuousValidation_ptr
2579 ✗ hpp::core_idl::ContinuousValidation::_unchecked_narrow(::CORBA::Object_ptr obj)
2580 {
2581 ✗ if (!obj || obj->_NP_is_nil() || obj->_NP_is_pseudo()) return _nil();
2582 ✗ _ptr_type e = (_ptr_type) obj->_PR_getobj()->_uncheckedNarrow(_PD_repoId);
2583 ✗ return e ? e : _nil();
2584 }
2585
2586 hpp::core_idl::ContinuousValidation_ptr
2587 ✗ hpp::core_idl::ContinuousValidation::_nil()
2588 {
2589 #ifdef OMNI_UNLOADABLE_STUBS
2590 static _objref_ContinuousValidation _the_nil_obj;
2591 return &_the_nil_obj;
2592 #else
2593 static _objref_ContinuousValidation* _the_nil_ptr = 0;
2594 ✗ if (!_the_nil_ptr) {
2595 ✗ omni::nilRefLock().lock();
2596 ✗ if (!_the_nil_ptr) {
2597 ✗ _the_nil_ptr = new _objref_ContinuousValidation;
2598 ✗ registerNilCorbaObject(_the_nil_ptr);
2599 }
2600 ✗ omni::nilRefLock().unlock();
2601 }
2602 ✗ return _the_nil_ptr;
2603 #endif
2604 }
2605
2606 const char* hpp::core_idl::ContinuousValidation::_PD_repoId = "IDL:hpp/core_idl/ContinuousValidation:1.0";
2607
2608
2609 ✗ hpp::core_idl::_objref_ContinuousValidation::~_objref_ContinuousValidation() {
2610
2611 }
2612
2613
2614 ✗ hpp::core_idl::_objref_ContinuousValidation::_objref_ContinuousValidation(omniIOR* ior, omniIdentity* id) :
2615 omniObjRef(::hpp::core_idl::ContinuousValidation::_PD_repoId, ior, id, 1),
2616 ✗ _objref_PathValidation(ior, id)
2617
2618 {
2619 ✗ _PR_setobj(this);
2620 }
2621
2622 void*
2623 ✗ hpp::core_idl::_objref_ContinuousValidation::_ptrToObjRef(const char* id)
2624 {
2625 ✗ if (id == ::hpp::core_idl::ContinuousValidation::_PD_repoId)
2626 ✗ return (::hpp::core_idl::ContinuousValidation_ptr) this;
2627 ✗ if (id == ::hpp::core_idl::PathValidation::_PD_repoId)
2628 ✗ return (::hpp::core_idl::PathValidation_ptr) this;
2629
2630
2631 ✗ if (id == ::CORBA::Object::_PD_repoId)
2632 ✗ return (::CORBA::Object_ptr) this;
2633
2634 ✗ if (omni::strMatch(id, ::hpp::core_idl::ContinuousValidation::_PD_repoId))
2635 ✗ return (::hpp::core_idl::ContinuousValidation_ptr) this;
2636 ✗ if (omni::strMatch(id, ::hpp::core_idl::PathValidation::_PD_repoId))
2637 ✗ return (::hpp::core_idl::PathValidation_ptr) this;
2638
2639
2640 ✗ if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
2641 ✗ return (::CORBA::Object_ptr) this;
2642
2643 ✗ return 0;
2644 }
2645
2646
2647 //
2648 // Code for hpp::core_idl::ContinuousValidation::setSecurityMargins
2649
2650 // Local call call-back function.
2651 static void
2652 ✗ _0RL_lcfn_30be5f04cb3aeac2_f1000000(omniCallDescriptor* cd, omniServant* svnt)
2653 {
2654 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000* tcd = (_0RL_cd_30be5f04cb3aeac2_d0000000*)cd;
2655 ✗ hpp::core_idl::_impl_ContinuousValidation* impl = (hpp::core_idl::_impl_ContinuousValidation*) svnt->_ptrToInterface(hpp::core_idl::ContinuousValidation::_PD_repoId);
2656 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
2657 ✗ impl->setSecurityMargins(*tcd->arg_0);
2658 #else
2659 if (!cd->is_upcall())
2660 impl->setSecurityMargins(*tcd->arg_0);
2661 else {
2662 try {
2663 impl->setSecurityMargins(*tcd->arg_0);
2664 }
2665 catch(hpp::Error& ex) {
2666 throw omniORB::StubUserException(ex._NP_duplicate());
2667 }
2668
2669
2670 }
2671 #endif
2672
2673
2674 }
2675
2676 ✗ void hpp::core_idl::_objref_ContinuousValidation::setSecurityMargins(const ::hpp::floatSeqSeq& margins)
2677 {
2678 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_f1000000, "setSecurityMargins", 19);
2679 ✗ _call_desc.arg_0 = &(::hpp::floatSeqSeq&) margins;
2680
2681 ✗ _invoke(_call_desc);
2682
2683
2684
2685 }
2686
2687
2688 //
2689 // Code for hpp::core_idl::ContinuousValidation::setSecurityMarginBetweenBodies
2690
2691 // Local call call-back function.
2692 static void
2693 ✗ _0RL_lcfn_30be5f04cb3aeac2_02000000(omniCallDescriptor* cd, omniServant* svnt)
2694 {
2695 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000* tcd = (_0RL_cd_30be5f04cb3aeac2_f0000000*)cd;
2696 ✗ hpp::core_idl::_impl_ContinuousValidation* impl = (hpp::core_idl::_impl_ContinuousValidation*) svnt->_ptrToInterface(hpp::core_idl::ContinuousValidation::_PD_repoId);
2697 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
2698 ✗ impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
2699 #else
2700 if (!cd->is_upcall())
2701 impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
2702 else {
2703 try {
2704 impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
2705 }
2706 catch(hpp::Error& ex) {
2707 throw omniORB::StubUserException(ex._NP_duplicate());
2708 }
2709
2710
2711 }
2712 #endif
2713
2714
2715 }
2716
2717 ✗ void hpp::core_idl::_objref_ContinuousValidation::setSecurityMarginBetweenBodies(const char* body_a, const char* body_b, ::hpp::value_type margin)
2718 {
2719 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_02000000, "setSecurityMarginBetweenBodies", 31);
2720 ✗ _call_desc.arg_0 = body_a;
2721 ✗ _call_desc.arg_1 = body_b;
2722 ✗ _call_desc.arg_2 = margin;
2723
2724 ✗ _invoke(_call_desc);
2725
2726
2727
2728 }
2729
2730
2731 //
2732 // Code for hpp::core_idl::ContinuousValidation::filterCollisionPairs
2733
2734 // Local call call-back function.
2735 static void
2736 ✗ _0RL_lcfn_30be5f04cb3aeac2_12000000(omniCallDescriptor* cd, omniServant* svnt)
2737 {
2738 ✗ _0RL_cd_30be5f04cb3aeac2_11000000* tcd = (_0RL_cd_30be5f04cb3aeac2_11000000*)cd;
2739 ✗ hpp::core_idl::_impl_ContinuousValidation* impl = (hpp::core_idl::_impl_ContinuousValidation*) svnt->_ptrToInterface(hpp::core_idl::ContinuousValidation::_PD_repoId);
2740 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
2741 ✗ impl->filterCollisionPairs(*tcd->arg_0);
2742 #else
2743 if (!cd->is_upcall())
2744 impl->filterCollisionPairs(*tcd->arg_0);
2745 else {
2746 try {
2747 impl->filterCollisionPairs(*tcd->arg_0);
2748 }
2749 catch(hpp::Error& ex) {
2750 throw omniORB::StubUserException(ex._NP_duplicate());
2751 }
2752
2753
2754 }
2755 #endif
2756
2757
2758 }
2759
2760 ✗ void hpp::core_idl::_objref_ContinuousValidation::filterCollisionPairs(const ::hpp::core_idl::RelativeMotionMatrix& relMotion)
2761 {
2762 ✗ _0RL_cd_30be5f04cb3aeac2_11000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_12000000, "filterCollisionPairs", 21);
2763 ✗ _call_desc.arg_0 = &(::hpp::core_idl::RelativeMotionMatrix&) relMotion;
2764
2765 ✗ _invoke(_call_desc);
2766
2767
2768
2769 }
2770
2771
2772 //
2773 // Code for hpp::core_idl::ContinuousValidation::setBreakDistance
2774
2775 // Proxy call descriptor class. Mangled signature:
2776 // void_i_cdouble_e_chpp_mError
2777 class _0RL_cd_30be5f04cb3aeac2_22000000
2778 : public omniCallDescriptor
2779 {
2780 public:
2781 ✗ inline _0RL_cd_30be5f04cb3aeac2_22000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
2782 ✗ : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
2783 {
2784
2785 }
2786
2787 void marshalArguments(cdrStream&);
2788 void unmarshalArguments(cdrStream&);
2789
2790
2791 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
2792 static const char* const _user_exns[];
2793
2794 hpp::value_type arg_0;
2795 };
2796
2797 ✗ void _0RL_cd_30be5f04cb3aeac2_22000000::marshalArguments(cdrStream& _n)
2798 {
2799 ✗ arg_0 >>= _n;
2800
2801 }
2802
2803 ✗ void _0RL_cd_30be5f04cb3aeac2_22000000::unmarshalArguments(cdrStream& _n)
2804 {
2805 ✗ (hpp::value_type&)arg_0 <<= _n;
2806
2807 }
2808
2809 const char* const _0RL_cd_30be5f04cb3aeac2_22000000::_user_exns[] = {
2810 hpp::Error::_PD_repoId
2811 };
2812
2813 ✗ void _0RL_cd_30be5f04cb3aeac2_22000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
2814 {
2815 ✗ if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
2816 ✗ hpp::Error _ex;
2817 ✗ _ex <<= s;
2818 ✗ if (iop_client) iop_client->RequestCompleted();
2819 ✗ throw _ex;
2820 }
2821
2822
2823 else {
2824 ✗ if (iop_client) iop_client->RequestCompleted(1);
2825 ✗ OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
2826 (::CORBA::CompletionStatus)s.completion());
2827 }
2828 }
2829
2830 // Local call call-back function.
2831 static void
2832 ✗ _0RL_lcfn_30be5f04cb3aeac2_32000000(omniCallDescriptor* cd, omniServant* svnt)
2833 {
2834 ✗ _0RL_cd_30be5f04cb3aeac2_22000000* tcd = (_0RL_cd_30be5f04cb3aeac2_22000000*)cd;
2835 ✗ hpp::core_idl::_impl_ContinuousValidation* impl = (hpp::core_idl::_impl_ContinuousValidation*) svnt->_ptrToInterface(hpp::core_idl::ContinuousValidation::_PD_repoId);
2836 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
2837 ✗ impl->setBreakDistance(tcd->arg_0);
2838 #else
2839 if (!cd->is_upcall())
2840 impl->setBreakDistance(tcd->arg_0);
2841 else {
2842 try {
2843 impl->setBreakDistance(tcd->arg_0);
2844 }
2845 catch(hpp::Error& ex) {
2846 throw omniORB::StubUserException(ex._NP_duplicate());
2847 }
2848
2849
2850 }
2851 #endif
2852
2853
2854 }
2855
2856 ✗ void hpp::core_idl::_objref_ContinuousValidation::setBreakDistance(::hpp::value_type breakDistance)
2857 {
2858 ✗ _0RL_cd_30be5f04cb3aeac2_22000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_32000000, "setBreakDistance", 17);
2859 ✗ _call_desc.arg_0 = breakDistance;
2860
2861 ✗ _invoke(_call_desc);
2862
2863
2864
2865 }
2866
2867
2868 //
2869 // Code for hpp::core_idl::ContinuousValidation::getBreakDistance
2870
2871 // Proxy call descriptor class. Mangled signature:
2872 // _cdouble_e_chpp_mError
2873 class _0RL_cd_30be5f04cb3aeac2_42000000
2874 : public omniCallDescriptor
2875 {
2876 public:
2877 ✗ inline _0RL_cd_30be5f04cb3aeac2_42000000(LocalCallFn lcfn, const char* op_, size_t oplen, _CORBA_Boolean upcall=0)
2878 ✗ : omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 1, upcall)
2879 {
2880
2881 }
2882
2883
2884 void unmarshalReturnedValues(cdrStream&);
2885 void marshalReturnedValues(cdrStream&);
2886
2887 void userException(cdrStream&, _OMNI_NS(IOP_C)*, const char*);
2888 static const char* const _user_exns[];
2889
2890 hpp::value_type result;
2891 };
2892
2893 ✗ void _0RL_cd_30be5f04cb3aeac2_42000000::marshalReturnedValues(cdrStream& _n)
2894 {
2895 ✗ result >>= _n;
2896
2897 }
2898
2899 ✗ void _0RL_cd_30be5f04cb3aeac2_42000000::unmarshalReturnedValues(cdrStream& _n)
2900 {
2901 ✗ (hpp::value_type&)result <<= _n;
2902
2903 }
2904
2905 const char* const _0RL_cd_30be5f04cb3aeac2_42000000::_user_exns[] = {
2906 hpp::Error::_PD_repoId
2907 };
2908
2909 ✗ void _0RL_cd_30be5f04cb3aeac2_42000000::userException(cdrStream& s, _OMNI_NS(IOP_C)* iop_client, const char* repoId)
2910 {
2911 ✗ if (omni::strMatch(repoId, hpp::Error::_PD_repoId)) {
2912 ✗ hpp::Error _ex;
2913 ✗ _ex <<= s;
2914 ✗ if (iop_client) iop_client->RequestCompleted();
2915 ✗ throw _ex;
2916 }
2917
2918
2919 else {
2920 ✗ if (iop_client) iop_client->RequestCompleted(1);
2921 ✗ OMNIORB_THROW(UNKNOWN,UNKNOWN_UserException,
2922 (::CORBA::CompletionStatus)s.completion());
2923 }
2924 }
2925
2926 // Local call call-back function.
2927 static void
2928 ✗ _0RL_lcfn_30be5f04cb3aeac2_52000000(omniCallDescriptor* cd, omniServant* svnt)
2929 {
2930 ✗ _0RL_cd_30be5f04cb3aeac2_42000000* tcd = (_0RL_cd_30be5f04cb3aeac2_42000000*)cd;
2931 ✗ hpp::core_idl::_impl_ContinuousValidation* impl = (hpp::core_idl::_impl_ContinuousValidation*) svnt->_ptrToInterface(hpp::core_idl::ContinuousValidation::_PD_repoId);
2932 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
2933 ✗ tcd->result = impl->getBreakDistance();
2934 #else
2935 if (!cd->is_upcall())
2936 tcd->result = impl->getBreakDistance();
2937 else {
2938 try {
2939 tcd->result = impl->getBreakDistance();
2940 }
2941 catch(hpp::Error& ex) {
2942 throw omniORB::StubUserException(ex._NP_duplicate());
2943 }
2944
2945
2946 }
2947 #endif
2948
2949
2950 }
2951
2952 ✗ hpp::value_type hpp::core_idl::_objref_ContinuousValidation::getBreakDistance()
2953 {
2954 ✗ _0RL_cd_30be5f04cb3aeac2_42000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_52000000, "getBreakDistance", 17);
2955
2956
2957 ✗ _invoke(_call_desc);
2958 ✗ return _call_desc.result;
2959
2960
2961 }
2962
2963 16 hpp::core_idl::_pof_ContinuousValidation::~_pof_ContinuousValidation() {}
2964
2965
2966 omniObjRef*
2967 ✗ hpp::core_idl::_pof_ContinuousValidation::newObjRef(omniIOR* ior, omniIdentity* id)
2968 {
2969 ✗ return new ::hpp::core_idl::_objref_ContinuousValidation(ior, id);
2970 }
2971
2972
2973 ::CORBA::Boolean
2974 ✗ hpp::core_idl::_pof_ContinuousValidation::is_a(const char* id) const
2975 {
2976 ✗ if (omni::ptrStrMatch(id, ::hpp::core_idl::ContinuousValidation::_PD_repoId))
2977 ✗ return 1;
2978 ✗ if (omni::ptrStrMatch(id, hpp::core_idl::PathValidation::_PD_repoId))
2979 ✗ return 1;
2980
2981
2982 ✗ return 0;
2983 }
2984
2985 const hpp::core_idl::_pof_ContinuousValidation _the_pof_hpp_mcore__idl_mContinuousValidation;
2986
2987 ✗ hpp::core_idl::_impl_ContinuousValidation::~_impl_ContinuousValidation() {}
2988
2989
2990 ::CORBA::Boolean
2991 ✗ hpp::core_idl::_impl_ContinuousValidation::_dispatch(omniCallHandle& _handle)
2992 {
2993 ✗ const char* op = _handle.operation_name();
2994
2995 ✗ if (omni::strMatch(op, "setSecurityMargins")) {
2996
2997 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_f1000000, "setSecurityMargins", 19, 1);
2998
2999 ✗ _handle.upcall(this,_call_desc);
3000 ✗ return 1;
3001 }
3002
3003 ✗ if (omni::strMatch(op, "setSecurityMarginBetweenBodies")) {
3004
3005 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_02000000, "setSecurityMarginBetweenBodies", 31, 1);
3006
3007 ✗ _handle.upcall(this,_call_desc);
3008 ✗ return 1;
3009 }
3010
3011 ✗ if (omni::strMatch(op, "filterCollisionPairs")) {
3012
3013 ✗ _0RL_cd_30be5f04cb3aeac2_11000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_12000000, "filterCollisionPairs", 21, 1);
3014
3015 ✗ _handle.upcall(this,_call_desc);
3016 ✗ return 1;
3017 }
3018
3019 ✗ if (omni::strMatch(op, "setBreakDistance")) {
3020
3021 ✗ _0RL_cd_30be5f04cb3aeac2_22000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_32000000, "setBreakDistance", 17, 1);
3022
3023 ✗ _handle.upcall(this,_call_desc);
3024 ✗ return 1;
3025 }
3026
3027 ✗ if (omni::strMatch(op, "getBreakDistance")) {
3028
3029 ✗ _0RL_cd_30be5f04cb3aeac2_42000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_52000000, "getBreakDistance", 17, 1);
3030
3031 ✗ _handle.upcall(this,_call_desc);
3032 ✗ return 1;
3033 }
3034
3035
3036 #ifndef _MSC_VER
3037 ✗ if (_impl_PathValidation::_dispatch(_handle)) {
3038 ✗ return 1;
3039 }
3040 #else
3041 // Work-around for incorrect MSVC code generation.
3042 if (((_impl_PathValidation*)this)->
3043 _impl_PathValidation::_dispatch(_handle)) {
3044 return 1;
3045 }
3046 #endif
3047
3048
3049 ✗ return 0;
3050 }
3051
3052 void*
3053 ✗ hpp::core_idl::_impl_ContinuousValidation::_ptrToInterface(const char* id)
3054 {
3055 ✗ if (id == ::hpp::core_idl::ContinuousValidation::_PD_repoId)
3056 ✗ return (::hpp::core_idl::_impl_ContinuousValidation*) this;
3057 ✗ if (id == ::hpp::core_idl::PathValidation::_PD_repoId)
3058 ✗ return (::hpp::core_idl::_impl_PathValidation*) this;
3059
3060
3061 ✗ if (id == ::CORBA::Object::_PD_repoId)
3062 ✗ return (void*) 1;
3063
3064 ✗ if (omni::strMatch(id, ::hpp::core_idl::ContinuousValidation::_PD_repoId))
3065 ✗ return (::hpp::core_idl::_impl_ContinuousValidation*) this;
3066 ✗ if (omni::strMatch(id, ::hpp::core_idl::PathValidation::_PD_repoId))
3067 ✗ return (::hpp::core_idl::_impl_PathValidation*) this;
3068
3069
3070 ✗ if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
3071 ✗ return (void*) 1;
3072 ✗ return 0;
3073 }
3074
3075 const char*
3076 ✗ hpp::core_idl::_impl_ContinuousValidation::_mostDerivedRepoId()
3077 {
3078 ✗ return ::hpp::core_idl::ContinuousValidation::_PD_repoId;
3079 }
3080
3081 ✗ hpp::core_idl::pathValidation_idl::Discretized_ptr hpp::core_idl::pathValidation_idl::Discretized_Helper::_nil() {
3082 ✗ return ::hpp::core_idl::pathValidation_idl::Discretized::_nil();
3083 }
3084
3085 ✗ ::CORBA::Boolean hpp::core_idl::pathValidation_idl::Discretized_Helper::is_nil(::hpp::core_idl::pathValidation_idl::Discretized_ptr p) {
3086 ✗ return ::CORBA::is_nil(p);
3087
3088 }
3089
3090 ✗ void hpp::core_idl::pathValidation_idl::Discretized_Helper::release(::hpp::core_idl::pathValidation_idl::Discretized_ptr p) {
3091 ✗ ::CORBA::release(p);
3092 }
3093
3094 ✗ void hpp::core_idl::pathValidation_idl::Discretized_Helper::marshalObjRef(::hpp::core_idl::pathValidation_idl::Discretized_ptr obj, cdrStream& s) {
3095 ✗ ::hpp::core_idl::pathValidation_idl::Discretized::_marshalObjRef(obj, s);
3096 }
3097
3098 ✗ hpp::core_idl::pathValidation_idl::Discretized_ptr hpp::core_idl::pathValidation_idl::Discretized_Helper::unmarshalObjRef(cdrStream& s) {
3099 ✗ return ::hpp::core_idl::pathValidation_idl::Discretized::_unmarshalObjRef(s);
3100 }
3101
3102 ✗ void hpp::core_idl::pathValidation_idl::Discretized_Helper::duplicate(::hpp::core_idl::pathValidation_idl::Discretized_ptr obj) {
3103 ✗ if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
3104 }
3105
3106 hpp::core_idl::pathValidation_idl::Discretized_ptr
3107 ✗ hpp::core_idl::pathValidation_idl::Discretized::_duplicate(::hpp::core_idl::pathValidation_idl::Discretized_ptr obj)
3108 {
3109 ✗ if (obj && !obj->_NP_is_nil()) omni::duplicateObjRef(obj);
3110 ✗ return obj;
3111 }
3112
3113 hpp::core_idl::pathValidation_idl::Discretized_ptr
3114 ✗ hpp::core_idl::pathValidation_idl::Discretized::_narrow(::CORBA::Object_ptr obj)
3115 {
3116 ✗ if (!obj || obj->_NP_is_nil() || obj->_NP_is_pseudo()) return _nil();
3117 ✗ _ptr_type e = (_ptr_type) obj->_PR_getobj()->_realNarrow(_PD_repoId);
3118 ✗ return e ? e : _nil();
3119 }
3120
3121
3122 hpp::core_idl::pathValidation_idl::Discretized_ptr
3123 ✗ hpp::core_idl::pathValidation_idl::Discretized::_unchecked_narrow(::CORBA::Object_ptr obj)
3124 {
3125 ✗ if (!obj || obj->_NP_is_nil() || obj->_NP_is_pseudo()) return _nil();
3126 ✗ _ptr_type e = (_ptr_type) obj->_PR_getobj()->_uncheckedNarrow(_PD_repoId);
3127 ✗ return e ? e : _nil();
3128 }
3129
3130 hpp::core_idl::pathValidation_idl::Discretized_ptr
3131 ✗ hpp::core_idl::pathValidation_idl::Discretized::_nil()
3132 {
3133 #ifdef OMNI_UNLOADABLE_STUBS
3134 static _objref_Discretized _the_nil_obj;
3135 return &_the_nil_obj;
3136 #else
3137 static _objref_Discretized* _the_nil_ptr = 0;
3138 ✗ if (!_the_nil_ptr) {
3139 ✗ omni::nilRefLock().lock();
3140 ✗ if (!_the_nil_ptr) {
3141 ✗ _the_nil_ptr = new _objref_Discretized;
3142 ✗ registerNilCorbaObject(_the_nil_ptr);
3143 }
3144 ✗ omni::nilRefLock().unlock();
3145 }
3146 ✗ return _the_nil_ptr;
3147 #endif
3148 }
3149
3150 const char* hpp::core_idl::pathValidation_idl::Discretized::_PD_repoId = "IDL:hpp/core_idl/pathValidation_idl/Discretized:1.0";
3151
3152
3153 ✗ hpp::core_idl::pathValidation_idl::_objref_Discretized::~_objref_Discretized() {
3154
3155 }
3156
3157
3158 ✗ hpp::core_idl::pathValidation_idl::_objref_Discretized::_objref_Discretized(omniIOR* ior, omniIdentity* id) :
3159 omniObjRef(::hpp::core_idl::pathValidation_idl::Discretized::_PD_repoId, ior, id, 1),
3160 ✗ _objref_PathValidation(ior, id)
3161
3162 {
3163 ✗ _PR_setobj(this);
3164 }
3165
3166 void*
3167 ✗ hpp::core_idl::pathValidation_idl::_objref_Discretized::_ptrToObjRef(const char* id)
3168 {
3169 ✗ if (id == ::hpp::core_idl::pathValidation_idl::Discretized::_PD_repoId)
3170 ✗ return (::hpp::core_idl::pathValidation_idl::Discretized_ptr) this;
3171 ✗ if (id == ::hpp::core_idl::PathValidation::_PD_repoId)
3172 ✗ return (::hpp::core_idl::PathValidation_ptr) this;
3173
3174
3175 ✗ if (id == ::CORBA::Object::_PD_repoId)
3176 ✗ return (::CORBA::Object_ptr) this;
3177
3178 ✗ if (omni::strMatch(id, ::hpp::core_idl::pathValidation_idl::Discretized::_PD_repoId))
3179 ✗ return (::hpp::core_idl::pathValidation_idl::Discretized_ptr) this;
3180 ✗ if (omni::strMatch(id, ::hpp::core_idl::PathValidation::_PD_repoId))
3181 ✗ return (::hpp::core_idl::PathValidation_ptr) this;
3182
3183
3184 ✗ if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
3185 ✗ return (::CORBA::Object_ptr) this;
3186
3187 ✗ return 0;
3188 }
3189
3190
3191 //
3192 // Code for hpp::core_idl::pathValidation_idl::Discretized::setSecurityMargins
3193
3194 // Local call call-back function.
3195 static void
3196 ✗ _0RL_lcfn_30be5f04cb3aeac2_62000000(omniCallDescriptor* cd, omniServant* svnt)
3197 {
3198 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000* tcd = (_0RL_cd_30be5f04cb3aeac2_d0000000*)cd;
3199 ✗ hpp::core_idl::pathValidation_idl::_impl_Discretized* impl = (hpp::core_idl::pathValidation_idl::_impl_Discretized*) svnt->_ptrToInterface(hpp::core_idl::pathValidation_idl::Discretized::_PD_repoId);
3200 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
3201 ✗ impl->setSecurityMargins(*tcd->arg_0);
3202 #else
3203 if (!cd->is_upcall())
3204 impl->setSecurityMargins(*tcd->arg_0);
3205 else {
3206 try {
3207 impl->setSecurityMargins(*tcd->arg_0);
3208 }
3209 catch(hpp::Error& ex) {
3210 throw omniORB::StubUserException(ex._NP_duplicate());
3211 }
3212
3213
3214 }
3215 #endif
3216
3217
3218 }
3219
3220 ✗ void hpp::core_idl::pathValidation_idl::_objref_Discretized::setSecurityMargins(const ::hpp::floatSeqSeq& margins)
3221 {
3222 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_62000000, "setSecurityMargins", 19);
3223 ✗ _call_desc.arg_0 = &(::hpp::floatSeqSeq&) margins;
3224
3225 ✗ _invoke(_call_desc);
3226
3227
3228
3229 }
3230
3231
3232 //
3233 // Code for hpp::core_idl::pathValidation_idl::Discretized::setSecurityMarginBetweenBodies
3234
3235 // Local call call-back function.
3236 static void
3237 ✗ _0RL_lcfn_30be5f04cb3aeac2_72000000(omniCallDescriptor* cd, omniServant* svnt)
3238 {
3239 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000* tcd = (_0RL_cd_30be5f04cb3aeac2_f0000000*)cd;
3240 ✗ hpp::core_idl::pathValidation_idl::_impl_Discretized* impl = (hpp::core_idl::pathValidation_idl::_impl_Discretized*) svnt->_ptrToInterface(hpp::core_idl::pathValidation_idl::Discretized::_PD_repoId);
3241 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
3242 ✗ impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
3243 #else
3244 if (!cd->is_upcall())
3245 impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
3246 else {
3247 try {
3248 impl->setSecurityMarginBetweenBodies(tcd->arg_0, tcd->arg_1, tcd->arg_2);
3249 }
3250 catch(hpp::Error& ex) {
3251 throw omniORB::StubUserException(ex._NP_duplicate());
3252 }
3253
3254
3255 }
3256 #endif
3257
3258
3259 }
3260
3261 ✗ void hpp::core_idl::pathValidation_idl::_objref_Discretized::setSecurityMarginBetweenBodies(const char* body_a, const char* body_b, ::hpp::value_type margin)
3262 {
3263 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_72000000, "setSecurityMarginBetweenBodies", 31);
3264 ✗ _call_desc.arg_0 = body_a;
3265 ✗ _call_desc.arg_1 = body_b;
3266 ✗ _call_desc.arg_2 = margin;
3267
3268 ✗ _invoke(_call_desc);
3269
3270
3271
3272 }
3273
3274
3275 //
3276 // Code for hpp::core_idl::pathValidation_idl::Discretized::filterCollisionPairs
3277
3278 // Local call call-back function.
3279 static void
3280 ✗ _0RL_lcfn_30be5f04cb3aeac2_82000000(omniCallDescriptor* cd, omniServant* svnt)
3281 {
3282 ✗ _0RL_cd_30be5f04cb3aeac2_11000000* tcd = (_0RL_cd_30be5f04cb3aeac2_11000000*)cd;
3283 ✗ hpp::core_idl::pathValidation_idl::_impl_Discretized* impl = (hpp::core_idl::pathValidation_idl::_impl_Discretized*) svnt->_ptrToInterface(hpp::core_idl::pathValidation_idl::Discretized::_PD_repoId);
3284 #ifdef OMNI_HAS_Cplusplus_catch_exception_by_base
3285 ✗ impl->filterCollisionPairs(*tcd->arg_0);
3286 #else
3287 if (!cd->is_upcall())
3288 impl->filterCollisionPairs(*tcd->arg_0);
3289 else {
3290 try {
3291 impl->filterCollisionPairs(*tcd->arg_0);
3292 }
3293 catch(hpp::Error& ex) {
3294 throw omniORB::StubUserException(ex._NP_duplicate());
3295 }
3296
3297
3298 }
3299 #endif
3300
3301
3302 }
3303
3304 ✗ void hpp::core_idl::pathValidation_idl::_objref_Discretized::filterCollisionPairs(const ::hpp::core_idl::RelativeMotionMatrix& relMotion)
3305 {
3306 ✗ _0RL_cd_30be5f04cb3aeac2_11000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_82000000, "filterCollisionPairs", 21);
3307 ✗ _call_desc.arg_0 = &(::hpp::core_idl::RelativeMotionMatrix&) relMotion;
3308
3309 ✗ _invoke(_call_desc);
3310
3311
3312
3313 }
3314
3315 16 hpp::core_idl::pathValidation_idl::_pof_Discretized::~_pof_Discretized() {}
3316
3317
3318 omniObjRef*
3319 ✗ hpp::core_idl::pathValidation_idl::_pof_Discretized::newObjRef(omniIOR* ior, omniIdentity* id)
3320 {
3321 ✗ return new ::hpp::core_idl::pathValidation_idl::_objref_Discretized(ior, id);
3322 }
3323
3324
3325 ::CORBA::Boolean
3326 ✗ hpp::core_idl::pathValidation_idl::_pof_Discretized::is_a(const char* id) const
3327 {
3328 ✗ if (omni::ptrStrMatch(id, ::hpp::core_idl::pathValidation_idl::Discretized::_PD_repoId))
3329 ✗ return 1;
3330 ✗ if (omni::ptrStrMatch(id, hpp::core_idl::PathValidation::_PD_repoId))
3331 ✗ return 1;
3332
3333
3334 ✗ return 0;
3335 }
3336
3337 const hpp::core_idl::pathValidation_idl::_pof_Discretized _the_pof_hpp_mcore__idl_mpathValidation__idl_mDiscretized;
3338
3339 ✗ hpp::core_idl::pathValidation_idl::_impl_Discretized::~_impl_Discretized() {}
3340
3341
3342 ::CORBA::Boolean
3343 ✗ hpp::core_idl::pathValidation_idl::_impl_Discretized::_dispatch(omniCallHandle& _handle)
3344 {
3345 ✗ const char* op = _handle.operation_name();
3346
3347 ✗ if (omni::strMatch(op, "setSecurityMargins")) {
3348
3349 ✗ _0RL_cd_30be5f04cb3aeac2_d0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_62000000, "setSecurityMargins", 19, 1);
3350
3351 ✗ _handle.upcall(this,_call_desc);
3352 ✗ return 1;
3353 }
3354
3355 ✗ if (omni::strMatch(op, "setSecurityMarginBetweenBodies")) {
3356
3357 ✗ _0RL_cd_30be5f04cb3aeac2_f0000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_72000000, "setSecurityMarginBetweenBodies", 31, 1);
3358
3359 ✗ _handle.upcall(this,_call_desc);
3360 ✗ return 1;
3361 }
3362
3363 ✗ if (omni::strMatch(op, "filterCollisionPairs")) {
3364
3365 ✗ _0RL_cd_30be5f04cb3aeac2_11000000 _call_desc(_0RL_lcfn_30be5f04cb3aeac2_82000000, "filterCollisionPairs", 21, 1);
3366
3367 ✗ _handle.upcall(this,_call_desc);
3368 ✗ return 1;
3369 }
3370
3371
3372 #ifndef _MSC_VER
3373 ✗ if (_impl_PathValidation::_dispatch(_handle)) {
3374 ✗ return 1;
3375 }
3376 #else
3377 // Work-around for incorrect MSVC code generation.
3378 if (((_impl_PathValidation*)this)->
3379 _impl_PathValidation::_dispatch(_handle)) {
3380 return 1;
3381 }
3382 #endif
3383
3384
3385 ✗ return 0;
3386 }
3387
3388 void*
3389 ✗ hpp::core_idl::pathValidation_idl::_impl_Discretized::_ptrToInterface(const char* id)
3390 {
3391 ✗ if (id == ::hpp::core_idl::pathValidation_idl::Discretized::_PD_repoId)
3392 ✗ return (::hpp::core_idl::pathValidation_idl::_impl_Discretized*) this;
3393 ✗ if (id == ::hpp::core_idl::PathValidation::_PD_repoId)
3394 ✗ return (::hpp::core_idl::_impl_PathValidation*) this;
3395
3396
3397 ✗ if (id == ::CORBA::Object::_PD_repoId)
3398 ✗ return (void*) 1;
3399
3400 ✗ if (omni::strMatch(id, ::hpp::core_idl::pathValidation_idl::Discretized::_PD_repoId))
3401 ✗ return (::hpp::core_idl::pathValidation_idl::_impl_Discretized*) this;
3402 ✗ if (omni::strMatch(id, ::hpp::core_idl::PathValidation::_PD_repoId))
3403 ✗ return (::hpp::core_idl::_impl_PathValidation*) this;
3404
3405
3406 ✗ if (omni::strMatch(id, ::CORBA::Object::_PD_repoId))
3407 ✗ return (void*) 1;
3408 ✗ return 0;
3409 }
3410
3411 const char*
3412 ✗ hpp::core_idl::pathValidation_idl::_impl_Discretized::_mostDerivedRepoId()
3413 {
3414 ✗ return ::hpp::core_idl::pathValidation_idl::Discretized::_PD_repoId;
3415 }
3416
3417 ✗ POA_hpp::core_idl::ConfigValidation::~ConfigValidation() {}
3418
3419 ✗ POA_hpp::core_idl::ConfigValidations::~ConfigValidations() {}
3420
3421 ✗ POA_hpp::core_idl::CollisionValidation::~CollisionValidation() {}
3422
3423 ✗ POA_hpp::core_idl::PathValidation::~PathValidation() {}
3424
3425 ✗ POA_hpp::core_idl::PathValidations::~PathValidations() {}
3426
3427 ✗ POA_hpp::core_idl::ContinuousValidation::~ContinuousValidation() {}
3428
3429 ✗ POA_hpp::core_idl::pathValidation_idl::Discretized::~Discretized() {}
3430
3431